diff --git a/.devcontainer/Dockerfile b/.devcontainer/Dockerfile
new file mode 100644
index 0000000..c0838a9
--- /dev/null
+++ b/.devcontainer/Dockerfile
@@ -0,0 +1,16 @@
+FROM ghcr.io/astral-sh/uv:latest AS uv
+
+FROM mcr.microsoft.com/devcontainers/base:2-ubuntu24.04
+
+# install needed packages
+RUN apt-get update && export DEBIAN_FRONTEND=noninteractive \
+    && apt-get -y install \
+    build-essential \
+    cmake \
+    gcc \
+    gdb \
+    libgmp-dev \
+    ninja-build
+
+
+COPY --from=uv --chown=vscode /uv /uvx /bin/
diff --git a/.devcontainer/devcontainer.json b/.devcontainer/devcontainer.json
new file mode 100644
index 0000000..e2beb68
--- /dev/null
+++ b/.devcontainer/devcontainer.json
@@ -0,0 +1,57 @@
+{
+  "name": "PauliEngine development environment",
+  "build": {
+    "dockerfile": "Dockerfile",
+    "context": ".."
+  },
+  "capAdd": [
+    "SYS_PTRACE"
+  ],
+  "securityOpt": [
+    "seccomp=unconfined"
+  ],
+  "remoteUser": "vscode",
+  "customizations": {
+    "vscode": {
+      "settings": {
+        "python.defaultInterpreterPath": "${containerEnv:UV_PROJECT_ENVIRONMENT}/bin/python",
+        "python.terminal.activateEnvInCurrentTerminal": true,
+        "terminal.integrated.defaultProfile.linux": "zsh",
+        "terminal.integrated.profiles.linux": {
+          "zsh": {
+            "path": "/bin/zsh"
+          }
+        }
+      },
+      "extensions": [
+        "MS-vsliveshare.vsliveshare",
+        "benjamin-simmonds.pythoncpp-debug",
+        "charliermarsh.ruff",
+        "cschlosser.doxdocgen",
+        "ms-python.python",
+        "ms-toolsai.jupyter",
+        "ms-vscode.cmake-tools",
+        "ms-vscode.cpptools",
+        "ms-vscode.cpptools-themes",
+        "mutantdino.resourcemonitor",
+        "njpwerner.autodocstring",
+        "streetsidesoftware.code-spell-checker",
+        "streetsidesoftware.code-spell-checker-scientific-terms",
+        "tamasfe.even-better-toml",
+        "vivaxy.vscode-conventional-commits"
+      ]
+    }
+  },
+  "containerEnv": {
+    "PYTHONUNBUFFERED": "True",
+    "WORKSPACE": "${containerWorkspaceFolder}",
+    "UV_LINK_MODE": "copy",
+    "UV_PROJECT_ENVIRONMENT": "/home/vscode/.venv"
+  },
+  "postCreateCommand": "./.devcontainer/postCreateCommand.sh",
+  "postStartCommand": "./.devcontainer/postStartCommand.sh",
+  "hostRequirements": {
+    "cpus": 4,
+    "memory": "6gb"
+  }
+}
\ No newline at end of file
diff --git a/.devcontainer/postCreateCommand.sh b/.devcontainer/postCreateCommand.sh
new file mode 100755
index 0000000..8c5c040
--- /dev/null
+++ b/.devcontainer/postCreateCommand.sh
@@ -0,0 +1,27 @@
+#!/usr/bin/env bash
+
+set -euxo pipefail
+
+# install uv and uvx shell completions
+echo 'eval "$(uv generate-shell-completion zsh)"' >> /home/vscode/.zshrc
+echo 'eval "$(uvx --generate-shell-completion zsh)"' >> /home/vscode/.zshrc
+
+# set up GDB to view contents of STL containers
+gcc_version="$(gcc --version | awk 'NR==1 {print $NF}')"
+cat <<EOT >> ~/.gdbinit
+python
+import sys
+sys.path.insert(0, "/usr/share/gcc-$gcc_version/python")
+from libstdcxx.v6.printers import register_libstdcxx_printers
+register_libstdcxx_printers (None)
+end
+EOT
+
+# install conan
+uv venv
+source /home/vscode/.venv/bin/activate
+uv pip install conan 
+
+# setup conan profile and install dependencies
+conan profile detect --force 
+conan install .  --output-folder=build --build=missing -pr ./conan_profile
\ No newline at end of file
diff --git a/.devcontainer/postStartCommand.sh b/.devcontainer/postStartCommand.sh
new file mode 100755
index 0000000..5a44871
--- /dev/null
+++ b/.devcontainer/postStartCommand.sh
@@ -0,0 +1,7 @@
+#!/usr/bin/env bash
+
+# install project with all dependencies
+uv sync --all-groups --all-extras
+
+# install pre-commit hooks
+uv run pre-commit install --install-hooks
diff --git a/.git_archival.txt b/.git_archival.txt
new file mode 100644
index 0000000..7c51009
--- /dev/null
+++ b/.git_archival.txt
@@ -0,0 +1,3 @@
+node: $Format:%H$
+node-date: $Format:%cI$
+describe-name: $Format:%(describe:tags=true,match=*[0-9]*)$
diff --git a/.github/workflows/deploy.yml b/.github/workflows/deploy.yml
new file mode 100644
index 0000000..56629a1
--- /dev/null
+++ b/.github/workflows/deploy.yml
@@ -0,0 +1,160 @@
+name: Publish PauliEngine Python sdist and wheels to PyPI
+
+on:
+  workflow_dispatch:
+    inputs:
+      force-upload:
+        description: 'Upload artifacts without a corresponding release'
+        required: false
+        default: false
+        type: boolean
+  release:
+    types:
+      - published
+  pull_request:
+    # PRs trigger for the "opened", "reopened", "synchronize" events (default) and
+    # "ready_for_review"
+    paths:
+      - .github/workflows/deploy.yml
+    types:
+      - opened
+      - reopened
+      - synchronize # when new commits are pushed to the PR
+      - ready_for_review # when the PR is un-drafted
+
+concurrency:
+  group: ${{ github.workflow }}-${{ github.ref }}
+  cancel-in-progress: true
+
+env:
+  COLUMNS: 120
+  FORCE_COLOR: 3
+
+jobs:
+  build-sdist:
+    name: Build source distribution
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v6
+        with:
+          fetch-depth: 0  # such that setuptools_scm can do its job correctly
+
+      - name: Build SDist
+        run: |
+          pipx install uv
+          pipx run build --verbose --sdist --installer=uv
+
+      - uses: actions/upload-artifact@v6
+        with:
+          name: cibw-sdist
+          path: dist/*.tar.gz
+
+  build-wheels:
+    # in combination with the PR types selection, this top-level if statement
+    # skips running the workflow for Draft PRs
+    if: ${{ github.event_name == 'push' || !github.event.pull_request.draft }}
+    name: Build Python wheels for ${{ matrix.os }}
+    runs-on: ${{ matrix.runs-on }}
+    strategy:
+      matrix:
+        os: [ linux-intel, linux-arm, macos-arm, windows-intel, windows-arm]
+        include:
+          - archs: native
+            platform: auto
+          - os: linux-intel
+            runs-on: ubuntu-latest
+          - os: linux-arm
+            runs-on: ubuntu-24.04-arm
+          - os: macos-arm
+            runs-on: macos-latest
+          - os: windows-intel
+            runs-on: windows-latest
+          - os: windows-arm
+            runs-on: windows-latest
+    steps:
+      - uses: actions/checkout@v6
+        with:
+          fetch-depth: 0
+
+      - uses: pypa/cibuildwheel@v3.3.1
+        with:
+          extras: "uv"
+        env:
+          # target platform
+          CIBW_PLATFORM: ${{ matrix.platform }}
+          # architectures to build
+          CIBW_ARCHS: ${{ matrix.archs }}
+          # use uv and build
+          CIBW_BUILD_FRONTEND: "build[uv]"
+          # increase pip debugging output
+          CIBW_BUILD_VERBOSITY: 1
+          CIBW_DEBUG_TRACEBACK: TRUE
+          CIBW_BEFORE_ALL_LINUX: |
+            dnf install -y ninja-build
+            # install conan and C++ dependencies for the project
+            pip install conan
+            conan profile detect --force
+
+            # install symengine
+            conan install .  --output-folder=build --build=missing -pr ./conan_profile  
+          CIBW_BEFORE_ALL_MACOS: |
+            # install conan and C++ dependencies for the project
+            pip install conan
+            conan profile detect --force 
+
+            # install symengine
+            conan install .  --output-folder=build --build=missing -pr ./conan_profile
+          CIBW_BEFORE_ALL_WINDOWS: |
+            pip install delvewheel conan && conan profile detect --force && conan install . --output-folder=build --build=missing -pr conan_profile 
+          # do not activate architecture-dependent compiler flags
+          # 4 jobs in parallel, but do not start new ones if load average exceeds 5
+          CIBW_ENVIRONMENT_LINUX: 
+            CMAKE_TOOLCHAIN_FILE=build/conan_toolchain.cmake
+            CIBW="true"
+            SKBUILD_BUILD_TOOL_ARGS="-j4;-l5"
+          # set deployment target for C++20 compatibility
+          # do not activate architecture-dependent compiler flags
+          # 4 jobs in parallel, but do not start new ones if load average exceeds 5
+          CIBW_ENVIRONMENT_MACOS: >
+            CIBW="true"
+            MACOSX_DEPLOYMENT_TARGET=15.0
+            SKBUILD_BUILD_TOOL_ARGS="-j4;-l5"
+          CIBW_ENVIRONMENT_WINDOWS: >
+            CIBW="true"
+            SKBUILD_BUILD_TOOL_ARGS="/m:4"
+            CMAKE_TOOLCHAIN_FILE=build\conan_toolchain.cmake
+          # build 3.10, 3.11, 3.12, 3.13 (with GIL), and 3.14 (with GIL)
+          CIBW_BUILD: "cp310-* cp311-* cp312-* cp313-* cp314-*"
+          # skip musl builds, and PyPy builds
+          CIBW_SKIP: "*-musllinux_*"
+          # use abi3audit to catch issues with Limited API wheels
+          CIBW_REPAIR_WHEEL_COMMAND_LINUX: |
+            auditwheel repair -w {dest_dir} {wheel}
+            if [[ "{wheel}" == *abi3* ]]; then
+              pipx run abi3audit --strict --report {wheel}
+            else
+              echo "{wheel} is not abi3, skipping abi3audit"
+            fi
+          # use abi3audit to catch issues with Limited API wheels
+          CIBW_REPAIR_WHEEL_COMMAND_MACOS: |
+            delocate-wheel --require-archs {delocate_archs} -w {dest_dir} -v {wheel}
+            if [[ "{wheel}" == *abi3* ]]; then
+              pipx run abi3audit --strict --report {wheel}
+            else
+              echo "{wheel} is not abi3, skipping abi3audit"
+            fi
+          CIBW_REPAIR_WHEEL_COMMAND_WINDOWS: |
+            delvewheel repair -w {dest_dir} {wheel}
+            if [[ "{wheel}" == *abi3* ]]; then
+              pipx run abi3audit --strict --report {wheel}
+            else
+              echo "{wheel} is not abi3, skipping abi3audit"
+            fi
+          CIBW_TEST_COMMAND: python -m pytest {package}/tests
+          CIBW_TEST_GROUPS: "test"
+
+      - name: Upload wheels
+        uses: actions/upload-artifact@v6
+        with:
+          name: cibw-wheels-${{ matrix.os }}-${{ strategy.job-index }}
+          path: wheelhouse/*.whl
\ No newline at end of file
diff --git a/.gitignore b/.gitignore
index 7102273..c648027 100644
--- a/.gitignore
+++ b/.gitignore
@@ -9,4 +9,6 @@ Thumbs.db
 .bat
 .cmake
 .env
-config.json
\ No newline at end of file
+config.json
+
+__pycache__/
diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml
new file mode 100644
index 0000000..8441899
--- /dev/null
+++ b/.pre-commit-config.yaml
@@ -0,0 +1,35 @@
+default_language_version:
+  python: python3
+
+default_stages: [pre-commit, pre-push]
+
+repos:
+  - repo: https://github.com/pre-commit/pre-commit-hooks
+    rev: v5.0.0
+    hooks:
+      - id: check-added-large-files
+        args: ["--maxkb=1024"]
+      - id: check-case-conflict
+      - id: check-merge-conflict
+      - id: check-symlinks
+      - id: check-toml
+      - id: destroyed-symlinks
+      - id: end-of-file-fixer
+      - id: forbid-submodules
+      - id: no-commit-to-branch
+        args: ['--pattern', '[^a-zA-Z0-9_\/-]']
+      - id: trailing-whitespace
+
+  - repo: https://github.com/charliermarsh/ruff-pre-commit
+    rev: v0.11.7
+    hooks:
+      - id: ruff
+      # Run the Ruff formatter.
+      - id: ruff-format
+        args: [--check]
+
+  - repo: https://github.com/astral-sh/uv-pre-commit
+    # uv version.
+    rev: 0.7.7
+    hooks:
+      - id: uv-lock
diff --git a/src/.vscode/settings.json b/.vscode/settings.json
similarity index 100%
rename from src/.vscode/settings.json
rename to .vscode/settings.json
diff --git a/CMakeLists.txt b/CMakeLists.txt
new file mode 100644
index 0000000..07c78cd
--- /dev/null
+++ b/CMakeLists.txt
@@ -0,0 +1,104 @@
+cmake_minimum_required(VERSION 3.28...4.2.1)
+
+if(SKBUILD)
+  # this value doesn't really matter, as it will be set by scikit-build-core
+  set(PROJECT_VERSION "0.1.0")
+else()
+  include(FetchContent)
+  FetchContent_Declare(
+    CMakeExtraUtils
+    QUIET
+    URL
+      https://github.com/LecrisUT/CMakeExtraUtils/archive/refs/tags/v0.4.1.tar.gz
+      SOURCE_DIR
+      ${CMAKE_CURRENT_BINARY_DIR}/external/upstream/_srcs/CMakeExtraUtils
+  )
+  FetchContent_MakeAvailable(CMakeExtraUtils)
+
+  include(DynamicVersion)
+  dynamic_version(PROJECT_PREFIX pauliengine_)
+endif()
+
+project(pauliengine LANGUAGES CXX VERSION ${PROJECT_VERSION})
+
+# if CMAKE_BUILD_TYPE undefined, we set it to Release
+if(NOT CMAKE_BUILD_TYPE)
+  set(CMAKE_BUILD_TYPE "Release")
+endif()
+
+
+# Options handling utilities Macro for printing an option in a consistent manner
+# Written by Lori A. Burns (@loriab) and Ryan M. Richard (@ryanmrichard) Syntax:
+# print_option(<option to print> <was specified>)
+macro(print_option variable default)
+  if(NOT DEFINED ${variable} OR "${${variable}}" STREQUAL "")
+    message(STATUS "Setting (unspecified) option ${variable}: ${default}")
+  else()
+    message(STATUS "Setting option ${variable}: ${${variable}}")
+  endif()
+endmacro()
+
+# Wraps an option with default ON/OFF. Adds nice messaging to option() Written
+# by Lori A. Burns (@loriab) and Ryan M. Richard (@ryanmrichard) Syntax:
+# option_with_print(<option name> <description> <default value>)
+macro(option_with_print variable msge default)
+  print_option(${variable} ${default})
+  option(${variable} ${msge} ${default})
+endmacro()
+
+# Wraps an option with a default other than ON/OFF and prints it Written by Lori
+# A. Burns (@loriab) and Ryan M. Richard (@ryanmrichard) NOTE: Can't combine
+# with above b/c CMake handles ON/OFF options specially NOTE2: CMake variables
+# are always defined so need to further check for if they are the NULL string.
+# This is also why we need the force Syntax: option_with_default(<option name>
+# <description> <default value>)
+macro(option_with_default variable msge default)
+  print_option(${variable} "${default}")
+  if(NOT DEFINED ${variable} OR "${${variable}}" STREQUAL "")
+    set(${variable} "${default}" CACHE STRING ${msge} FORCE)
+  endif()
+endmacro()
+
+set(CMAKE_CXX_STANDARD 20 CACHE STRING "C++ standard")
+set(CMAKE_CXX_STANDARD_REQUIRED ON CACHE BOOL "C++ standard required")
+set(CMAKE_CXX_EXTENSIONS OFF CACHE BOOL "C++ extensions")
+
+include(${PROJECT_SOURCE_DIR}/cmake/compiler_flags/CXXFlags.cmake)
+
+message(STATUS "${PROJECT_NAME} version: ${PROJECT_VERSION_FULL}")
+
+# report on compiler flags in use
+message(STATUS "Configuring a ${CMAKE_BUILD_TYPE} build")
+string(TOUPPER ${CMAKE_BUILD_TYPE} _cmake_build_type_upper)
+
+message(STATUS "Compiler flags for ${CMAKE_CXX_COMPILER_ID}")
+message(STATUS "   From environment       : ${CMAKE_CXX_FLAGS}")
+set(
+  _cmake_build_type_specific_flags
+  "${CMAKE_CXX_FLAGS_${_cmake_build_type_upper}}"
+)
+message(
+  STATUS
+  "   Build-type-specific    : ${_cmake_build_type_specific_flags}"
+)
+message(STATUS "   Vectorization flag     : ${ARCH_FLAG}")
+message(
+  STATUS
+  "   Project defaults       : ${CMAKE_CXX${CMAKE_CXX_STANDARD}_STANDARD_COMPILE_OPTION} ${pauliengine_CXX_FLAGS}"
+)
+message(STATUS "   User-appended          : ${EXTRA_CXXFLAGS}")
+
+include(GNUInstallDirs)
+set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/${CMAKE_INSTALL_BINDIR})
+set(CMAKE_ARCHIVE_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/${CMAKE_INSTALL_LIBDIR})
+
+configure_file(
+  ${PROJECT_SOURCE_DIR}/include/pauliengine/Info.h.in
+  ${PROJECT_BINARY_DIR}/include/pauliengine/Info.h
+)
+
+# Conan Toolchain einbinden (nach: conan install .. --install-folder=build --build=missing)
+include(${CMAKE_BINARY_DIR}/conan_toolchain.cmake OPTIONAL RESULT_VARIABLE _found)
+
+add_subdirectory(src)
+
diff --git a/src/CMakeUserPresets.json b/CMakeUserPresets.json
similarity index 100%
rename from src/CMakeUserPresets.json
rename to CMakeUserPresets.json
diff --git a/cmake/compiler_flags/CXXFlags.cmake b/cmake/compiler_flags/CXXFlags.cmake
new file mode 100644
index 0000000..4cdf72e
--- /dev/null
+++ b/cmake/compiler_flags/CXXFlags.cmake
@@ -0,0 +1,79 @@
+#.rst:
+#
+# Manages C++ compiler flags.
+#
+# There is one user-facing option to enable architecture-specific compiler
+# flags.
+# The complete list of flags is built as:
+#
+#   CMAKE_CXX_FLAGS CMAKE_CXX_FLAGS_<CONFIG> ARCH_FLAG PAULIENGINE_CXX_FLAGS EXTRA_CXXFLAGS
+#
+# where:
+#
+# - ``CMAKE_CXX_FLAGS`` is initialized by the contents of the ``CXXFLAGS``
+#   environment variable when configuring. Default is empty.
+# - ``CMAKE_CXX_FLAGS_<CONFIG>`` are build-type specific compiler flags.
+#   The defaults are compiler-dependent: have a look at the ``GNU.CXX.cmake``,
+#   ``Clang.CXX.cmake``, and ``Intel.CXX.cmake`` files.
+# - ``ARCH_FLAG`` is the architecture-dependent optimization flag, *e.g.*
+#   vectorization. Default is empty.
+# - ``PAULIENGINE_CXX_FLAGS`` are PAULIENGINE-specific flags to be used for all builds.
+#   The defaults are compiler-dependent: have a look at the ``GNU.CXX.cmake``,
+#   ``Clang.CXX.cmake``, and ``Intel.CXX.cmake`` files.
+# - ``EXTRA_CXXFLAGS`` useful if you need to append certain flags to the full
+#   list, *e.g.* to override previous compiler flags without touching the CMake
+#   scripts.  Default is empty.
+#
+# Variables used::
+#
+#   PAULIENGINE_ENABLE_ARCH_FLAGS
+#   EXTRA_CXXFLAGS
+#
+# Variables modified::
+#
+#   CMAKE_CXX_FLAGS
+#
+# Environment variables used::
+#
+#   CXXFLAGS
+
+option_with_print(PAULIENGINE_ENABLE_ARCH_FLAGS "Enable architecture-specific compiler flags" OFF)
+
+# code needs C++20 at least
+set(CMAKE_CXX_STANDARD 20)
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
+# do not use compiler extensions to the C++ standard
+set(CMAKE_CXX_EXTENSIONS FALSE)
+# generate a JSON database of compiler commands (useful for LSP IDEs)
+set(CMAKE_EXPORT_COMPILE_COMMANDS TRUE)
+# position-independent code
+set(CMAKE_POSITION_INDEPENDENT_CODE TRUE)
+# visibility levels
+set(CMAKE_CXX_VISIBILITY_PRESET "hidden")
+set(CMAKE_VISIBILITY_INLINES_HIDDEN TRUE)
+
+set(ARCH_FLAG "")
+if(PAULIENGINE_ENABLE_ARCH_FLAGS AND NOT CMAKE_BUILD_TYPE STREQUAL "Debug")
+  if(CMAKE_CXX_COMPILER_ID MATCHES GNU)
+    set(ARCH_FLAG "-march=native")
+  endif()
+  if(CMAKE_CXX_COMPILER_ID MATCHES Clang)
+    if(WIN32) # use AVX2 on Windows
+      set(ARCH_FLAG "/arch:AVX2")
+    else()
+      set(ARCH_FLAG "-march=native")
+    endif()
+  endif()
+  if(CMAKE_CXX_COMPILER_ID MATCHES MSVC)
+    set(ARCH_FLAG "/arch:AVX2")
+  endif()
+  if(CMAKE_CXX_COMPILER_ID MATCHES Intel)
+    set(ARCH_FLAG "-xHost")
+  endif()
+endif()
+
+set(PAULIENGINE_CXX_FLAGS "")
+include(${CMAKE_CURRENT_LIST_DIR}/GNU.CXX.cmake)
+include(${CMAKE_CURRENT_LIST_DIR}/Intel.CXX.cmake)
+include(${CMAKE_CURRENT_LIST_DIR}/Clang.CXX.cmake)
+include(${CMAKE_CURRENT_LIST_DIR}/MSVC.CXX.cmake)
diff --git a/cmake/compiler_flags/Clang.CXX.cmake b/cmake/compiler_flags/Clang.CXX.cmake
new file mode 100644
index 0000000..c659ca3
--- /dev/null
+++ b/cmake/compiler_flags/Clang.CXX.cmake
@@ -0,0 +1,22 @@
+if(CMAKE_CXX_COMPILER_ID MATCHES Clang)
+  if(WIN32) # clang-cl
+    set(pauliengine_CXX_FLAGS "/W3 /EHsc /bigobj")
+    set(CMAKE_CXX_FLAGS_RELEASE "/O2")
+    set(CMAKE_CXX_FLAGS_RELWITHDEBINFO "/O2")
+    set(CMAKE_CXX_FLAGS_DEBUG "/Od /W4")
+  else()
+    set(
+      pauliengine_CXX_FLAGS
+      "-Wall -Wno-padded -Wno-unknown-pragmas -Woverloaded-virtual -Wwrite-strings -fcolor-diagnostics -Wno-c++98-compat"
+    )
+    set(CMAKE_CXX_FLAGS_RELEASE "-O3 -DNDEBUG")
+    set(
+      CMAKE_CXX_FLAGS_RELWITHDEBINFO
+      "-O3 -g3 -DDEBUG -glldb -fno-limit-debug-info"
+    )
+    set(
+      CMAKE_CXX_FLAGS_DEBUG
+      "-O0 -g3 -DDEBUG -glldb -fno-limit-debug-info -Weffc++ -Wdeprecated -Wdocumentation"
+    )
+  endif()
+endif()
diff --git a/cmake/compiler_flags/GNU.CXX.cmake b/cmake/compiler_flags/GNU.CXX.cmake
new file mode 100644
index 0000000..e847ffd
--- /dev/null
+++ b/cmake/compiler_flags/GNU.CXX.cmake
@@ -0,0 +1,9 @@
+if(CMAKE_CXX_COMPILER_ID MATCHES GNU)
+  set(
+    pauliengine_CXX_FLAGS
+    "-Wall -Wno-unknown-pragmas -Wno-sign-compare -Woverloaded-virtual -Wwrite-strings -Wno-unused -Wextra -Wconversion -Wnon-virtual-dtor -Wcast-align -Wunused-parameter -fdiagnostics-color=always"
+  )
+  set(CMAKE_CXX_FLAGS_RELEASE "-O3 -DNDEBUG")
+  set(CMAKE_CXX_FLAGS_RELWITHDEBINFO "-O3 -g3 -DNDEBUG")
+  set(CMAKE_CXX_FLAGS_DEBUG "-O0 -g3 -DDEBUG")
+endif()
diff --git a/cmake/compiler_flags/Intel.CXX.cmake b/cmake/compiler_flags/Intel.CXX.cmake
new file mode 100644
index 0000000..dc24706
--- /dev/null
+++ b/cmake/compiler_flags/Intel.CXX.cmake
@@ -0,0 +1,6 @@
+if(CMAKE_CXX_COMPILER_ID MATCHES Intel)
+  set(pauliengine_CXX_FLAGS "-Wno-unknown-pragmas -Wall")
+  set(CMAKE_CXX_FLAGS_RELEASE "-O3 -DNDEBUG")
+  set(CMAKE_CXX_FLAGS_RELWITHDEBINFO "-O3 -debug -DNDEBUG")
+  set(CMAKE_CXX_FLAGS_DEBUG "-O0 -debug -DDEBUG")
+endif()
diff --git a/cmake/compiler_flags/MSVC.CXX.cmake b/cmake/compiler_flags/MSVC.CXX.cmake
new file mode 100644
index 0000000..fc658cf
--- /dev/null
+++ b/cmake/compiler_flags/MSVC.CXX.cmake
@@ -0,0 +1,6 @@
+if(CMAKE_CXX_COMPILER_ID MATCHES MSVC)
+  set(pauliengine_CXX_FLAGS "/W3 /EHsc /bigobj")
+  set(CMAKE_CXX_FLAGS_RELEASE "/O2")
+  set(CMAKE_CXX_FLAGS_RELWITHDEBINFO "/O2")
+  set(CMAKE_CXX_FLAGS_DEBUG "/Od /W4")
+endif()
diff --git a/conan_profile b/conan_profile
new file mode 100644
index 0000000..9d4f855
--- /dev/null
+++ b/conan_profile
@@ -0,0 +1,4 @@
+include(default)
+
+[conf]
+tools.cmake.cmaketoolchain:generator=Ninja
diff --git a/src/conanfile.txt b/conanfile.txt
similarity index 100%
rename from src/conanfile.txt
rename to conanfile.txt
diff --git a/include/pauliengine/Info.h.in b/include/pauliengine/Info.h.in
new file mode 100644
index 0000000..261c2ab
--- /dev/null
+++ b/include/pauliengine/Info.h.in
@@ -0,0 +1,29 @@
+#pragma once
+
+#include <map>
+#include <string>
+#include <string_view>
+
+namespace pauliengine {
+static constexpr auto version() noexcept -> std::string_view {
+    return "@PROJECT_VERSION_FULL@";
+}
+
+static constexpr auto git_commit() noexcept -> std::string_view {
+    return "@GIT_COMMIT@";
+}
+
+static constexpr auto build_type() noexcept -> std::string_view {
+    return "@CMAKE_BUILD_TYPE@";
+}
+
+static auto compiler_flags() noexcept -> std::map<std::string, std::string> {
+    return {
+        {"from-environment", "@CMAKE_CXX_FLAGS@"},
+        {"build-type-flags", "@_cmake_build_type_specific_flags@"},
+        {"vectorization", "@ARCH_FLAG@"},
+        {"project-defaults", "@CMAKE_CXX20_STANDARD_COMPILE_OPTION@ @pauliengine_CXX_FLAGS@"},
+        {"user-appended", "@EXTRA_CXXFLAGS@"},
+    };
+}
+} // namespace pauliengine
\ No newline at end of file
diff --git a/src/PauliString.h b/include/pauliengine/PauliString.h
similarity index 85%
rename from src/PauliString.h
rename to include/pauliengine/PauliString.h
index 3ec234c..7bbdeba 100644
--- a/src/PauliString.h
+++ b/include/pauliengine/PauliString.h
@@ -8,7 +8,6 @@
 #include <functional>
 #include <cstdint>
 
-
 #ifdef HAVE_SYMENGINE
 #include <symengine/expression.h>
 #include <symengine/symbol.h>
@@ -29,9 +28,6 @@ inline int popcount(uint64_t x);
 void testSymengine();
 
 
-
-
-
 template<typename Coeff = CoeffType>
 class PauliString {
         public:
@@ -40,17 +36,11 @@ class PauliString {
 
                 std::vector<uint64_t> x;
                 std::vector<uint64_t> y;
-                Coeff coeff;
-                bool is_zero = false;
-                PauliString() {
-                        this->x = {}; 
-                        this->y = {}; 
-                        this->coeff = 0.0;
-                        this->is_zero = true;
-                }
-
+                Coeff coeff{0.0};
+                uint64_t is_zero{true};
+                PauliString() = default;
 
-                PauliString(const std::unordered_map<int, std::string>& data, std::complex<double> coeff) {
+                PauliString(const std::unordered_map<int, std::string>& data, Coeff coeff) {
                         this->coeff = coeff;
                         uint64_t mask;
                         for (const auto& [key, value] : data) {
@@ -72,59 +62,7 @@ class PauliString {
                         }
                 }
 
-                PauliString(const std::unordered_map<int, std::string>& data, std::string coeff) {
-                        this->coeff = coeff;
-                        uint64_t mask;
-                        for (const auto& [key, value] : data) {
-
-
-                                size_t index = key / BITS_IN_INTEGER;
-                                if((index) + 1 > x.size()) {
-                                        size_t difference = index + 1 - x.size();
-                                        for (int i = 0; i < difference; i++) {
-                                                x.push_back(0);
-                                                y.push_back(0);
-                                        }
-                                }
-                                mask = ((uint64_t) 1 <<  key % BITS_IN_INTEGER);
-                                if (value == "X" || value == "Z") {
-                                        this->x[index] |= mask;
-                                } 
-                                if (value == "Y" || value == "Z") {
-                                        this->y[index] |= mask;
-                                }
-                        }
-                }
-
-#ifdef HAVE_SYMENGINE
-                PauliString(const std::unordered_map<int, std::string>& data, Expression coeff) {
-                        this->coeff = coeff;
-                        uint64_t mask;
-                        for (const auto& [key, value] : data) {
-
-                                size_t index = key / BITS_IN_INTEGER;
-                                if((index) + 1 > x.size()) {
-                                        size_t difference = index + 1 - x.size();
-                                        for (int i = 0; i < difference; i++) {
-                                                x.push_back(0);
-                                                y.push_back(0);
-                                        }
-                                }
-                                mask = ((uint64_t) 1 <<  key % BITS_IN_INTEGER);
-                                if (value == "X" || value == "Z") {
-                                        this->x[index] |= mask;
-                                } 
-                                if (value == "Y" || value == "Z") {
-                                        this->y[index] |= mask;
-                                }
-                        }
-                }
-#endif
-
-                PauliString(const std::vector<uint64_t>& x, const std::vector<uint64_t>& y, Coeff coeff) {
-                        this->x = x;
-                        this->y = y;
-                        this->coeff = coeff;
+                PauliString(const std::vector<uint64_t>& x, const std::vector<uint64_t>& y, Coeff coeff) : x{x}, y{y}, coeff{coeff} {
                 }
 
                 PauliString(const std::pair<std::vector<std::pair<char, int>>, Coeff>& input) {
@@ -169,9 +107,28 @@ class PauliString {
                         }
                 }
 
+                PauliString(const std::string &pauli_string, Coeff &coeff){
+                        uint64_t mask;
+                        for (size_t i = 0; i < pauli_string.size(); i++) {
+                                size_t index = i / BITS_IN_INTEGER;
+                                if((index) + 1 > x.size()) {
+                                        size_t difference = index + 1 - x.size();
+                                        for (int i = 0; i < difference; i++) {
+                                                x.push_back(0);
+                                                y.push_back(0);
+                                        }
+                                }
+                                mask = ((uint64_t) 1 <<  i % BITS_IN_INTEGER);
+                                if (pauli_string[i] == 'X' || pauli_string[i] == 'Z') {
+                                        this->x[index] |= mask;
+                                } 
+                                if (pauli_string[i] == 'Y' || pauli_string[i] == 'Z') {
+                                        this->y[index] |= mask;
+                                }
+                        }
+                }
 
-
-                bool operator==(const PauliString& other) const {
+                uint64_t operator==(const PauliString& other) const {
                         return x == other.x && y == other.y;
                 }
 
@@ -239,7 +196,7 @@ class PauliString {
                         return *this;
                 }
 
-                bool is_all_z() {
+                uint64_t is_all_z() {
                         for (size_t i = 0; i < this->x.size(); i++) {
                                 if (this->x[i] != this->y[i]) {
                                         return false;
@@ -256,8 +213,8 @@ class PauliString {
                                 uint64_t y_word = this->y[i];
                                 for (uint64_t j = 0; j < BITS_IN_INTEGER; ++j) {
                                         uint64_t bit = (uint64_t)1 << j;
-                                        bool x_bit = x_word & bit;
-                                        bool y_bit = y_word & bit;
+                                        uint64_t x_bit = x_word & bit;
+                                        uint64_t y_bit = y_word & bit;
                                         if (!x_bit && !y_bit) continue;
                                         uint64_t index = i * BITS_IN_INTEGER + j;
                                         if (x_bit && y_bit) {
@@ -298,8 +255,8 @@ class PauliString {
                         for (size_t i = 0; i < num_qubits; ++i) {
                                 size_t word = i / BITS_IN_INTEGER;
                                 size_t bit = i % BITS_IN_INTEGER;
-                                bool xi = (x[word] >> bit) & 1;
-                                bool yi = (y[word] >> bit) & 1;
+                                uint64_t xi = (x[word] >> bit) & 1;
+                                uint64_t yi = (y[word] >> bit) & 1;
                                 char p;
                                 if (xi && yi)      p = 'Z';
                                 else if (xi)       p = 'X';
@@ -311,22 +268,29 @@ class PauliString {
                         return oss.str();
                 }
 
-                PauliString commutator(PauliString other) {
+                PauliString commutator(const PauliString &other) const{
                         size_t max_length = std::max(this->x.size(), other.x.size());
-                        std::vector<uint64_t> new_x(max_length);
+                        size_t min_length = std::min(this->x.size(), other.x.size());
+                        std::vector<uint64_t> new_x(max_length); 
                         std::vector<uint64_t> new_y(max_length);
                         Coeff coeff_temp = this->coeff * other.coeff;
-                        this->x.resize(max_length);
-                        this->y.resize(max_length);
-                        other.x.resize(max_length);
-                        other.y.resize(max_length);
-                        for (int i = 0; i < max_length; i++) {
+
+                        for (int i = 0; i < min_length; i++) {
                                 new_x[i] = this->x[i] ^ other.x[i];
                                 new_y[i] = this->y[i] ^ other.y[i];
                         }
+
+                        const std::vector<uint64_t>& bigger_x = (this->x.size() >= other.x.size()) ? this->x : other.x;
+                        const std::vector<uint64_t>& bigger_y = (this->y.size() >= other.y.size()) ? this->y : other.y;
+                        
+                        for (size_t i = min_length; i <max_length; i++){
+
+                                new_x[i]= bigger_x[i];
+                                new_y[i]= bigger_y[i];
+                        }
                         int first_fac = 0;
                         int second_fac = 0;
-                        for (int i = 0; i < max_length; i++) {
+                        for (int i = 0; i < min_length; i++) {
                                 first_fac += std::popcount((~this->x[i] & other.x[i] & this->y[i] & other.y[i]) ^ (this->x[i] & ~other.x[i] & ~this->y[i] & other.y[i]) ^ (this->x[i] & other.x[i] & this->y[i] & ~other.y[i]));
                                 second_fac += std::popcount((~this->x[i] & other.x[i] & this->y[i] & ~other.y[i]) ^ (this->x[i] & ~other.x[i] & this->y[i] & other.y[i]) ^ (this->x[i] & other.x[i] & ~this->y[i] & other.y[i]));
                         }
@@ -346,24 +310,11 @@ class PauliString {
                         
                 }
 
-                Coeff get_coeff() {
-                        if constexpr (std::is_same_v<Coeff, std::complex<double>>) {
-                                return this->coeff;
-                        }
-                        #ifdef HAVE_SYMENGINE
-                        else if constexpr (std::is_same_v<Coeff, SymEngine::Expression>) {
+                Coeff get_coeff() const {
                                 return this->coeff;
-                        } 
-                        #endif
-                }
-
-#ifdef HAVE_SYMENGINE
-                void set_coeff(SymEngine::Expression new_coeff) {
-                        this->coeff = new_coeff;
                 }
-#endif
 
-                void set_coeff(std::complex<double> new_coeff) {
+                void set_coeff(Coeff new_coeff) {
                         this->coeff = new_coeff;
                 }
 
@@ -416,8 +367,8 @@ class PauliString {
                         for (int i = 0; i < this->x.size(); i++) {
                                 mask = 1;
                                 for (int j = 0; j < BITS_IN_INTEGER; j++) {
-                                        bool x_bit = (mask & this->x[i]) == mask;
-                                        bool y_bit = (mask & this->y[i]) == mask;
+                                        uint64_t x_bit = (mask & this->x[i]) == mask;
+                                        uint64_t y_bit = (mask & this->y[i]) == mask;
                                         if (x_bit && y_bit) {
                                                 result.push_back({'Z', i * BITS_IN_INTEGER + j});
                                         } else if (x_bit) {
@@ -434,8 +385,8 @@ class PauliString {
                 std::string get_pauli_from_index(int index) {
                         uint64_t position = index / BITS_IN_INTEGER;
                         uint64_t mask = (uint64_t) 1 << (index % BITS_IN_INTEGER);
-                        bool x_bit = (this->x[index] & mask) == mask;
-                        bool y_bit = (this->y[index] & mask) == mask;
+                        uint64_t x_bit = (this->x[index] & mask) == mask;
+                        uint64_t y_bit = (this->y[index] & mask) == mask;
                         if (x_bit && y_bit) {
                                 return "Z";
                         } else if(x_bit) {
@@ -518,10 +469,12 @@ class PauliString {
                                 }
                         }
                 }
+#else
+                static std::complex<double> to_complex(const std::complex<double>& value) {
+                        return value;
+                }
 #endif
 
-                
-
         private:
 #ifdef HAVE_SYMENGINE
                 static set_basic get_free_symbols(const Expression& expr) {
diff --git a/include/pauliengine/QubitHamiltonian.h b/include/pauliengine/QubitHamiltonian.h
new file mode 100644
index 0000000..d99c97b
--- /dev/null
+++ b/include/pauliengine/QubitHamiltonian.h
@@ -0,0 +1,178 @@
+#pragma once
+#include <unordered_map>
+#include <string>
+#include <complex>
+#include <vector>
+
+#include "pauliengine/PauliString.h"
+
+#ifdef HAVE_SYMENGINE
+#include <symengine/expression.h>
+using SymEngine::Expression;
+#else
+#endif
+
+
+
+#define BITS_IN_INTEGER (sizeof(uint64_t) * 8)
+
+
+using Pauli_structure = std::pair<std::complex<double>, std::unordered_map<int, std::string>>;
+#ifdef HAVE_SYMENGINE
+using Pauli_structure_variable = std::pair<SymEngine::Expression, std::unordered_map<int, std::string>>;
+using Hamiltonian_structure_variable = std::vector<Pauli_structure_variable>;
+#endif
+
+using Hamiltonian_structure = std::vector<Pauli_structure>;
+using Matrix2D = std::vector<std::vector<std::complex<double>>>;
+
+const std::complex<double> neg_I(0.0 , -1.0);
+
+
+class QubitHamiltonian{
+    public:
+    std::vector<PauliString<>> data;
+
+    QubitHamiltonian(const std::vector<PauliString<>>& data); 
+    QubitHamiltonian(const Hamiltonian_structure& data);
+    QubitHamiltonian trace_out_qubits(const std::vector<int>& qubits, const std::vector<int>& state);
+    std::string to_string();
+    
+    
+    QubitHamiltonian operator*(std::complex<double> scale) const{
+            QubitHamiltonian to_scale = QubitHamiltonian(this->data);
+            for (auto &entry : to_scale.data) {
+                    entry.coeff *= scale;
+                }
+                return to_scale;
+        }
+        QubitHamiltonian operator*(QubitHamiltonian other) const{
+                std::vector<PauliString<>> data;
+                data.reserve(this->data.size() * other.data.size());
+                for (auto &entry_first : this->data) {
+                        for (auto &entry_second : other.data) {
+                                data.push_back(entry_first * entry_second);                       
+                        }    
+                }
+                // return QubitHamiltonian(data).compact();
+                return QubitHamiltonian(data);
+        }
+        QubitHamiltonian operator+(const QubitHamiltonian& other) {
+                std::vector<PauliString<>> data;
+                QubitHamiltonian first_parsed = QubitHamiltonian(this->data);
+                QubitHamiltonian second_parsed = QubitHamiltonian(other.data);
+                size_t remaining_in_second = second_parsed.data.size();
+                for (auto &entry_first : first_parsed.data) {
+                        //TODO: Multi-Threading
+                        for (auto it = second_parsed.data.begin(); it != second_parsed.data.end(); ) {
+                                if (entry_first == *it) { 
+                                        entry_first.coeff += it->coeff; 
+                                        it = second_parsed.data.erase(it);
+                                        remaining_in_second--;
+                                        continue;
+                                } else {
+                                        ++it;
+                                }
+                        }
+                }
+                data.reserve(first_parsed.data.size() + remaining_in_second);
+                for (PauliString first_data : first_parsed.data) {
+                        data.push_back(first_data);
+                }
+                for (PauliString remaining : second_parsed.data) {
+                        data.push_back(remaining);
+                }
+                return QubitHamiltonian(data);
+        }
+        
+        QubitHamiltonian diff(std::string symbol) const{
+                std::vector<PauliString<>> data;
+                for (const PauliString<>& ps : this->data) {
+                        PauliString<> temp = ps.diff(symbol);
+                        if (temp.is_zero == false) {
+                                data.push_back(temp);
+                        }
+                }
+                return QubitHamiltonian(data);
+    }
+    
+    QubitHamiltonian substitute(const std::unordered_map<std::string, std::complex<double>>& substitution_map) const {
+            std::vector<PauliString<>> temp_data;
+            for (const auto &ps : data) {
+                    temp_data.push_back(ps.substitute(substitution_map));
+                }
+                return QubitHamiltonian(temp_data);
+        }
+        
+        #ifdef HAVE_SYMENGINE
+
+        QubitHamiltonian(const Hamiltonian_structure_variable& data);
+
+        QubitHamiltonian compact();
+
+        Hamiltonian_structure_variable parse_python_format() const{
+                Hamiltonian_structure_variable output;
+            output.reserve(this->data.size()); 
+            for (const auto& entry : this->data) {
+                    std::unordered_map<int, std::string> temp;
+                    temp.reserve(entry.x.size() * BITS_IN_INTEGER); 
+                    for (size_t i = 0; i < entry.x.size(); ++i) {
+                            uint64_t x_word = entry.x[i];
+                            uint64_t y_word = entry.y[i];
+                            for (int j = 0; j < BITS_IN_INTEGER; ++j) {
+                                    uint64_t bit = (uint64_t)1 << j;
+                                    bool x_bit = x_word & bit;
+                                    bool y_bit = y_word & bit;
+                                    if (!x_bit && !y_bit) continue;
+                                    int index = i * BITS_IN_INTEGER + j;
+                                    if (x_bit && y_bit) {
+                                            temp[(int)index] = "Z";
+                                    } else if (x_bit) {
+                                            temp[(int)index] = "X";
+                                    } else {
+                                            temp[(int)index] = "Y";
+                                    }
+                            }
+                    }
+
+                    output.emplace_back(entry.coeff, std::move(temp));
+            }
+            return output;
+    }
+    #else
+    Hamiltonian_structure parse_python_format() const{
+            Hamiltonian_structure output;
+            output.reserve(this->data.size()); 
+            for (const auto& entry : this->data) {
+                    std::unordered_map<int, std::string> temp;
+                    temp.reserve(entry.x.size() * BITS_IN_INTEGER); 
+                    for (size_t i = 0; i < entry.x.size(); ++i) {
+                            uint64_t x_word = entry.x[i];
+                            uint64_t y_word = entry.y[i];
+                            for (int j = 0; j < BITS_IN_INTEGER; ++j) {
+                                    uint64_t bit = (uint64_t)1 << j;
+                                    bool x_bit = x_word & bit;
+                                    bool y_bit = y_word & bit;
+                                    if (!x_bit && !y_bit) continue;
+                                    int index = i * BITS_IN_INTEGER + j;
+                                    if (x_bit && y_bit) {
+                                            temp[(int)index] = "Z";
+                                    } else if (x_bit) {
+                                            temp[(int)index] = "X";
+                                    } else {
+                                            temp[(int)index] = "Y";
+                                    }
+                            }
+                    }
+
+                    output.emplace_back(entry.coeff, std::move(temp));
+            }
+            return output;
+    }
+    #endif
+
+    private:
+    static Matrix2D get_pauli_matrix(const std::string& p);
+    static Matrix2D tensor_product(const Matrix2D& A, const Matrix2D& B);
+    static Matrix2D pauli_string_to_matrix(const std::unordered_map<int, std::string>& pauli_map, int num_qubits);
+};
\ No newline at end of file
diff --git a/pyproject.toml b/pyproject.toml
new file mode 100644
index 0000000..c34f9e7
--- /dev/null
+++ b/pyproject.toml
@@ -0,0 +1,294 @@
+[build-system]
+requires = ["nanobind", "scikit-build-core>=0.11", "setuptools-scm>=8", "conan"]
+build-backend = "scikit_build_core.build"
+
+[project]
+name = "pauliengine"
+
+description = "TDA."
+readme = "README.md"
+requires-python = ">=3.11,<3.14"
+classifiers = [
+  "Development Status :: 3 - Alpha",
+  "Intended Audience :: Science/Research",
+  "Intended Audience :: Developers",
+  "Operating System :: OS Independent",
+  "Programming Language :: Python",
+  "Programming Language :: Python :: 3",
+  "Programming Language :: Python :: 3 :: Only",
+  "Programming Language :: Python :: 3.11",
+  "Programming Language :: Python :: 3.12",
+  "Programming Language :: Python :: 3.13",
+  "Topic :: Scientific/Engineering :: Physics",
+  "Topic :: Scientific/Engineering",
+  "Topic :: Software Development :: Libraries :: Python Modules",
+  "Typing :: Typed",
+]
+dynamic = ["version"]
+dependencies = [
+  "numpy",
+]
+
+[dependency-groups]
+# test = ["pytest>=8.2.2,<9.0", "pytest-datadir"]
+test = ["pytest"]
+dev = ["coverage", "pre-commit>=3", "ruff==0.14.4", { include-group = "test" }]
+interactive = [
+  "ipykernel>=6.25",
+  "matplotlib>=3",
+  "pydot>=1.4",
+  "tqdm>=4.65.0",
+  "pylatexenc",
+]
+# TODO Sphinx+Breathe
+
+
+[tool.uv]
+python-preference = "only-managed"
+keyring-provider = "subprocess"
+cache-keys = [
+  { file = "pyproject.toml" },
+  { file = "include/**/*.h" },
+  { file = "src/**/*.{hpp,cpp}" },
+  { file = "CMakeLists.txt" },
+]
+
+[[tool.uv.index]]
+name = "pypi"
+url = "https://pypi.org/simple"
+
+
+[tool.scikit-build]
+# protect the configuration against future changes in scikit-build-core
+minimum-version = "build-system.requires"
+# setuptools-style build caching in a local directory
+build-dir = "build"
+# build stable ABI wheels for CPython 3.12+
+wheel.py-api = "cp312"
+metadata.version.provider = "scikit_build_core.metadata.setuptools_scm"
+logging.level = "INFO"
+# read CMake version from CMakeLists.txt
+cmake.version = "CMakeLists.txt"
+cmake.build-type = "Release"
+cmake.args = [
+  "-DCMAKE_TOOLCHAIN_FILE=build/conan_toolchain.cmake",
+]
+ninja.make-fallback = false
+sdist.exclude = [
+  ".clang-format",
+  ".clang-tidy",
+  ".copier-answers.yml",
+  ".devcontainer",
+  ".gersemirc",
+  ".github",
+  ".gitignore",
+  ".pre-commit-config.yaml",
+  ".prettierignore",
+  ".vscode",
+  "cspell.json",
+  "sandbox",
+  "tests/cpp",
+]
+sdist.include = ["src/pauliengine/_version.py"]
+build.verbose = true
+
+# Platform-specific build configuration
+[[tool.scikit-build.overrides]]
+if.platform-system = "linux"
+build.tool-args = ["-j8"]
+
+[[tool.scikit-build.overrides]]
+if.platform-system = "darwin"
+build.tool-args = ["-j8"]
+
+[[tool.scikit-build.overrides]]
+if.platform-system = "windows"
+build.tool-args = ["/m:8"]
+
+
+[tool.setuptools_scm]
+write_to = "src/pauliengine/_version.py"
+
+
+[tool.pytest.ini_options]
+minversion = "8.0"
+log_cli = true
+log_cli_level = "INFO"
+log_cli_format = "%(asctime)s [%(levelname)s] %(message)s (%(filename)s:%(lineno)s)"
+log_date_format = "%Y%m%d %H:%M:%S"
+addopts = [
+  "--import-mode=importlib",
+  "-ra",
+  "--showlocals",
+  "--strict-markers",
+  "--strict-config",
+]
+pythonpath = ["."]
+testpaths = ["tests"]
+# required_plugins = ["pytest-datadir"]
+
+[tool.coverage]
+run.source = ["src/pauliengine"]
+relative_files = true
+omit = ["src/pauliengine/_version.py"]
+
+[tool.coverage.report]
+omit = ["src/pauliengine/_version.py"]
+exclude_also = [
+  '\.\.\.',
+  "def __repr__",
+  "if self.debug:",
+  "if settings.DEBUG:",
+  "raise NotImplementedError",
+  "if 0:",
+  "if __name__ == .__main__.:",
+  "class .*\\bProtocol\\):",
+  "@(abc\\.)?abstractmethod",
+  "if (typing\\.)?TYPE_CHECKING:",
+  "@jit\\(",
+  "@njit\\(",
+  '^\s*\.\.\.',
+  "logger =",
+  "logger\\.",
+  "return NotImplemented",
+  "@overload",
+]
+
+
+[tool.ruff]
+# for the default settings, see: https://docs.astral.sh/ruff/configuration/#configuring-ruff
+
+exclude = ["docs", "src/pauliengine/_version.py", "tools/container"]
+
+target-version = "py311"
+
+[tool.ruff.format]
+# enable auto-formatting of code examples in docstrings
+docstring-code-format = true
+
+# set the line length limit used when formatting code snippets in
+# docstrings
+docstring-code-line-length = "dynamic"
+
+[tool.ruff.lint]
+extend-select = [
+  "A",      # flake8-builtins
+  "ANN",    # flake8-annotations
+  "ARG",    # flake8-unused-arguments
+  "BLE",    # flake8-blind-except
+  "C4",     # flake8-comprehensions
+  "C90",    # mccabe
+  "D",      # pydocstyle
+  "E",
+  "W",      # pycodestyle
+  "ERA",    # eradicate
+  "EXE",    # flake8-executable
+  "FBT",    # flake8-boolean-trap
+  "FLY",    # flynt
+  "FURB",   # refurb
+  "G",      # flake8-logging-format
+  "I",      # isort
+  "ICN",    # flake8-import-conventions
+  "INP",    # flake8-no-pep420
+  "ISC003", # flake8-implicit-str-concat: explicit-string-concatenation (other rules conflict with the formatter)
+  "N",      # pep8-naming
+  "NPY",    # NumPy-specific rules
+  "PERF",   # perflint
+  "PIE",    # flake8-pie
+  "PLC",    # pylint convention
+  "PLE",    # pylint error
+  "PLR",    # pylint refactor
+  "PLW",    # pylint warning
+  "PT",     # flake8-pytest-style
+  "PTH",    # flake8-use-pathlib
+  "PYI",    # flake8-pyi
+  "RET",    # flake8-return
+  "RSE",    # flake8-raise
+  "RUF",    # Ruff-specific rules
+  "S",      # flake8-bandit
+  "SIM",    # flake8-simplify
+  "SLOT",   # flake8-slot
+  "T20",    # flake8-print
+  "TCH",    # flake8-type-checking
+  "TID",    # flake8-tidy-imports
+  "UP",     # pyupgrade
+  "YTT",    # flake8-2020
+  "TRY",    # tryceratops
+]
+
+ignore = [
+  "D206",    # indent-with-spaces: enforced by the formatter
+  "E111",    # indentation-with-invalid-multiple: enforced by the formatter
+  "E114",    # indentation-with-invalid-multiple-ment: enforced by the formatter
+  "E117",    # over-indented: enforced by the formatter
+  "N803",    # pep8-naming: "argument name should be lowercase"
+  "N806",    # pep8-naming: "variable in function should be lowercase"
+  "PLR0913", # pylint refactor: "too many arguments to function call"
+  "PLR0915", # pylint refactor: "too many statements"
+  "PLR2004", # pylint refactor: "magic value used in comparison"
+  "TRY003",  # tryceratops: "Avoid specifying long messages outside the exception class"
+  "W191",    # tab-indentation: enforced by the formatter
+]
+
+# do not attempt autofix with `--fix` for the following rules
+unfixable = [
+  "ERA",  # removes commented-out code
+  "F401", # removes unused imports
+  "F841", # removes unused variables
+  "T20",  # removes print statements
+]
+
+# allow unused variadic arguments, like *args and **kwargs.
+flake8-unused-arguments.ignore-variadic-names = true
+flake8-annotations.allow-star-arg-any = true
+
+[tool.ruff.lint.per-file-ignores]
+# ignore for contents of `tests`:
+# - S101 (flake8-bandit `AssertUsed`),
+# - D (pydocstyle)
+# - C901 (mccabe)
+# - INP001 (flake8-no-pep420)
+# - E721 (type-comparison)
+"tests/*" = ["S101", "D", "C901", "INP001", "E721"]
+# ignore for all `test_*.py` files
+# - ANN (flake8-annotations)
+# - I002 (isort required import)
+"tests/**/test_*.py" = ["ANN", "I002"]
+# ignore I002 (isort required import) for all `__init__.py` files
+"src/pauliengine/**/__init__.py" = ["I002"]
+
+[tool.ruff.lint.pycodestyle]
+# maximum line length to allow for line-length violations within documentation,
+# including standalone comments
+max-doc-length = 140
+max-line-length = 120
+
+[tool.ruff.lint.pydocstyle]
+convention = "google"
+
+[tool.ruff.lint.isort]
+required-imports = ["from __future__ import annotations"]
+
+
+[tool.pyright]
+pythonVersion = "3.11"
+
+include = ["src/pauliengine/**/*.py"]
+
+exclude = ["test_*.py", "docs/**", "**/__pycache__", "tools/container/**"]
+
+typeCheckingMode = "basic"
+useLibraryCodeForTypes = true
+
+reportGeneralTypeIssues = "information"
+reportMissingImports = true
+reportMissingTypeStubs = "warning"
+reportImportCycles = "information"
+reportPrivateUsage = "information"
+reportPrivateImportUsage = "information"
+reportUnnecessaryIsInstance = "information"
+reportUnnecessaryCast = "information"
+reportUnnecessaryComparison = "information"
+reportUnnecessaryContains = "information"
+reportUnnecessaryTypeIgnoreComment = "information"
+reportMatchNotExhaustive = "information"
\ No newline at end of file
diff --git a/src/.vs/CMake Overview b/src/.vs/CMake Overview
deleted file mode 100644
index e69de29..0000000
diff --git a/src/.vs/Modul/FileContentIndex/56ca19f5-7ec7-4164-887a-f5708baad850.vsidx b/src/.vs/Modul/FileContentIndex/56ca19f5-7ec7-4164-887a-f5708baad850.vsidx
deleted file mode 100644
index 631362e..0000000
Binary files a/src/.vs/Modul/FileContentIndex/56ca19f5-7ec7-4164-887a-f5708baad850.vsidx and /dev/null differ
diff --git a/src/.vs/Modul/FileContentIndex/8939f018-00c0-4566-b8c4-5c2231b3b9d4.vsidx b/src/.vs/Modul/FileContentIndex/8939f018-00c0-4566-b8c4-5c2231b3b9d4.vsidx
deleted file mode 100644
index f49c247..0000000
Binary files a/src/.vs/Modul/FileContentIndex/8939f018-00c0-4566-b8c4-5c2231b3b9d4.vsidx and /dev/null differ
diff --git a/src/.vs/Modul/FileContentIndex/cda6efeb-eccc-4afd-9506-518abeb485e9.vsidx b/src/.vs/Modul/FileContentIndex/cda6efeb-eccc-4afd-9506-518abeb485e9.vsidx
deleted file mode 100644
index 41cac44..0000000
Binary files a/src/.vs/Modul/FileContentIndex/cda6efeb-eccc-4afd-9506-518abeb485e9.vsidx and /dev/null differ
diff --git a/src/.vs/Modul/v17/.wsuo b/src/.vs/Modul/v17/.wsuo
deleted file mode 100644
index ad57639..0000000
Binary files a/src/.vs/Modul/v17/.wsuo and /dev/null differ
diff --git a/src/.vs/Modul/v17/Browse.VC.db b/src/.vs/Modul/v17/Browse.VC.db
deleted file mode 100644
index b021880..0000000
Binary files a/src/.vs/Modul/v17/Browse.VC.db and /dev/null differ
diff --git a/src/.vs/Modul/v17/DocumentLayout.json b/src/.vs/Modul/v17/DocumentLayout.json
deleted file mode 100644
index 2140181..0000000
--- a/src/.vs/Modul/v17/DocumentLayout.json
+++ /dev/null
@@ -1,37 +0,0 @@
-{
-  "Version": 1,
-  "WorkspaceRootPath": "C:\\Users\\demps\\OneDrive\\Desktop\\Code\\Pauli_Arithmetic\\Modul\\",
-  "Documents": [
-    {
-      "AbsoluteMoniker": "D:0:0:{A2FE74E1-B743-11D0-AE1A-00A0C90FFFC3}|\u003CMiscFiles\u003E|CMake-\u00DCbersichtsseiten||{B1CAA5B0-FEB1-4350-8AB9-F895876842F2}"
-    }
-  ],
-  "DocumentGroupContainers": [
-    {
-      "Orientation": 0,
-      "VerticalTabListWidth": 256,
-      "DocumentGroups": [
-        {
-          "DockedWidth": 200,
-          "SelectedChildIndex": 0,
-          "Children": [
-            {
-              "$type": "Document",
-              "DocumentIndex": 0,
-              "Title": "CMake-\u00DCbersichtsseiten",
-              "DocumentMoniker": "CMake-\u00DCbersichtsseiten",
-              "ToolTip": "CMake-\u00DCbersichtsseiten",
-              "Icon": "ae27a6b0-e345-4288-96df-5eaf394ee369.001001|",
-              "WhenOpened": "2025-07-07T00:07:05.417Z",
-              "EditorCaption": ""
-            },
-            {
-              "$type": "Bookmark",
-              "Name": "ST:0:0:{cce594b6-0c39-4442-ba28-10c64ac7e89f}"
-            }
-          ]
-        }
-      ]
-    }
-  ]
-}
\ No newline at end of file
diff --git a/src/.vs/ProjectSettings.json b/src/.vs/ProjectSettings.json
deleted file mode 100644
index 404f913..0000000
--- a/src/.vs/ProjectSettings.json
+++ /dev/null
@@ -1,3 +0,0 @@
-{
-  "CurrentProjectSetting": "conan-release"
-}
\ No newline at end of file
diff --git a/src/.vs/VSWorkspaceState.json b/src/.vs/VSWorkspaceState.json
deleted file mode 100644
index c81bb70..0000000
--- a/src/.vs/VSWorkspaceState.json
+++ /dev/null
@@ -1,11 +0,0 @@
-{
-  "OutputFoldersPerTargetSystem": {
-    "Local Machine": [
-      "build"
-    ]
-  },
-  "ExpandedNodes": [
-    ""
-  ],
-  "PreviewInSolutionExplorer": false
-}
\ No newline at end of file
diff --git a/src/.vs/slnx.sqlite b/src/.vs/slnx.sqlite
deleted file mode 100644
index 1542bb7..0000000
Binary files a/src/.vs/slnx.sqlite and /dev/null differ
diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt
index d9a74e1..9b1b2d6 100644
--- a/src/CMakeLists.txt
+++ b/src/CMakeLists.txt
@@ -1,47 +1,54 @@
-cmake_minimum_required(VERSION 3.15...3.27)
-cmake_policy(SET CMP0091 NEW)
-
-project(PauliEngine LANGUAGES CXX)
-
-# Standardkonfiguration
-set(CMAKE_CXX_STANDARD 20)
-set(CMAKE_POSITION_INDEPENDENT_CODE ON)
-
-if (CMAKE_VERSION VERSION_LESS 3.18)
-    set(DEV_MODULE Development)
-else()
-    set(DEV_MODULE Development.Module)
+# transform pauliengine_CXX_FLAGS and EXTRA_CXXFLAGS to ;-separated lists
+message(STATUS "pauliengine_CXX_FLAGS : ${pauliengine_CXX_FLAGS}")
+if(DEFINED pauliengine_CXX_FLAGS)
+  string(REPLACE " " ";" pauliengine_CXX_FLAGS ${pauliengine_CXX_FLAGS})
 endif()
-
-if (NOT CMAKE_BUILD_TYPE AND NOT CMAKE_CONFIGURATION_TYPES)
-    set(CMAKE_BUILD_TYPE Release CACHE STRING "Choose the type of build." FORCE)
-    set_property(CACHE CMAKE_BUILD_TYPE PROPERTY STRINGS "Debug" "Release" "MinSizeRel" "RelWithDebInfo")
+if(DEFINED EXTRA_CXXFLAGS)
+  string(REPLACE " " ";" EXTRA_CXXFLAGS ${EXTRA_CXXFLAGS})
 endif()
 
-# Conan Toolchain einbinden (nach: conan install .. --install-folder=build --build=missing)
-include(${CMAKE_BINARY_DIR}/conan_toolchain.cmake OPTIONAL RESULT_VARIABLE _found)
-
-# Python & SymEngine
-find_package(Python REQUIRED COMPONENTS Interpreter Development.Module)
-find_package(SymEngine REQUIRED CONFIG)
-
-# Nanobind einbinden
-add_subdirectory(nanobind)
+# create object library for core pauliengine functionality
+add_library(
+  pauliengine-objs 
+  OBJECT
+  QubitHamiltonian.cpp)
+
+# target_include_directories(pauliengine-objs INTERFACE ${CMAKE_CURRENT_SOURCE_DIR}/include)
+target_include_directories(
+  pauliengine-objs
+  PUBLIC
+    $<BUILD_INTERFACE:${PROJECT_SOURCE_DIR}/include>
+    $<BUILD_INTERFACE:${PROJECT_BINARY_DIR}/include>
+)
 
-# Header-only Bibliothek definieren
-add_library(pauli_string INTERFACE)
-target_include_directories(pauli_string INTERFACE ${CMAKE_CURRENT_SOURCE_DIR}/include)
+# find_package(SymEngine REQUIRED CONFIG) 
+find_package(SymEngine CONFIG) 
 
 if (SymEngine_FOUND)
-    target_compile_definitions(pauli_string INTERFACE HAVE_SYMENGINE)
-    target_link_libraries(pauli_string INTERFACE symengine)
+    target_compile_definitions(pauliengine-objs PUBLIC HAVE_SYMENGINE)
+    # target_link_libraries(pauliengine-objs PUBLIC symengine gmp)
+    target_link_libraries(pauliengine-objs PUBLIC symengine)
 endif()
-
-# Python-Modul erstellen
-nanobind_add_module(PauliEngine 
-    QubitHamiltonian.cpp 
+    
+# flags to prepend
+target_compile_options(
+  pauliengine-objs
+  BEFORE
+  PUBLIC
+    "${pauliengine_CXX_FLAGS}"
+    "${ARCH_FLAG}"
 )
 
-target_link_libraries(PauliEngine PRIVATE 
-    pauli_string
-)
+# flags to append
+target_compile_options(pauliengine-objs PUBLIC "${EXTRA_CXXFLAGS}")
+
+if(DEFINED SKBUILD)
+  add_subdirectory(bindings)
+# else()
+  # if you want to compile some local C++ executable for testing
+  # if (SymEngine_FOUND)
+      # add_executable(example.x example.cpp)
+      # target_compile_definitions(example.x PUBLIC HAVE_SYMENGINE)
+  # endif()
+endif()
+
diff --git a/src/QubitHamiltonian.cpp b/src/QubitHamiltonian.cpp
index af4144b..7aad1bc 100644
--- a/src/QubitHamiltonian.cpp
+++ b/src/QubitHamiltonian.cpp
@@ -1,287 +1,101 @@
-#include "QubitHamiltonian.h"
-#include "PauliString.h"
+#include "pauliengine/QubitHamiltonian.h"
 
-class QubitHamiltonian {
 
-        public:
+QubitHamiltonian::QubitHamiltonian(const std::vector<PauliString<>>& data) {
+            this->data = data;
+    }
 
-                std::vector<PauliString<>> data;
-
-                QubitHamiltonian(const std::vector<PauliString<>>& data) {
-                        this->data = data;
-                }
-
-                QubitHamiltonian(const Hamiltonian_structure& data) {
+QubitHamiltonian::QubitHamiltonian(const Hamiltonian_structure& data) {
                         std::vector<PauliString<>> converted_data;
                         converted_data.reserve(data.size());
                         for (Pauli_structure entry : data) {
                                 converted_data.push_back(PauliString<>(entry.second, entry.first));
                         }
                         this->data = converted_data;
-                }
-
-                QubitHamiltonian(const Hamiltonian_structure_variable& data) {
-                        std::vector<PauliString<>> converted_data;
-                        converted_data.reserve(data.size());
-                        for (Pauli_structure_variable entry : data) {
-                                converted_data.push_back(PauliString<>(entry.second, entry.first));
-                        }
-                        this->data = converted_data;
-                }
-
-                QubitHamiltonian operator+(const QubitHamiltonian& other) {
-                        std::vector<PauliString<>> data;
-                        QubitHamiltonian first_parsed = QubitHamiltonian(this->data);
-                        QubitHamiltonian second_parsed = QubitHamiltonian(other.data);
-                        size_t remaining_in_second = second_parsed.data.size();
-                        for (auto &entry_first : first_parsed.data) {
-                                //TODO: Multi-Threading
-                                for (auto it = second_parsed.data.begin(); it != second_parsed.data.end(); ) {
-                                        if (entry_first == *it) { 
-                                            entry_first.coeff += it->coeff; 
-                                            it = second_parsed.data.erase(it);
-                                            remaining_in_second--;
-                                            continue;
-                                        } else {
-                                            ++it;
-                                        }
-                                }
-                        }
-                        data.reserve(first_parsed.data.size() + remaining_in_second);
-                        for (PauliString first_data : first_parsed.data) {
-                                data.push_back(first_data);
-                        }
-                        for (PauliString remaining : second_parsed.data) {
-                                data.push_back(remaining);
-                        }
-                        return QubitHamiltonian(data);
-                }
-
-                QubitHamiltonian operator*(std::complex<double> scale) const{
-                        QubitHamiltonian to_scale = QubitHamiltonian(this->data);
-                        for (auto &entry : to_scale.data) {
-                                entry.coeff *= scale;
-                        }
-                        return to_scale;
-                }
-
-                QubitHamiltonian operator*(QubitHamiltonian other) const{
-                        std::vector<PauliString<>> data;
-                        data.reserve(this->data.size() * other.data.size());
-                        for (auto &entry_first : this->data) {
-                                for (auto &entry_second : other.data) {
-                                        data.push_back(entry_first * entry_second);                       
-                                }    
-                        }
-                        return QubitHamiltonian(data).compact();
-                }
-
-                QubitHamiltonian trace_out_qubits(const std::vector<int>& qubits, const std::vector<int>& state) {
-                        std::vector<PauliString<>> reduced(this->data.size());
-                        for (PauliString<>& current : this-> data) {
-                                PauliString traced_out_string = current.trace_out_qubits(qubits, state);
-                                if (traced_out_string.coeff != 0.0) {
-                                        reduced.push_back(traced_out_string);
-                                }
-                        }
-                        return QubitHamiltonian(reduced);
-                }
-
-                #ifdef HAVE_SYMENGINE
-                Hamiltonian_structure_variable parse_python_format() const{
-                        Hamiltonian_structure_variable output;
-                        output.reserve(this->data.size()); 
-                        for (const auto& entry : this->data) {
-                                std::unordered_map<int, std::string> temp;
-                                temp.reserve(entry.x.size() * BITS_IN_INTEGER); 
-                                for (size_t i = 0; i < entry.x.size(); ++i) {
-                                        uint64_t x_word = entry.x[i];
-                                        uint64_t y_word = entry.y[i];
-                                        for (int j = 0; j < BITS_IN_INTEGER; ++j) {
-                                                uint64_t bit = (uint64_t)1 << j;
-                                                bool x_bit = x_word & bit;
-                                                bool y_bit = y_word & bit;
-                                                if (!x_bit && !y_bit) continue;
-                                                int index = i * BITS_IN_INTEGER + j;
-                                                if (x_bit && y_bit) {
-                                                        temp[(int)index] = "Z";
-                                                } else if (x_bit) {
-                                                        temp[(int)index] = "X";
-                                                } else {
-                                                        temp[(int)index] = "Y";
-                                                }
-                                        }
-                                }
-
-                                output.emplace_back(entry.coeff, std::move(temp));
-                        }
-                        return output;
-                }
-                #else
-                Hamiltonian_structure parse_python_format() const{
-                        Hamiltonian_structure output;
-                        output.reserve(this->data.size()); 
-                        for (const auto& entry : this->data) {
-                                std::unordered_map<int, std::string> temp;
-                                temp.reserve(entry.x.size() * BITS_IN_INTEGER); 
-                                for (size_t i = 0; i < entry.x.size(); ++i) {
-                                        uint64_t x_word = entry.x[i];
-                                        uint64_t y_word = entry.y[i];
-                                        for (int j = 0; j < BITS_IN_INTEGER; ++j) {
-                                                uint64_t bit = (uint64_t)1 << j;
-                                                bool x_bit = x_word & bit;
-                                                bool y_bit = y_word & bit;
-                                                if (!x_bit && !y_bit) continue;
-                                                int index = i * BITS_IN_INTEGER + j;
-                                                if (x_bit && y_bit) {
-                                                        temp[(int)index] = "Z";
-                                                } else if (x_bit) {
-                                                        temp[(int)index] = "X";
-                                                } else {
-                                                        temp[(int)index] = "Y";
-                                                }
-                                        }
-                                }
-
-                                output.emplace_back(entry.coeff, std::move(temp));
-                        }
-                        return output;
-                }
-                #endif
-
-                std::string to_string() {
-                        std::string result = "";
-                        for (int i = 0; i < this->data.size(); i++) {
-                                result.append(data[i].to_string() + "\n");
-                        }    
-                        return result;   
-                }
-                QubitHamiltonian diff(std::string symbol) const{
-                        std::vector<PauliString<>> data;
-                        for (const PauliString<>& ps : this->data) {
-                                PauliString<> temp = ps.diff(symbol);
-                                if (temp.is_zero == false) {
-                                        data.push_back(temp);
-                                }
-                        }
-                        return QubitHamiltonian(data);
-                }
-
-                QubitHamiltonian substitute(const std::unordered_map<std::string, std::complex<double>>& substitution_map) const {
-                        std::vector<PauliString<>> temp_data;
-                        for (const auto ps : data) {
-                                temp_data.push_back(ps.substitute(substitution_map));
-                        }
-                        return QubitHamiltonian(temp_data);
-                }
-
-                QubitHamiltonian compact() {
-                        std::unordered_map<PauliString<>, SymEngine::Expression, PauliStringHash> merged;
-                        for (const auto& ps : data) {
-                                merged[ps] = merged[ps] + ps.coeff;
-                        }
-                        data.clear();
-                        for (const auto& [ps, coeff] : merged) {
-                                PauliString<> new_ps = ps;
-                                new_ps.coeff = coeff;
-                                data.push_back(new_ps);
-                        }
-                        return QubitHamiltonian(data);
-                }
-                
-
-        private:
+                }    
                 
+#ifdef HAVE_SYMENGINE
+QubitHamiltonian::QubitHamiltonian(const Hamiltonian_structure_variable& data) {
+        std::vector<PauliString<>> converted_data;
+        converted_data.reserve(data.size());
+        for (Pauli_structure_variable entry : data) {
+                converted_data.push_back(PauliString<>(entry.second, entry.first));
+        }
+        this->data = converted_data;
+}
+
+QubitHamiltonian QubitHamiltonian::compact() {
+        std::unordered_map<PauliString<>, SymEngine::Expression, PauliStringHash> merged;
+        for (const auto& ps : data) {
+                merged[ps] = merged[ps] + ps.coeff;
+        }
+        data.clear();
+        for (const auto& [ps, coeff] : merged) {
+                PauliString<> new_ps = ps;
+                new_ps.coeff = coeff;
+                data.push_back(new_ps);
+        }
+        return QubitHamiltonian(data);
+}
+#endif
+
+
+QubitHamiltonian QubitHamiltonian::trace_out_qubits(const std::vector<int>& qubits, const std::vector<int>& state) {
+        std::vector<PauliString<>> reduced(this->data.size());
+        for (PauliString<>& current : this-> data) {
+                PauliString traced_out_string = current.trace_out_qubits(qubits, state);
+                if (traced_out_string.coeff != 0.0) {
+                        reduced.push_back(traced_out_string);
+                }
+        }
+        return QubitHamiltonian(reduced);
+}
+
+
+std::string QubitHamiltonian::to_string() {
+        std::string result = "";
+        for (int i = 0; i < this->data.size(); i++) {
+                result.append(data[i].to_string() + "\n");
+        }    
+        return result;   
+}
+               
                 
-
-                static Matrix2D get_pauli_matrix(const std::string& p) {
-                        static const std::complex<double> I(0,1);
-                        if (p == "I") return {{1,0},{0,1}};
-                        else if (p == "X") return {{0,1},{1,0}};
-                        else if (p == "Y") return {{0,-I},{I,0}};
-                        else if (p == "Z") return {{1,0},{0,-1}};
-                        else throw std::runtime_error("Unbekannter Pauli-Operator");
-                }
-
-                static Matrix2D tensor_product(const Matrix2D& A, const Matrix2D& B) {
-                        int rows = A.size() * B.size();
-                        int cols = A[0].size() * B[0].size();
-                        Matrix2D result(rows, std::vector<std::complex<double>>(cols, 0));
-
-                        for (int i=0; i<(int)A.size(); ++i) {
-                                for (int j=0; j<(int)A[0].size(); ++j) {
-                                        for (int k=0; k<(int)B.size(); ++k) {
-                                                for (int l=0; l<(int)B[0].size(); ++l) {
-                                                        result[i*B.size()+k][j*B[0].size()+l] = A[i][j] * B[k][l];
-                                                }
-                                        }
+Matrix2D QubitHamiltonian::get_pauli_matrix(const std::string& p){static const std::complex<double> I(0,1);
+        if (p == "I") return {{1,0},{0,1}};
+        else if (p == "X") return {{0,1},{1,0}};
+        else if (p == "Y") return {{0,-I},{I,0}};
+        else if (p == "Z") return {{1,0},{0,-1}};
+        else throw std::runtime_error("Unbekannter Pauli-Operator");
+}
+
+
+Matrix2D QubitHamiltonian::tensor_product(const Matrix2D& A, const Matrix2D& B)
+{
+        int rows = A.size() * B.size();
+        int cols = A[0].size() * B[0].size();
+        Matrix2D result(rows, std::vector<std::complex<double>>(cols, 0));
+
+        for (int i=0; i<(int)A.size(); ++i) {
+                for (int j=0; j<(int)A[0].size(); ++j) {
+                        for (int k=0; k<(int)B.size(); ++k) {
+                                for (int l=0; l<(int)B[0].size(); ++l) {
+                                        result[i*B.size()+k][j*B[0].size()+l] = A[i][j] * B[k][l];
                                 }
                         }
-                        return result;
                 }
-
-                static Matrix2D pauli_string_to_matrix(const std::unordered_map<int, std::string>& pauli_map, int num_qubits) {
-                        Matrix2D result = get_pauli_matrix("I");
-                        for (int q=0; q < num_qubits; ++q) {
-                                std::string op = "I";
-                                auto it = pauli_map.find(q);
-                                if (it != pauli_map.end()) op = it->second;
-                                Matrix2D pmat = get_pauli_matrix(op);
-                                result = tensor_product(result, pmat);
-                        }
-                        return result;
-                }
-
-};
-
-NB_MODULE(PauliEngine, m) {
-        nb::class_<PauliString<>>(m, "PauliString", "Represents a Pauli string in binary symplectic form.")
-                .def(nb::init<>(), "Default constructor.")
-                .def(nb::init<const std::unordered_map<int, std::string>&, std::complex<double>>(),
-                "Constructor from a map of qubit indices to Pauli operators and a complex coefficient.")
-                .def(nb::init<const std::unordered_map<int, std::string>&, std::string>(),
-                "Constructor from a map of qubit indices to Pauli operators and a complex coefficient.")
-                .def("to_string", &PauliString<>::to_string, "Returns a human-readable string representation of the Pauli string.")
-                .def("is_all_z", &PauliString<>::is_all_z, "Checks if the Pauli string consists only of Z operators.")
-                .def("get_coeff", &PauliString<>::get_coeff, "Returns the complex coefficient of the Pauli string.")
-                .def("to_dictionary", &PauliString<>::to_dictionary, "Converts the Pauli string to a dictionary with coefficient and operators.")
-                .def("commutator", &PauliString<>::commutator, "Computes the commutator with another Pauli string.")
-                .def("map_qubits", &PauliString<>::map_qubits, "Remaps qubit indices according to a given mapping.")
-                .def("diff", &PauliString<>::diff, "Differentiation after given Variable")
-                .def("__mul__", nb::overload_cast<const PauliString<>&>(&PauliString<>::operator*, nb::const_), "Multiply two PauliStrings")
-                .def("__mul__", nb::overload_cast<const std::complex<double>>(&PauliString<>::operator*), "Scale PauliString by complex scalar")
-                .def("__imul__", nb::overload_cast<const std::complex<double>>(&PauliString<>::operator*=), "In-place scale")
-                .def("__imul__", nb::overload_cast<const PauliString<>&>(&PauliString<>::operator*=),"In-place multiply")
-                .def("__repr__",  &PauliString<>::to_string, "Returns a human-readable string representation of the Pauli string.")
-                .def("__str__",  &PauliString<>::to_string, "Returns a human-readable string representation of the Pauli string.")
-                .def("__eq__", &PauliString<>::equals, "Checks if 2 PauliStrings have same data and Coefficient")
-                .def("diff", &PauliString<>::key_openfermion, "Returns Paulistring in Openfermion format")
-                .def("qubits", &PauliString<>::qubits, "Returns list of qubits")
-                .def("equals", &PauliString<>::operator==, "Checks if 2 PauliStrings have same data")
-                .def("set_coeff", nb::overload_cast<SymEngine::Expression>(&PauliString<>::set_coeff), "Sets coefficient using a SymEngine expression")
-                .def("set_coeff", nb::overload_cast<std::complex<double>>(&PauliString<>::set_coeff), "Sets coefficient using a complex number")
-                .def_static("to_complex", &PauliString<>::to_complex, "Parse SymEngine expression into complex number")
-                .def("copy", &PauliString<>::copy, "Create a copy of the PauliString")
-                .def("get_pauli_at_index", &PauliString<>::get_pauli_from_index, "Returns list of qubits");
-
-        nb::class_<QubitHamiltonian>(m, "QubitHamiltonian", "Represents a Hamiltonian as a sum of Pauli strings.")
-                .def(nb::init<const std::vector<PauliString<>>&>(), "Constructor from a vector of Pauli strings.")
-                .def(nb::init<const Hamiltonian_structure&>(), "Constructor from a Hamiltonian structure (coefficient and operator map).")
-                .def(nb::init<const Hamiltonian_structure_variable&>(), "Constructor from a Hamiltonian structure (coefficient and operator map).")
-                .def("__add__", &QubitHamiltonian::operator+, "Adds two Hamiltonians.")
-                .def("__mul__", nb::overload_cast<std::complex<double> const>(&QubitHamiltonian::operator*, nb::const_), "Scales the Hamiltonian by a complex scalar.")
-                .def("__mul__", nb::overload_cast<QubitHamiltonian const>(&QubitHamiltonian::operator*, nb::const_), "Multiplies two Hamiltonians.")
-                .def("trace_out_qubits", &QubitHamiltonian::trace_out_qubits, "Traces out specified qubits in given states.")
-                .def("to_string", &QubitHamiltonian::to_string, "Converts the Hamiltonian to its full matrix representation.")
-                .def("diff", &QubitHamiltonian::diff, "Differentiation after given Variable")
-                .def("subs", &QubitHamiltonian::substitute, "Replace Variable with value")
-                .def("parse_python_format", &QubitHamiltonian::parse_python_format, "Konvertiert mit SymEngine-Koeffizienten");
-
-
-
-        nb::class_<SymEngine::Expression>(m, "Expression")
-                .def(nb::init<const std::string&>())  // Konstruktor aus String
-                .def("__str__", [](const SymEngine::Expression &e) {
-                        return SymEngine::str(*e.get_basic());
-                });
+        }
+        return result;
+}
+
+Matrix2D QubitHamiltonian::pauli_string_to_matrix(const std::unordered_map<int, std::string>& pauli_map, int num_qubits){
+        Matrix2D result = get_pauli_matrix("I");
+        for (int q=0; q < num_qubits; ++q) {
+                std::string op = "I";
+                auto it = pauli_map.find(q);
+                if (it != pauli_map.end()) op = it->second;
+                Matrix2D pmat = get_pauli_matrix(op);
+                result = tensor_product(result, pmat);
+        }
+        return result;
 }
\ No newline at end of file
diff --git a/src/QubitHamiltonian.h b/src/QubitHamiltonian.h
deleted file mode 100644
index 5aa5c9e..0000000
--- a/src/QubitHamiltonian.h
+++ /dev/null
@@ -1,37 +0,0 @@
-#pragma once
-
-#include <nanobind/nanobind.h>
-#include <nanobind/stl/complex.h>   
-#include <nanobind/stl/string.h>       
-#include <nanobind/stl/vector.h>       
-#include <nanobind/stl/unordered_map.h>
-#include <nanobind/stl/map.h>
-#include <nanobind/stl/pair.h>
-
-#include <unordered_map>
-#include <string>
-#include <complex>
-#include <vector>
-#include <omp.h>
-
-#ifdef HAVE_SYMENGINE
-#include <symengine/expression.h>
-using SymEngine::Expression;
-#else
-#endif
-
-
-
-#define BITS_IN_INTEGER (sizeof(uint64_t) * 8)
-
-namespace nb = nanobind;
-
-using Pauli_structure = std::pair<std::complex<double>, std::unordered_map<int, std::string>>;
-using Pauli_structure_variable = std::pair<SymEngine::Expression, std::unordered_map<int, std::string>>;
-using Hamiltonian_structure = std::vector<Pauli_structure>;
-using Hamiltonian_structure_variable = std::vector<Pauli_structure_variable>;
-using Matrix2D = std::vector<std::vector<std::complex<double>>>;
-
-const std::complex<double> neg_I(0.0 , -1.0);
-
-
diff --git a/src/bindings/CMakeLists.txt b/src/bindings/CMakeLists.txt
new file mode 100644
index 0000000..731ed0d
--- /dev/null
+++ b/src/bindings/CMakeLists.txt
@@ -0,0 +1,42 @@
+find_package(
+  Python
+  3.11
+  REQUIRED
+  COMPONENTS
+    Interpreter
+    Development.Module
+    ${SKBUILD_SABI_COMPONENT}
+)
+
+find_package(nanobind CONFIG REQUIRED)
+message(STATUS "Using nanobind: ${nanobind_DIR} (version ${nanobind_VERSION})")
+
+nanobind_add_module(_core
+  STABLE_ABI  # Perform a stable ABI build
+  NB_STATIC  # Compile the core nanobind library as a static library
+  LTO  # Perform link time optimization
+  NOMINSIZE  # Don’t perform optimizations to minimize binary size
+  bindings.cpp
+)
+
+target_include_directories(
+  _core
+  PRIVATE
+    ${CMAKE_CURRENT_BINARY_DIR}
+    ${CMAKE_CURRENT_SOURCE_DIR}
+)
+
+target_link_libraries(_core PRIVATE pauliengine-objs)
+
+install(TARGETS _core LIBRARY DESTINATION ${PROJECT_NAME})
+
+# generation of Python typing stubs
+# NOTE must come after installing the _core target
+nanobind_add_stub(_core
+  INSTALL_TIME  # Stub generation postponed to the installation phase.
+  MODULE pauliengine  # Specifies the name of the module that should be imported.
+  OUTPUT "${PROJECT_NAME}/_core.pyi"  # Specifies the name of the stub file that should be written.
+  PYTHON_PATH "${PROJECT_NAME}"  # List of search paths - relative to CMAKE_INSTALL_PREFIX - that should be considered when importing the module.
+  VERBOSE  # Show status messages generated by stubgen.
+  MARKER_FILE "${PROJECT_NAME}/py.typed"  # Automatically generate an empty marker file.~
+)
\ No newline at end of file
diff --git a/src/bindings/bindings.cpp b/src/bindings/bindings.cpp
new file mode 100644
index 0000000..59ad399
--- /dev/null
+++ b/src/bindings/bindings.cpp
@@ -0,0 +1,77 @@
+#include <nanobind/nanobind.h>
+#include <nanobind/stl/complex.h>   
+#include <nanobind/stl/string.h>       
+#include <nanobind/stl/vector.h>       
+#include <nanobind/stl/unordered_map.h>
+#include <nanobind/stl/map.h>
+#include <nanobind/stl/pair.h>
+
+#include "pauliengine/QubitHamiltonian.h"
+#include "pauliengine/Info.h"
+
+namespace nb = nanobind;
+using namespace pauliengine;
+
+
+NB_MODULE(_core, m) {
+
+        m.doc() = "PauliEngine";
+        m.attr("__build_type__") = std::string(build_type());
+        m.attr("__compiler_flags__") = compiler_flags();
+        
+        nb::class_<PauliString<>>(m, "PauliString", "Represents a Pauli string in binary symplectic form.")
+                .def(nb::init<>(), "Default constructor.")
+                .def(nb::init<const std::unordered_map<int, std::string>&, std::complex<double>>(),
+                "Constructor from a map of qubit indices to Pauli operators and a complex coefficient.")
+                .def("to_string", &PauliString<>::to_string, "Returns a human-readable string representation of the Pauli string.")
+                .def("is_all_z", &PauliString<>::is_all_z, "Checks if the Pauli string consists only of Z operators.")
+                .def("get_coeff", &PauliString<>::get_coeff, "Returns the complex coefficient of the Pauli string.")
+                .def("to_dictionary", &PauliString<>::to_dictionary, "Converts the Pauli string to a dictionary with coefficient and operators.")
+                .def("commutator", &PauliString<>::commutator, "Computes the commutator with another Pauli string.")
+                .def("map_qubits", &PauliString<>::map_qubits, "Remaps qubit indices according to a given mapping.")
+                .def("diff", &PauliString<>::diff, "Differentiation after given Variable")
+                .def("__mul__", nb::overload_cast<const PauliString<>&>(&PauliString<>::operator*, nb::const_), "Multiply two PauliStrings")
+                .def("__mul__", nb::overload_cast<const std::complex<double>>(&PauliString<>::operator*), "Scale PauliString by complex scalar")
+                .def("__imul__", nb::overload_cast<const std::complex<double>>(&PauliString<>::operator*=), "In-place scale")
+                .def("__imul__", nb::overload_cast<const PauliString<>&>(&PauliString<>::operator*=), "In-place multiply")
+                .def("__repr__",  &PauliString<>::to_string, "Returns a human-readable string representation of the Pauli string.")
+                .def("__str__",  &PauliString<>::to_string, "Returns a human-readable string representation of the Pauli string.")
+                .def("__eq__", &PauliString<>::equals, "Checks if 2 PauliStrings have same data and Coefficient")
+                .def("diff", &PauliString<>::key_openfermion, "Returns Paulistring in Openfermion format")
+                .def("qubits", &PauliString<>::qubits, "Returns list of qubits")
+                .def("equals", &PauliString<>::operator==, "Checks if 2 PauliStrings have same data")
+                .def("set_coeff", &PauliString<>::set_coeff, "Sets coefficient using a SymEngine expression")
+                .def_static("to_complex", &PauliString<>::to_complex, "Parse SymEngine expression into complex number")
+                .def("copy", &PauliString<>::copy, "Create a copy of the PauliString")
+                .def("get_pauli_at_index", &PauliString<>::get_pauli_from_index, "Returns list of qubits")
+                .def_ro("x", &PauliString<>::x, "Returns the x vector of the Pauli string.")
+                .def_ro("y", &PauliString<>::y, "Returns the y vector of the Pauli string.")
+                .def_ro("coeff", &PauliString<>::coeff, "Returns the coefficient of the Pauli string.")
+                .def_ro("is_zero", &PauliString<>::is_zero, "Returns whether the Pauli string is zero.");
+
+        nb::class_<QubitHamiltonian>(m, "QubitHamiltonian", "Represents a Hamiltonian as a sum of Pauli strings.")
+                .def(nb::init<const std::vector<PauliString<>>&>(), "Constructor from a vector of Pauli strings.")
+                .def(nb::init<const Hamiltonian_structure&>(), "Constructor from a Hamiltonian structure (coefficient and operator map).")
+                #ifdef HAVE_SYMENGINE
+                .def(nb::init<const Hamiltonian_structure_variable&>(), "Constructor from a Hamiltonian structure (coefficient and operator map).")
+                #endif
+                .def("__add__", &QubitHamiltonian::operator+, "Adds two Hamiltonians.")
+                .def("__mul__", nb::overload_cast<std::complex<double> const>(&QubitHamiltonian::operator*, nb::const_), "Scales the Hamiltonian by a complex scalar.")
+                .def("__mul__", nb::overload_cast<QubitHamiltonian const>(&QubitHamiltonian::operator*, nb::const_), "Multiplies two Hamiltonians.")
+                .def("trace_out_qubits", &QubitHamiltonian::trace_out_qubits, "Traces out specified qubits in given states.")
+                .def("to_string", &QubitHamiltonian::to_string, "Converts the Hamiltonian to its full matrix representation.")
+                .def("diff", &QubitHamiltonian::diff, "Differentiation after given Variable")
+                .def("subs", &QubitHamiltonian::substitute, "Replace Variable with value")
+                .def("parse_python_format", &QubitHamiltonian::parse_python_format, "Konvertiert mit SymEngine-Koeffizienten")
+                .def("__str__",&QubitHamiltonian::to_string, "Returns a human-readable string representation of the QubitHamiltonian operator.")
+                .def("__repr__",&QubitHamiltonian::to_string, "Returns a human-readable string representation of the QubitHamiltonian operator.");
+
+
+        #ifdef HAVE_SYMENGINE
+        nb::class_<SymEngine::Expression>(m, "Expression")
+                .def(nb::init<const std::string&>())  // Konstruktor aus String
+                .def("__str__", [](const SymEngine::Expression &e) {
+                        return SymEngine::str(*e.get_basic());
+                });
+        #endif
+}
\ No newline at end of file
diff --git a/src/example.cpp b/src/example.cpp
new file mode 100644
index 0000000..bb7fdcc
--- /dev/null
+++ b/src/example.cpp
@@ -0,0 +1,20 @@
+#include <symengine/constants.h>
+#include <symengine/expression.h>
+#include <symengine/integer.h>
+#include <symengine/mul.h>
+#include <symengine/mp_class.h>
+#include <symengine/parser.h>
+
+#include <string>
+#include <iostream>
+
+int main() {
+  SymEngine::Expression pi_by_12 =
+      SymEngine::div(SymEngine::pi, SymEngine::integer(12));
+  std::cout << pi_by_12 << std::endl;
+  std::cout << SymEngine::mp_perfect_power_p(SymEngine::integer_class("9")) << std::endl;
+  std::string input = "123.0";
+  auto parsed_value = SymEngine::parse(input, true);
+
+  return 0;
+}
\ No newline at end of file
diff --git a/src/nanobind/.gitignore b/src/nanobind/.gitignore
deleted file mode 100644
index bc78714..0000000
--- a/src/nanobind/.gitignore
+++ /dev/null
@@ -1,43 +0,0 @@
-libnanobind-static.a
-libnanobind-static-abi3.a
-libnanobind-static-ft.a
-libnanobind.so
-libnanobind-abi3.so
-libnanobind-ft.so
-libnanobind.dylib
-libnanobind-abi3.dylib
-libnanobind-ft.dylib
-nanobind.dll
-nanobind-abi3.dll
-nanobind-ft.dll
-
-libinter_module.dylib
-libinter_module.so
-inter_module.dll
-
-/.ninja_deps
-/.ninja_log
-/.cache
-/build.ninja
-/build
-/src/nanobind/cmake
-/src/nanobind/include
-/src/nanobind/ext
-/src/nanobind/src
-/dist
-/bench
-compile_commands.json
-
-CMakeFiles
-CMakeCache.txt
-cmake_install.cmake
-nanobind-config-version.cmake
-\.DS_Store
-\.cmake
-__pycache__
-nanobind.egg-info
-test_*_ext*.so
-test_*_ext*.pyd
-test_*.pyi
-py\.typed
-.mypy_cache
diff --git a/src/nanobind/.gitmodules b/src/nanobind/.gitmodules
deleted file mode 100644
index 1aa486e..0000000
--- a/src/nanobind/.gitmodules
+++ /dev/null
@@ -1,3 +0,0 @@
-[submodule "ext/robin_map"]
-	path = ext/robin_map
-	url = https://github.com/Tessil/robin-map
diff --git a/src/nanobind/.readthedocs.yaml b/src/nanobind/.readthedocs.yaml
deleted file mode 100644
index 7947625..0000000
--- a/src/nanobind/.readthedocs.yaml
+++ /dev/null
@@ -1,18 +0,0 @@
-version: 2
-
-build:
-  os: ubuntu-22.04
-  apt_packages:
-    - librsvg2-bin
-  tools:
-    python: "3.11"
-
-sphinx:
-   configuration: docs/conf.py
-
-python:
-   install:
-   - requirements: docs/requirements.txt
-
-formats:
-  - pdf
diff --git a/src/nanobind/CMakeLists.txt b/src/nanobind/CMakeLists.txt
deleted file mode 100644
index 1c1ebdf..0000000
--- a/src/nanobind/CMakeLists.txt
+++ /dev/null
@@ -1,160 +0,0 @@
-cmake_minimum_required(VERSION 3.15...3.27)
-
-# ---------------------------------------------------------------------------
-# Read the project version from nanobind.h
-# ---------------------------------------------------------------------------
-
-file(STRINGS "include/nanobind/nanobind.h" _nanobind_h_version REGEX "^#define NB_VERSION_.*$")
-string(REGEX MATCH "#define NB_VERSION_MAJOR ([0-9]+)" _ "${_nanobind_h_version}")
-set(_major ${CMAKE_MATCH_1})
-string(REGEX MATCH "#define NB_VERSION_MINOR ([0-9]+)" _ "${_nanobind_h_version}")
-set(_minor ${CMAKE_MATCH_1})
-string(REGEX MATCH "#define NB_VERSION_PATCH ([0-9]+)" _ "${_nanobind_h_version}")
-set(_patch ${CMAKE_MATCH_1})
-
-project(nanobind LANGUAGES NONE VERSION "${_major}.${_minor}.${_patch}")
-
-# ---------------------------------------------------------------------------
-# Only build tests by default if this is the top-level CMake project
-# ---------------------------------------------------------------------------
-
-if (CMAKE_PROJECT_NAME STREQUAL PROJECT_NAME)
-  set(NB_MASTER_PROJECT ON)
-else()
-  set(NB_MASTER_PROJECT OFF)
-endif()
-
-option(NB_CREATE_INSTALL_RULES "Create installation rules" ${NB_MASTER_PROJECT})
-option(NB_USE_SUBMODULE_DEPS   "Use the nanobind dependencies shipped as a git submodule of this repository" ON)
-
-option(NB_TEST               "Compile nanobind tests?" ${NB_MASTER_PROJECT})
-option(NB_TEST_STABLE_ABI    "Test the stable ABI interface?" OFF)
-option(NB_TEST_SHARED_BUILD  "Build a shared nanobind library for the test suite?" OFF)
-option(NB_TEST_CUDA          "Force the use of the CUDA/NVCC compiler for testing purposes" OFF)
-option(NB_TEST_FREE_THREADED "Build free-threaded extensions for the test suite?" ON)
-
-if (NOT MSVC)
-  option(NB_TEST_SANITIZERS_ASAN  "Build tests with the address sanitizer?" OFF)
-  option(NB_TEST_SANITIZERS_UBSAN "Build tests with the address undefined behavior sanitizer?" OFF)
-  option(NB_TEST_SANITIZERS_TSAN  "Build tests with the thread sanitizer?" OFF)
-endif()
-
-# ---------------------------------------------------------------------------
-# Do a release build if nothing was specified
-# ---------------------------------------------------------------------------
-
-if (NB_MASTER_PROJECT AND NOT CMAKE_BUILD_TYPE AND NOT CMAKE_CONFIGURATION_TYPES)
-  message(STATUS "nanobind: setting build type to 'Release' as none was specified.")
-  set(CMAKE_BUILD_TYPE Release CACHE STRING "Choose the type of build." FORCE)
-  set_property(CACHE CMAKE_BUILD_TYPE PROPERTY STRINGS "Debug" "Release"
-    "MinSizeRel" "RelWithDebInfo")
-endif()
-
-# ---------------------------------------------------------------------------
-# Check whether all dependencies are present
-# ---------------------------------------------------------------------------
-
-if (NB_USE_SUBMODULE_DEPS AND NOT IS_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}/ext/robin_map/include")
-  message(FATAL_ERROR "The nanobind dependencies are missing! "
-    "You probably did not clone the project with --recursive. It is possible to recover "
-    "by invoking\n$ git submodule update --init --recursive")
-endif()
-
-# ---------------------------------------------------------------------------
-# Installation rules
-# ---------------------------------------------------------------------------
-if(NB_CREATE_INSTALL_RULES AND NOT CMAKE_SKIP_INSTALL_RULES)
-  # Silence warning in GNUInstallDirs due to no enabled languages
-  set(CMAKE_INSTALL_LIBDIR "")
-  include(GNUInstallDirs)
-  set(NB_INSTALL_DATADIR "nanobind"
-    CACHE PATH "Installation path for read-only architecture-independent nanobind data files")
-
-  # Normally these would be configurable by the user, but we can't allow that
-  # because the lookup paths are hard-coded in 'cmake/nanobind-config.cmake'
-  set(NB_INSTALL_INC_DIR "${NB_INSTALL_DATADIR}/include")
-  set(NB_INSTALL_SRC_DIR "${NB_INSTALL_DATADIR}/src")
-  set(NB_INSTALL_EXT_DIR "${NB_INSTALL_DATADIR}/ext")
-  set(NB_INSTALL_MODULE_DIR "${NB_INSTALL_DATADIR}")
-  set(NB_INSTALL_CMAKE_DIR "${NB_INSTALL_DATADIR}/cmake")
-
-  install(
-    DIRECTORY include/
-    DESTINATION "${NB_INSTALL_INC_DIR}"
-  )
-
-  install(
-    DIRECTORY src/
-    DESTINATION "${NB_INSTALL_SRC_DIR}"
-    PATTERN "*.py" EXCLUDE
-  )
-
-  install(
-    DIRECTORY src/
-    DESTINATION "${NB_INSTALL_MODULE_DIR}"
-    FILES_MATCHING PATTERN "*\.py"
-    PATTERN "version.py" EXCLUDE
-  )
-
-  if(NB_USE_SUBMODULE_DEPS)
-    install(
-      FILES ext/robin_map/include/tsl/robin_map.h
-            ext/robin_map/include/tsl/robin_hash.h
-            ext/robin_map/include/tsl/robin_growth_policy.h
-      DESTINATION "${NB_INSTALL_EXT_DIR}/robin_map/include/tsl"
-    )
-  endif()
-
-  install(
-    FILES cmake/nanobind-config.cmake
-          cmake/darwin-python-path.py
-          cmake/darwin-ld-cpython.sym
-          cmake/darwin-ld-pypy.sym
-    DESTINATION "${NB_INSTALL_CMAKE_DIR}"
-  )
-
-  include(CMakePackageConfigHelpers)
-  write_basic_package_version_file(
-    ${CMAKE_CURRENT_BINARY_DIR}/${PROJECT_NAME}-config-version.cmake
-    COMPATIBILITY SameMajorVersion
-  )
-  install(
-    FILES ${CMAKE_CURRENT_BINARY_DIR}/${PROJECT_NAME}-config-version.cmake
-    DESTINATION "${NB_INSTALL_CMAKE_DIR}"
-  )
-endif()
-
-# Return early to skip finding needless dependencies if the user only wishes to
-# install nanobind
-if (NB_MASTER_PROJECT AND NOT NB_TEST)
-  return()
-else()
-  enable_language(CXX)
-endif()
-
-# ---------------------------------------------------------------------------
-# Find the Python interpreter and development libraries
-# ---------------------------------------------------------------------------
-
-if (NOT TARGET Python::Module OR NOT TARGET Python::Interpreter)
-  set(Python_FIND_FRAMEWORK LAST) # Prefer Brew/Conda to Apple framework python
-
-  if (CMAKE_VERSION VERSION_LESS 3.18)
-    set(NB_PYTHON_DEV_MODULE Development)
-  else()
-    set(NB_PYTHON_DEV_MODULE Development.Module)
-  endif()
-
-  find_package(Python 3.8
-    REQUIRED COMPONENTS Interpreter ${NB_PYTHON_DEV_MODULE}
-    OPTIONAL_COMPONENTS Development.SABIModule)
-endif()
-
-# ---------------------------------------------------------------------------
-# Include nanobind cmake functionality
-# ---------------------------------------------------------------------------
-include(cmake/nanobind-config.cmake)
-
-if (NB_TEST)
-  add_subdirectory(tests)
-endif()
diff --git a/src/nanobind/LICENSE b/src/nanobind/LICENSE
deleted file mode 100644
index 3d3426d..0000000
--- a/src/nanobind/LICENSE
+++ /dev/null
@@ -1,26 +0,0 @@
-Copyright (c) 2022 Wenzel Jakob <wenzel.jakob@epfl.ch>, All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
-1. Redistributions of source code must retain the above copyright notice, this
-   list of conditions and the following disclaimer.
-
-2. Redistributions in binary form must reproduce the above copyright notice,
-   this list of conditions and the following disclaimer in the documentation
-   and/or other materials provided with the distribution.
-
-3. Neither the name of the copyright holder nor the names of its contributors
-   may be used to endorse or promote products derived from this software
-   without specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
-ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
-DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
-FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
-DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
-SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
-CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
-OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
diff --git a/src/nanobind/README.md b/src/nanobind/README.md
deleted file mode 100644
index 19abaf1..0000000
--- a/src/nanobind/README.md
+++ /dev/null
@@ -1,59 +0,0 @@
-# nanobind: tiny and efficient C++/Python bindings
-
-[![Documentation](https://img.shields.io/readthedocs/nanobind/latest)](https://nanobind.readthedocs.io/en/latest/)
-[![Continuous Integration](https://img.shields.io/github/actions/workflow/status/wjakob/nanobind/ci.yml?label=tests)](https://github.com/wjakob/nanobind/actions/workflows/ci.yml)
-[![](https://img.shields.io/pypi/v/nanobind.svg?color=brightgreen)](https://pypi.org/pypi/nanobind/)
-![](https://img.shields.io/pypi/l/nanobind.svg?color=brightgreen)
-[![](https://img.shields.io/badge/Example-Link-brightgreen)](https://github.com/wjakob/nanobind_example)
-[![](https://img.shields.io/badge/Changelog-Link-brightgreen)](https://nanobind.readthedocs.io/en/latest/changelog.html)
-
-<p align="center">
-    <picture>
-      <source media="(prefers-color-scheme: dark)" width="800" srcset="https://rgl.s3.eu-central-1.amazonaws.com/media/uploads/wjakob/2023/03/28/nanobind_logo_dark.png">
-      <source media="(prefers-color-scheme: light)" width="800" srcset="https://github.com/wjakob/nanobind/raw/master/docs/images/logo.jpg">
-      <img alt="nanobind logo" width="800" src="https://github.com/wjakob/nanobind/raw/master/docs/images/logo.jpg">
-    </picture>
-</p>
-
-_nanobind_ is a small binding library that exposes C++ types in Python and vice
-versa. It is reminiscent of
-[Boost.Python](https://www.boost.org/doc/libs/1_64_0/libs/python/doc/html) and
-[pybind11](https://github.com/pybind/pybind11) and uses near-identical syntax.
-In contrast to these existing tools, nanobind is more efficient: bindings
-compile in a shorter amount of time, produce smaller binaries, and have better
-runtime performance.
-
-More concretely,
-[benchmarks](https://nanobind.readthedocs.io/en/latest/benchmark.html) show up
-to **~4× faster** compile time, **~5× smaller** binaries, and **~10× lower**
-runtime overheads compared to pybind11. nanobind also outperforms Cython in
-important metrics (**3-12×** binary size reduction, **1.6-4×** compilation time
-reduction, similar runtime performance).
-
-## Documentation
-
-Please see the following links for tutorial and reference documentation in
-[HTML](https://nanobind.readthedocs.io/en/latest/) and
-[PDF](https://nanobind.readthedocs.io/_/downloads/en/latest/pdf/) formats.
-
-## License and attribution
-
-All material in this repository is licensed under a three-clause [BSD
-license](LICENSE).
-
-Please use the following BibTeX template to cite nanobind in scientific
-discourse:
-
-```bibtex
-@misc{nanobind,
-   author = {Wenzel Jakob},
-   year = {2022},
-   note = {https://github.com/wjakob/nanobind},
-   title = {nanobind: tiny and efficient C++/Python bindings}
-}
-```
-
-The nanobind logo was designed by [AndoTwin Studio](https://andotwinstudio.com)
-(high-resolution download:
-[light](https://rgl.s3.eu-central-1.amazonaws.com/media/uploads/wjakob/2023/03/27/nanobind_logo.jpg),
-[dark](https://rgl.s3.eu-central-1.amazonaws.com/media/uploads/wjakob/2023/03/28/nanobind_logo_dark_1.png)).
diff --git a/src/nanobind/cmake/collect-symbols-pypy.py b/src/nanobind/cmake/collect-symbols-pypy.py
deleted file mode 100644
index 805490d..0000000
--- a/src/nanobind/cmake/collect-symbols-pypy.py
+++ /dev/null
@@ -1,28 +0,0 @@
-from urllib.request import urlopen
-import tarfile
-import subprocess
-
-funcs: "set[str]" = set()
-
-files = [
-    ('https://downloads.python.org/pypy/pypy3.9-v7.3.11-macos_arm64.tar.bz2', 'pypy3.9-v7.3.11-macos_arm64/bin/libpypy3.9-c.dylib')
-]
-
-for f in files:
-    fs = urlopen(f[0])
-    ft = tarfile.open(fileobj=fs, mode="r|bz2")
-    success = False
-    for member in ft: # move to the next file each loop
-        if member.name == f[1]:
-            ft.extract(member, path='tmp')
-            success = True
-    assert success
-
-    out = subprocess.check_output(['nm', '-gjU', 'tmp/' + f[1]])
-    for line in out.decode().split('\n'):
-        if line.startswith('_Py') or line.startswith('__Py'):
-            funcs.add(line)
-
-with open("darwin-ld-pypy.sym", "w") as f:
-    for func in sorted(list(funcs)):
-        f.write(f'-U _{func}\n')
diff --git a/src/nanobind/cmake/collect-symbols.py b/src/nanobind/cmake/collect-symbols.py
deleted file mode 100644
index ad92da4..0000000
--- a/src/nanobind/cmake/collect-symbols.py
+++ /dev/null
@@ -1,42 +0,0 @@
-#!/usr/bin/env python3
-#
-# This script collects a list of symbols that are considered to be part of the
-# CPython API. The result is used to inform the macOS linker that it's fine for
-# those symbols to be undefined when an extension module is linked, as they
-# will be provided when the extension module is loaded into the interpreter.
-
-from urllib.request import urlopen
-import re
-
-funcs: "set[str]" = set()
-
-for ver in ['3.7', '3.8', '3.9']:
-  url = f'https://raw.githubusercontent.com/python/cpython/{ver}/PC/python3.def'
-  output = urlopen(url).read().decode('utf-8')
-  for match in re.findall(r"  (.*)=.*", output):
-      funcs.add(match)
-
-for ver in ['3.10', '3.11', 'main']:
-    url = f'https://raw.githubusercontent.com/python/cpython/{ver}/PC/python3dll.c'
-    output = urlopen(url).read().decode('utf-8')
-    for match in re.findall(r"EXPORT_FUNC\((.*)\)", output):
-        funcs.add(match)
-
-funcs.remove('name')
-
-# Add a few more functions that nanobind uses and which aren't in the above list
-funcs |= {
-    'PyFrame_GetBack',
-    'PyGILState_Check',
-    'PyObject_LengthHint',
-    'Py_CompileStringExFlags',
-    '_PyInterpreterState_Get',
-    '_PyObject_MakeTpCall',
-    '_PyObject_NextNotImplemented',
-    '_Py_CheckFunctionResult',
-    '_Py_RefTotal'
-}
-
-with open("darwin-ld-cpython.sym", "w") as f:
-    for func in sorted(list(funcs)):
-        f.write(f'-U _{func}\n')
diff --git a/src/nanobind/cmake/darwin-ld-cpython.sym b/src/nanobind/cmake/darwin-ld-cpython.sym
deleted file mode 100644
index 0c15d6d..0000000
--- a/src/nanobind/cmake/darwin-ld-cpython.sym
+++ /dev/null
@@ -1,930 +0,0 @@
--U _PyAIter_Check
--U _PyArg_Parse
--U _PyArg_ParseTuple
--U _PyArg_ParseTupleAndKeywords
--U _PyArg_UnpackTuple
--U _PyArg_VaParse
--U _PyArg_VaParseTupleAndKeywords
--U _PyArg_ValidateKeywordArguments
--U _PyBaseObject_Type
--U _PyBool_FromLong
--U _PyBool_Type
--U _PyBuffer_FillContiguousStrides
--U _PyBuffer_FillInfo
--U _PyBuffer_FromContiguous
--U _PyBuffer_GetPointer
--U _PyBuffer_IsContiguous
--U _PyBuffer_Release
--U _PyBuffer_SizeFromFormat
--U _PyBuffer_ToContiguous
--U _PyByteArrayIter_Type
--U _PyByteArray_AsString
--U _PyByteArray_Concat
--U _PyByteArray_FromObject
--U _PyByteArray_FromStringAndSize
--U _PyByteArray_Resize
--U _PyByteArray_Size
--U _PyByteArray_Type
--U _PyBytesIter_Type
--U _PyBytes_AsString
--U _PyBytes_AsStringAndSize
--U _PyBytes_Concat
--U _PyBytes_ConcatAndDel
--U _PyBytes_DecodeEscape
--U _PyBytes_FromFormat
--U _PyBytes_FromFormatV
--U _PyBytes_FromObject
--U _PyBytes_FromString
--U _PyBytes_FromStringAndSize
--U _PyBytes_Repr
--U _PyBytes_Size
--U _PyBytes_Type
--U _PyCFunction_Call
--U _PyCFunction_ClearFreeList
--U _PyCFunction_GetFlags
--U _PyCFunction_GetFunction
--U _PyCFunction_GetSelf
--U _PyCFunction_New
--U _PyCFunction_NewEx
--U _PyCFunction_Type
--U _PyCMethod_New
--U _PyCallIter_New
--U _PyCallIter_Type
--U _PyCallable_Check
--U _PyCapsule_GetContext
--U _PyCapsule_GetDestructor
--U _PyCapsule_GetName
--U _PyCapsule_GetPointer
--U _PyCapsule_Import
--U _PyCapsule_IsValid
--U _PyCapsule_New
--U _PyCapsule_SetContext
--U _PyCapsule_SetDestructor
--U _PyCapsule_SetName
--U _PyCapsule_SetPointer
--U _PyCapsule_Type
--U _PyClassMethodDescr_Type
--U _PyCodec_BackslashReplaceErrors
--U _PyCodec_Decode
--U _PyCodec_Decoder
--U _PyCodec_Encode
--U _PyCodec_Encoder
--U _PyCodec_IgnoreErrors
--U _PyCodec_IncrementalDecoder
--U _PyCodec_IncrementalEncoder
--U _PyCodec_KnownEncoding
--U _PyCodec_LookupError
--U _PyCodec_NameReplaceErrors
--U _PyCodec_Register
--U _PyCodec_RegisterError
--U _PyCodec_ReplaceErrors
--U _PyCodec_StreamReader
--U _PyCodec_StreamWriter
--U _PyCodec_StrictErrors
--U _PyCodec_Unregister
--U _PyCodec_XMLCharRefReplaceErrors
--U _PyComplex_AsCComplex
--U _PyComplex_FromCComplex
--U _PyComplex_FromDoubles
--U _PyComplex_ImagAsDouble
--U _PyComplex_RealAsDouble
--U _PyComplex_Type
--U _PyDescr_NewClassMethod
--U _PyDescr_NewGetSet
--U _PyDescr_NewMember
--U _PyDescr_NewMethod
--U _PyDictItems_Type
--U _PyDictIterItem_Type
--U _PyDictIterKey_Type
--U _PyDictIterValue_Type
--U _PyDictKeys_Type
--U _PyDictProxy_New
--U _PyDictProxy_Type
--U _PyDictValues_Type
--U _PyDict_Clear
--U _PyDict_Contains
--U _PyDict_Copy
--U _PyDict_DelItem
--U _PyDict_DelItemString
--U _PyDict_GetItem
--U _PyDict_GetItemString
--U _PyDict_GetItemWithError
--U _PyDict_Items
--U _PyDict_Keys
--U _PyDict_Merge
--U _PyDict_MergeFromSeq2
--U _PyDict_New
--U _PyDict_Next
--U _PyDict_SetItem
--U _PyDict_SetItemString
--U _PyDict_Size
--U _PyDict_Type
--U _PyDict_Update
--U _PyDict_Values
--U _PyEllipsis_Type
--U _PyEnum_Type
--U _PyErr_BadArgument
--U _PyErr_BadInternalCall
--U _PyErr_CheckSignals
--U _PyErr_Clear
--U _PyErr_Display
--U _PyErr_ExceptionMatches
--U _PyErr_Fetch
--U _PyErr_Format
--U _PyErr_FormatV
--U _PyErr_GetExcInfo
--U _PyErr_GetHandledException
--U _PyErr_GetRaisedException
--U _PyErr_GivenExceptionMatches
--U _PyErr_NewException
--U _PyErr_NewExceptionWithDoc
--U _PyErr_NoMemory
--U _PyErr_NormalizeException
--U _PyErr_Occurred
--U _PyErr_Print
--U _PyErr_PrintEx
--U _PyErr_ProgramText
--U _PyErr_ResourceWarning
--U _PyErr_Restore
--U _PyErr_SetExcFromWindowsErr
--U _PyErr_SetExcFromWindowsErrWithFilename
--U _PyErr_SetExcFromWindowsErrWithFilenameObject
--U _PyErr_SetExcFromWindowsErrWithFilenameObjects
--U _PyErr_SetExcInfo
--U _PyErr_SetFromErrno
--U _PyErr_SetFromErrnoWithFilename
--U _PyErr_SetFromErrnoWithFilenameObject
--U _PyErr_SetFromErrnoWithFilenameObjects
--U _PyErr_SetFromWindowsErr
--U _PyErr_SetFromWindowsErrWithFilename
--U _PyErr_SetHandledException
--U _PyErr_SetImportError
--U _PyErr_SetImportErrorSubclass
--U _PyErr_SetInterrupt
--U _PyErr_SetInterruptEx
--U _PyErr_SetNone
--U _PyErr_SetObject
--U _PyErr_SetRaisedException
--U _PyErr_SetString
--U _PyErr_SyntaxLocation
--U _PyErr_SyntaxLocationEx
--U _PyErr_WarnEx
--U _PyErr_WarnExplicit
--U _PyErr_WarnFormat
--U _PyErr_WriteUnraisable
--U _PyEval_AcquireLock
--U _PyEval_AcquireThread
--U _PyEval_CallFunction
--U _PyEval_CallMethod
--U _PyEval_CallObjectWithKeywords
--U _PyEval_EvalCode
--U _PyEval_EvalCodeEx
--U _PyEval_EvalFrame
--U _PyEval_EvalFrameEx
--U _PyEval_GetBuiltins
--U _PyEval_GetCallStats
--U _PyEval_GetFrame
--U _PyEval_GetFuncDesc
--U _PyEval_GetFuncName
--U _PyEval_GetGlobals
--U _PyEval_GetLocals
--U _PyEval_InitThreads
--U _PyEval_ReInitThreads
--U _PyEval_ReleaseLock
--U _PyEval_ReleaseThread
--U _PyEval_RestoreThread
--U _PyEval_SaveThread
--U _PyEval_ThreadsInitialized
--U _PyExc_ArithmeticError
--U _PyExc_AssertionError
--U _PyExc_AttributeError
--U _PyExc_BaseException
--U _PyExc_BlockingIOError
--U _PyExc_BrokenPipeError
--U _PyExc_BufferError
--U _PyExc_BytesWarning
--U _PyExc_ChildProcessError
--U _PyExc_ConnectionAbortedError
--U _PyExc_ConnectionError
--U _PyExc_ConnectionRefusedError
--U _PyExc_ConnectionResetError
--U _PyExc_DeprecationWarning
--U _PyExc_EOFError
--U _PyExc_EnvironmentError
--U _PyExc_Exception
--U _PyExc_FileExistsError
--U _PyExc_FileNotFoundError
--U _PyExc_FloatingPointError
--U _PyExc_FutureWarning
--U _PyExc_GeneratorExit
--U _PyExc_IOError
--U _PyExc_ImportError
--U _PyExc_ImportWarning
--U _PyExc_IndentationError
--U _PyExc_IndexError
--U _PyExc_InterruptedError
--U _PyExc_IsADirectoryError
--U _PyExc_KeyError
--U _PyExc_KeyboardInterrupt
--U _PyExc_LookupError
--U _PyExc_MemoryError
--U _PyExc_ModuleNotFoundError
--U _PyExc_NameError
--U _PyExc_NotADirectoryError
--U _PyExc_NotImplementedError
--U _PyExc_OSError
--U _PyExc_OverflowError
--U _PyExc_PendingDeprecationWarning
--U _PyExc_PermissionError
--U _PyExc_ProcessLookupError
--U _PyExc_RecursionError
--U _PyExc_ReferenceError
--U _PyExc_ResourceWarning
--U _PyExc_RuntimeError
--U _PyExc_RuntimeWarning
--U _PyExc_StopAsyncIteration
--U _PyExc_StopIteration
--U _PyExc_SyntaxError
--U _PyExc_SyntaxWarning
--U _PyExc_SystemError
--U _PyExc_SystemExit
--U _PyExc_TabError
--U _PyExc_TimeoutError
--U _PyExc_TypeError
--U _PyExc_UnboundLocalError
--U _PyExc_UnicodeDecodeError
--U _PyExc_UnicodeEncodeError
--U _PyExc_UnicodeError
--U _PyExc_UnicodeTranslateError
--U _PyExc_UnicodeWarning
--U _PyExc_UserWarning
--U _PyExc_ValueError
--U _PyExc_Warning
--U _PyExc_WindowsError
--U _PyExc_ZeroDivisionError
--U _PyExceptionClass_Name
--U _PyException_GetCause
--U _PyException_GetContext
--U _PyException_GetTraceback
--U _PyException_SetCause
--U _PyException_SetContext
--U _PyException_SetTraceback
--U _PyFile_FromFd
--U _PyFile_GetLine
--U _PyFile_WriteObject
--U _PyFile_WriteString
--U _PyFilter_Type
--U _PyFloat_AsDouble
--U _PyFloat_FromDouble
--U _PyFloat_FromString
--U _PyFloat_GetInfo
--U _PyFloat_GetMax
--U _PyFloat_GetMin
--U _PyFloat_Type
--U _PyFrame_GetBack
--U _PyFrame_GetCode
--U _PyFrame_GetLineNumber
--U _PyFrozenSet_New
--U _PyFrozenSet_Type
--U _PyGC_Collect
--U _PyGC_Disable
--U _PyGC_Enable
--U _PyGC_IsEnabled
--U _PyGILState_Check
--U _PyGILState_Ensure
--U _PyGILState_GetThisThreadState
--U _PyGILState_Release
--U _PyGetSetDescr_Type
--U _PyGen_Type
--U _PyImport_AddModule
--U _PyImport_AddModuleObject
--U _PyImport_AppendInittab
--U _PyImport_Cleanup
--U _PyImport_ExecCodeModule
--U _PyImport_ExecCodeModuleEx
--U _PyImport_ExecCodeModuleObject
--U _PyImport_ExecCodeModuleWithPathnames
--U _PyImport_GetImporter
--U _PyImport_GetMagicNumber
--U _PyImport_GetMagicTag
--U _PyImport_GetModule
--U _PyImport_GetModuleDict
--U _PyImport_Import
--U _PyImport_ImportFrozenModule
--U _PyImport_ImportFrozenModuleObject
--U _PyImport_ImportModule
--U _PyImport_ImportModuleLevel
--U _PyImport_ImportModuleLevelObject
--U _PyImport_ImportModuleNoBlock
--U _PyImport_ReloadModule
--U _PyIndex_Check
--U _PyInterpreterState_Clear
--U _PyInterpreterState_Delete
--U _PyInterpreterState_Get
--U _PyInterpreterState_GetDict
--U _PyInterpreterState_GetID
--U _PyInterpreterState_New
--U _PyIter_Check
--U _PyIter_Next
--U _PyIter_Send
--U _PyListIter_Type
--U _PyListRevIter_Type
--U _PyList_Append
--U _PyList_AsTuple
--U _PyList_GetItem
--U _PyList_GetSlice
--U _PyList_Insert
--U _PyList_New
--U _PyList_Reverse
--U _PyList_SetItem
--U _PyList_SetSlice
--U _PyList_Size
--U _PyList_Sort
--U _PyList_Type
--U _PyLongRangeIter_Type
--U _PyLong_AsDouble
--U _PyLong_AsLong
--U _PyLong_AsLongAndOverflow
--U _PyLong_AsLongLong
--U _PyLong_AsLongLongAndOverflow
--U _PyLong_AsSize_t
--U _PyLong_AsSsize_t
--U _PyLong_AsUnsignedLong
--U _PyLong_AsUnsignedLongLong
--U _PyLong_AsUnsignedLongLongMask
--U _PyLong_AsUnsignedLongMask
--U _PyLong_AsVoidPtr
--U _PyLong_FromDouble
--U _PyLong_FromLong
--U _PyLong_FromLongLong
--U _PyLong_FromSize_t
--U _PyLong_FromSsize_t
--U _PyLong_FromString
--U _PyLong_FromUnsignedLong
--U _PyLong_FromUnsignedLongLong
--U _PyLong_FromVoidPtr
--U _PyLong_GetInfo
--U _PyLong_Type
--U _PyMap_Type
--U _PyMapping_Check
--U _PyMapping_GetItemString
--U _PyMapping_HasKey
--U _PyMapping_HasKeyString
--U _PyMapping_Items
--U _PyMapping_Keys
--U _PyMapping_Length
--U _PyMapping_SetItemString
--U _PyMapping_Size
--U _PyMapping_Values
--U _PyMarshal_ReadObjectFromString
--U _PyMarshal_WriteObjectToString
--U _PyMem_Calloc
--U _PyMem_Free
--U _PyMem_Malloc
--U _PyMem_Realloc
--U _PyMemberDescr_Type
--U _PyMember_GetOne
--U _PyMember_SetOne
--U _PyMemoryView_FromBuffer
--U _PyMemoryView_FromMemory
--U _PyMemoryView_FromObject
--U _PyMemoryView_GetContiguous
--U _PyMemoryView_Type
--U _PyMethodDescr_Type
--U _PyModuleDef_Init
--U _PyModuleDef_Type
--U _PyModule_AddFunctions
--U _PyModule_AddIntConstant
--U _PyModule_AddObject
--U _PyModule_AddObjectRef
--U _PyModule_AddStringConstant
--U _PyModule_AddType
--U _PyModule_Create2
--U _PyModule_ExecDef
--U _PyModule_FromDefAndSpec2
--U _PyModule_GetDef
--U _PyModule_GetDict
--U _PyModule_GetFilename
--U _PyModule_GetFilenameObject
--U _PyModule_GetName
--U _PyModule_GetNameObject
--U _PyModule_GetState
--U _PyModule_New
--U _PyModule_NewObject
--U _PyModule_SetDocString
--U _PyModule_Type
--U _PyNullImporter_Type
--U _PyNumber_Absolute
--U _PyNumber_Add
--U _PyNumber_And
--U _PyNumber_AsSsize_t
--U _PyNumber_Check
--U _PyNumber_Divmod
--U _PyNumber_Float
--U _PyNumber_FloorDivide
--U _PyNumber_InPlaceAdd
--U _PyNumber_InPlaceAnd
--U _PyNumber_InPlaceFloorDivide
--U _PyNumber_InPlaceLshift
--U _PyNumber_InPlaceMatrixMultiply
--U _PyNumber_InPlaceMultiply
--U _PyNumber_InPlaceOr
--U _PyNumber_InPlacePower
--U _PyNumber_InPlaceRemainder
--U _PyNumber_InPlaceRshift
--U _PyNumber_InPlaceSubtract
--U _PyNumber_InPlaceTrueDivide
--U _PyNumber_InPlaceXor
--U _PyNumber_Index
--U _PyNumber_Invert
--U _PyNumber_Long
--U _PyNumber_Lshift
--U _PyNumber_MatrixMultiply
--U _PyNumber_Multiply
--U _PyNumber_Negative
--U _PyNumber_Or
--U _PyNumber_Positive
--U _PyNumber_Power
--U _PyNumber_Remainder
--U _PyNumber_Rshift
--U _PyNumber_Subtract
--U _PyNumber_ToBase
--U _PyNumber_TrueDivide
--U _PyNumber_Xor
--U _PyODictItems_Type
--U _PyODictIter_Type
--U _PyODictKeys_Type
--U _PyODictValues_Type
--U _PyODict_DelItem
--U _PyODict_New
--U _PyODict_SetItem
--U _PyODict_Type
--U _PyOS_AfterFork
--U _PyOS_CheckStack
--U _PyOS_FSPath
--U _PyOS_InitInterrupts
--U _PyOS_InputHook
--U _PyOS_InterruptOccurred
--U _PyOS_ReadlineFunctionPointer
--U _PyOS_double_to_string
--U _PyOS_getsig
--U _PyOS_mystricmp
--U _PyOS_mystrnicmp
--U _PyOS_setsig
--U _PyOS_snprintf
--U _PyOS_string_to_double
--U _PyOS_strtol
--U _PyOS_strtoul
--U _PyOS_vsnprintf
--U _PyObject_ASCII
--U _PyObject_AsCharBuffer
--U _PyObject_AsFileDescriptor
--U _PyObject_AsReadBuffer
--U _PyObject_AsWriteBuffer
--U _PyObject_Bytes
--U _PyObject_Call
--U _PyObject_CallFunction
--U _PyObject_CallFunctionObjArgs
--U _PyObject_CallMethod
--U _PyObject_CallMethodObjArgs
--U _PyObject_CallNoArgs
--U _PyObject_CallObject
--U _PyObject_Calloc
--U _PyObject_CheckBuffer
--U _PyObject_CheckReadBuffer
--U _PyObject_ClearWeakRefs
--U _PyObject_CopyData
--U _PyObject_DelAttr
--U _PyObject_DelAttrString
--U _PyObject_DelItem
--U _PyObject_DelItemString
--U _PyObject_Dir
--U _PyObject_Format
--U _PyObject_Free
--U _PyObject_GetTypeData
--U _PyObject_GetOptionalAttr
--U _PyObject_GetOptionalAttrString
--U _PyObject_GC_Del
--U _PyObject_GC_IsFinalized
--U _PyObject_GC_IsTracked
--U _PyObject_GC_Track
--U _PyObject_GC_UnTrack
--U _PyObject_GenericGetAttr
--U _PyObject_GenericGetDict
--U _PyObject_GenericSetAttr
--U _PyObject_GenericSetDict
--U _PyObject_GetAIter
--U _PyObject_GetAttr
--U _PyObject_GetAttrString
--U _PyObject_GetBuffer
--U _PyObject_GetItem
--U _PyObject_GetIter
--U _PyObject_HasAttr
--U _PyObject_HasAttrString
--U _PyObject_Hash
--U _PyObject_HashNotImplemented
--U _PyObject_Init
--U _PyObject_InitVar
--U _PyObject_IsInstance
--U _PyObject_IsSubclass
--U _PyObject_IsTrue
--U _PyObject_Length
--U _PyObject_LengthHint
--U _PyObject_Malloc
--U _PyObject_Not
--U _PyObject_Realloc
--U _PyObject_Repr
--U _PyObject_RichCompare
--U _PyObject_RichCompareBool
--U _PyObject_SelfIter
--U _PyObject_SetAttr
--U _PyObject_SetAttrString
--U _PyObject_SetItem
--U _PyObject_Size
--U _PyObject_Str
--U _PyObject_Type
--U _PyObject_Vectorcall
--U _PyObject_VectorcallMethod
--U _PyParser_SimpleParseFileFlags
--U _PyParser_SimpleParseStringFlags
--U _PyParser_SimpleParseStringFlagsFilename
--U _PyProperty_Type
--U _PyRangeIter_Type
--U _PyRange_Type
--U _PyReversed_Type
--U _PySeqIter_New
--U _PySeqIter_Type
--U _PySequence_Check
--U _PySequence_Concat
--U _PySequence_Contains
--U _PySequence_Count
--U _PySequence_DelItem
--U _PySequence_DelSlice
--U _PySequence_Fast
--U _PySequence_GetItem
--U _PySequence_GetSlice
--U _PySequence_In
--U _PySequence_InPlaceConcat
--U _PySequence_InPlaceRepeat
--U _PySequence_Index
--U _PySequence_Length
--U _PySequence_List
--U _PySequence_Repeat
--U _PySequence_SetItem
--U _PySequence_SetSlice
--U _PySequence_Size
--U _PySequence_Tuple
--U _PySetIter_Type
--U _PySet_Add
--U _PySet_Clear
--U _PySet_Contains
--U _PySet_Discard
--U _PySet_New
--U _PySet_Pop
--U _PySet_Size
--U _PySet_Type
--U _PySlice_AdjustIndices
--U _PySlice_GetIndices
--U _PySlice_GetIndicesEx
--U _PySlice_New
--U _PySlice_Type
--U _PySlice_Unpack
--U _PySortWrapper_Type
--U _PyState_AddModule
--U _PyState_FindModule
--U _PyState_RemoveModule
--U _PyStructSequence_GetItem
--U _PyStructSequence_New
--U _PyStructSequence_NewType
--U _PyStructSequence_SetItem
--U _PySuper_Type
--U _PySys_AddWarnOption
--U _PySys_AddWarnOptionUnicode
--U _PySys_AddXOption
--U _PySys_FormatStderr
--U _PySys_FormatStdout
--U _PySys_GetObject
--U _PySys_GetXOptions
--U _PySys_HasWarnOptions
--U _PySys_ResetWarnOptions
--U _PySys_SetArgv
--U _PySys_SetArgvEx
--U _PySys_SetObject
--U _PySys_SetPath
--U _PySys_WriteStderr
--U _PySys_WriteStdout
--U _PyThreadState_Clear
--U _PyThreadState_Delete
--U _PyThreadState_DeleteCurrent
--U _PyThreadState_Get
--U _PyThreadState_GetDict
--U _PyThreadState_GetFrame
--U _PyThreadState_GetID
--U _PyThreadState_GetInterpreter
--U _PyThreadState_New
--U _PyThreadState_SetAsyncExc
--U _PyThreadState_Swap
--U _PyThread_GetInfo
--U _PyThread_ReInitTLS
--U _PyThread_acquire_lock
--U _PyThread_acquire_lock_timed
--U _PyThread_allocate_lock
--U _PyThread_create_key
--U _PyThread_delete_key
--U _PyThread_delete_key_value
--U _PyThread_exit_thread
--U _PyThread_free_lock
--U _PyThread_get_key_value
--U _PyThread_get_stacksize
--U _PyThread_get_thread_ident
--U _PyThread_get_thread_native_id
--U _PyThread_init_thread
--U _PyThread_release_lock
--U _PyThread_set_key_value
--U _PyThread_set_stacksize
--U _PyThread_start_new_thread
--U _PyThread_tss_alloc
--U _PyThread_tss_create
--U _PyThread_tss_delete
--U _PyThread_tss_free
--U _PyThread_tss_get
--U _PyThread_tss_is_created
--U _PyThread_tss_set
--U _PyTraceBack_Here
--U _PyTraceBack_Print
--U _PyTraceBack_Type
--U _PyTupleIter_Type
--U _PyTuple_ClearFreeList
--U _PyTuple_GetItem
--U _PyTuple_GetSlice
--U _PyTuple_New
--U _PyTuple_Pack
--U _PyTuple_SetItem
--U _PyTuple_Size
--U _PyTuple_Type
--U _PyType_ClearCache
--U _PyType_FromMetaclass
--U _PyType_FromModuleAndSpec
--U _PyType_FromSpec
--U _PyType_FromSpecWithBases
--U _PyType_GenericAlloc
--U _PyType_GenericNew
--U _PyType_GetFlags
--U _PyType_GetModule
--U _PyType_GetModuleState
--U _PyType_GetName
--U _PyType_GetQualName
--U _PyType_GetSlot
--U _PyType_IsSubtype
--U _PyType_Modified
--U _PyType_Ready
--U _PyType_Type
--U _PyType_GetTypeDataSize
--U _PyUnicodeDecodeError_Create
--U _PyUnicodeDecodeError_GetEncoding
--U _PyUnicodeDecodeError_GetEnd
--U _PyUnicodeDecodeError_GetObject
--U _PyUnicodeDecodeError_GetReason
--U _PyUnicodeDecodeError_GetStart
--U _PyUnicodeDecodeError_SetEnd
--U _PyUnicodeDecodeError_SetReason
--U _PyUnicodeDecodeError_SetStart
--U _PyUnicodeEncodeError_GetEncoding
--U _PyUnicodeEncodeError_GetEnd
--U _PyUnicodeEncodeError_GetObject
--U _PyUnicodeEncodeError_GetReason
--U _PyUnicodeEncodeError_GetStart
--U _PyUnicodeEncodeError_SetEnd
--U _PyUnicodeEncodeError_SetReason
--U _PyUnicodeEncodeError_SetStart
--U _PyUnicodeIter_Type
--U _PyUnicodeTranslateError_GetEnd
--U _PyUnicodeTranslateError_GetObject
--U _PyUnicodeTranslateError_GetReason
--U _PyUnicodeTranslateError_GetStart
--U _PyUnicodeTranslateError_SetEnd
--U _PyUnicodeTranslateError_SetReason
--U _PyUnicodeTranslateError_SetStart
--U _PyUnicode_Append
--U _PyUnicode_AppendAndDel
--U _PyUnicode_AsASCIIString
--U _PyUnicode_AsCharmapString
--U _PyUnicode_AsDecodedObject
--U _PyUnicode_AsDecodedUnicode
--U _PyUnicode_AsEncodedObject
--U _PyUnicode_AsEncodedString
--U _PyUnicode_AsEncodedUnicode
--U _PyUnicode_AsLatin1String
--U _PyUnicode_AsMBCSString
--U _PyUnicode_AsRawUnicodeEscapeString
--U _PyUnicode_AsUCS4
--U _PyUnicode_AsUCS4Copy
--U _PyUnicode_AsUTF16String
--U _PyUnicode_AsUTF32String
--U _PyUnicode_AsUTF8AndSize
--U _PyUnicode_AsUTF8String
--U _PyUnicode_AsUnicodeEscapeString
--U _PyUnicode_AsWideChar
--U _PyUnicode_AsWideCharString
--U _PyUnicode_BuildEncodingMap
--U _PyUnicode_ClearFreeList
--U _PyUnicode_Compare
--U _PyUnicode_CompareWithASCIIString
--U _PyUnicode_Concat
--U _PyUnicode_Contains
--U _PyUnicode_Count
--U _PyUnicode_Decode
--U _PyUnicode_DecodeASCII
--U _PyUnicode_DecodeCharmap
--U _PyUnicode_DecodeCodePageStateful
--U _PyUnicode_DecodeFSDefault
--U _PyUnicode_DecodeFSDefaultAndSize
--U _PyUnicode_DecodeLatin1
--U _PyUnicode_DecodeLocale
--U _PyUnicode_DecodeLocaleAndSize
--U _PyUnicode_DecodeMBCS
--U _PyUnicode_DecodeMBCSStateful
--U _PyUnicode_DecodeRawUnicodeEscape
--U _PyUnicode_DecodeUTF16
--U _PyUnicode_DecodeUTF16Stateful
--U _PyUnicode_DecodeUTF32
--U _PyUnicode_DecodeUTF32Stateful
--U _PyUnicode_DecodeUTF7
--U _PyUnicode_DecodeUTF7Stateful
--U _PyUnicode_DecodeUTF8
--U _PyUnicode_DecodeUTF8Stateful
--U _PyUnicode_DecodeUnicodeEscape
--U _PyUnicode_EncodeCodePage
--U _PyUnicode_EncodeFSDefault
--U _PyUnicode_EncodeLocale
--U _PyUnicode_FSConverter
--U _PyUnicode_FSDecoder
--U _PyUnicode_Find
--U _PyUnicode_FindChar
--U _PyUnicode_Format
--U _PyUnicode_FromEncodedObject
--U _PyUnicode_FromFormat
--U _PyUnicode_FromFormatV
--U _PyUnicode_FromObject
--U _PyUnicode_FromOrdinal
--U _PyUnicode_FromString
--U _PyUnicode_FromStringAndSize
--U _PyUnicode_FromWideChar
--U _PyUnicode_GetDefaultEncoding
--U _PyUnicode_GetLength
--U _PyUnicode_GetSize
--U _PyUnicode_InternFromString
--U _PyUnicode_InternImmortal
--U _PyUnicode_InternInPlace
--U _PyUnicode_IsIdentifier
--U _PyUnicode_Join
--U _PyUnicode_Partition
--U _PyUnicode_RPartition
--U _PyUnicode_RSplit
--U _PyUnicode_ReadChar
--U _PyUnicode_Replace
--U _PyUnicode_Resize
--U _PyUnicode_RichCompare
--U _PyUnicode_Split
--U _PyUnicode_Splitlines
--U _PyUnicode_Substring
--U _PyUnicode_Tailmatch
--U _PyUnicode_Translate
--U _PyUnicode_Type
--U _PyUnicode_WriteChar
--U _PyVectorcall_Call
--U _PyVectorcall_NARGS
--U _PyWeakref_GetObject
--U _PyWeakref_NewProxy
--U _PyWeakref_NewRef
--U _PyWrapperDescr_Type
--U _PyWrapper_New
--U _PyZip_Type
--U _Py_AddPendingCall
--U _Py_AtExit
--U _Py_BuildValue
--U _Py_BytesMain
--U _Py_CompileString
--U _Py_CompileStringExFlags
--U _Py_DecRef
--U _Py_DecodeLocale
--U _Py_EncodeLocale
--U _Py_EndInterpreter
--U _Py_EnterRecursiveCall
--U _Py_Exit
--U _Py_FatalError
--U _Py_FileSystemDefaultEncodeErrors
--U _Py_FileSystemDefaultEncoding
--U _Py_Finalize
--U _Py_FinalizeEx
--U _Py_GenericAlias
--U _Py_GenericAliasType
--U _Py_GetArgcArgv
--U _Py_GetBuildInfo
--U _Py_GetCompiler
--U _Py_GetCopyright
--U _Py_GetExecPrefix
--U _Py_GetPath
--U _Py_GetPlatform
--U _Py_GetPrefix
--U _Py_GetProgramFullPath
--U _Py_GetProgramName
--U _Py_GetPythonHome
--U _Py_GetRecursionLimit
--U _Py_GetVersion
--U _Py_HasFileSystemDefaultEncoding
--U _Py_IncRef
--U _Py_Initialize
--U _Py_InitializeEx
--U _Py_Is
--U _Py_IsFalse
--U _Py_IsFinalizing
--U _Py_IsInitialized
--U _Py_IsNone
--U _Py_IsTrue
--U _Py_LeaveRecursiveCall
--U _Py_Main
--U _Py_MakePendingCalls
--U _Py_NewInterpreter
--U _Py_NewRef
--U _Py_ReprEnter
--U _Py_ReprLeave
--U _Py_SetPath
--U _Py_SetProgramName
--U _Py_SetPythonHome
--U _Py_SetRecursionLimit
--U _Py_SymtableString
--U _Py_UTF8Mode
--U _Py_VaBuildValue
--U _Py_XNewRef
--U __PyArg_ParseTupleAndKeywords_SizeT
--U __PyArg_ParseTuple_SizeT
--U __PyArg_Parse_SizeT
--U __PyArg_VaParseTupleAndKeywords_SizeT
--U __PyArg_VaParse_SizeT
--U __PyErr_BadInternalCall
--U __PyInterpreterState_Get
--U __PyObject_CallFunction_SizeT
--U __PyObject_CallMethod_SizeT
--U __PyObject_GC_Malloc
--U __PyObject_GC_New
--U __PyObject_GC_NewVar
--U __PyObject_GC_Resize
--U __PyObject_LookupAttr
--U __PyObject_MakeTpCall
--U __PyObject_New
--U __PyObject_NewVar
--U __PyObject_NextNotImplemented
--U __PyState_AddModule
--U __PyThreadState_Init
--U __PyThreadState_Prealloc
--U __PyTrash_delete_later
--U __PyTrash_delete_nesting
--U __PyTrash_deposit_object
--U __PyTrash_destroy_chain
--U __PyTrash_thread_deposit_object
--U __PyTrash_thread_destroy_chain
--U __PyWeakref_CallableProxyType
--U __PyWeakref_ProxyType
--U __PyWeakref_RefType
--U __Py_IsFinalizing
--U __Py_BuildValue_SizeT
--U __Py_CheckFunctionResult
--U __Py_CheckRecursionLimit
--U __Py_CheckRecursiveCall
--U __Py_Dealloc
--U __Py_DecRef
--U __Py_EllipsisObject
--U __Py_FalseStruct
--U __Py_IncRef
--U __Py_NegativeRefcount
--U __Py_NoneStruct
--U __Py_NotImplementedStruct
--U __Py_RefTotal
--U __Py_SwappedOp
--U __Py_TrueStruct
--U __Py_VaBuildValue_SizeT
--U _Py_Version
--U __Py_MergeZeroLocalRefcount
--U __Py_DecRefShared
--U __Py_DecRefSharedDebug
--U __Py_DECREF_DecRefTotal
--U __Py_INCREF_IncRefTotal
--U __PyObject_GetDictPtr
--U _PyList_GetItemRef
--U _PyDict_GetItemRef
--U _PyDict_GetItemStringRef
--U _PyDict_SetDefault
--U _PyDict_SetDefaultRef
--U _PyWeakref_GetRef
--U _PyImport_AddModuleRef
--U _PyUnstable_Module_SetGIL
--U _PyMutex_Unlock
--U _PyMutex_Lock
--U _PyObject_IS_GC
--U _PyCriticalSection_Begin
--U _PyCriticalSection_End
--U _PyCriticalSection2_Begin
--U _PyCriticalSection2_End
--U _PyUnicode_AsUTF8
--U _Py_REFCNT
diff --git a/src/nanobind/cmake/darwin-ld-pypy.sym b/src/nanobind/cmake/darwin-ld-pypy.sym
deleted file mode 100644
index 73ecb77..0000000
--- a/src/nanobind/cmake/darwin-ld-pypy.sym
+++ /dev/null
@@ -1,965 +0,0 @@
--U _PyArg_ValidateKeywordArguments
--U _PyModule_AddType
--U _PyPyAnySet_Check
--U _PyPyAnySet_CheckExact
--U _PyPyArg_Parse
--U _PyPyArg_ParseTuple
--U _PyPyArg_ParseTupleAndKeywords
--U _PyPyArg_UnpackTuple
--U _PyPyArg_VaParse
--U _PyPyArg_VaParseTupleAndKeywords
--U _PyPyBaseObject_Type
--U _PyPyBool_FromLong
--U _PyPyBool_Type
--U _PyPyBuffer_FillInfo
--U _PyPyBuffer_FromContiguous
--U _PyPyBuffer_GetPointer
--U _PyPyBuffer_IsContiguous
--U _PyPyBuffer_Release
--U _PyPyBuffer_ToContiguous
--U _PyPyBufferable_Type
--U _PyPyByteArray_AsString
--U _PyPyByteArray_Check
--U _PyPyByteArray_CheckExact
--U _PyPyByteArray_Concat
--U _PyPyByteArray_FromObject
--U _PyPyByteArray_FromStringAndSize
--U _PyPyByteArray_Resize
--U _PyPyByteArray_Size
--U _PyPyByteArray_Type
--U _PyPyBytes_AS_STRING
--U _PyPyBytes_AsString
--U _PyPyBytes_AsStringAndSize
--U _PyPyBytes_Concat
--U _PyPyBytes_ConcatAndDel
--U _PyPyBytes_FromFormat
--U _PyPyBytes_FromFormatV
--U _PyPyBytes_FromObject
--U _PyPyBytes_FromString
--U _PyPyBytes_FromStringAndSize
--U _PyPyBytes_Size
--U _PyPyBytes_Type
--U _PyPyCFunction_Call
--U _PyPyCFunction_Check
--U _PyPyCFunction_GetFunction
--U _PyPyCFunction_Type
--U _PyPyCFunction_NewEx
--U _PyPyCMethod_New
--U _PyPyCallIter_New
--U _PyPyCallable_Check
--U _PyPyCapsule_GetContext
--U _PyPyCapsule_GetDestructor
--U _PyPyCapsule_GetName
--U _PyPyCapsule_GetPointer
--U _PyPyCapsule_Import
--U _PyPyCapsule_IsValid
--U _PyPyCapsule_New
--U _PyPyCapsule_SetContext
--U _PyPyCapsule_SetDestructor
--U _PyPyCapsule_SetName
--U _PyPyCapsule_SetPointer
--U _PyPyCapsule_Type
--U _PyPyCell_Type
--U _PyPyClassMethodDescr_Type
--U _PyPyClassMethod_New
--U _PyPyClassMethod_Type
--U _PyPyCode_Addr2Line
--U _PyPyCode_Check
--U _PyPyCode_CheckExact
--U _PyPyCode_GetNumFree
--U _PyPyCode_New
--U _PyPyCode_NewEmpty
--U _PyPyCodec_Decode
--U _PyPyCodec_Decoder
--U _PyPyCodec_Encode
--U _PyPyCodec_Encoder
--U _PyPyCodec_IncrementalDecoder
--U _PyPyCodec_IncrementalEncoder
--U _PyPyComplex_AsCComplex
--U _PyPyComplex_Check
--U _PyPyComplex_CheckExact
--U _PyPyComplex_FromCComplex
--U _PyPyComplex_FromDoubles
--U _PyPyComplex_ImagAsDouble
--U _PyPyComplex_RealAsDouble
--U _PyPyComplex_Type
--U _PyPyContextVar_Get
--U _PyPyContextVar_New
--U _PyPyContextVar_Set
--U _PyPyCoro_Check
--U _PyPyCoro_CheckExact
--U _PyPyDateTimeAPI
--U _PyPyDateTime_Check
--U _PyPyDateTime_CheckExact
--U _PyPyDateTime_DATE_GET_HOUR
--U _PyPyDateTime_DATE_GET_MICROSECOND
--U _PyPyDateTime_DATE_GET_MINUTE
--U _PyPyDateTime_DATE_GET_SECOND
--U _PyPyDateTime_DELTA_GET_DAYS
--U _PyPyDateTime_DELTA_GET_MICROSECONDS
--U _PyPyDateTime_DELTA_GET_SECONDS
--U _PyPyDateTime_FromTimestamp
--U _PyPyDateTime_GET_DAY
--U _PyPyDateTime_GET_FOLD
--U _PyPyDateTime_GET_MONTH
--U _PyPyDateTime_GET_YEAR
--U _PyPyDateTime_TIME_GET_FOLD
--U _PyPyDateTime_TIME_GET_HOUR
--U _PyPyDateTime_TIME_GET_MICROSECOND
--U _PyPyDateTime_TIME_GET_MINUTE
--U _PyPyDateTime_TIME_GET_SECOND
--U _PyPyDate_Check
--U _PyPyDate_CheckExact
--U _PyPyDate_FromTimestamp
--U _PyPyDelta_Check
--U _PyPyDelta_CheckExact
--U _PyPyDescr_NewClassMethod
--U _PyPyDescr_NewGetSet
--U _PyPyDescr_NewMethod
--U _PyPyDictKeys_Type
--U _PyPyDictProxy_Check
--U _PyPyDictProxy_CheckExact
--U _PyPyDictProxy_New
--U _PyPyDictProxy_Type
--U _PyPyDictValues_Type
--U _PyPyDict_Clear
--U _PyPyDict_Contains
--U _PyPyDict_Copy
--U _PyPyDict_DelItem
--U _PyPyDict_DelItemString
--U _PyPyDict_GetItem
--U _PyPyDict_GetItemString
--U _PyPyDict_GetItemWithError
--U _PyPyDict_Items
--U _PyPyDict_Keys
--U _PyPyDict_Merge
--U _PyPyDict_New
--U _PyPyDict_Next
--U _PyPyDict_SetDefault
--U _PyPyDict_SetItem
--U _PyPyDict_SetItemString
--U _PyPyDict_Size
--U _PyPyDict_Type
--U _PyPyDict_Update
--U _PyPyDict_Values
--U _PyPyErr_BadArgument
--U _PyPyErr_BadInternalCall
--U _PyPyErr_CheckSignals
--U _PyPyErr_Clear
--U _PyPyErr_Display
--U _PyPyErr_ExceptionMatches
--U _PyPyErr_Fetch
--U _PyPyErr_Format
--U _PyPyErr_GetExcInfo
--U _PyPyErr_GivenExceptionMatches
--U _PyPyErr_NewException
--U _PyPyErr_NewExceptionWithDoc
--U _PyPyErr_NoMemory
--U _PyPyErr_NormalizeException
--U _PyPyErr_Occurred
--U _PyPyErr_Print
--U _PyPyErr_PrintEx
--U _PyPyErr_Restore
--U _PyPyErr_SetExcInfo
--U _PyPyErr_SetFromErrno
--U _PyPyErr_SetFromErrnoWithFilename
--U _PyPyErr_SetFromErrnoWithFilenameObject
--U _PyPyErr_SetFromErrnoWithFilenameObjects
--U _PyPyErr_SetInterrupt
--U _PyPyErr_SetNone
--U _PyPyErr_SetObject
--U _PyPyErr_SetString
--U _PyPyErr_Warn
--U _PyPyErr_WarnEx
--U _PyPyErr_WarnExplicit
--U _PyPyErr_WarnFormat
--U _PyPyErr_WriteUnraisable
--U _PyPyEval_AcquireThread
--U _PyPyEval_CallFunction
--U _PyPyEval_CallMethod
--U _PyPyEval_CallObjectWithKeywords
--U _PyPyEval_EvalCode
--U _PyPyEval_GetBuiltins
--U _PyPyEval_GetFrame
--U _PyPyEval_GetGlobals
--U _PyPyEval_GetLocals
--U _PyPyEval_InitThreads
--U _PyPyEval_MergeCompilerFlags
--U _PyPyEval_ReleaseThread
--U _PyPyEval_RestoreThread
--U _PyPyEval_SaveThread
--U _PyPyEval_ThreadsInitialized
--U _PyPyExc_ArithmeticError
--U _PyPyExc_AssertionError
--U _PyPyExc_AttributeError
--U _PyPyExc_BaseException
--U _PyPyExc_BlockingIOError
--U _PyPyExc_BrokenPipeError
--U _PyPyExc_BufferError
--U _PyPyExc_BytesWarning
--U _PyPyExc_ChildProcessError
--U _PyPyExc_ConnectionAbortedError
--U _PyPyExc_ConnectionError
--U _PyPyExc_ConnectionRefusedError
--U _PyPyExc_ConnectionResetError
--U _PyPyExc_DeprecationWarning
--U _PyPyExc_EOFError
--U _PyPyExc_Exception
--U _PyPyExc_FileExistsError
--U _PyPyExc_FileNotFoundError
--U _PyPyExc_FloatingPointError
--U _PyPyExc_FutureWarning
--U _PyPyExc_GeneratorExit
--U _PyPyExc_ImportError
--U _PyPyExc_ImportWarning
--U _PyPyExc_IndentationError
--U _PyPyExc_IndexError
--U _PyPyExc_InterruptedError
--U _PyPyExc_IsADirectoryError
--U _PyPyExc_KeyError
--U _PyPyExc_KeyboardInterrupt
--U _PyPyExc_LookupError
--U _PyPyExc_MemoryError
--U _PyPyExc_ModuleNotFoundError
--U _PyPyExc_NameError
--U _PyPyExc_NotADirectoryError
--U _PyPyExc_NotImplementedError
--U _PyPyExc_OSError
--U _PyPyExc_OverflowError
--U _PyPyExc_PendingDeprecationWarning
--U _PyPyExc_PermissionError
--U _PyPyExc_ProcessLookupError
--U _PyPyExc_RecursionError
--U _PyPyExc_ReferenceError
--U _PyPyExc_ResourceWarning
--U _PyPyExc_RuntimeError
--U _PyPyExc_RuntimeWarning
--U _PyPyExc_StopAsyncIteration
--U _PyPyExc_StopIteration
--U _PyPyExc_SyntaxError
--U _PyPyExc_SyntaxWarning
--U _PyPyExc_SystemError
--U _PyPyExc_SystemExit
--U _PyPyExc_TabError
--U _PyPyExc_TimeoutError
--U _PyPyExc_TypeError
--U _PyPyExc_UnboundLocalError
--U _PyPyExc_UnicodeDecodeError
--U _PyPyExc_UnicodeEncodeError
--U _PyPyExc_UnicodeError
--U _PyPyExc_UnicodeTranslateError
--U _PyPyExc_UnicodeWarning
--U _PyPyExc_UserWarning
--U _PyPyExc_ValueError
--U _PyPyExc_Warning
--U _PyPyExc_ZeroDivisionError
--U _PyPyExceptionInstance_Class
--U _PyPyException_GetCause
--U _PyPyException_GetContext
--U _PyPyException_GetTraceback
--U _PyPyException_SetCause
--U _PyPyException_SetContext
--U _PyPyException_SetTraceback
--U _PyPyFile_FromFd
--U _PyPyFile_FromString
--U _PyPyFile_GetLine
--U _PyPyFile_WriteObject
--U _PyPyFile_WriteString
--U _PyPyFloat_AS_DOUBLE
--U _PyPyFloat_AsDouble
--U _PyPyFloat_Check
--U _PyPyFloat_CheckExact
--U _PyPyFloat_FromDouble
--U _PyPyFloat_FromString
--U _PyPyFloat_Type
--U _PyPyFrame_New
--U _PyPyFrozenSet_Check
--U _PyPyFrozenSet_CheckExact
--U _PyPyFrozenSet_New
--U _PyPyFrozenSet_Type
--U _PyPyFunction_Check
--U _PyPyFunction_CheckExact
--U _PyPyFunction_GetCode
--U _PyPyFunction_Type
--U _PyPyGILState_Check
--U _PyPyGILState_Ensure
--U _PyPyGILState_Release
--U _PyPyGen_Check
--U _PyPyGen_CheckExact
--U _PyPyGetSetDescr_Type
--U _PyPyImport_AddModule
--U _PyPyImport_ExecCodeModule
--U _PyPyImport_ExecCodeModuleEx
--U _PyPyImport_GetModule
--U _PyPyImport_GetModuleDict
--U _PyPyImport_Import
--U _PyPyImport_ImportModule
--U _PyPyImport_ImportModuleLevelObject
--U _PyPyImport_ImportModuleNoBlock
--U _PyPyImport_ReloadModule
--U _PyPyIndex_Check
--U _PyPyInstanceMethod_Check
--U _PyPyInstanceMethod_Function
--U _PyPyInstanceMethod_GET_FUNCTION
--U _PyPyInstanceMethod_New
--U _PyPyInstanceMethod_Type
--U _PyPyInterpreterState_GetID
--U _PyPyInterpreterState_Head
--U _PyPyInterpreterState_Next
--U _PyPyIter_Check
--U _PyPyIter_Next
--U _PyPyList_Append
--U _PyPyList_AsTuple
--U _PyPyList_GET_ITEM
--U _PyPyList_GET_SIZE
--U _PyPyList_GetItem
--U _PyPyList_GetSlice
--U _PyPyList_Insert
--U _PyPyList_New
--U _PyPyList_Reverse
--U _PyPyList_SET_ITEM
--U _PyPyList_SetItem
--U _PyPyList_SetSlice
--U _PyPyList_Size
--U _PyPyList_Sort
--U _PyPyList_Type
--U _PyPyLong_AsDouble
--U _PyPyLong_AsLong
--U _PyPyLong_AsLongAndOverflow
--U _PyPyLong_AsLongLong
--U _PyPyLong_AsLongLongAndOverflow
--U _PyPyLong_AsSize_t
--U _PyPyLong_AsSsize_t
--U _PyPyLong_AsUnsignedLong
--U _PyPyLong_AsUnsignedLongLong
--U _PyPyLong_AsUnsignedLongLongMask
--U _PyPyLong_AsUnsignedLongMask
--U _PyPyLong_AsVoidPtr
--U _PyPyLong_FromDouble
--U _PyPyLong_FromLong
--U _PyPyLong_FromLongLong
--U _PyPyLong_FromSize_t
--U _PyPyLong_FromSsize_t
--U _PyPyLong_FromString
--U _PyPyLong_FromUnicode
--U _PyPyLong_FromUnicodeObject
--U _PyPyLong_FromUnsignedLong
--U _PyPyLong_FromUnsignedLongLong
--U _PyPyLong_FromVoidPtr
--U _PyPyLong_Type
--U _PyPyMapping_Check
--U _PyPyMapping_GetItemString
--U _PyPyMapping_HasKey
--U _PyPyMapping_HasKeyString
--U _PyPyMapping_Items
--U _PyPyMapping_Keys
--U _PyPyMapping_Length
--U _PyPyMapping_SetItemString
--U _PyPyMapping_Size
--U _PyPyMapping_Values
--U _PyPyMarshal_ReadObjectFromString
--U _PyPyMarshal_WriteObjectToString
--U _PyPyMem_Calloc
--U _PyPyMem_Free
--U _PyPyMem_Malloc
--U _PyPyMem_RawCalloc
--U _PyPyMem_RawFree
--U _PyPyMem_RawMalloc
--U _PyPyMem_RawRealloc
--U _PyPyMem_Realloc
--U _PyPyMemberDescr_Type
--U _PyPyMember_GetOne
--U _PyPyMember_SetOne
--U _PyPyMemoryView_Check
--U _PyPyMemoryView_CheckExact
--U _PyPyMemoryView_FromBuffer
--U _PyPyMemoryView_FromMemory
--U _PyPyMemoryView_FromObject
--U _PyPyMemoryView_GetContiguous
--U _PyPyMemoryView_Type
--U _PyPyMethodDescr_Check
--U _PyPyMethodDescr_CheckExact
--U _PyPyMethodDescr_Type
--U _PyPyMethod_Check
--U _PyPyMethod_CheckExact
--U _PyPyMethod_Function
--U _PyPyMethod_New
--U _PyPyMethod_Self
--U _PyPyMethod_Type
--U _PyPyModuleDef_Init
--U _PyPyModule_AddFunctions
--U _PyPyModule_AddIntConstant
--U _PyPyModule_AddObject
--U _PyPyModule_AddStringConstant
--U _PyPyModule_Check
--U _PyPyModule_CheckExact
--U _PyPyModule_Create2
--U _PyPyModule_ExecDef
--U _PyPyModule_GetDef
--U _PyPyModule_GetDict
--U _PyPyModule_GetName
--U _PyPyModule_GetState
--U _PyPyModule_New
--U _PyPyModule_NewObject
--U _PyPyModule_Type
--U _PyPyNumber_Absolute
--U _PyPyNumber_Add
--U _PyPyNumber_And
--U _PyPyNumber_AsSsize_t
--U _PyPyNumber_Check
--U _PyPyNumber_Divide
--U _PyPyNumber_Divmod
--U _PyPyNumber_Float
--U _PyPyNumber_FloorDivide
--U _PyPyNumber_InPlaceAdd
--U _PyPyNumber_InPlaceAnd
--U _PyPyNumber_InPlaceDivide
--U _PyPyNumber_InPlaceFloorDivide
--U _PyPyNumber_InPlaceLshift
--U _PyPyNumber_InPlaceMatrixMultiply
--U _PyPyNumber_InPlaceMultiply
--U _PyPyNumber_InPlaceOr
--U _PyPyNumber_InPlacePower
--U _PyPyNumber_InPlaceRemainder
--U _PyPyNumber_InPlaceRshift
--U _PyPyNumber_InPlaceSubtract
--U _PyPyNumber_InPlaceTrueDivide
--U _PyPyNumber_InPlaceXor
--U _PyPyNumber_Index
--U _PyPyNumber_Invert
--U _PyPyNumber_Long
--U _PyPyNumber_Lshift
--U _PyPyNumber_MatrixMultiply
--U _PyPyNumber_Multiply
--U _PyPyNumber_Negative
--U _PyPyNumber_Or
--U _PyPyNumber_Positive
--U _PyPyNumber_Power
--U _PyPyNumber_Remainder
--U _PyPyNumber_Rshift
--U _PyPyNumber_Subtract
--U _PyPyNumber_ToBase
--U _PyPyNumber_TrueDivide
--U _PyPyNumber_Xor
--U _PyPyOS_AfterFork
--U _PyPyOS_FSPath
--U _PyPyOS_InputHook
--U _PyPyOS_InterruptOccurred
--U _PyPyOS_double_to_string
--U _PyPyOS_getsig
--U _PyPyOS_setsig
--U _PyPyOS_snprintf
--U _PyPyOS_string_to_double
--U _PyPyOS_vsnprintf
--U _PyPyObject_ASCII
--U _PyPyObject_AsCharBuffer
--U _PyPyObject_AsFileDescriptor
--U _PyPyObject_AsReadBuffer
--U _PyPyObject_AsWriteBuffer
--U _PyPyObject_Bytes
--U _PyPyObject_Call
--U _PyPyObject_CallFinalizerFromDealloc
--U _PyPyObject_CallFunction
--U _PyPyObject_CallFunctionObjArgs
--U _PyPyObject_CallMethod
--U _PyPyObject_CallMethodNoArgs
--U _PyPyObject_CallMethodObjArgs
--U _PyPyObject_CallMethodOneArg
--U _PyPyObject_CallNoArgs
--U _PyPyObject_CallObject
--U _PyPyObject_CallOneArg
--U _PyPyObject_Calloc
--U _PyPyObject_CheckReadBuffer
--U _PyPyObject_ClearWeakRefs
--U _PyPyObject_Del
--U _PyPyObject_DelAttr
--U _PyPyObject_DelAttrString
--U _PyPyObject_DelItem
--U _PyPyObject_DelItemString
--U _PyPyObject_Dir
--U _PyPyObject_Format
--U _PyPyObject_Free
--U _PyPyObject_GC_Del
--U _PyPyObject_GenericGetAttr
--U _PyPyObject_GenericGetDict
--U _PyPyObject_GenericSetAttr
--U _PyPyObject_GenericSetDict
--U _PyPyObject_GetAttr
--U _PyPyObject_GetAttrString
--U _PyPyObject_GetBuffer
--U _PyPyObject_GetItem
--U _PyPyObject_GetIter
--U _PyPyObject_HasAttr
--U _PyPyObject_HasAttrString
--U _PyPyObject_Hash
--U _PyPyObject_HashNotImplemented
--U _PyPyObject_Init
--U _PyPyObject_InitVar
--U _PyPyObject_IsInstance
--U _PyPyObject_IsSubclass
--U _PyPyObject_IsTrue
--U _PyPyObject_LengthHint
--U _PyPyObject_Malloc
--U _PyPyObject_Not
--U _PyPyObject_Print
--U _PyPyObject_Realloc
--U _PyPyObject_Repr
--U _PyPyObject_RichCompare
--U _PyPyObject_RichCompareBool
--U _PyPyObject_SelfIter
--U _PyPyObject_SetAttr
--U _PyPyObject_SetAttrString
--U _PyPyObject_SetItem
--U _PyPyObject_Size
--U _PyPyObject_Str
--U _PyPyObject_Type
--U _PyPyObject_Unicode
--U _PyPyObject_Vectorcall
--U _PyPyObject_VectorcallDict
--U _PyPyObject_VectorcallMethod
--U _PyPyProperty_Type
--U _PyPyRange_Type
--U _PyPyReversed_Type
--U _PyPyRun_File
--U _PyPyRun_SimpleString
--U _PyPyRun_String
--U _PyPyRun_StringFlags
--U _PyPySeqIter_New
--U _PyPySequence_Check
--U _PyPySequence_Concat
--U _PyPySequence_Contains
--U _PyPySequence_DelItem
--U _PyPySequence_DelSlice
--U _PyPySequence_Fast
--U _PyPySequence_Fast_GET_ITEM
--U _PyPySequence_Fast_GET_SIZE
--U _PyPySequence_Fast_ITEMS
--U _PyPySequence_GetItem
--U _PyPySequence_GetSlice
--U _PyPySequence_ITEM
--U _PyPySequence_InPlaceConcat
--U _PyPySequence_InPlaceRepeat
--U _PyPySequence_Index
--U _PyPySequence_Length
--U _PyPySequence_List
--U _PyPySequence_Repeat
--U _PyPySequence_SetItem
--U _PyPySequence_SetSlice
--U _PyPySequence_Size
--U _PyPySequence_Tuple
--U _PyPySet_Add
--U _PyPySet_Check
--U _PyPySet_CheckExact
--U _PyPySet_Clear
--U _PyPySet_Contains
--U _PyPySet_Discard
--U _PyPySet_GET_SIZE
--U _PyPySet_New
--U _PyPySet_Pop
--U _PyPySet_Size
--U _PyPySet_Type
--U _PyPySlice_AdjustIndices
--U _PyPySlice_GetIndices
--U _PyPySlice_GetIndicesEx
--U _PyPySlice_New
--U _PyPySlice_Type
--U _PyPySlice_Unpack
--U _PyPyState_AddModule
--U _PyPyState_RemoveModule
--U _PyPyStaticMethod_New
--U _PyPyStaticMethod_Type
--U _PyPyStructSequence_GetItem
--U _PyPyStructSequence_InitType
--U _PyPyStructSequence_InitType2
--U _PyPyStructSequence_New
--U _PyPyStructSequence_NewType
--U _PyPyStructSequence_SetItem
--U _PyPyStructSequence_UnnamedField
--U _PyPySys_GetObject
--U _PyPySys_SetObject
--U _PyPySys_WriteStderr
--U _PyPySys_WriteStdout
--U _PyPyTZInfo_Check
--U _PyPyTZInfo_CheckExact
--U _PyPyThreadState_Clear
--U _PyPyThreadState_Delete
--U _PyPyThreadState_DeleteCurrent
--U _PyPyThreadState_Get
--U _PyPyThreadState_GetDict
--U _PyPyThreadState_New
--U _PyPyThreadState_SetAsyncExc
--U _PyPyThreadState_Swap
--U _PyPyThread_ReInitTLS
--U _PyPyThread_acquire_lock
--U _PyPyThread_allocate_lock
--U _PyPyThread_create_key
--U _PyPyThread_delete_key
--U _PyPyThread_delete_key_value
--U _PyPyThread_exit_thread
--U _PyPyThread_free_lock
--U _PyPyThread_get_key_value
--U _PyPyThread_get_thread_ident
--U _PyPyThread_init_thread
--U _PyPyThread_release_lock
--U _PyPyThread_set_key_value
--U _PyPyThread_start_new_thread
--U _PyPyTime_Check
--U _PyPyTime_CheckExact
--U _PyPyTraceBack_Check
--U _PyPyTraceBack_Here
--U _PyPyTraceBack_Print
--U _PyPyTraceBack_Type
--U _PyPyTraceMalloc_Track
--U _PyPyTraceMalloc_Untrack
--U _PyPyTuple_GetItem
--U _PyPyTuple_GetSlice
--U _PyPyTuple_New
--U _PyPyTuple_Pack
--U _PyPyTuple_SetItem
--U _PyPyTuple_Size
--U _PyPyTuple_Type
--U _PyPyType_FromModuleAndSpec
--U _PyPyType_FromSpec
--U _PyPyType_FromSpecWithBases
--U _PyPyType_GenericAlloc
--U _PyPyType_GenericNew
--U _PyPyType_GetModule
--U _PyPyType_GetModuleState
--U _PyPyType_GetName
--U _PyPyType_GetSlot
--U _PyPyType_IsSubtype
--U _PyPyType_Modified
--U _PyPyType_Ready
--U _PyPyType_Type
--U _PyPyUnicode_Append
--U _PyPyUnicode_AppendAndDel
--U _PyPyUnicode_AsASCIIString
--U _PyPyUnicode_AsEncodedObject
--U _PyPyUnicode_AsEncodedString
--U _PyPyUnicode_AsLatin1String
--U _PyPyUnicode_AsUCS4
--U _PyPyUnicode_AsUCS4Copy
--U _PyPyUnicode_AsUTF16String
--U _PyPyUnicode_AsUTF32String
--U _PyPyUnicode_AsUTF8
--U _PyPyUnicode_AsUTF8AndSize
--U _PyPyUnicode_AsUTF8String
--U _PyPyUnicode_AsUnicode
--U _PyPyUnicode_AsUnicodeAndSize
--U _PyPyUnicode_AsUnicodeEscapeString
--U _PyPyUnicode_AsWideChar
--U _PyPyUnicode_AsWideCharString
--U _PyPyUnicode_Check
--U _PyPyUnicode_CheckExact
--U _PyPyUnicode_Compare
--U _PyPyUnicode_CompareWithASCIIString
--U _PyPyUnicode_Concat
--U _PyPyUnicode_Contains
--U _PyPyUnicode_Count
--U _PyPyUnicode_Decode
--U _PyPyUnicode_DecodeASCII
--U _PyPyUnicode_DecodeFSDefault
--U _PyPyUnicode_DecodeFSDefaultAndSize
--U _PyPyUnicode_DecodeLatin1
--U _PyPyUnicode_DecodeLocale
--U _PyPyUnicode_DecodeLocaleAndSize
--U _PyPyUnicode_DecodeUTF16
--U _PyPyUnicode_DecodeUTF32
--U _PyPyUnicode_DecodeUTF8
--U _PyPyUnicode_EncodeASCII
--U _PyPyUnicode_EncodeDecimal
--U _PyPyUnicode_EncodeFSDefault
--U _PyPyUnicode_EncodeLatin1
--U _PyPyUnicode_EncodeLocale
--U _PyPyUnicode_EncodeUTF8
--U _PyPyUnicode_FSConverter
--U _PyPyUnicode_FSDecoder
--U _PyPyUnicode_Find
--U _PyPyUnicode_FindChar
--U _PyPyUnicode_Format
--U _PyPyUnicode_FromEncodedObject
--U _PyPyUnicode_FromFormat
--U _PyPyUnicode_FromFormatV
--U _PyPyUnicode_FromKindAndData
--U _PyPyUnicode_FromObject
--U _PyPyUnicode_FromOrdinal
--U _PyPyUnicode_FromString
--U _PyPyUnicode_FromStringAndSize
--U _PyPyUnicode_FromUnicode
--U _PyPyUnicode_FromWideChar
--U _PyPyUnicode_GetDefaultEncoding
--U _PyPyUnicode_GetLength
--U _PyPyUnicode_GetMax
--U _PyPyUnicode_GetSize
--U _PyPyUnicode_InternFromString
--U _PyPyUnicode_InternInPlace
--U _PyPyUnicode_Join
--U _PyPyUnicode_New
--U _PyPyUnicode_ReadChar
--U _PyPyUnicode_Replace
--U _PyPyUnicode_Resize
--U _PyPyUnicode_Split
--U _PyPyUnicode_Splitlines
--U _PyPyUnicode_Substring
--U _PyPyUnicode_Tailmatch
--U _PyPyUnicode_TransformDecimalToASCII
--U _PyPyUnicode_Type
--U _PyPyUnicode_WriteChar
--U _PyPyVectorcall_Call
--U _PyPyWeakref_Check
--U _PyPyWeakref_CheckProxy
--U _PyPyWeakref_CheckRef
--U _PyPyWeakref_CheckRefExact
--U _PyPyWeakref_GET_OBJECT
--U _PyPyWeakref_GetObject
--U _PyPyWeakref_LockObject
--U _PyPyWeakref_NewProxy
--U _PyPyWeakref_NewRef
--U _PyPyWrapperDescr_Type
--U _PyPy_AddPendingCall
--U _PyPy_AtExit
--U _PyPy_BuildValue
--U _PyPy_BytesWarningFlag
--U _PyPy_CompileStringFlags
--U _PyPy_DebugFlag
--U _PyPy_DecRef
--U _PyPy_DontWriteBytecodeFlag
--U _PyPy_EnterRecursiveCall
--U _PyPy_FatalError
--U _PyPy_FindMethod
--U _PyPy_FrozenFlag
--U _PyPy_GenericAlias
--U _PyPy_GetProgramName
--U _PyPy_GetRecursionLimit
--U _PyPy_GetVersion
--U _PyPy_HashRandomizationFlag
--U _PyPy_IgnoreEnvironmentFlag
--U _PyPy_IncRef
--U _PyPy_InspectFlag
--U _PyPy_InteractiveFlag
--U _PyPy_IsInitialized
--U _PyPy_IsolatedFlag
--U _PyPy_LeaveRecursiveCall
--U _PyPy_MakePendingCalls
--U _PyPy_NoSiteFlag
--U _PyPy_NoUserSiteDirectory
--U _PyPy_OptimizeFlag
--U _PyPy_QuietFlag
--U _PyPy_ReprEnter
--U _PyPy_ReprLeave
--U _PyPy_SetRecursionLimit
--U _PyPy_UNICODE_COPY
--U _PyPy_UNICODE_ISALNUM
--U _PyPy_UNICODE_ISALPHA
--U _PyPy_UNICODE_ISDECIMAL
--U _PyPy_UNICODE_ISDIGIT
--U _PyPy_UNICODE_ISLINEBREAK
--U _PyPy_UNICODE_ISLOWER
--U _PyPy_UNICODE_ISNUMERIC
--U _PyPy_UNICODE_ISSPACE
--U _PyPy_UNICODE_ISTITLE
--U _PyPy_UNICODE_ISUPPER
--U _PyPy_UNICODE_TODECIMAL
--U _PyPy_UNICODE_TODIGIT
--U _PyPy_UNICODE_TOLOWER
--U _PyPy_UNICODE_TONUMERIC
--U _PyPy_UNICODE_TOTITLE
--U _PyPy_UNICODE_TOUPPER
--U _PyPy_UnbufferedStdioFlag
--U _PyPy_VaBuildValue
--U _PyPy_VerboseFlag
--U _PySlice_AdjustIndices
--U _PyState_FindModule
--U _PyThread_tss_alloc
--U _PyThread_tss_create
--U _PyThread_tss_delete
--U _PyThread_tss_free
--U _PyThread_tss_get
--U _PyThread_tss_is_created
--U _PyThread_tss_set
--U _PyType_GetFlags
--U _Py_FileSystemDefaultEncoding
--U __PyArg_BadArgument
--U __PyArg_CheckPositional
--U __PyArg_NoKeywords
--U __PyArg_NoKwnames
--U __PyArg_NoPositional
--U __PyArg_ParseStack
--U __PyArg_ParseStackAndKeywords
--U __PyArg_ParseStackAndKeywords_SizeT
--U __PyArg_ParseStack_SizeT
--U __PyArg_ParseTupleAndKeywordsFast
--U __PyArg_ParseTupleAndKeywordsFast_SizeT
--U __PyArg_UnpackKeywords
--U __PyArg_UnpackStack
--U __PyArg_VaParseTupleAndKeywordsFast
--U __PyArg_VaParseTupleAndKeywordsFast_SizeT
--U __PyExc_ArithmeticError
--U __PyExc_AssertionError
--U __PyExc_AttributeError
--U __PyExc_BaseException
--U __PyExc_BlockingIOError
--U __PyExc_BrokenPipeError
--U __PyExc_BufferError
--U __PyExc_BytesWarning
--U __PyExc_ChildProcessError
--U __PyExc_ConnectionAbortedError
--U __PyExc_ConnectionError
--U __PyExc_ConnectionRefusedError
--U __PyExc_ConnectionResetError
--U __PyExc_DeprecationWarning
--U __PyExc_EOFError
--U __PyExc_Exception
--U __PyExc_FileExistsError
--U __PyExc_FileNotFoundError
--U __PyExc_FloatingPointError
--U __PyExc_FutureWarning
--U __PyExc_GeneratorExit
--U __PyExc_ImportError
--U __PyExc_ImportWarning
--U __PyExc_IndentationError
--U __PyExc_IndexError
--U __PyExc_InterruptedError
--U __PyExc_IsADirectoryError
--U __PyExc_KeyError
--U __PyExc_KeyboardInterrupt
--U __PyExc_LookupError
--U __PyExc_MemoryError
--U __PyExc_ModuleNotFoundError
--U __PyExc_NameError
--U __PyExc_NotADirectoryError
--U __PyExc_NotImplementedError
--U __PyExc_OSError
--U __PyExc_OverflowError
--U __PyExc_PendingDeprecationWarning
--U __PyExc_PermissionError
--U __PyExc_ProcessLookupError
--U __PyExc_RecursionError
--U __PyExc_ReferenceError
--U __PyExc_ResourceWarning
--U __PyExc_RuntimeError
--U __PyExc_RuntimeWarning
--U __PyExc_StopAsyncIteration
--U __PyExc_StopIteration
--U __PyExc_SyntaxError
--U __PyExc_SyntaxWarning
--U __PyExc_SystemError
--U __PyExc_SystemExit
--U __PyExc_TabError
--U __PyExc_TimeoutError
--U __PyExc_TypeError
--U __PyExc_UnboundLocalError
--U __PyExc_UnicodeDecodeError
--U __PyExc_UnicodeEncodeError
--U __PyExc_UnicodeError
--U __PyExc_UnicodeTranslateError
--U __PyExc_UnicodeWarning
--U __PyExc_UserWarning
--U __PyExc_ValueError
--U __PyExc_Warning
--U __PyExc_ZeroDivisionError
--U __PyLong_AsTime_t
--U __PyLong_FromTime_t
--U __PyPyArg_ParseTupleAndKeywords_SizeT
--U __PyPyArg_ParseTuple_SizeT
--U __PyPyArg_Parse_SizeT
--U __PyPyArg_VaParseTupleAndKeywords_SizeT
--U __PyPyArg_VaParse_SizeT
--U __PyPyBytes_Eq
--U __PyPyBytes_Join
--U __PyPyBytes_Resize
--U __PyPyComplex_AsCComplex
--U __PyPyComplex_FromCComplex
--U __PyPyDateTime_FromDateAndTime
--U __PyPyDateTime_FromDateAndTimeAndFold
--U __PyPyDateTime_FromTimestamp
--U __PyPyDateTime_Import
--U __PyPyDate_FromDate
--U __PyPyDate_FromTimestamp
--U __PyPyDelta_FromDelta
--U __PyPyDict_GetItemStringWithError
--U __PyPyDict_HasOnlyStringKeys
--U __PyPyErr_FormatFromCause
--U __PyPyErr_WriteUnraisableMsg
--U __PyPyEval_SliceIndex
--U __PyPyFloat_Unpack4
--U __PyPyFloat_Unpack8
--U __PyPyImport_AcquireLock
--U __PyPyImport_ReleaseLock
--U __PyPyList_Extend
--U __PyPyLong_AsByteArrayO
--U __PyPyLong_FromByteArray
--U __PyPyLong_NumBits
--U __PyPyLong_Sign
--U __PyPyNamespace_New
--U __PyPyNone_Type
--U __PyPyNotImplemented_Type
--U __PyPyObject_CallFunction_SizeT
--U __PyPyObject_CallMethod_SizeT
--U __PyPyObject_FastCall
--U __PyPyObject_GC_Malloc
--U __PyPyObject_GC_New
--U __PyPyObject_GC_NewVar
--U __PyPyObject_GetDictPtr
--U __PyPyObject_New
--U __PyPyObject_NewVar
--U __PyPyObject_Vectorcall
--U __PyPyPyGC_AddMemoryPressure
--U __PyPyPy_Free
--U __PyPyPy_Malloc
--U __PyPySet_Next
--U __PyPySet_NextEntry
--U __PyPyThreadState_UncheckedGet
--U __PyPyTimeZone_FromTimeZone
--U __PyPyTime_FromTime
--U __PyPyTime_FromTimeAndFold
--U __PyPyTuple_Resize
--U __PyPyType_Lookup
--U __PyPyUnicode_EQ
--U __PyPyUnicode_EqualToASCIIString
--U __PyPyUnicode_Ready
--U __PyPy_BuildValue_SizeT
--U __PyPy_Dealloc
--U __PyPy_EllipsisObject
--U __PyPy_FalseStruct
--U __PyPy_HashDouble
--U __PyPy_HashPointer
--U __PyPy_IsFinalizing
--U __PyPy_NoneStruct
--U __PyPy_NotImplementedStruct
--U __PyPy_PackageContext
--U __PyPy_RestoreSignals
--U __PyPy_TrueStruct
--U __PyPy_VaBuildValue_SizeT
--U __PyPy_get_PyOS_InputHook
--U __PyPy_get_capsule_type
--U __PyPy_object_dealloc
--U __PyPy_setfilesystemdefaultencoding
--U __PyPy_strhex
--U __PyPy_strhex_bytes
--U __PyPy_subtype_dealloc
--U __PyPy_tuple_dealloc
--U __PyPy_tuple_new
--U __PyTime_AsMicroseconds
--U __PyTime_AsMilliseconds
--U __PyTime_AsNanosecondsObject
--U __PyTime_AsSecondsDouble
--U __PyTime_AsTimeval
--U __PyTime_AsTimevalTime_t
--U __PyTime_AsTimeval_noraise
--U __PyTime_FromMillisecondsObject
--U __PyTime_FromNanoseconds
--U __PyTime_FromNanosecondsObject
--U __PyTime_FromSeconds
--U __PyTime_FromSecondsObject
--U __PyTime_GetMonotonicClock
--U __PyTime_GetMonotonicClockWithInfo
--U __PyTime_GetSystemClock
--U __PyTime_GetSystemClockWithInfo
--U __PyTime_Init
--U __PyTime_ObjectToTime_t
--U __PyTime_ObjectToTimespec
--U __PyTime_ObjectToTimeval
--U __PyTime_gmtime
--U __PyTime_localtime
--U __PyType_Name
diff --git a/src/nanobind/cmake/darwin-python-path.py b/src/nanobind/cmake/darwin-python-path.py
deleted file mode 100644
index c9d216f..0000000
--- a/src/nanobind/cmake/darwin-python-path.py
+++ /dev/null
@@ -1,15 +0,0 @@
-#!/usr/bin/env python3
-
-# On macOS, system python binaries like /usr/bin/python and $(xcrun -f python3)
-# are shims. They do some light validation work and then spawn the "real" python
-# binary. Find the "real" python by asking dyld -- sys.executable reports the
-# wrong thing more often than not. This is also useful when we're running under
-# a Homebrew python3 binary, which also appears to be some kind of shim.
-# (Taken from https://reviews.llvm.org/D79607)
-
-import ctypes
-dyld = ctypes.cdll.LoadLibrary('/usr/lib/system/libdyld.dylib')
-namelen = ctypes.c_ulong(1024)
-name = ctypes.create_string_buffer(b'\000', namelen.value)
-dyld._NSGetExecutablePath(ctypes.byref(name), ctypes.byref(namelen))
-print(name.value.decode('utf8').strip())
diff --git a/src/nanobind/cmake/nanobind-config.cmake b/src/nanobind/cmake/nanobind-config.cmake
deleted file mode 100644
index 3053285..0000000
--- a/src/nanobind/cmake/nanobind-config.cmake
+++ /dev/null
@@ -1,681 +0,0 @@
-include_guard(GLOBAL)
-
-if (NOT TARGET Python::Module)
-  message(FATAL_ERROR "You must invoke 'find_package(Python COMPONENTS Interpreter Development REQUIRED)' prior to including nanobind.")
-endif()
-
-# Determine the right suffix for ordinary and stable ABI extensions.
-
-# We always need to know the extension
-if(WIN32)
-  set(NB_SUFFIX_EXT ".pyd")
-else()
-  set(NB_SUFFIX_EXT "${CMAKE_SHARED_MODULE_SUFFIX}")
-endif()
-
-# Check if FindPython/scikit-build-core defined a SOABI/SOSABI variable
-if(DEFINED SKBUILD_SOABI)
-  set(NB_SOABI "${SKBUILD_SOABI}")
-elseif(DEFINED Python_SOABI)
-  set(NB_SOABI "${Python_SOABI}")
-endif()
-
-if(DEFINED SKBUILD_SOSABI)
-  set(NB_SOSABI "${SKBUILD_SOSABI}")
-elseif(DEFINED Python_SOSABI)
-  set(NB_SOSABI "${Python_SOSABI}")
-endif()
-
-# Error if scikit-build-core is trying to build Stable ABI < 3.12 wheels
-if(DEFINED SKBUILD_SABI_VERSION AND SKBUILD_ABI_VERSION AND SKBUILD_SABI_VERSION VERSION_LESS "3.12")
-  message(FATAL_ERROR "You must set tool.scikit-build.wheel.py-api to 'cp312' or later when "
-                      "using scikit-build-core with nanobind, '${SKBUILD_SABI_VERSION}' is too old.")
-endif()
-
-# PyPy sets an invalid SOABI (platform missing), causing older FindPythons to
-# report an incorrect value. Only use it if it looks correct (X-X-X form).
-if(DEFINED NB_SOABI AND "${NB_SOABI}" MATCHES ".+-.+-.+")
-  set(NB_SUFFIX ".${NB_SOABI}${NB_SUFFIX_EXT}")
-endif()
-
-if(DEFINED NB_SOSABI)
-  if(NB_SOSABI STREQUAL "")
-    set(NB_SUFFIX_S "${NB_SUFFIX_EXT}")
-  else()
-    set(NB_SUFFIX_S ".${NB_SOSABI}${NB_SUFFIX_EXT}")
-  endif()
-endif()
-
-# Extract Python version and extensions (e.g. free-threaded build)
-string(REGEX REPLACE "[^-]*-([^-]*)-.*" "\\1" NB_ABI "${NB_SOABI}")
-
-# If either suffix is missing, call Python to compute it
-if(NOT DEFINED NB_SUFFIX OR NOT DEFINED NB_SUFFIX_S)
-  # Query Python directly to get the right suffix.
-  execute_process(
-    COMMAND "${Python_EXECUTABLE}" "-c"
-      "import sysconfig; print(sysconfig.get_config_var('EXT_SUFFIX'))"
-    RESULT_VARIABLE NB_SUFFIX_RET
-    OUTPUT_VARIABLE EXT_SUFFIX
-    OUTPUT_STRIP_TRAILING_WHITESPACE)
-
-  if(NB_SUFFIX_RET AND NOT NB_SUFFIX_RET EQUAL 0)
-    message(FATAL_ERROR "nanobind: Python sysconfig query to "
-      "find 'EXT_SUFFIX' property failed!")
-  endif()
-
-  if(NOT DEFINED NB_SUFFIX)
-    set(NB_SUFFIX "${EXT_SUFFIX}")
-  endif()
-
-  if(NOT DEFINED NB_SUFFIX_S)
-    get_filename_component(NB_SUFFIX_EXT "${EXT_SUFFIX}" LAST_EXT)
-    if(WIN32)
-      set(NB_SUFFIX_S "${NB_SUFFIX_EXT}")
-    else()
-      set(NB_SUFFIX_S ".abi3${NB_SUFFIX_EXT}")
-    endif()
-  endif()
-endif()
-
-# Stash these for later use
-set(NB_SUFFIX   ${NB_SUFFIX}   CACHE INTERNAL "")
-set(NB_SUFFIX_S ${NB_SUFFIX_S} CACHE INTERNAL "")
-set(NB_ABI      ${NB_ABI}      CACHE INTERNAL "")
-
-get_filename_component(NB_DIR "${CMAKE_CURRENT_LIST_FILE}" PATH)
-get_filename_component(NB_DIR "${NB_DIR}" PATH)
-
-set(NB_DIR      ${NB_DIR} CACHE INTERNAL "")
-set(NB_OPT      $<OR:$<CONFIG:Release>,$<CONFIG:MinSizeRel>> CACHE INTERNAL "")
-set(NB_OPT_SIZE $<OR:$<CONFIG:Release>,$<CONFIG:MinSizeRel>,$<CONFIG:RelWithDebInfo>> CACHE INTERNAL "")
-
-# ---------------------------------------------------------------------------
-# Helper function to handle undefined CPython API symbols on macOS
-# ---------------------------------------------------------------------------
-
-function (nanobind_link_options name)
-  if (APPLE)
-    if (Python_INTERPRETER_ID STREQUAL "PyPy")
-      set(NB_LINKER_RESPONSE_FILE darwin-ld-pypy.sym)
-    else()
-      set(NB_LINKER_RESPONSE_FILE darwin-ld-cpython.sym)
-    endif()
-    target_link_options(${name} PRIVATE "-Wl,@${NB_DIR}/cmake/${NB_LINKER_RESPONSE_FILE}")
-  endif()
-endfunction()
-
-# ---------------------------------------------------------------------------
-# Create shared/static library targets for nanobind's non-templated core
-# ---------------------------------------------------------------------------
-
-function (nanobind_build_library TARGET_NAME)
-  cmake_parse_arguments(PARSE_ARGV 1 ARG
-    "AS_SYSINCLUDE" "" "")
-
-  if (TARGET ${TARGET_NAME})
-    return()
-  endif()
-
-  if (TARGET_NAME MATCHES "-static")
-    set (TARGET_TYPE STATIC)
-  else()
-    set (TARGET_TYPE SHARED)
-  endif()
-
-  if (${ARG_AS_SYSINCLUDE})
-    set (AS_SYSINCLUDE SYSTEM)
-  endif()
-
-  add_library(${TARGET_NAME} ${TARGET_TYPE}
-    EXCLUDE_FROM_ALL
-    ${NB_DIR}/include/nanobind/make_iterator.h
-    ${NB_DIR}/include/nanobind/nanobind.h
-    ${NB_DIR}/include/nanobind/nb_accessor.h
-    ${NB_DIR}/include/nanobind/nb_attr.h
-    ${NB_DIR}/include/nanobind/nb_call.h
-    ${NB_DIR}/include/nanobind/nb_cast.h
-    ${NB_DIR}/include/nanobind/nb_class.h
-    ${NB_DIR}/include/nanobind/nb_defs.h
-    ${NB_DIR}/include/nanobind/nb_descr.h
-    ${NB_DIR}/include/nanobind/nb_enums.h
-    ${NB_DIR}/include/nanobind/nb_error.h
-    ${NB_DIR}/include/nanobind/nb_func.h
-    ${NB_DIR}/include/nanobind/nb_lib.h
-    ${NB_DIR}/include/nanobind/nb_misc.h
-    ${NB_DIR}/include/nanobind/nb_python.h
-    ${NB_DIR}/include/nanobind/nb_traits.h
-    ${NB_DIR}/include/nanobind/nb_tuple.h
-    ${NB_DIR}/include/nanobind/nb_types.h
-    ${NB_DIR}/include/nanobind/ndarray.h
-    ${NB_DIR}/include/nanobind/trampoline.h
-    ${NB_DIR}/include/nanobind/typing.h
-    ${NB_DIR}/include/nanobind/operators.h
-    ${NB_DIR}/include/nanobind/stl/array.h
-    ${NB_DIR}/include/nanobind/stl/bind_map.h
-    ${NB_DIR}/include/nanobind/stl/bind_vector.h
-    ${NB_DIR}/include/nanobind/stl/detail
-    ${NB_DIR}/include/nanobind/stl/detail/nb_array.h
-    ${NB_DIR}/include/nanobind/stl/detail/nb_dict.h
-    ${NB_DIR}/include/nanobind/stl/detail/nb_list.h
-    ${NB_DIR}/include/nanobind/stl/detail/nb_set.h
-    ${NB_DIR}/include/nanobind/stl/detail/traits.h
-    ${NB_DIR}/include/nanobind/stl/filesystem.h
-    ${NB_DIR}/include/nanobind/stl/function.h
-    ${NB_DIR}/include/nanobind/stl/list.h
-    ${NB_DIR}/include/nanobind/stl/map.h
-    ${NB_DIR}/include/nanobind/stl/optional.h
-    ${NB_DIR}/include/nanobind/stl/pair.h
-    ${NB_DIR}/include/nanobind/stl/set.h
-    ${NB_DIR}/include/nanobind/stl/shared_ptr.h
-    ${NB_DIR}/include/nanobind/stl/string.h
-    ${NB_DIR}/include/nanobind/stl/string_view.h
-    ${NB_DIR}/include/nanobind/stl/tuple.h
-    ${NB_DIR}/include/nanobind/stl/unique_ptr.h
-    ${NB_DIR}/include/nanobind/stl/unordered_map.h
-    ${NB_DIR}/include/nanobind/stl/unordered_set.h
-    ${NB_DIR}/include/nanobind/stl/variant.h
-    ${NB_DIR}/include/nanobind/stl/vector.h
-    ${NB_DIR}/include/nanobind/eigen/dense.h
-    ${NB_DIR}/include/nanobind/eigen/sparse.h
-
-    ${NB_DIR}/src/buffer.h
-    ${NB_DIR}/src/hash.h
-    ${NB_DIR}/src/nb_internals.h
-    ${NB_DIR}/src/nb_internals.cpp
-    ${NB_DIR}/src/nb_func.cpp
-    ${NB_DIR}/src/nb_type.cpp
-    ${NB_DIR}/src/nb_enum.cpp
-    ${NB_DIR}/src/nb_ndarray.cpp
-    ${NB_DIR}/src/nb_static_property.cpp
-    ${NB_DIR}/src/nb_ft.h
-    ${NB_DIR}/src/nb_ft.cpp
-    ${NB_DIR}/src/common.cpp
-    ${NB_DIR}/src/error.cpp
-    ${NB_DIR}/src/trampoline.cpp
-    ${NB_DIR}/src/implicit.cpp
-  )
-
-  if (TARGET_TYPE STREQUAL "SHARED")
-    nanobind_link_options(${TARGET_NAME})
-    target_compile_definitions(${TARGET_NAME} PRIVATE -DNB_BUILD)
-    target_compile_definitions(${TARGET_NAME} PUBLIC -DNB_SHARED)
-    nanobind_lto(${TARGET_NAME})
-
-    nanobind_strip(${TARGET_NAME})
-  elseif(NOT WIN32 AND NOT APPLE)
-    target_compile_options(${TARGET_NAME} PUBLIC $<${NB_OPT_SIZE}:-ffunction-sections -fdata-sections>)
-    target_link_options(${TARGET_NAME} PUBLIC $<${NB_OPT_SIZE}:-Wl,--gc-sections>)
-  endif()
-
-  set_target_properties(${TARGET_NAME} PROPERTIES
-    POSITION_INDEPENDENT_CODE ON)
-
-  if (${ARG_AS_SYSINCLUDE})
-    set_target_properties(${TARGET_NAME} PROPERTIES
-      CXX_CLANG_TIDY "")
-  endif()
-
-  if (MSVC)
-    # Do not complain about vsnprintf
-    target_compile_definitions(${TARGET_NAME} PRIVATE -D_CRT_SECURE_NO_WARNINGS)
-  else()
-    # Generally needed to handle type punning in Python code
-    target_compile_options(${TARGET_NAME} PRIVATE -fno-strict-aliasing)
-  endif()
-
-  if (WIN32)
-    if (${TARGET_NAME} MATCHES "-abi3")
-      target_link_libraries(${TARGET_NAME} PUBLIC Python::SABIModule)
-    else()
-      target_link_libraries(${TARGET_NAME} PUBLIC Python::Module)
-    endif()
-  endif()
-
-  if (TARGET_NAME MATCHES "-ft")
-    target_compile_definitions(${TARGET_NAME} PUBLIC NB_FREE_THREADED)
-  endif()
-
-  # Nanobind performs many assertion checks -- detailed error messages aren't
-  # included in Release/MinSizeRel modes
-  target_compile_definitions(${TARGET_NAME} PRIVATE
-    $<${NB_OPT_SIZE}:NB_COMPACT_ASSERTIONS>)
-
-  # If nanobind was installed without submodule dependencies, then the
-  # dependencies directory won't exist and we need to find them.
-  # However, if the directory _does_ exist, then the user is free to choose
-  # whether nanobind uses them (based on `NB_USE_SUBMODULE_DEPS`), with a
-  # preference to choose them if `NB_USE_SUBMODULE_DEPS` is not defined
-  if (NOT IS_DIRECTORY ${NB_DIR}/ext/robin_map/include OR
-      (DEFINED NB_USE_SUBMODULE_DEPS AND NOT NB_USE_SUBMODULE_DEPS))
-    include(CMakeFindDependencyMacro)
-    find_dependency(tsl-robin-map)
-    target_link_libraries(${TARGET_NAME} PRIVATE tsl::robin_map)
-  else()
-    target_include_directories(${TARGET_NAME} PRIVATE
-      ${NB_DIR}/ext/robin_map/include)
-  endif()
-
-  target_include_directories(${TARGET_NAME} ${AS_SYSINCLUDE} PUBLIC
-    ${Python_INCLUDE_DIRS}
-    ${NB_DIR}/include)
-
-  target_compile_features(${TARGET_NAME} PUBLIC cxx_std_17)
-  nanobind_set_visibility(${TARGET_NAME})
-
-  if (MSVC)
-    # warning #1388-D: base class dllexport/dllimport specification differs from that of the derived class
-    target_compile_options(${TARGET_NAME} PUBLIC $<$<COMPILE_LANGUAGE:CUDA>:-Xcudafe --diag_suppress=1388>)
-  endif()
-endfunction()
-
-# ---------------------------------------------------------------------------
-# Define a convenience function for creating nanobind targets
-# ---------------------------------------------------------------------------
-
-function(nanobind_opt_size name)
-  if (MSVC)
-    target_compile_options(${name} PRIVATE $<${NB_OPT_SIZE}:$<$<COMPILE_LANGUAGE:CXX>:/Os>>)
-  else()
-    target_compile_options(${name} PRIVATE $<${NB_OPT_SIZE}:$<$<COMPILE_LANGUAGE:CXX>:-Os>>)
-  endif()
-endfunction()
-
-function(nanobind_disable_stack_protector name)
-  if (NOT MSVC)
-    # The stack protector affects binding size negatively (+8% on Linux in my
-    # benchmarks). Protecting from stack smashing in a Python VM seems in any
-    # case futile, so let's get rid of it by default in optimized modes.
-    target_compile_options(${name} PRIVATE $<${NB_OPT}:-fno-stack-protector>)
-  endif()
-endfunction()
-
-function(nanobind_extension name)
-  set_target_properties(${name} PROPERTIES PREFIX "" SUFFIX "${NB_SUFFIX}")
-endfunction()
-
-function(nanobind_extension_abi3 name)
-  set_target_properties(${name} PROPERTIES PREFIX "" SUFFIX "${NB_SUFFIX_S}")
-endfunction()
-
-function (nanobind_lto name)
-  set_target_properties(${name} PROPERTIES
-    INTERPROCEDURAL_OPTIMIZATION_RELEASE ON
-    INTERPROCEDURAL_OPTIMIZATION_MINSIZEREL ON)
-endfunction()
-
-function (nanobind_compile_options name)
-  if (MSVC)
-    target_compile_options(${name} PRIVATE $<$<COMPILE_LANGUAGE:CXX>:/bigobj /MP>)
-  endif()
-endfunction()
-
-function (nanobind_strip name)
-  if (APPLE)
-    target_link_options(${name} PRIVATE $<${NB_OPT}:-Wl,-dead_strip -Wl,-x -Wl,-S>)
-  elseif (NOT WIN32)
-    target_link_options(${name} PRIVATE $<${NB_OPT}:-Wl,-s>)
-  endif()
-endfunction()
-
-function (nanobind_set_visibility name)
-  set_target_properties(${name} PROPERTIES CXX_VISIBILITY_PRESET hidden)
-endfunction()
-
-function (nanobind_musl_static_libcpp name)
-  if ("$ENV{AUDITWHEEL_PLAT}" MATCHES "musllinux")
-    target_link_options(${name} PRIVATE -static-libstdc++ -static-libgcc)
-  endif()
-endfunction()
-
-function(nanobind_add_module name)
-  cmake_parse_arguments(PARSE_ARGV 1 ARG
-    "STABLE_ABI;FREE_THREADED;NB_STATIC;NB_SHARED;PROTECT_STACK;LTO;NOMINSIZE;NOSTRIP;MUSL_DYNAMIC_LIBCPP;NB_SUPPRESS_WARNINGS"
-    "NB_DOMAIN" "")
-
-  add_library(${name} MODULE ${ARG_UNPARSED_ARGUMENTS})
-
-  nanobind_compile_options(${name})
-  nanobind_link_options(${name})
-  set_target_properties(${name} PROPERTIES LINKER_LANGUAGE CXX)
-
-  if (ARG_NB_SHARED AND ARG_NB_STATIC)
-    message(FATAL_ERROR "NB_SHARED and NB_STATIC cannot be specified at the same time!")
-  elseif (NOT ARG_NB_SHARED)
-    set(ARG_NB_STATIC TRUE)
-  endif()
-
-  # Stable ABI builds require CPython >= 3.12 and Python::SABIModule
-  if ((Python_VERSION VERSION_LESS 3.12) OR
-      (NOT Python_INTERPRETER_ID STREQUAL "Python") OR
-      (NOT TARGET Python::SABIModule))
-    set(ARG_STABLE_ABI FALSE)
-  endif()
-
-  if (NB_ABI MATCHES "t")
-    # Free-threaded Python interpreters don't support building a nanobind
-    # module that uses the stable ABI.
-    set(ARG_STABLE_ABI FALSE)
-  else()
-    # A free-threaded Python interpreter is required to build a free-threaded
-    # nanobind module.
-    set(ARG_FREE_THREADED FALSE)
-  endif()
-
-  set(libname "nanobind")
-  if (ARG_NB_STATIC)
-    set(libname "${libname}-static")
-  endif()
-
-  if (ARG_STABLE_ABI)
-    set(libname "${libname}-abi3")
-  endif()
-
-  if (ARG_FREE_THREADED)
-    set(libname "${libname}-ft")
-  endif()
-
-  if (ARG_NB_DOMAIN AND ARG_NB_SHARED)
-    set(libname ${libname}-${ARG_NB_DOMAIN})
-  endif()
-
-  if (ARG_NB_SUPPRESS_WARNINGS)
-    set(EXTRA_LIBRARY_PARAMS AS_SYSINCLUDE)
-  endif()
-
-  nanobind_build_library(${libname} ${EXTRA_LIBRARY_PARAMS})
-
-  if (ARG_NB_DOMAIN)
-    target_compile_definitions(${name} PRIVATE NB_DOMAIN=${ARG_NB_DOMAIN})
-  endif()
-
-  if (ARG_STABLE_ABI)
-    target_compile_definitions(${libname} PUBLIC -DPy_LIMITED_API=0x030C0000)
-    nanobind_extension_abi3(${name})
-  else()
-    nanobind_extension(${name})
-  endif()
-
-  if (ARG_FREE_THREADED)
-    target_compile_definitions(${name} PRIVATE NB_FREE_THREADED)
-  endif()
-
-  target_link_libraries(${name} PRIVATE ${libname})
-
-  if (NOT ARG_PROTECT_STACK)
-    nanobind_disable_stack_protector(${name})
-  endif()
-
-  if (NOT ARG_NOMINSIZE)
-    nanobind_opt_size(${name})
-  endif()
-
-  if (NOT ARG_NOSTRIP)
-    nanobind_strip(${name})
-  endif()
-
-  if (ARG_LTO)
-    nanobind_lto(${name})
-  endif()
-
-  if (ARG_NB_STATIC AND NOT ARG_MUSL_DYNAMIC_LIBCPP)
-    nanobind_musl_static_libcpp(${name})
-  endif()
-
-  nanobind_set_visibility(${name})
-endfunction()
-
-# ---------------------------------------------------------------------------
-# Detect if a list of targets uses sanitizers (ASAN/UBSAN/TSAN). If so, compute
-# a shared library preload directive so that these sanitizers can be safely
-# together with a Python binary that will in general not import them.
-# ---------------------------------------------------------------------------
-
-function(nanobind_sanitizer_preload_env env_var)
-  set(detected_san "")
-
-  # Process each target
-  foreach(target ${ARGN})
-    if (NOT TARGET ${target})
-      continue()
-    endif()
-
-    # Check for sanitizer flags in various compile and link options
-    set(san_flags "")
-    set(san_options_to_search
-      COMPILE_OPTIONS LINK_OPTIONS
-      INTERFACE_LINK_OPTIONS INTERFACE_COMPILE_OPTIONS
-    )
-    if(CMAKE_VERSION VERSION_GREATER_EQUAL "3.30")
-      set(san_options_to_search
-        ${san_options_to_search}
-        TRANSITIVE_LINK_PROPERTIES
-        TRANSITIVE_COMPILE_PROPERTIES
-      )
-    endif()
-
-    # create a list of all dependent targets and scan those for dependencies on sanitizers
-    set(all_deps "${target}")
-    get_target_property(deps ${target} LINK_LIBRARIES)
-    if(deps AND NOT deps STREQUAL "deps-NOTFOUND")
-        foreach(dep ${deps})
-            if(NOT "${dep}" IN_LIST all_deps)
-                list(APPEND all_deps "${dep}")
-            endif()
-        endforeach()
-    endif()
-
-    foreach(tgt ${all_deps})
-      # Check target type
-      get_target_property(target_type ${tgt} TYPE)
-
-      foreach(prop ${san_options_to_search})
-        # Skip non-interface properties for INTERFACE_LIBRARY targets
-        if(target_type STREQUAL "INTERFACE_LIBRARY")
-          if(NOT prop MATCHES "^INTERFACE_")
-            continue()
-          endif()
-        endif()
-
-        get_target_property(options ${tgt} ${prop})
-        if(options)
-          foreach(opt ${options})
-            if(opt MATCHES "-fsanitize=([^ ]+)")
-              list(APPEND san_flags "${CMAKE_MATCH_1}")
-            endif()
-          endforeach()
-        endif()
-      endforeach()
-    endforeach()
-
-    # Parse sanitizer flags
-    foreach(flag ${san_flags})
-      string(REPLACE "\"" "" flag "${flag}")
-      string(REPLACE "," ";" san_list "${flag}")
-      foreach(san ${san_list})
-        if(san MATCHES "^(address|asan)$")
-          list(APPEND detected_san "asan")
-        elseif(san MATCHES "^(thread|tsan)$")
-          list(APPEND detected_san "tsan")
-        elseif(san MATCHES "^(undefined|ubsan)$")
-          list(APPEND detected_san "ubsan")
-        endif()
-      endforeach()
-    endforeach()
-  endforeach()
-
-  if (detected_san)
-    list(REMOVE_DUPLICATES detected_san)
-    set(libs "")
-
-    foreach(san ${detected_san})
-      set(san_libname "")
-
-      if(CMAKE_CXX_COMPILER_ID MATCHES "Clang")
-        if(APPLE)
-          set(san_libname "libclang_rt.${san}_osx_dynamic.dylib")
-        else()
-          set(san_libname "libclang_rt.${san}.so")
-        endif()
-      else()
-        set(san_libname "lib${san}.so")
-      endif()
-
-      # Get the full path using a file name query
-      execute_process(
-        COMMAND ${CMAKE_CXX_COMPILER} -print-file-name=${san_libname}
-        RESULT_VARIABLE san_success
-        OUTPUT_VARIABLE san_libpath
-        OUTPUT_STRIP_TRAILING_WHITESPACE
-      )
-
-      if(NOT san_success EQUAL 0)
-        message(FATAL_ERROR "Error querying ${san_libname}: ${san_success}")
-      endif()
-
-      # Check if a real path was returned (and not just echoing back the input)
-      if(NOT san_libpath OR (san_libpath STREQUAL san_libname))
-        continue()
-      endif()
-
-      # Read the file content and turn into a single-line string
-      file(READ "${san_libpath}" san_libdata LIMIT 1024)
-      string(REPLACE "\n" " " san_libdata "${san_libdata}")
-
-      if(san_libdata MATCHES "INPUT[ \t]*\\([ \t]*([^ \t)]+)")
-        # If this is a linker script with INPUT directive, extract the path
-        list(APPEND libs "${CMAKE_MATCH_1}")
-      else()
-        # Use the original library path
-        list(APPEND libs "${san_libpath}")
-      endif()
-    endforeach()
-
-    # Set platform-specific environment variable
-    string(REPLACE ";" ":" libs_str "${libs}")
-    if(APPLE)
-      set(${env_var} "DYLD_INSERT_LIBRARIES=${libs_str}" PARENT_SCOPE)
-    else()
-      set(${env_var} "LD_PRELOAD=${libs_str}" PARENT_SCOPE)
-    endif()
-  else()
-    set(${env_var} "" PARENT_SCOPE)
-  endif()
-endfunction()
-
-# On macOS, it's quite tricky to get the actual path of the Python executable
-# which is often hidden behind several layers of shims. We need this path to
-# inject sanitizers.
-function(nanobind_resolve_python_path)
-  if(NOT DEFINED NB_PY_PATH)
-    if (APPLE)
-      execute_process(
-        COMMAND ${Python_EXECUTABLE} "${NB_DIR}/cmake/darwin-python-path.py"
-        RESULT_VARIABLE rv
-        OUTPUT_VARIABLE NB_PY_PATH
-        OUTPUT_STRIP_TRAILING_WHITESPACE
-      )
-      if(NOT rv EQUAL 0)
-        message(FATAL_ERROR "Could not query Python binary path")
-      endif()
-    else()
-      set(NB_PY_PATH "${Python_EXECUTABLE}")
-    endif()
-    set(NB_PY_PATH ${NB_PY_PATH} CACHE STRING "" FORCE)
-  endif()
-endfunction()
-
-# ---------------------------------------------------------------------------
-# Convenient Cmake frontent for nanobind's stub generator
-# ---------------------------------------------------------------------------
-
-function (nanobind_add_stub name)
-  cmake_parse_arguments(PARSE_ARGV 1 ARG "VERBOSE;INCLUDE_PRIVATE;EXCLUDE_DOCSTRINGS;INSTALL_TIME;EXCLUDE_FROM_ALL" "MODULE;OUTPUT;MARKER_FILE;COMPONENT;PATTERN_FILE" "PYTHON_PATH;DEPENDS")
-
-  if (EXISTS ${NB_DIR}/src/stubgen.py)
-    set(NB_STUBGEN "${NB_DIR}/src/stubgen.py")
-  elseif (EXISTS ${NB_DIR}/stubgen.py)
-    set(NB_STUBGEN "${NB_DIR}/stubgen.py")
-  else()
-    message(FATAL_ERROR "nanobind_add_stub(): could not locate 'stubgen.py'!")
-  endif()
-
-  if (NOT ARG_VERBOSE)
-    list(APPEND NB_STUBGEN_ARGS -q)
-  else()
-    set(NB_STUBGEN_EXTRA USES_TERMINAL)
-  endif()
-
-  if (ARG_INCLUDE_PRIVATE)
-    list(APPEND NB_STUBGEN_ARGS -P)
-  endif()
-
-  if (ARG_EXCLUDE_DOCSTRINGS)
-    list(APPEND NB_STUBGEN_ARGS -D)
-  endif()
-
-  foreach (TMP IN LISTS ARG_PYTHON_PATH)
-    list(APPEND NB_STUBGEN_ARGS -i "${TMP}")
-  endforeach()
-
-  if (ARG_PATTERN_FILE)
-    list(APPEND NB_STUBGEN_ARGS -p "${ARG_PATTERN_FILE}")
-  endif()
-
-  if (ARG_MARKER_FILE)
-    list(APPEND NB_STUBGEN_ARGS -M "${ARG_MARKER_FILE}")
-    list(APPEND NB_STUBGEN_OUTPUTS "${ARG_MARKER_FILE}")
-  endif()
-
-  if (NOT ARG_MODULE)
-    message(FATAL_ERROR "nanobind_add_stub(): a 'MODULE' argument must be specified!")
-  else()
-    list(APPEND NB_STUBGEN_ARGS -m "${ARG_MODULE}")
-  endif()
-
-  if (NOT ARG_OUTPUT)
-    message(FATAL_ERROR "nanobind_add_stub(): an 'OUTPUT' argument must be specified!")
-  else()
-    list(APPEND NB_STUBGEN_ARGS -o "${ARG_OUTPUT}")
-    list(APPEND NB_STUBGEN_OUTPUTS "${ARG_OUTPUT}")
-  endif()
-
-  file(TO_CMAKE_PATH ${Python_EXECUTABLE} NB_Python_EXECUTABLE)
-
-  set(NB_STUBGEN_CMD "${NB_Python_EXECUTABLE}" "${NB_STUBGEN}" ${NB_STUBGEN_ARGS})
-
-  if (NOT WIN32)
-    # Pass sanitizer flags to nanobind if needed
-    nanobind_sanitizer_preload_env(NB_STUBGEN_ENV ${ARG_DEPENDS})
-    if (NB_STUBGEN_ENV)
-      nanobind_resolve_python_path()
-      if (NB_STUBGEN_ENV MATCHES asan)
-        list(APPEND NB_STUBGEN_ENV "ASAN_OPTIONS=detect_leaks=0")
-      endif()
-      set(NB_STUBGEN_CMD ${CMAKE_COMMAND} -E env "${NB_STUBGEN_ENV}" "${NB_PY_PATH}" "${NB_STUBGEN}" ${NB_STUBGEN_ARGS})
-    endif()
-  endif()
-
-  if (NOT ARG_INSTALL_TIME)
-    add_custom_command(
-      OUTPUT ${NB_STUBGEN_OUTPUTS}
-      COMMAND ${NB_STUBGEN_CMD}
-      WORKING_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}"
-      DEPENDS ${ARG_DEPENDS} "${NB_STUBGEN}" "${ARG_PATTERN_FILE}"
-      ${NB_STUBGEN_EXTRA}
-    )
-    add_custom_target(${name} ALL DEPENDS ${NB_STUBGEN_OUTPUTS})
-  else()
-    set(NB_STUBGEN_EXTRA "")
-    if (ARG_COMPONENT)
-      list(APPEND NB_STUBGEN_EXTRA COMPONENT ${ARG_COMPONENT})
-    endif()
-    if (ARG_EXCLUDE_FROM_ALL)
-      list(APPEND NB_STUBGEN_EXTRA EXCLUDE_FROM_ALL)
-    endif()
-    # \${CMAKE_INSTALL_PREFIX} has same effect as $<INSTALL_PREFIX>
-    # This is for compatibility with CMake < 3.27.
-    # For more info: https://github.com/wjakob/nanobind/issues/420#issuecomment-1971353531
-    install(CODE "set(CMD \"${NB_STUBGEN_CMD}\")\nexecute_process(\n COMMAND \$\{CMD\}\n WORKING_DIRECTORY \"\${CMAKE_INSTALL_PREFIX}\"\n)" ${NB_STUBGEN_EXTRA})
-  endif()
-endfunction()
diff --git a/src/nanobind/docs/api_bazel.rst b/src/nanobind/docs/api_bazel.rst
deleted file mode 100644
index 6aca46e..0000000
--- a/src/nanobind/docs/api_bazel.rst
+++ /dev/null
@@ -1,185 +0,0 @@
-.. _api_bazel:
-
-Bazel API Reference (3rd party)
-===============================
-
-This page contains a reference of the basic APIs of
-`nanobind-bazel <https://github.com/nicholasjng/nanobind-bazel>`__.
-
-.. _rules-bazel:
-
-Rules
------
-
-nanobind-bazel's rules can be used to declare different types of targets in
-your Bazel project. Each of these rules is a thin wrapper around a
-corresponding builtin Bazel rule producing the equivalent C++ target.
-
-The main tool to build nanobind extensions is the ``nanobind_extension`` rule.
-
-.. py:function:: nanobind_extension
-
-    Declares a Bazel target representing a nanobind extension, which contains
-    the Python bindings of your C++ code.
-
-    .. code-block:: python
-
-        def nanobind_extension(
-            name,
-            domain = "",
-            srcs = [],
-            copts = [],
-            deps = [],
-            local_defines = [],
-            **kwargs):
-
-    It corresponds directly to the builtin
-    `cc_binary <https://bazel.build/reference/be/c-cpp#cc_binary>`__ rule,
-    with all keyword arguments being directly forwarded to a ``cc_binary``
-    target.
-
-    The ``domain`` argument can be used to build the target extension under a
-    different ABI domain, as described in the :ref:`FAQ <type-visibility>`
-    section.
-
-To generate typing stubs for an extension, you can use the ``nanobind_stubgen``
-rule.
-
-.. py:function:: nanobind_stubgen
-
-    Declares a Bazel target for generating a stub file from a previously
-    built nanobind bindings extension.
-
-    .. code-block:: python
-
-        def nanobind_stubgen(
-            name,
-            module,
-            output_file = None,
-            output_directory = None,
-            imports = [],
-            pattern_file = None,
-            marker_file = None,
-            include_private_members = False,
-            exclude_docstrings = False,
-            recursive = False):
-
-    It generates a `py_binary <https://bazel.build/reference/be/python#py_binary>`__ 
-    rule with a corresponding runfiles distribution, which invokes nanobind's 
-    builtin stubgen script, outputs a stub file and, optionally, 
-    a typing marker file into ``output_directory`` (defaults to
-    the build output directory, commonly called "bindir" in Bazel terms).
-
-    All arguments (except the name, which is used only to refer to the target
-    in Bazel) correspond directly to nanobind's stubgen command line interface,
-    which is described in more detail in the :ref:`typing documentation <stubs>`.
-
-    *New in nanobind-bazel version 2.1.0.*
-
-    *New in nanobind-bazel v2.5.0: Added the "output_directory" and "recursive"
-    keyword arguments.*
-
-To build a C++ library with nanobind as a dependency, use the
-``nanobind_library`` rule.
-
-.. py:function:: nanobind_library
-
-    Declares a Bazel target representing a C++ library depending on nanobind.
-
-    .. code-block:: python
-
-        def nanobind_library(
-            name,
-            copts = [],
-            deps = [],
-            **kwargs):
-
-    It corresponds directly to the builtin
-    `cc_library <https://bazel.build/reference/be/c-cpp#cc_library>`__ rule,
-    with all keyword arguments being directly forwarded to a ``cc_library``
-    target.
-
-To build a C++ shared library with nanobind as a dependency, use the
-``nanobind_shared_library`` rule.
-
-.. py:function:: nanobind_shared_library
-
-    Declares a Bazel target representing a C++ shared library depending on
-    nanobind.
-
-    .. code-block:: python
-
-        def nanobind_shared_library(
-            name,
-            deps = [],
-            **kwargs):
-
-    It corresponds directly to the builtin
-    `cc_shared_library <https://bazel.build/reference/be/c-cpp#cc_shared_library>`__
-    rule, with all keyword arguments being directly forwarded to a
-    ``cc_shared_library`` target.
-
-    *New in nanobind-bazel version 2.1.0.*
-
-To build a C++ static library containing nanobind, use the
-``nanobind_static_library`` rule.
-
-.. py:function:: nanobind_static_library
-
-    Declares a Bazel target representing a static library (or archive) containing
-    nanobind.
-
-    .. code-block:: python
-
-        def nanobind_static_library(name, deps, **kwargs):
-
-    It corresponds directly to the builtin
-    `cc_static_library <https://bazel.build/reference/be/c-cpp#cc_static_library>`__ 
-    rule, with all keyword arguments being directly
-    forwarded to a ``cc_static_library`` target.
-
-    NB: This macro requires Bazel 7.4.0 or greater to use, as well as setting the
-    ``--experimental_cc_static_library`` flag for the build, since the 
-    ``cc_static_library`` rule is considered experimental.
-
-    *New in nanobind-bazel version 2.7.0.*
-
-To build a C++ test target requiring nanobind, use the ``nanobind_test`` rule.
-
-.. py:function:: nanobind_test
-
-    Declares a Bazel target representing a C++ test depending on nanobind.
-
-    .. code-block:: python
-
-        def nanobind_test(
-            name,
-            copts = [],
-            deps = [],
-            **kwargs):
-
-    It corresponds directly to the builtin
-    `cc_test <https://bazel.build/reference/be/c-cpp#cc_test>`__ rule, with all
-    keyword arguments being directly forwarded to a ``cc_test`` target.
-
-.. _flags-bazel:
-
-Flags
------
-
-To customize some of nanobind's build options, nanobind-bazel exposes the
-following flag settings.
-
-.. py:function:: @nanobind_bazel//:minsize (boolean)
-
-    Apply nanobind's size optimizations to the built extensions. Size
-    optimizations are turned on by default, similarly to the CMake build.
-    To turn off size optimizations, you can use the shorthand notation
-    ``--no@nanobind_bazel//:minsize``.
-
-.. py:function:: @nanobind_bazel//:py-limited-api (string)
-
-    Build nanobind extensions against the stable ABI of the configured Python
-    version. Allowed values are ``"cp312"``, ``"cp313"``, and ``"cp314"``, which
-    target the stable ABI starting from CPython 3.12, 3.13, or 3.14 respectively. 
-    By default, all extensions are built without any ABI limitations.
diff --git a/src/nanobind/docs/api_cmake.rst b/src/nanobind/docs/api_cmake.rst
deleted file mode 100644
index 1547535..0000000
--- a/src/nanobind/docs/api_cmake.rst
+++ /dev/null
@@ -1,491 +0,0 @@
-.. _api_cmake:
-
-CMake API Reference
-===================
-
-nanobind's CMake API simplifies the process of building python extension
-modules. This is needed because quite a few steps are involved: nanobind must
-build the module, a library component, link the two together, and add a
-different set of compilation and linker flags depending on the target platform.
-
-If you prefer another build system, then you have the following options:
-
-- `Nicholas Junge <https://github.com/nicholasjng>`__ has created a `Bazel
-  interface <https://github.com/nicholasjng/nanobind-Bazel>`__ to nanobind.
-  Please report Bazel-specific issues there.
-
-- `Will Ayd <https://github.com/WillAyd/>`__ has created a `Meson WrapDB
-  package <https://mesonbuild.com/Wrapdb-projects.html>`__ for nanobind. Please
-  report Meson-specific issues on the `Meson WrapDB
-  <https://github.com/mesonbuild/wrapdb/issues>`__ repository.
-
-- You could create a new build system from scratch that takes care of these
-  steps. See `this file
-  <https://github.com/wjakob/nanobind/blob/master/src/nb_combined.cpp>`__ for
-  inspiration on how to do this on Linux. Note that you will be on your own if
-  you choose to go this route---I unfortunately do not have the time to respond
-  to GitHub tickets related to custom build systems.
-
-The section on :ref:`building extensions <building>` provided an introductory
-example of how to set up a basic build system via the
-:cmake:command:`nanobind_add_module` command, which is the :ref:`high level
-<highlevel-cmake>` build interface. The defaults chosen by this function are
-somewhat opinionated, however. For this reason, nanobind also provides an
-alternative :ref:`low level <lowlevel-cmake>` interface that decomposes it into
-smaller steps.
-
-A later part of this section explains how a Git submodule dependency can be
-:ref:`avoided <submodule_deps>` in exchange for a system-provided package.
-
-Finally, the section ends with an explanation of the CMake convenience
-interface for :ref:`stub generation <stub_generation_cmake>`.
-
-.. _highlevel-cmake:
-
-High-level interface
---------------------
-
-The high-level interface consists of just one CMake command:
-
-.. cmake:command:: nanobind_add_module
-
-   Compile a nanobind extension module using the specified target name,
-   optional flags, and source code files. Use it as follows:
-
-   .. code-block:: cmake
-
-      nanobind_add_module(
-        my_ext                   # Target name
-        NB_STATIC STABLE_ABI LTO # Optional flags (see below)
-        my_ext.h                 # Source code files below
-        my_ext.cpp)
-
-   It supports the following optional parameters:
-
-   .. list-table::
-
-      * - ``STABLE_ABI``
-        - Perform a `stable ABI
-          <https://docs.python.org/3/c-api/stable.html>`__ build, making it
-          possible to use a compiled extension across Python minor versions.
-          The flag is ignored on Python versions older than < 3.12.
-      * - ``FREE_THREADED``
-        - Compile an Python extension that opts into free-threaded (i.e.,
-          GIL-less) Python behavior, which requires a special free-threaded
-          build of Python 3.13 or newer. The flag is ignored on unsupported
-          Python versions.
-      * - ``NB_STATIC``
-        - Compile the core nanobind library as a static library. This
-          simplifies redistribution but can increase the combined binary
-          storage footprint when a project contains many Python extensions
-          (this is the default).
-      * - ``NB_SHARED``
-        - The opposite of ``NB_STATIC``: compile the core nanobind library
-          as a shared library for use in projects that consist of multiple
-          extensions.
-      * - ``NB_SUPPRESS_WARNINGS``
-        - Mark the include directories of nanobind and Python as
-          `SYSTEM <https://cmake.org/cmake/help/latest/command/include_directories.html>`__
-          include directories, which suppresses any potential warning messages
-          originating there. This is mainly of relevance if your project artificially
-          raises the warning level via flags like ``-pedantic``, ``-Wcast-qual``,
-          ``-Wsign-conversion``.
-      * - ``PROTECT_STACK``
-        - Don't remove stack smashing-related protections.
-      * - ``LTO``
-        - Perform link time optimization.
-      * - ``NOMINSIZE``
-        - Don't perform optimizations to minimize binary size.
-      * - ``NOSTRIP``
-        - Don't strip unneded symbols and debug information from the compiled
-          extension when performing release builds.
-      * - ``NB_DOMAIN <name>``
-        - Restrict the inter-extension type visibility to a named subdomain.
-          See the associated :ref:`FAQ entry <type-visibility>` for details.
-      * - ``MUSL_DYNAMIC_LIBCPP``
-        - When `cibuildwheel
-          <https://cibuildwheel.readthedocs.io/en/stable/>`__ is used to
-          produce `musllinux <https://peps.python.org/pep-0656/>`__ wheels,
-          don't statically link against ``libstdc++`` and ``libgcc`` (which is
-          an optimization that nanobind does by default in this specific case).
-          If this explanation sounds confusing, then you can ignore it. See the
-          detailed description below for more information on this step.
-
-   :cmake:command:`nanobind_add_module` performs the following
-   steps to produce bindings.
-
-   - It creates a CMake library via ``add_library(target_name MODULE ...)`` and
-     enables the use of C++17 features during compilation.
-
-   - It creates a CMake target for an internal library component required by
-     nanobind (named ``nanobind-..`` where ``..`` depends on the compilation
-     flags). This is only done once when compiling multiple extensions.
-
-     This library component can either be a static or shared library depending
-     on whether the optional ``NB_STATIC`` or ``NB_SHARED`` parameter was
-     provided to ``nanobind_add_module()``. The default is a static build,
-     which simplifies redistribution (only one shared library must be deployed).
-
-     When a project contains many Python extensions, a shared build is
-     preferable to avoid unnecessary binary size overheads that arise from
-     redundant copies of the ``nanobind-...`` component.
-
-   - It links the newly created library against the ``nanobind-..`` target.
-
-   - It appends the library suffix (e.g., ``.cpython-39-darwin.so``) based
-     on information provided by CMake’s ``FindPython`` module.
-
-   - When requested via the optional ``STABLE_ABI`` parameter, the build system
-     will create a `stable ABI <https://docs.python.org/3/c-api/stable.html>`_
-     extension module with a different suffix (e.g., ``.abi3.so``).
-
-     Once compiled, a stable ABI extension can be reused across Python minor
-     versions. In contrast, ordinary builds are only compatible across patch
-     versions. This feature requires Python >= 3.12 and is ignored on older
-     versions. Note that use of the stable ABI come at a small performance cost
-     since nanobind can no longer access the internals of various data
-     structures directly. If in doubt, benchmark your code to see if the cost
-     is acceptable.
-
-   - In non-debug modes, it compiles with *size optimizations* (i.e.,
-     ``-Os``). This is generally the mode that you will want to use for
-     C++/Python bindings. Switching to ``-O3`` would enable further
-     optimizations like vectorization, loop unrolling, etc., but these all
-     increase compilation time and binary size with no real benefit for
-     bindings.
-
-     If your project contains portions that benefit from ``-O3``-level
-     optimizations, then it’s better to run two separate compilation
-     steps. An example is shown below:
-
-     .. code:: cmake
-
-        # Compile project code with current optimization mode configured in CMake
-        add_library(example_lib STATIC source_1.cpp source_2.cpp)
-        # Need position independent code (-fPIC) to link into 'example_ext' below
-        set_target_properties(example_lib PROPERTIES POSITION_INDEPENDENT_CODE ON)
-
-        # Compile extension module with size optimization and add 'example_lib'
-        nanobind_add_module(example_ext common.h source_1.cpp source_2.cpp)
-        target_link_libraries(example_ext PRIVATE example_lib)
-
-     Size optimizations can be disabled by specifying the optional
-     ``NOMINSIZE`` argument, though doing so is not recommended.
-
-   - ``nanobind_add_module()`` also disables stack-smashing protections
-     (i.e., it specifies ``-fno-stack-protector`` to Clang/GCC).
-     Protecting against such vulnerabilities in a Python VM seems futile,
-     and it adds non-negligible extra cost (+8% binary size in
-     benchmarks). This behavior can be disabled by specifying the optional
-     ``PROTECT_STACK`` flag. Either way, is not recommended that you use
-     nanobind in a setting where it presents an attack surface.
-
-   - It sets the default symbol visibility to ``hidden`` so that only functions
-     and types specifically marked for export generate symbols in the resulting
-     binary. This substantially reduces the size of the generated binary.
-
-   - In release builds, it strips unreferenced functions and debug information
-     names from the resulting binary. This can substantially reduce the size of
-     the generated binary and can be disabled using the optional ``NOSTRIP``
-     argument.
-
-   - Link-time optimization (LTO) is *not active* by default; benefits compared
-     to pybind11 are relatively low, and this can make linking a build
-     bottleneck. That said, the optional ``LTO`` argument can be specified to
-     enable LTO in release builds.
-
-   - nanobind's CMake build system is often combined with `cibuildwheel
-     <https://cibuildwheel.readthedocs.io/en/stable/>`__ to automate the
-     generation of wheels for many different platforms. One such platform
-     called `musllinux <https://peps.python.org/pep-0656/>`__ exists to create
-     tiny self-contained binaries that are cheap to install in a container
-     environment (Docker, etc.). An issue of the combination with nanobind is
-     that ``musllinux`` doesn't include the ``libstdc++`` and ``libgcc``
-     libraries which nanobind depends on. ``cibuildwheel`` then has to ship
-     those along in each wheel, which actually increases their size rather
-     dramatically (by a factor of >5x for small projects). To avoid this,
-     nanobind prefers to link against these libraries *statically* when it
-     detects a ``cibuildwheel`` build targeting ``musllinux``. Pass the
-     ``MUSL_DYNAMIC_LIBCPP`` parameter to avoid this behavior.
-
-   - If desired (via the optional ``NB_DOMAIN`` parameter), nanobind will
-     restrict the visibility of symbols to a named subdomain to avoid conflicts
-     between bindings. See the associated :ref:`FAQ entry <type-visibility>`
-     for details.
-
-.. _lowlevel-cmake:
-
-Low-level interface
--------------------
-
-Instead of :cmake:command:`nanobind_add_module` nanobind also exposes a more
-fine-grained interface to the underlying operations.
-The following
-
-.. code-block:: cmake
-
-    nanobind_add_module(my_ext NB_SHARED LTO my_ext.cpp)
-
-is equivalent to
-
-.. code-block:: cmake
-
-    # Build the core parts of nanobind once
-    nanobind_build_library(nanobind SHARED)
-
-    # Compile an extension library
-    add_library(my_ext MODULE my_ext.cpp)
-
-    # .. and link it against the nanobind parts
-    target_link_libraries(my_ext PRIVATE nanobind)
-
-    # .. enable size optimizations
-    nanobind_opt_size(my_ext)
-
-    # .. enable link time optimization
-    nanobind_lto(my_ext)
-
-    # .. set the default symbol visibility to 'hidden'
-    nanobind_set_visibility(my_ext)
-
-    # .. strip unneeded symbols and debug info from the binary (only active in release builds)
-    nanobind_strip(my_ext)
-
-    # .. disable the stack protector
-    nanobind_disable_stack_protector(my_ext)
-
-    # .. set the Python extension suffix
-    nanobind_extension(my_ext)
-
-    # .. set important compilation flags
-    nanobind_compile_options(my_ext)
-
-    # .. set important linker flags
-    nanobind_link_options(my_ext)
-
-    # Statically link against libstdc++/libgcc when targeting musllinux
-    nanobind_musl_static_libcpp(my_ext)
-
-The various commands are described below:
-
-.. cmake:command:: nanobind_build_library
-
-   Compile the core nanobind library. The function expects only the target
-   name and uses a slightly unusual parameter passing policy: its behavior
-   changes based on whether or not one the following substrings is detected
-   in the target name:
-
-   .. list-table::
-      :widths: 10 50
-
-      * - ``-static``
-        - Perform a static library build (without this suffix, a shared build is used)
-      * - ``-abi3``
-        - Perform a stable ABI build targeting Python v3.12+.
-      * - ``-ft``
-        - Perform a build that opts into the Python 3.13+ free-threaded behavior.
-
-   .. code-block:: cmake
-
-      # Normal shared library build
-      nanobind_build_library(nanobind)
-
-      # Static ABI3 build
-      nanobind_build_library(nanobind-static-abi3)
-
-.. cmake:command:: nanobind_opt_size
-
-   This function enable size optimizations in ``Release``, ``MinSizeRel``,
-   ``RelWithDebInfo`` builds. It expects a single target as argument, as in
-
-   .. code-block:: cmake
-
-      nanobind_opt_size(my_target)
-
-.. cmake:command:: nanobind_set_visibility
-
-
-   This function sets the default symbol visibility to ``hidden`` so that only
-   functions and types specifically marked for export generate symbols in the
-   resulting binary. It expects a single target as argument, as in
-
-   .. code-block:: cmake
-
-      nanobind_trim(my_target)
-
-   This substantially reduces the size of the generated binary.
-
-.. cmake:command:: nanobind_strip
-
-   This function strips unused and debug symbols in ``Release`` and
-   ``MinSizeRel`` builds on Linux and macOS. It expects a single target as
-   argument, as in
-
-   .. code-block:: cmake
-
-      nanobind_strip(my_target)
-
-.. cmake:command:: nanobind_disable_stack_protector
-
-   The stack protector affects the binary size of bindings negatively (+8%
-   on Linux in benchmarks). Protecting from stack smashing in a Python VM
-   seems in any case futile, so this function disables it for the specified
-   target when performing a build with optimizations. Use it as follows:
-
-   .. code-block:: cmake
-
-      nanobind_disable_stack_protector(my_target)
-
-.. cmake:command:: nanobind_extension
-
-   This function assigns an extension name to the compiled binding, e.g.,
-   ``.cpython-311-darwin.so``. Use it as follows:
-
-   .. code-block:: cmake
-
-      nanobind_extension(my_target)
-
-.. cmake:command:: nanobind_extension_abi3
-
-   This function assigns a stable ABI extension name to the compiled binding,
-   e.g., ``.abi3.so``. Use it as follows:
-
-   .. code-block:: cmake
-
-      nanobind_extension_abi3(my_target)
-
-
-.. cmake:command:: nanobind_compile_options
-
-   This function sets recommended compilation flags. Currently, it specifies
-   ``/bigobj`` and ``/MP`` on MSVC builds, and it does nothing other platforms
-   or compilers. Use it as follows:
-
-   .. code-block:: cmake
-
-      nanobind_compile_options(my_target)
-
-.. cmake:command:: nanobind_link_options
-
-   This function sets recommended linker flags. Currently, it controls link
-   time handling of undefined symbols on Apple platforms related to Python C
-   API calls, and it does nothing other platforms. Use it as follows:
-
-   .. code-block:: cmake
-
-      nanobind_link_options(my_target)
-
-.. cmake:command:: nanobind_musl_static_libcpp
-
-   This function passes the linker flags ``-static-libstdc++`` and
-   ``-static-libgcc`` to ``gcc`` when the environment variable
-   ``AUDITWHEEL_PLAT`` contains the string ``musllinux``, which indicates a
-   cibuildwheel build targeting that platform.
-
-   The function expects a single target as argument, as in
-
-   .. code-block:: cmake
-
-      nanobind_musl_static_libcpp(my_target)
-
-.. _submodule_deps:
-
-Submodule dependencies
-----------------------
-
-nanobind includes a dependency (a fast hash map named ``tsl::robin_map``) as a
-Git submodule. If you prefer to use another (e.g., system-provided) version of
-this dependency, set the ``NB_USE_SUBMODULE_DEPS`` variable before importing
-nanobind into CMake. In this case, nanobind's CMake scripts will internally
-invoke ``find_dependency(tsl-robin-map)`` to locate the associated header
-files.
-
-.. _stub_generation_cmake:
-
-Stub generation
----------------
-
-Nanobind's CMake tooling includes a convenience command to interface with the
-``stubgen`` program explained in the section on :ref:`stub generation <stubs>`.
-
-.. cmake:command:: nanobind_add_stub
-
-   Import the specified module (``MODULE`` parameter), generate a stub, and
-   write it to the specified file (``OUTPUT`` parameter). Here is an example
-   use:
-
-   .. code-block:: cmake
-
-      nanobind_add_stub(
-          my_ext_stub
-          MODULE my_ext
-          OUTPUT my_ext.pyi
-          PYTHON_PATH $<TARGET_FILE_DIR:my_ext>
-          DEPENDS my_ext
-      )
-
-   The target name (``my_ext_stub`` in this example) must be unique but has no
-   other significance.
-
-   ``stubgen`` will add all paths specified as part of the ``PYTHON_PATH``
-   block and then execute ``import my_ext`` in a Python session. If the
-   extension is not importable, this will cause stub generation to fail.
-
-   This command supports the following parameters:
-
-   .. list-table::
-
-      * - ``INSTALL_TIME``
-        - By default, stub generation takes place at build time following
-          generation of all dependencies (see ``DEPENDS``). When this parameter
-          is specified, stub generation is instead postponed to the
-          installation phase.
-      * - ``MODULE``
-        - Specifies the name of the module that should be imported. Mandatory.
-      * - ``OUTPUT``
-        - Specifies the name of the stub file that should be written. The path
-          is relative to ``CMAKE_CURRENT_BINARY_DIR`` for build-time stub
-          generation and relative to ``CMAKE_INSTALL_PREFIX`` for install-time
-          stub generation. Mandatory.
-      * - ``PYTHON_PATH``
-        - List of search paths that should be considered when importing the
-          module. The paths are relative to ``CMAKE_CURRENT_BINARY_DIR`` for
-          build-time stub generation and relative to ``CMAKE_INSTALL_PREFIX``
-          for install-time stub generation. The current directory (``"."``) is
-          always included and does not need to be specified. The parameter may
-          contain CMake `generator expressions
-          <https://cmake.org/cmake/help/latest/manual/cmake-generator-expressions.7.html>`__
-          when :cmake:command:`nanobind_add_stub` is used for build-time stub
-          generation. Otherwise, generator expressions should not be used.
-          Optional.
-      * - ``DEPENDS``
-        - Any targets listed here will be marked as a dependencies. This should
-          generally be used to list the target names of one or more prior
-          :cmake:command:`nanobind_add_module` declarations. Note that this
-          parameter tracks *build-time* dependencies and does not need to be
-          specified when stub generation occurs at install time (see
-          ``INSTALL_TIME``). Optional.
-      * - ``VERBOSE``
-        - Show status messages generated by ``stubgen``.
-      * - ``EXCLUDE_DOCSTRINGS``
-        - Generate a stub containing only typed signatures without docstrings.
-      * - ``INCLUDE_PRIVATE``
-        - Also include private members, whose names begin or end with a single
-          underscore.
-      * - ``MARKER_FILE``
-        - Typed extensions normally identify themselves via the presence of an
-          empty file named ``py.typed`` in each module directory. When this
-          parameter is specified, :cmake:command:`nanobind_add_stub` will
-          automatically generate such an empty file as well.
-      * - ``PATTERN_FILE``
-        - Specify a pattern file used to replace declarations in the stub. The
-          syntax is described in the section on :ref:`stub generation <stubs>`.
-      * - ``COMPONENT``
-        - Specify a component when ``INSTALL_TIME`` stub generation is used.
-          This is analogous to ``install(..., COMPONENT [name])`` in other
-          install targets.
-      * - ``EXCLUDE_FROM_ALL``
-        - If specified, the file is only installed as part of a
-          component-specific installation when ``INSTALL_TIME`` stub generation
-          is used. This is analogous to ``install(..., EXCLUDE_FROM_ALL)`` in
-          other install targets.
diff --git a/src/nanobind/docs/api_core.rst b/src/nanobind/docs/api_core.rst
deleted file mode 100644
index 216d991..0000000
--- a/src/nanobind/docs/api_core.rst
+++ /dev/null
@@ -1,3253 +0,0 @@
-.. _api:
-
-.. cpp:namespace:: nanobind
-
-C++ API Reference (Core)
-========================
-
-Macros
-------
-
-.. c:macro:: NB_MODULE(name, variable)
-
-   This macro creates the entry point that will be invoked when the Python
-   interpreter imports an extension module. The module name is given as the
-   first argument and it should not be in quotes. It **must** match the module
-   name given to the :cmake:command:`nanobind_add_module()` function in the
-   CMake build system.
-
-   The second macro argument defines a variable of type :cpp:class:`module_`.
-   The body of the declaration typically contains a sequence of operations
-   that populate the module variable with contents.
-
-   .. code-block:: cpp
-
-       NB_MODULE(example, m) {
-           m.doc() = "Example module";
-
-           // Add bindings here
-           m.def("add", []() {
-               return "Hello, World!";
-           });
-       }
-
-.. c:macro:: NB_MAKE_OPAQUE(T)
-
-   The macro registers a partial template specialization pattern for the type
-   `T` that marks it as *opaque*, meaning that nanobind won't try to run its
-   type casting template machinery on it.
-
-   This is useful when trying to register a binding for `T` that is simultaneously
-   also covered by an existing type caster.
-
-   This macro should be used at the top level (outside of namespaces and
-   program code).
-
-Python object API
------------------
-
-Nanobind ships with a wide range of Python wrapper classes like
-:cpp:class:`object`, :cpp:class:`list`, etc. Besides class-specific operations
-(e.g., :cpp:func:`list::append`), these classes also implement core operations
-that can be performed on *any* Python object. Since it would be tedious to
-implement this functionality over and over again, it is realized by the
-following mixin class that lives in the ``nanobind::detail`` namespace.
-
-.. cpp:namespace:: nanobind::detail
-
-.. cpp:class:: template <typename Derived> api
-
-   This mixin class adds common functionality to various nanobind types using
-   the `curiously recurring template pattern
-   <https://en.wikipedia.org/wiki/Curiously_recurring_template_pattern>`_
-   (CRTP). The only requirement for the `Derived` template parameter is that it
-   implements the member function ``PyObject *ptr() const`` that gives access
-   to the underlying Python object pointer.
-
-   .. cpp:function:: Derived &derived()
-
-      Obtain a mutable reference to the derived class.
-
-   .. cpp:function:: const Derived &derived() const
-
-      Obtain a const reference to the derived class.
-
-   .. cpp:function:: handle inc_ref() const
-
-      Increases the reference count and returns a reference to the Python object.
-
-   .. cpp:function:: handle dec_ref() const
-
-      Decreases the reference count and returns a reference to the Python object.
-
-   .. cpp:function:: iterator begin() const
-
-      Return a forward iterator analogous to ``iter()`` in Python. The object
-      must be a collection that supports the iteration protocol. This interface
-      provides a generic iterator that works any type of Python object. The
-      :cpp:class:`tuple`, :cpp:class:`list`, and :cpp:class:`dict` wrappers
-      provide more efficient specialized alternatives.
-
-   .. cpp:function:: iterator end() const
-
-      Return a sentinel that ends the iteration.
-
-   .. cpp:function:: handle type() const
-
-      Return a :cpp:class:`handle` to the underlying Python type object.
-
-   .. cpp:function:: operator handle() const
-
-      Return a :cpp:class:`handle` wrapping the underlying ``PyObject*`` pointer.
-
-   .. cpp:function:: detail::accessor<obj_attr> attr(handle key) const
-
-      Analogous to ``self.key`` in Python, where ``key`` is a Python object.
-      The result is wrapped in an :cpp:class:`accessor <detail::accessor>` so
-      that it can be read and written.
-
-   .. cpp:function:: detail::accessor<str_attr> attr(const char * key) const
-
-      Analogous to ``self.key`` in Python, where ``key`` is a C-style string.
-      The result is wrapped in an :cpp:class:`accessor <detail::accessor>` so
-      that it can be read and written.
-
-   .. cpp:function:: detail::accessor<str_attr> doc() const
-
-       Analogous to ``self.__doc__``. The result is wrapped in an
-       :cpp:class:`accessor <detail::accessor>` so that it can be read and
-       written.
-
-   .. cpp:function:: detail::accessor<obj_item> operator[](handle key) const
-
-      Analogous to ``self[key]`` in Python, where ``key`` is a Python object.
-      The result is wrapped in an :cpp:class:`accessor <detail::accessor>` so that it can be read and
-      written.
-
-   .. cpp:function:: detail::accessor<str_item> operator[](const char * key) const
-
-      Analogous to ``self[key]`` in Python, where ``key`` is a C-style string.
-      The result is wrapped in an :cpp:class:`accessor <detail::accessor>` so that it can be read and
-      written.
-
-   .. cpp:function:: template <typename T, enable_if_t<std::is_arithmetic_v<T>> = 1> detail::accessor<num_item> operator[](T key) const
-
-      Analogous to ``self[key]`` in Python, where ``key`` is an arithmetic
-      type (e.g., an integer). The result is wrapped in an :cpp:class:`accessor <detail::accessor>` so
-      that it can be read and written.
-
-   .. cpp:function:: template <rv_policy policy = rv_policy::automatic_reference, typename... Args> object operator()(Args &&...args) const
-
-      Assuming the Python object is a function or implements the ``__call__``
-      protocol, `operator()` invokes the underlying function, passing an
-      arbitrary set of parameters, while expanding any detected variable length
-      argument and keyword argument packs. The result is returned as an
-      :cpp:class:`object` and may need to be converted back into a Python
-      object using :cpp:func:`cast()`.
-
-      Type conversion is performed using the return value policy `policy`
-
-      When type conversion of arguments or return value fails, the function
-      raises a :cpp:type:`cast_error`. When the Python function call fails, it
-      instead raises a :cpp:class:`python_error`.
-
-   .. cpp:function:: args_proxy operator*() const
-
-      Given a a tuple or list, this helper function performs variable argument
-      list unpacking in function calls resembling the ``*`` operator in Python.
-      Applying `operator*()` twice yields ``**`` keyword argument
-      unpacking for dictionaries.
-
-   .. cpp:function:: bool is(handle value) const
-
-      Analogous to ``self is value`` in Python.
-
-   .. cpp:function:: bool is_none() const
-
-      Analogous to ``self is None`` in Python.
-
-   .. cpp:function:: bool is_type() const
-
-      Analogous to ``isinstance(self, type)`` in Python.
-
-   .. cpp:function:: bool is_valid() const
-
-      Checks if this wrapper contains a valid Python object (in the sense that
-      the ``PyObject *`` pointer is non-null).
-
-   .. cpp:function:: template <typename T> bool equal(const api<T> &other)
-
-      Equivalent to ``self == other`` in Python.
-
-   .. cpp:function:: template <typename T> bool not_equal(const api<T> &other)
-
-      Equivalent to ``self != other`` in Python.
-
-   .. cpp:function:: template <typename T> bool operator<(const api<T> &other)
-
-      Equivalent to ``self < other`` in Python.
-
-   .. cpp:function:: template <typename T> bool operator<=(const api<T> &other)
-
-      Equivalent to ``self <= other`` in Python.
-
-   .. cpp:function:: template <typename T> bool operator>(const api<T> &other)
-
-      Equivalent to ``self > other`` in Python.
-
-   .. cpp:function:: template <typename T> bool operator>=(const api<T> &other)
-
-      Equivalent to ``self >= other`` in Python.
-
-   .. cpp:function:: object operator-()
-
-      Equivalent to ``-self`` in Python.
-
-   .. cpp:function:: object operator~()
-
-      Equivalent to ``~self`` in Python.
-
-   .. cpp:function:: template <typename T> object operator+(const api<T> &other)
-
-      Equivalent to ``self + other`` in Python.
-
-   .. cpp:function:: template <typename T> object operator-(const api<T> &other)
-
-      Equivalent to ``self - other`` in Python.
-
-   .. cpp:function:: template <typename T> object operator*(const api<T> &other)
-
-      Equivalent to ``self * other`` in Python.
-
-   .. cpp:function:: template <typename T> object operator/(const api<T> &other)
-
-      Equivalent to ``self / other`` in Python.
-
-   .. cpp:function:: template <typename T> object floor_div(const api<T> &other)
-
-      Equivalent to ``self // other`` in Python.
-
-   .. cpp:function:: template <typename T> object operator|(const api<T> &other)
-
-      Equivalent to ``self | other`` in Python.
-
-   .. cpp:function:: template <typename T> object operator&(const api<T> &other)
-
-      Equivalent to ``self & other`` in Python.
-
-   .. cpp:function:: template <typename T> object operator^(const api<T> &other)
-
-      Equivalent to ``self ^ other`` in Python.
-
-   .. cpp:function:: template <typename T> object operator<<(const api<T> &other)
-
-      Equivalent to ``self << other`` in Python.
-
-   .. cpp:function:: template <typename T> object operator>>(const api<T> &other)
-
-      Equivalent to ``self >> other`` in Python.
-
-   .. cpp:function:: template <typename T> object operator+=(const api<T> &other)
-
-      Equivalent to ``self += other`` in Python. Note that the `api<T>` version
-      of the in-place operator does not update the ``self`` reference, which
-      may lead to unexpected results when working with immutable types that
-      return their result instead of updating ``self``.
-
-      The :cpp:class:`object` class and subclasses override the in-place
-      operators to achieve more intuitive behavior.
-
-   .. cpp:function:: template <typename T> object operator-=(const api<T> &other)
-
-       Equivalent to ``self -= other`` in Python. See :cpp:func:`operator+=` for limitations.
-
-   .. cpp:function:: template <typename T> object operator*=(const api<T> &other)
-
-       Equivalent to ``self *= other`` in Python. See :cpp:func:`operator+=` for limitations.
-
-   .. cpp:function:: template <typename T> object operator/=(const api<T> &other)
-
-       Equivalent to ``self /= other`` in Python. See :cpp:func:`operator+=` for limitations.
-
-   .. cpp:function:: template <typename T> object operator|=(const api<T> &other)
-
-       Equivalent to ``self |= other`` in Python. See :cpp:func:`operator+=` for limitations.
-
-   .. cpp:function:: template <typename T> object operator&=(const api<T> &other)
-
-       Equivalent to ``self &= other`` in Python. See :cpp:func:`operator+=` for limitations.
-
-   .. cpp:function:: template <typename T> object operator^=(const api<T> &other)
-
-       Equivalent to ``self ^= other`` in Python. See :cpp:func:`operator+=` for limitations.
-
-   .. cpp:function:: template <typename T> object operator<<=(const api<T> &other)
-
-       Equivalent to ``self <<= other`` in Python. See :cpp:func:`operator+=` for limitations.
-
-   .. cpp:function:: template <typename T> object operator>>=(const api<T> &other)
-
-       Equivalent to ``self >>= other`` in Python. See :cpp:func:`operator+=` for limitations.
-
-.. cpp:class:: template <typename Impl> accessor
-
-   This helper class facilitates attribute and item access. Casting an
-   :cpp:class:`accessor` to a :cpp:class:`handle` or :cpp:class:`object`
-   subclass causes a corresponding call to ``__getitem__`` or ``__getattr__``
-   depending on the template argument `Impl`. Assigning a
-   :cpp:class:`handle` or :cpp:class:`object` subclass causes a call to
-   ``__setitem__`` or ``__setattr__``.
-
-.. cpp:namespace:: nanobind
-
-Handles and objects
--------------------
-
-nanobind provides two styles of Python object wrappers: classes without
-reference counting deriving from :cpp:class:`handle`, and reference-counted
-wrappers deriving from :cpp:class:`object`. Reference counting bugs can be
-really tricky to track down, hence it is recommended that you always prefer
-:cpp:class:`object`-style wrappers unless there are specific reasons that
-warrant the use of raw handles.
-
-Without reference counting
-^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-.. cpp:class:: handle: public detail::api<handle>
-
-   This class provides a thin wrapper around a raw ``PyObject *`` pointer. Its
-   main purpose is to intercept various C++ operations and convert them into
-   Python C API calls. It does *not* do any reference counting and can be
-   somewhat unsafe to use.
-
-   .. cpp:function:: handle() = default
-
-      Default constructor. Creates an invalid handle wrapping a null pointer.
-      (:cpp:func:`detail::api::is_valid()` is ``false``)
-
-   .. cpp:function:: handle(const handle &) = default
-
-      Default copy constructor.
-
-   .. cpp:function:: handle(handle &&) = default
-
-      Default move constructor.
-
-   .. cpp:function:: handle(const PyObject * o)
-
-      Initialize a handle from a Python object pointer. Does not change the reference count of `o`.
-
-   .. cpp:function:: handle(const PyTypeObject * o)
-
-      Initialize a handle from a Python type object pointer. Does not change the reference count of `o`.
-
-   .. cpp:function:: handle &operator=(const handle &) = default
-
-      Default copy assignment operator.
-
-   .. cpp:function:: handle &operator=(handle &&) = default
-
-      Default move assignment operator.
-
-   .. cpp:function:: explicit operator bool() const
-
-      Check if the handle refers to a valid Python object. Equivalent to
-      :cpp:func:`detail::api::is_valid()`
-
-   .. cpp:function:: handle inc_ref() const noexcept
-
-      Increases the reference count and returns a reference to the Python object.
-      Never raises an exception.
-
-   .. cpp:function:: handle dec_ref() const noexcept
-
-      Decreases the reference count and returns a reference to the Python object.
-      Never raises an exception.
-
-   .. cpp:function:: PyObject * ptr() const
-
-      Return the underlying ``PyObject*`` pointer.
-
-With reference counting
-^^^^^^^^^^^^^^^^^^^^^^^
-
-.. cpp:class:: object: public handle
-
-   This class provides a convenient `RAII
-   <https://en.wikipedia.org/wiki/Resource_acquisition_is_initialization>`_
-   wrapper around a ``PyObject*`` pointer. Like :cpp:class:`handle`, it
-   intercepts various C++ operations and converts them into Python C API calls.
-
-   The main difference to :cpp:class:`handle` is that it uses reference
-   counting to keep the underlying Python object alive.
-
-   Use the :cpp:func:`borrow()` and :cpp:func:`steal()` functions to create an
-   :cpp:class:`object` from a :cpp:class:`handle` or ``PyObject*`` pointer.
-
-   .. cpp:function:: object() = default
-
-      Default constructor. Creates an invalid object wrapping a null pointer.
-      (:cpp:func:`detail::api::is_valid()` is ``false``)
-
-   .. cpp:function:: object(object &&o)
-
-      Move constructor. Steals the object from `o` without
-      changing its reference count.
-
-   .. cpp:function:: object(const object &o)
-
-      Copy constructor. Acquires a new reference to `o` (if valid).
-
-   .. cpp:function:: ~object()
-
-      Decrease the reference count of the referenced Python object (if valid).
-
-   .. cpp:function:: object& operator=(object &&o)
-
-      Move assignment operator. Decreases the reference count of the currently
-      held object (if valid) and steals the object from `o` without
-      changing its reference count.
-
-   .. cpp:function:: object& operator=(const object &o)
-
-      Copy assignment operator. Decreases the reference count of the currently
-      held object (if valid) and acquires a new reference to the object
-      `o` (if valid).
-
-   .. cpp:function:: void reset()
-
-      Decreases the reference count of the currently held object (if valid) and
-      resets the internal pointer to ``nullptr``.
-
-   .. cpp:function:: handle release()
-
-      Resets the internal pointer to ``nullptr`` and returns its previous
-      contents as a :cpp:class:`handle`. This operation does not change
-      the object's reference count and should be used carefully.
-
-   .. cpp:function:: template <typename T> object& operator+=(const api<T> &other)
-
-      Equivalent to ``self += other`` in Python.
-
-   .. cpp:function:: template <typename T> object& operator-=(const api<T> &other)
-
-       Equivalent to ``self -= other`` in Python.
-
-   .. cpp:function:: template <typename T> object& operator*=(const api<T> &other)
-
-       Equivalent to ``self *= other`` in Python.
-
-   .. cpp:function:: template <typename T> object& operator/=(const api<T> &other)
-
-       Equivalent to ``self /= other`` in Python.
-
-   .. cpp:function:: template <typename T> object& operator|=(const api<T> &other)
-
-       Equivalent to ``self |= other`` in Python.
-
-   .. cpp:function:: template <typename T> object& operator&=(const api<T> &other)
-
-       Equivalent to ``self &= other`` in Python.
-
-   .. cpp:function:: template <typename T> object& operator^=(const api<T> &other)
-
-       Equivalent to ``self ^= other`` in Python.
-
-   .. cpp:function:: template <typename T> object& operator<<=(const api<T> &other)
-
-       Equivalent to ``self <<= other`` in Python.
-
-   .. cpp:function:: template <typename T> object& operator>>=(const api<T> &other)
-
-       Equivalent to ``self >>= other`` in Python.
-
-
-.. cpp:function:: template <typename T = object> T borrow(handle h)
-
-   Create a reference-counted Python object wrapper of type `T` from a raw
-   handle or ``PyObject *`` pointer. The target type `T` must be
-   :cpp:class:`object` (the default) or one of its derived classes. The
-   function does not perform any conversions or checks---it is up to the user
-   to make sure that the target type is correct.
-
-   The function *borrows* a reference, which means that it will increase the
-   reference count while constructing ``T``.
-
-   For example, consider the Python C API function `PyList_GetItem()
-   <https://docs.python.org/3/c-api/list.html#c.PyList_GetItem>`_, whose
-   documentation states that it returns a borrowed reference. An interface
-   between this API and nanobind could look as follows:
-
-   .. code-block:: cpp
-
-
-       PyObject* list = ...;
-       Py_ssize_t index = ...;
-       nb::object o = nb::borrow(PyList_GetItem(list, index));
-
-   Using :cpp:func:`steal()` in this setting is incorrect and would lead to a
-   reference underflow.
-
-.. cpp:function:: template <typename T = object> T steal(handle h)
-
-   Create a reference-counted Python object wrapper of type `T` from a raw
-   handle or ``PyObject *`` pointer. The target type `T` must be
-   :cpp:class:`object` (the default) or one of its derived classes. The
-   function does not perform any conversions or checks---it is up to the user
-   to make sure that the target type is correct.
-
-   The function *steals* a reference, which means that constructing ``T``
-   leaves the object's reference count unchanged.
-
-   For example, consider the Python C API function `PyObject_Str()
-   <https://docs.python.org/3/c-api/object.html#c.PyObject_Str>`_, whose
-   documentation states that it returns a *new reference*. An interface
-   between this API and nanobind could look as follows:
-
-   .. code-block:: cpp
-
-       PyObject* value = ...;
-       nb::object o = nb::steal(PyObject_Str(value));
-
-   Using :cpp:func:`borrow()` in this setting is incorrect and would lead to a
-   reference leak.
-
-
-Attribute access
-----------------
-
-.. cpp:function:: bool hasattr(handle h, const char * key) noexcept
-
-   Check if the given object has an attribute string ``key``. The function never
-   raises an exception and returns ``false`` in case of an internal error.
-
-   Equivalent to ``hasattr(h, key)`` in Python.
-
-.. cpp:function:: bool hasattr(handle h, handle key) noexcept
-
-   Check if the given object has a attribute represented by the Python object
-   ``key``. The function never raises an exception and returns ``false`` in
-   case of an internal error.
-
-   Equivalent to ``hasattr(h, key)`` in Python.
-
-.. cpp:function:: object getattr(handle h, const char * key)
-
-   Equivalent to ``h.key`` and ``getattr(h, key)`` in Python.
-   Raises :cpp:class:`python_error` if the operation fails.
-
-.. cpp:function:: object getattr(handle h, handle key)
-
-   Equivalent to ``h.key`` and ``getattr(h, key)`` in Python.
-   Raises :cpp:class:`python_error` if the operation fails.
-
-.. cpp:function:: object getattr(handle h, const char * key, handle def) noexcept
-
-   Equivalent to ``getattr(h, key, def)`` in Python. Never raises an
-   exception and returns ``def`` when the operation fails, or when the desired
-   attribute could not be found.
-
-.. cpp:function:: object getattr(handle h, handle key, handle def) noexcept
-
-   Equivalent to ``getattr(h, key, def)`` in Python. Never raises an
-   exception and returns ``def`` when the operation fails, or when the desired
-   attribute could not be found.
-
-.. cpp:function:: void setattr(handle h, const char * key, handle value)
-
-   Equivalent to ``h.key = value`` and ``setattr(h, key, value)`` in Python.
-   Raises :cpp:class:`python_error` if the operation fails.
-
-.. cpp:function:: void setattr(handle h, handle key, handle value)
-
-   Equivalent to ``h.key = value`` and ``setattr(h, key, value)`` in Python.
-   Raises :cpp:class:`python_error` if the operation fails.
-
-.. cpp:function:: void delattr(handle h, const char * key)
-
-   Equivalent to ``del h.key`` and ``delattr(h, key)`` in Python.
-   Raises :cpp:class:`python_error` if the operation fails.
-
-.. cpp:function:: void delattr(handle h, handle key)
-
-   Equivalent to ``del h.key`` and ``delattr(h, key)`` in Python.
-   Raises :cpp:class:`python_error` if the operation fails.
-
-.. cpp:function:: template <typename T> void del(detail::accessor<T> &)
-
-   Remove an element from a sequence or mapping. The C++ statement
-
-   .. code-block:: cpp
-
-      nb::del(o[key]);
-
-   is equivalent to ``del o[key]`` in Python.
-
-   When the element cannot be removed, the function will raise
-   :cpp:class:`python_error` wrapping either a Python ``IndexError`` (for
-   sequence types) or a ``KeyError`` (for mapping types).
-
-.. cpp:function:: template <typename T> void del(detail::accessor<T> &&)
-
-   Rvalue equivalent of the above expression.
-
-Size queries
-------------
-
-.. cpp:function:: size_t len(handle h)
-
-   Equivalent to ``len(h)`` in Python. Raises :cpp:class:`python_error` if the
-   operation fails.
-
-.. cpp:function:: size_t len(const tuple &t)
-
-   Equivalent to ``len(t)`` in Python. Optimized variant for tuples.
-
-.. cpp:function:: size_t len(const list &l)
-
-   Equivalent to ``len(l)`` in Python. Optimized variant for lists.
-
-.. cpp:function:: size_t len(const dict &d)
-
-   Equivalent to ``len(d)`` in Python. Optimized variant for dictionaries.
-
-.. cpp:function:: size_t len(const set &d)
-
-   Equivalent to ``len(d)`` in Python. Optimized variant for sets.
-
-.. cpp:function:: size_t len_hint(handle h)
-
-   Equivalent to ``operator.length_hint(h)`` in Python. Raises
-   :cpp:class:`python_error` if the operation fails.
-
-Type queries
-------------
-
-.. cpp:function:: template <typename T> isinstance(handle h)
-
-   Checks if the Python object `h` represents a valid instance of the C++ type
-   `T`. This works for bound C++ classes, basic types (``int``, ``bool``,
-   etc.), and Python type wrappers ( :cpp:class:`list`, :cpp:class:`dict`,
-   :cpp:class:`module_`, etc.).
-
-   *Note*: the check even works when `T` involves a type caster (e.g., an STL
-   types like ``std::vector<float>``). However, this involve a wasteful attempt
-   to convert the object to C++. It may be more efficient to just perform the
-   conversion using :cpp:func:`cast` and catch potential raised exceptions.
-
-.. cpp:function:: isinstance(handle inst, handle cls)
-
-   Checks if the Python object `inst` is an instance of the Python type `cls`.
-
-.. cpp:function:: template <typename T> handle type() noexcept
-
-   Returns the Python type object associated with the C++ type `T`. When the
-   type not been bound via nanobind, the function returns an invalid handle
-   (:cpp:func:`detail::api::is_valid()` is ``false``).
-
-   *Note*: in contrast to the :cpp:func:`isinstance()` function above, builtin
-   types, type wrappers, and types handled using type casters, are *not*
-   supported.
-
-Wrapper classes
----------------
-
-.. cpp:class:: tuple: public object
-
-   Wrapper class representing Python ``tuple`` instances.
-
-   Use the standard ``operator[]`` C++ operator with an integer argument to
-   read tuple elements (the bindings for this operator are provided by the
-   parent class and not listed here). Once created, the set is immutable and
-   its elements cannot be replaced.
-
-   Use the :py:func:`make_tuple` function to create new tuples.
-
-   .. cpp:function:: tuple()
-
-      Create an empty tuple
-
-   .. cpp:function:: tuple(handle h)
-
-      Attempt to convert a given Python object into a tuple. Analogous to the
-      expression ``tuple(h)`` in Python.
-
-   .. cpp:function:: size_t size() const
-
-      Return the number of tuple elements.
-
-   .. cpp:function:: bool empty() const
-
-      Check whether the tuple is empty.
-
-   .. cpp:function:: detail::fast_iterator begin() const
-
-      Return a forward iterator analogous to ``iter()`` in Python. The function
-      overrides a generic version in :cpp:class:`detail::api` and is more
-      efficient for tuples.
-
-   .. cpp:function:: detail::fast_iterator end() const
-
-      Return a sentinel that ends the iteration.
-
-   .. cpp:function:: template <typename T, enable_if_t<std::is_arithmetic_v<T>> = 1> detail::accessor<num_item_tuple> operator[](T key) const
-
-      Analogous to ``self[key]`` in Python, where ``key`` is an arithmetic
-      type (e.g., an integer). The result is wrapped in an :cpp:class:`accessor <detail::accessor>` so
-      that it can be read and converted. Write access is not possible.
-
-      The function overrides the generic version in :cpp:class:`detail::api`
-      and is more efficient for tuples.
-
-
-.. cpp:class:: list : public object
-
-   Wrapper class representing Python ``list`` instances.
-
-   Use the standard ``operator[]`` C++ operator with an integer argument to
-   read and write list elements (the bindings for this operator are provided by
-   the parent class and not listed here).
-
-   Use the :cpp:func:`nb::del <del>` function to remove elements.
-
-   .. cpp:function:: list()
-
-      Create an empty list
-
-   .. cpp:function:: list(handle h)
-
-      Attempt to convert a given Python object into a list. Analogous to the
-      expression ``list(h)`` in Python.
-
-   .. cpp:function:: size_t size() const
-
-      Return the number of list elements.
-
-   .. cpp:function:: bool empty() const
-
-      Check whether the list is empty.
-
-   .. cpp:function:: template <typename T> void append(T&& value)
-
-      Append an element to the list. When `T` does not already represent a
-      wrapped Python object, the function performs a cast.
-
-   .. cpp:function:: template <typename T> void insert(Py_ssize_t index, T&& value)
-
-      Insert an element to the list (at index ``index``, which may also be
-      negative). When `T` does not already represent a wrapped Python object,
-      the function performs a cast.
-
-   .. cpp:function:: void clear()
-
-      Clear the list entries.
-
-   .. cpp:function:: void extend(handle h)
-
-      Analogous to the ``.extend(h)`` method of ``list`` in Python.
-
-   .. cpp:function:: void sort()
-
-      Analogous to the ``.sort()`` method of ``list`` in Python.
-
-   .. cpp:function:: void reverse()
-
-      Analogous to the ``.reverse()`` method of ``list`` in Python.
-
-   .. cpp:function:: template <typename T, enable_if_t<std::is_arithmetic_v<T>> = 1> detail::accessor<num_item_list> operator[](T key) const
-
-      Analogous to ``self[key]`` in Python, where ``key`` is an arithmetic
-      type (e.g., an integer). The result is wrapped in an :cpp:class:`accessor <detail::accessor>` so
-      that it can be read and written.
-
-      The function overrides the generic version in :cpp:class:`detail::api`
-      and is more efficient for lists.
-
-   .. cpp:function:: detail::fast_iterator begin() const
-
-      Return a forward iterator analogous to ``iter()`` in Python. The operator
-      provided here overrides the generic version in :cpp:class:`detail::api`
-      and is more efficient for lists.
-
-   .. cpp:function:: detail::fast_iterator end() const
-
-      Return a sentinel that ends the iteration.
-
-
-.. cpp:class:: dict: public object
-
-   Wrapper class representing Python ``dict`` instances.
-
-   Use the standard ``operator[]`` C++ operator to read and write dictionary
-   elements (the bindings for this operator are provided by the parent class
-   and not listed here).
-
-   Use the :cpp:func:`nb::del <del>` function to remove elements.
-
-   .. cpp:function:: dict()
-
-      Create an empty dictionary
-
-   .. cpp:function:: size_t size() const
-
-      Return the number of dictionary elements.
-
-   .. cpp:function:: bool empty() const
-
-      Check whether the dictionary is empty.
-
-   .. cpp:function:: template <typename T> bool contains(T&& key) const
-
-      Check whether the dictionary contains a particular key. When `T` does not
-      already represent a wrapped Python object, the function performs a cast.
-
-   .. cpp:function:: detail::dict_iterator begin() const
-
-      Return an item iterator that returns ``std::pair<handle, handle>``
-      key-value pairs analogous to ``iter(dict.items())`` in Python.
-
-      In free-threaded Python, the :cpp:class:``detail::dict_iterator`` class
-      acquires a lock to the underlying dictionary to enable the use of the
-      efficient but thread-unsafe ``PyDict_Next()`` Python C traversal routine.
-
-   .. cpp:function:: detail::dict_iterator end() const
-
-      Return a sentinel that ends the iteration.
-
-   .. cpp:function:: list keys() const
-
-      Return a list containing all dictionary keys.
-
-   .. cpp:function:: list values() const
-
-      Return a list containing all dictionary values.
-
-   .. cpp:function:: list items() const
-
-      Return a list containing all dictionary items as ``(key, value)`` pairs.
-
-   .. cpp:function:: void clear()
-
-      Clear the contents of the dictionary.
-
-   .. cpp:function:: void update(handle h)
-
-      Analogous to the ``.update(h)`` method of ``dict`` in Python.
-
-   .. cpp:function:: object get(handle key, handle def)
-
-      Analogous to ``.get(key, def)`` method of ``dict`` in Python with a
-      fallback value ``def``. This is more efficient than checking the presence
-      of ``.contains(key)`` first, or using ``operator[]`` and catching a
-      potential exceptions.
-
-   .. cpp:function:: object get(const char * key, handle def)
-
-      Overload of the above method that takes a C-string as key.
-
-.. cpp:class:: set: public object
-
-   Wrapper class representing Python ``set`` instances.
-
-   .. cpp:function:: set()
-
-      Create an empty set
-
-   .. cpp:function:: set(handle h)
-
-      Attempt to convert a given Python object into a set. Analogous to the
-      expression ``set(h)`` in Python.
-
-   .. cpp:function:: size_t size() const
-
-      Return the number of set elements.
-
-   .. cpp:function:: bool empty() const
-
-      Check whether the set is empty.
-
-   .. cpp:function:: template <typename T> void add(T&& key)
-
-      Add a key to the set. When `T` does not already represent a wrapped
-      Python object, the function performs a cast.
-
-   .. cpp:function:: template <typename T> bool contains(T&& key) const
-
-      Check whether the set contains a particular key. When `T` does not
-      already represent a wrapped Python object, the function performs a cast.
-
-   .. cpp:function:: void clear()
-
-      Clear the contents of the set.
-
-   .. cpp:function:: template <typename T> bool discard(T&& key)
-
-      Analogous to the ``.discard(h)`` method of the ``set`` type in Python.
-      Returns ``true`` if the item was deleted successfully, and ``false`` if
-      the value was not present. When `T` does not already represent a wrapped
-      Python object, the function performs a cast.
-
-.. cpp:class:: frozenset: public object
-
-   Wrapper class representing Python ``frozenset`` instances.
-
-   .. cpp:function:: frozenset()
-
-      Create an empty frozenset.
-
-   .. cpp:function:: frozenset(handle h)
-
-      Attempt to convert a given Python object into a ``frozenset``. Analogous
-      to the expression ``frozenset(h)`` in Python.
-
-   .. cpp:function:: size_t size() const
-
-      Return the number of set elements.
-
-   .. cpp:function:: bool empty() const
-
-      Check whether the set is empty.
-
-   .. cpp:function:: template <typename T> bool contains(T&& key) const
-
-      Check whether the set contains a particular key. When `T` does not
-      already represent a wrapped Python object, the function performs a cast.
-
-.. cpp:class:: module_: public object
-
-   Wrapper class representing Python ``module`` instances. The underscore at
-   the end disambiguates the class name from the C++20 ``module`` declaration.
-
-   .. cpp:function:: template <typename Func, typename... Extra> module_ &def(const char * name, Func &&f, const Extra &...extra)
-
-      Bind the function `f` to the identifier `name` within the module. Returns
-      a reference to ``*this`` so that longer sequences of binding declarations
-      can be chained, as in ``m.def(...).def(...);``. The variable length
-      `extra` parameter can be used to pass docstrings and other :ref:`function
-      binding annotations <function_binding_annotations>`.
-
-      Example syntax:
-
-      .. code-block:: cpp
-
-         void test() { printf("Hello world!"); }
-
-         NB_MODULE(example, m) {
-             // here, "m" is variable of type 'module_'.
-             m.def("test", &test, "A test function")
-              .def(...); // more binding declarations
-         }
-
-
-   .. cpp:function:: module_ import_(const char * name)
-
-      Import the Python module with the specified name and return a reference
-      to it. The underscore at the end disambiguates the function name from the
-      C++20 ``import`` statement.
-
-      Example usage:
-
-      .. code-block:: cpp
-
-         nb::module_ np = nb::module_::import_("numpy");
-         nb::object np_array = np.attr("array");
-
-   .. cpp:function:: module_ import_(handle name)
-
-      Import the Python module with the specified name and return a reference
-      to it. In contrast to the version above, this function expects a Python
-      object as key.
-
-   .. cpp:function:: module_ def_submodule(const char * name, const char * doc = nullptr)
-
-      Create a Python submodule within an existing module and return a
-      reference to it. Can be chained recursively.
-
-      Example usage:
-
-      .. code-block:: cpp
-
-         NB_MODULE(example, m) {
-             nb::module_ m2 = m.def_submodule("sub", "A submodule of 'example'");
-             nb::module_ m3 = m2.def_submodule("subsub", "A submodule of 'example.sub'");
-         }
-
-.. cpp:class:: capsule: public object
-
-   Capsules are small opaque Python objects that wrap a C or C++ pointer and a cleanup routine.
-
-   .. cpp:function:: capsule(const void * ptr, void (* cleanup)(void*) noexcept = nullptr)
-
-      Construct an *unnamed* capsule wrapping the pointer `p`. When the
-      capsule is garbage collected, Python will call the destructor `cleanup`
-      (if provided) with the value of `p`.
-
-   .. cpp:function:: capsule(const void * ptr, const char * name, void (* cleanup)(void*) noexcept = nullptr)
-
-      Construct a *named* capsule with name `name` wrapping the pointer `p`.
-      When the capsule is garbage collected, Python will call the destructor
-      `cleanup` (if provided) with the value of `p`.
-
-   .. cpp:function:: const char * name() const
-
-      Return the capsule name (or ``nullptr`` when the capsule is unnamed)
-
-   .. cpp:function:: void * data() const
-
-      Return the pointer wrapped by the capsule.
-
-   .. cpp:function:: void * data(const char *name) const
-
-      Return the pointer wrapped by the capsule. Check that the
-      capsule name matches the specified value, or raise an exception.
-
-
-.. cpp:class:: bool_: public object
-
-   This wrapper class represents Python ``bool`` instances.
-
-   .. cpp:function:: bool_(handle h)
-
-      Performs a boolean cast within Python. This is equivalent to the Python
-      expression ``bool(h)``.
-
-   .. cpp:function:: explicit bool_(bool value)
-
-      Convert an C++ boolean instance into a Python ``bool``.
-
-   .. cpp:function:: explicit operator bool() const
-
-      Extract the boolean value underlying this object.
-
-
-.. cpp:class:: int_: public object
-
-   This wrapper class represents Python ``int`` instances. It can handle large
-   numbers requiring more than 64 bits of storage.
-
-   .. cpp:function:: int_(handle h)
-
-      Performs an integer cast within Python. This is equivalent to the Python
-      expression ``int(h)``.
-
-   .. cpp:function:: template <typename T, detail::enable_if_t<std::is_arithmetic_v<T>> = 0> explicit int_(T value)
-
-      Convert an C++ arithmetic type into a Python integer.
-
-   .. cpp:function:: template <typename T, detail::enable_if_t<std::is_arithmetic_v<T>> = 0> explicit operator T() const
-
-      Convert a Python integer into a C++ arithmetic type.
-
-
-.. cpp:class:: float_: public object
-
-   This wrapper class represents Python ``float`` instances.
-
-   .. cpp:function:: float_(handle h)
-
-      Performs an floating point cast within Python. This is equivalent to the
-      Python expression ``float(h)``.
-
-   .. cpp:function:: explicit float_(double value)
-
-      Convert an C++ double value into a Python float objecct
-
-   .. cpp:function:: explicit operator double() const
-
-      Convert a Python float object into a C++ double value
-
-
-.. cpp:class:: str: public object
-
-   This wrapper class represents Python unicode ``str`` instances.
-
-   .. cpp:function:: str(handle h)
-
-      Performs a string cast within Python. This is equivalent equivalent to
-      the Python expression ``str(h)``.
-
-   .. cpp:function:: str(const char * s)
-
-      Convert a null-terminated C-style string in UTF-8 encoding into a Python string.
-
-   .. cpp:function:: str(const char * s, size_t n)
-
-      Convert a C-style string in UTF-8 encoding of length ``n`` bytes into a Python string.
-
-      There is a user-defined string literal ``_s`` accessible in the
-      ``nanobind::literals`` namespace::
-
-            using namespace nanobind::literals;
-            auto s = "Hello world!"_s; // equivalent to str("Hello world!")
-
-   .. cpp:function:: const char * c_str() const
-
-      Convert a Python string into a null-terminated C-style string with UTF-8
-      encoding.
-
-      *Note*: The C string will be deleted when the `str` instance is garbage
-      collected.
-
-   .. cpp:function:: template <typename... Args> str format(Args&&... args)
-
-      C++ analog of the Python routine ``str.format``. Can be called with
-      positional and keyword arguments.
-
-
-.. cpp:class:: bytes: public object
-
-   This wrapper class represents Python unicode ``bytes`` instances.
-
-   .. cpp:function:: bytes(handle h)
-
-      Performs a cast within Python. This is equivalent to
-      the Python expression ``bytes(h)``.
-
-   .. cpp:function:: bytes(const char * s)
-
-      Convert a null-terminated C-style string encoding into a Python ``bytes`` object.
-
-   .. cpp:function:: bytes(const void * buf, size_t n)
-
-      Convert a byte buffer ``buf`` of length ``n`` bytes into a Python ``bytes`` object.  The buffer can contain embedded null bytes.
-
-   .. cpp:function:: const char * c_str() const
-
-      Convert a Python bytes object into a null-terminated C-style string.
-
-   .. cpp:function:: size_t size() const
-
-      Return the size in bytes.
-
-   .. cpp:function:: const void * data() const
-
-      Convert a Python ``bytes`` object into a byte buffer of length :cpp:func:`bytes::size()` bytes.
-
-
-.. cpp:class:: bytearray: public object
-
-   This wrapper class represents Python ``bytearray`` instances.
-
-   .. cpp:function:: bytearray()
-
-      Create an empty ``bytearray``.
-
-   .. cpp:function:: bytearray(handle h)
-
-      Performs a cast within Python. This is equivalent to
-      the Python expression ``bytearray(h)``.
-
-   .. cpp:function:: bytearray(const void * buf, size_t n)
-
-      Convert a byte buffer ``buf`` of length ``n`` bytes into a Python ``bytearray`` object.  The buffer can contain embedded null bytes.
-
-   .. cpp:function:: const char * c_str() const
-
-      Convert a Python ``bytearray`` object into a null-terminated C-style string.
-
-   .. cpp:function:: size_t size() const
-
-      Return the size in bytes.
-
-   .. cpp:function:: void * data()
-
-      Convert a Python ``bytearray`` object into a byte buffer of length :cpp:func:`bytearray::size()` bytes.
-
-   .. cpp:function:: const void * data() const
-
-      Convert a Python ``bytearray`` object into a byte buffer of length :cpp:func:`bytearray::size()` bytes.
-
-   .. cpp:function:: void resize(size_t n)
-
-      Resize the internal buffer of a Python ``bytearray`` object to ``n``. Any
-      space added by this method, which calls `PyByteArray_Resize`, will not be
-      initialized and may contain random data.
-
-
-.. cpp:class:: type_object: public object
-
-   Wrapper class representing Python ``type`` instances.
-
-.. cpp:class:: sequence: public object
-
-   Wrapper class representing arbitrary Python sequence types.
-
-.. cpp:class:: mapping : public object
-
-   Wrapper class representing arbitrary Python mapping types.
-
-   .. cpp:function:: template <typename T> bool contains(T&& key) const
-
-      Check whether the map contains a particular key. When `T` does not
-      already represent a wrapped Python object, the function performs a cast.
-
-   .. cpp:function:: list keys() const
-
-      Return a list containing all of the map's keys.
-
-   .. cpp:function:: list values() const
-
-      Return a list containing all of the map's values.
-
-   .. cpp:function:: list items() const
-
-      Return a list containing all of the map's items as ``(key, value)`` pairs.
-
-.. cpp:class:: iterator : public object
-
-   Wrapper class representing a Python iterator.
-
-   .. cpp:function:: iterator& operator++()
-
-      Advance to the next element (pre-increment form).
-
-   .. cpp:function:: iterator& operator++(int)
-
-      Advance to the next element (post-increment form).
-
-   .. cpp:function:: handle operator*() const
-
-      Return the item at the current position.
-
-   .. cpp:function:: handle operator->() const
-
-      Convenience routine for pointer-style access.
-
-   .. static iterator sentinel();
-
-      Return a sentinel that ends the iteration.
-
-   .. cpp:function:: friend bool operator==(const iterator &a, const iterator &b);
-
-      Iterator equality comparison operator.
-
-   .. cpp:function:: friend bool operator!=(const iterator &a, const iterator &b);
-
-      Iterator inequality comparison operator.
-
-.. cpp:class:: iterable : public object
-
-   Wrapper class representing an object that can be iterated upon (in the sense
-   that calling :cpp:func:`iter()` is valid).
-
-.. cpp:class:: slice : public object
-
-   Wrapper class representing a Python slice object.
-
-   .. cpp:function:: slice(handle start, handle stop, handle step)
-
-      Create the slice object given by ``slice(start, stop, step)`` in Python.
-
-   .. cpp:function:: template <typename T, detail::enable_if_t<std::is_arithmetic_v<T>> = 0> slice(T stop)
-
-      Create the slice object ``slice(stop)``, where `stop` is represented by a
-      C++ integer type.
-
-   .. cpp:function:: template <typename T, detail::enable_if_t<std::is_arithmetic_v<T>> = 0> slice(T start, T stop)
-
-      Create the slice object ``slice(start, stop)``, where `start` and `stop`
-      are represented by a C++ integer type.
-
-   .. cpp:function:: template <typename T, detail::enable_if_t<std::is_arithmetic_v<T>> = 0> slice(T start, T stop, T step)
-
-      Create the slice object ``slice(start, stop, step)``, where `start`,
-      `stop`, and `step` are represented by a C++ integer type.
-
-   .. cpp:function:: detail::tuple<Py_ssize_t, Py_ssize_t, Py_ssize_t, size_t> compute(size_t size) const
-
-      Adjust the slice to the `size` value of a given container. Returns a tuple containing
-      ``(start, stop, step, slice_length)``.
-
-.. cpp:class:: ellipsis: public object
-
-   Wrapper class representing a Python ellipsis (``...``) object.
-
-   .. cpp:function:: ellipsis()
-
-      Create a wrapper referencing the unique Python ``Ellipsis`` object.
-
-.. cpp:class:: not_implemented: public object
-
-   Wrapper class representing a Python ``NotImplemented`` object.
-
-   .. cpp:function:: not_implemented()
-
-      Create a wrapper referencing the unique Python ``NotImplemented`` object.
-
-.. cpp:class:: callable: public object
-
-   Wrapper class representing a callable Python object.
-
-.. cpp:class:: weakref: public object
-
-   Wrapper class representing a Python weak reference object.
-
-   .. cpp:function:: explicit weakref(handle obj, handle callback = { })
-
-      Construct a new weak reference that points to `obj`. If provided,
-      Python will invoke the callable `callback` when `obj` expires.
-
-.. cpp:class:: args : public tuple
-
-   Variable argument keyword list for use in function argument declarations.
-
-.. cpp:class:: kwargs : public dict
-
-   Variable keyword argument keyword list for use in function argument declarations.
-
-.. cpp:class:: any : public object
-
-   This wrapper class represents Python ``typing.Any``-typed values. On the C++
-   end, this type is interchangeable with :py:class:`object`. The only
-   difference is the type signature when used in function arguments and return
-   values.
-
-.. cpp:class:: fallback : public object
-
-   Instances of this wrapper class behave just like :cpp:class:`handle`. When
-   used to pass arguments in function bindings, the associated arguments
-   *require* implicit conversion (which, however, adds no runtime cost).
-
-   The type is convenient in overload chains where a generic fallback should
-   accept any Python object, e.g.,
-
-   .. code-block:: cpp
-
-      m.def("func", [](MyClass &arg)) { ... });
-      m.def("func", [](nb::fallback arg)) { ... });
-
-   If :cpp:class:`handle` or :cpp:class:`object` were used instead on the
-   second line, they would always match and prevent potential implicit
-   conversion of arguments to `MyClass`.
-
-Parameterized wrapper classes
------------------------------
-
-.. cpp:class:: template <typename T> handle_t : public handle
-
-   Wrapper class representing a handle to a subclass of the C++ type `T`. It
-   can be used to bind functions that take the associated Python object in its
-   wrapped form, while rejecting objects with a different type (i.e., it is
-   more discerning than :cpp:class:`handle`, which accepts *any* Python object).
-
-   .. code-block:: cpp
-
-      // Bind the class A
-      class A { int value; };
-      nb::class_<A>(m, "A");
-
-      // Bind a function that takes a Python object representing a 'A' instance
-      m.def("process_a", [](nb::handle_t<A> h) {
-         PyObject * a_py = h.ptr();   // PyObject* pointer to wrapper
-         A &a_cpp = nb::cast<A &>(h); // Reference to C++ instance
-      });
-
-.. cpp:class:: template <typename T> type_object_t : public type_object
-
-   Wrapper class representing a Python type object that is a subtype of the C++
-   type `T`. It can be used to bind functions that only accept type objects
-   satisfying this criterion (i.e., it is more discerning than
-   :cpp:class:`type_object`, which accepts *any* Python type object).
-
-Error management
-----------------
-
-nanobind provides a range of functionality to convert C++ exceptions into
-equivalent Python exceptions and raise captured Python error state in C++. The
-:cpp:class:`exception` class is also relevant in this context, but is listed in
-the reference section on :ref:`class binding <class_binding>`.
-
-.. cpp:struct:: error_scope
-
-   RAII helper class that temporarily stashes any existing Python error status.
-   This is important when running Python code in the context of an existing
-   failure that must be processed (e.g., to generate an error message).
-
-   .. cpp:function:: error_scope()
-
-      Stash the current error status (if any)
-
-   .. cpp:function:: ~error_scope()
-
-      Restore the stashed error status (if any)
-
-.. cpp:struct:: python_error : public std::exception
-
-   Exception that represents a detected Python error status.
-
-   .. cpp:function:: python_error()
-
-      This constructor may only be called when a Python error has occurred
-      (``PyErr_Occurred()`` must be ``true``). It creates a C++ exception
-      object that represents this error and clears the Python error status.
-
-   .. cpp:function:: python_error(const python_error &)
-
-      Copy constructor
-
-   .. cpp:function:: python_error(python_error &&) noexcept
-
-      Move constructor
-
-   .. cpp:function:: const char * what() noexcept
-
-      Return a stringified version of the exception. nanobind internally
-      normalizes the exception and generates a traceback that is included
-      as part of this string. This can be a relatively costly operation
-      and should only be used if all of this detail is actually needed.
-
-   .. cpp:function:: bool matches(handle exc) noexcept
-
-      Checks whether the exception has the same type as `exc`.
-
-      The argument to this function is usually one of the `Standard Exceptions
-      <https://docs.python.org/3/c-api/exceptions.html#standard-exceptions>`_.
-
-   .. cpp:function:: void restore() noexcept
-
-      Restore the error status in Python and clear the `python_error`
-      contents. This may only be called once, and you should not
-      reraise the `python_error` in C++ afterward.
-
-   .. cpp:function:: void discard_as_unraisable(handle context) noexcept
-
-      Pass the error to Python's :py:func:`sys.unraisablehook`, which
-      prints a traceback to :py:data:`sys.stderr` by default but may
-      be overridden.  Like :cpp:func:`restore`, this consumes the
-      error and you should not reraise the exception in C++ afterward.
-
-      The *context* argument should be some object whose ``repr()``
-      helps identify the location of the error. The default
-      :py:func:`sys.unraisablehook` prints a traceback that begins
-      with the text ``Exception ignored in:`` followed by
-      the result of ``repr(context)``.
-
-      Example use case: handling a Python error that occurs in a C++
-      destructor where you cannot raise a C++ exception.
-
-   .. cpp:function:: void discard_as_unraisable(const char * context) noexcept
-
-      Convenience wrapper around the above function, which takes a C-style
-      string for the ``context`` argument.
-
-   .. cpp:function:: handle type() const
-
-      Returns a handle to the exception type
-
-   .. cpp:function:: handle value() const
-
-      Returns a handle to the exception value
-
-   .. cpp:function:: object traceback() const
-
-      Returns a handle to the exception's traceback object
-
-.. cpp:class:: cast_error
-
-   The function :cpp:func:`cast` raises this exception to indicate that a cast
-   was unsuccessful.
-
-   .. cpp:function:: cast_error()
-
-      Constructor
-
-.. cpp:class:: next_overload
-
-   Raising this special exception from a bound function informs nanobind that
-   the function overload detected incompatible inputs. nanobind will then try
-   other overloads before reporting a ``TypeError``.
-
-   This feature is useful when a multiple overloads of a function accept
-   overlapping or identical input types (e.g. :cpp:class:`object`) and must run
-   code at runtime to select the right overload.
-
-   You should probably write a thorough docstring that explicitly mentions the
-   expected inputs in this case, since the behavior won't be obvious from the
-   auto-generated function signature. It can be frustrating when a function
-   call fails with an error message stating that the provided arguments aren't
-   compatible with any overload, when the associated error message suggests
-   otherwise.
-
-   .. cpp:function:: next_overload()
-
-      Constructor
-
-.. cpp:class:: builtin_exception : public std::runtime_error
-
-   General-purpose class to propagate builtin Python exceptions from C++. A
-   number of convenience functions (see below) instantiate it.
-
-.. cpp:function:: builtin_exception stop_iteration(const char * what = nullptr)
-
-   Convenience wrapper to create a :cpp:class:`builtin_exception` C++ exception
-   instance that nanobind will re-raise as a Python ``StopIteration`` exception
-   when it crosses the C++ ↔ Python interface.
-
-.. cpp:function:: builtin_exception index_error(const char * what = nullptr)
-
-   Convenience wrapper to create a :cpp:class:`builtin_exception` C++ exception
-   instance that nanobind will re-raise as a Python ``IndexError`` exception
-   when it crosses the C++ ↔ Python interface.
-
-.. cpp:function:: builtin_exception key_error(const char * what = nullptr)
-
-   Convenience wrapper to create a :cpp:class:`builtin_exception` C++ exception
-   instance that nanobind will re-raise as a Python ``KeyError`` exception
-   when it crosses the C++ ↔ Python interface.
-
-.. cpp:function:: builtin_exception value_error(const char * what = nullptr)
-
-   Convenience wrapper to create a :cpp:class:`builtin_exception` C++ exception
-   instance that nanobind will re-raise as a Python ``ValueError`` exception
-   when it crosses the C++ ↔ Python interface.
-
-.. cpp:function:: builtin_exception type_error(const char * what = nullptr)
-
-   Convenience wrapper to create a :cpp:class:`builtin_exception` C++ exception
-   instance that nanobind will re-raise as a Python ``TypeError`` exception
-   when it crosses the C++ ↔ Python interface.
-
-.. cpp:function:: builtin_exception buffer_error(const char * what = nullptr)
-
-   Convenience wrapper to create a :cpp:class:`builtin_exception` C++ exception
-   instance that nanobind will re-raise as a Python ``BufferError`` exception
-   when it crosses the C++ ↔ Python interface.
-
-.. cpp:function:: builtin_exception import_error(const char * what = nullptr)
-
-   Convenience wrapper to create a :cpp:class:`builtin_exception` C++ exception
-   instance that nanobind will re-raise as a Python ``ImportError`` exception
-   when it crosses the C++ ↔ Python interface.
-
-.. cpp:function:: builtin_exception attribute_error(const char * what = nullptr)
-
-   Convenience wrapper to create a :cpp:class:`builtin_exception` C++ exception
-   instance that nanobind will re-raise as a Python ``AttributeError`` exception
-   when it crosses the C++ ↔ Python interface.
-
-.. cpp:function:: void register_exception_translator(void (* exception_translator)(const std::exception_ptr &, void*), void * payload = nullptr)
-
-   Install an exception translator callback that will be invoked whenever
-   nanobind's function call dispatcher catches a previously unknown C++
-   exception. This exception translator should follow a standard structure of
-   re-throwing an exception, catching a specific type, and converting this into
-   a Python error status upon "success".
-
-   Here is an example for a hypothetical ``ZeroDivisionException``.
-
-   .. code-block:: cpp
-
-      register_exception_translator(
-          [](const std::exception_ptr &p, void * /*payload*/) {
-              try {
-                  std::rethrow_exception(p);
-              } catch (const ZeroDivisionException &e) {
-                  PyErr_SetString(PyExc_ZeroDivisionError, e.what());
-              }
-          }, nullptr /*payload*/);
-
-   Generally, you will want to use the more convenient exception binding
-   interface provided by :cpp:class:`exception` class. This function provides
-   an escape hatch for more specialized use cases.
-
-.. cpp:function:: void chain_error(handle type, const char * fmt, ...) noexcept
-
-   Raise a Python error of type ``type`` using the format string ``fmt``
-   interpreted by ``PyErr_FormatV``.
-
-   If a Python error state was already set prior to calling this method, then
-   the new error is *chained* on top of the existing one. Otherwise, the
-   function creates a new error without initializing its ``__cause__`` field.
-
-.. cpp:function:: void raise_from(python_error &e, handle type, const char * fmt, ...)
-
-   Convenience wrapper around :cpp:func:`chain_error <chain_error>`. It takes
-   an existing Python error (e.g. caught in a ``catch`` block) and creates an
-   additional Python exception with the current error as cause. It then
-   re-raises :cpp:class:`python_error`. The argument ``fmt`` is a
-   ``printf``-style format string interpreted by ``PyErr_FormatV``.
-
-   Usage of this function is explained in the documentation section on
-   :ref:`exception chaining <exception_chaining>`.
-
-.. cpp:function:: void raise(const char * fmt, ...)
-
-   This function takes a ``printf``-style format string with arguments and then
-   raises a ``std::runtime_error`` with the formatted string. The function has
-   no dependence on Python, and nanobind merely includes it for convenience.
-
-.. cpp:function:: void raise_type_error(const char * fmt, ...)
-
-   This function is analogous to :cpp:func:`raise`, except that it raises a
-   :cpp:class:`builtin_exception` that will convert into a Python ``TypeError``
-   when crossing the language interface.
-
-.. cpp:function:: void raise_python_error()
-
-   This function should only be called if a Python error status was set by a
-   prior operation, which should now be raised as a C++ exception. The function
-   is analogous to the statement ``throw python_error();`` but compiles into
-   more compact code.
-
-Casting
--------
-
-.. cpp:function:: template <typename T, typename Derived> T cast(const detail::api<Derived> &value, bool convert = true)
-
-   Convert the Python object `value` (typically a :cpp:class:`handle` or a
-   :cpp:class:`object` subclass) into a C++ object of type `T`.
-
-   When the `convert` argument is set to ``true`` (the default), the
-   implementation may also attempt *implicit conversions* to perform the cast.
-
-   The function raises a :cpp:type:`cast_error` when the conversion fails.
-   See :cpp:func:`try_cast()` for an alternative that never raises.
-
-.. cpp:function:: template <typename T, typename Derived> bool try_cast(const detail::api<Derived> &value, T &out, bool convert = true) noexcept
-
-   Convert the Python object `value` (typically a :cpp:class:`handle` or a
-   :cpp:class:`object` subclass) into a C++ object of type `T`, and store it
-   in the output parameter `out`.
-
-   When the `convert` argument is set to ``true`` (the default), the
-   implementation may also attempt *implicit conversions* to perform the cast.
-
-   The function returns ``false`` when the conversion fails. In this case, the
-   `out` parameter is left untouched. See :cpp:func:`cast()` for an alternative
-   that instead raises an exception in this case.
-
-.. cpp:function:: template <typename T> object cast(T &&value, rv_policy policy = rv_policy::automatic_reference)
-
-   Convert the C++ object ``value`` into a Python object. The return value
-   policy `policy` is used to handle ownership-related questions when a new
-   Python object must be created.
-
-   The function raises a :cpp:type:`cast_error` when the conversion fails.
-
-.. cpp:function:: template <typename T> object cast(T &&value, rv_policy policy, handle parent)
-
-   Convert the C++ object ``value`` into a Python object. The return value
-   policy `policy` is used to handle ownership-related questions when a new
-   Python object must be created. A valid `parent` object is required when
-   specifying a `reference_internal` return value policy.
-
-   The function raises a :cpp:type:`cast_error` when the conversion fails.
-
-.. cpp:function:: template <typename T> object find(const T &value) noexcept
-
-   Return the Python object associated with the C++ instance `value`. When no
-   such object can be found, the function it returns an invalid object
-   (:cpp:func:`detail::api::is_valid()` is ``false``).
-
-.. cpp:function:: template <rv_policy policy = rv_policy::automatic, typename... Args> tuple make_tuple(Args&&... args)
-
-   Create a Python tuple from a sequence of C++ objects ``args...``. The return
-   value policy `policy` is used to handle ownership-related questions when a
-   new Python objects must be created.
-
-   The function raises a :cpp:type:`cast_error` when the conversion fails.
-
-Common binding annotations
---------------------------
-
-The following annotations can be specified in both function and class bindings.
-
-.. cpp:struct:: scope
-
-   .. cpp:function:: scope(handle value)
-
-      Captures the Python scope (e.g., a :cpp:class:`module_` or
-      :cpp:class:`type_object`) in which the function or class should be
-      registered.
-
-.. _function_binding_annotations:
-
-Function binding annotations
-----------------------------
-
-The following annotations can be specified using the variable-length ``Extra``
-parameter of :cpp:func:`module_::def`, :cpp:func:`class_::def`,
-:cpp:func:`cpp_function`, etc.
-
-.. cpp:struct:: name
-
-   .. cpp:function:: name(const char * value)
-
-      Specify this annotation to override the name of the function.
-
-      nanobind will internally copy the string when creating a function
-      binding, hence dynamically generated arguments with a limited lifetime
-      are legal.
-
-.. cpp:struct:: arg
-
-   Function argument annotation to enable keyword-based calling, default
-   arguments, passing ``None``, and implicit conversion hints. Note that when a
-   function argument should be annotated, you *must* specify annotations for all
-   arguments of that function.
-
-   Example use:
-
-   .. code-block:: cpp
-
-       m.def("add", [](int a, int b) { return a + b; }, nb::arg("a"), nb::arg("b"));
-
-   It is usually convenient to add the following ``using`` declaration to your binding code.
-
-   .. code-block:: cpp
-
-       using namespace nb::literals;
-
-   In this case, the argument annotations can be shortened:
-
-   .. code-block:: cpp
-
-       m.def("add", [](int a, int b) { return a + b; }, "a"_a, "b"_a);
-
-   .. cpp:function:: explicit arg(const char * name = nullptr)
-
-      Create a function argument annotation. The name is optional.
-
-   .. cpp:function:: template <typename T> arg_v operator=(T &&value) const
-
-      Return an argument annotation that is like this one but also assigns a
-      default value to the argument. The default will be converted into a Python
-      object immediately, so its bindings must have already been defined.
-
-   .. cpp:function:: arg &none(bool value = true)
-
-      Set a flag noting that the function argument accepts ``None``. Can only
-      be used for python wrapper types (e.g. :cpp:class:`handle`,
-      :cpp:class:`int_`) and types that have been bound using
-      :cpp:class:`class_`. You cannot use this to implement functions that
-      accept null pointers to builtin C++ types like ``int *i = nullptr``.
-
-   .. cpp:function:: arg &noconvert(bool value = true)
-
-      Set a flag noting that implicit conversion should never be performed for
-      this function argument.
-
-   .. cpp:function:: arg &sig(const char * sig)
-
-      Override the signature of the default argument value. This is useful when
-      the argument value is unusually complex so that the default method to
-      explain it in docstrings and stubs (``str(value)``) does not produce
-      acceptable output.
-
-   .. cpp:function:: arg_locked lock()
-
-      Return an argument annotation that is like this one but also requests that
-      this argument be locked when dispatching a function call in free-threaded
-      Python extensions. It does nothing in regular GIL-protected extensions.
-
-.. cpp:struct:: is_method
-
-   Indicate that the bound function is a method.
-
-.. cpp:struct:: is_operator
-
-   Indicate that the bound operator represents a special double underscore
-   method (``__add__``, ``__radd__``, etc.) that implements an arithmetic
-   operation.
-
-   When a bound functions with this annotation is called with incompatible
-   arguments, it will return ``NotImplemented`` rather than raising a
-   ``TypeError``.
-
-.. cpp:struct:: is_implicit
-
-   Indicate that the bound constructor can be used to perform implicit conversions.
-
-.. cpp:struct:: lock_self
-
-   Indicate that the implicit ``self`` argument of a method should be locked
-   when dispatching a call in a free-threaded extension. This annotation does
-   nothing in regular GIL-protected extensions.
-
-.. cpp:struct:: template <typename... Ts> call_guard
-
-   Invoke the call guard(s) `Ts` when the bound function executes. The RAII
-   helper :cpp:struct:`gil_scoped_release` is often combined with this feature.
-
-.. cpp:struct:: template <size_t Nurse, size_t Patient> keep_alive
-
-   Following evaluation of the bound function, keep the object referenced by
-   index ``Patient`` alive *as long as* the object with index ``Nurse`` exists.
-   This uses the following indexing convention:
-
-   - Index ``0`` refers to the return value of methods. It should not be used
-     in constructors or functions that do not return a result.
-
-   - Index ``1`` refers to the first argument. In methods and constructors,
-     index ``1`` refers to the implicit ``this`` pointer, while regular
-     arguments begin at index ``2``.
-
-   The annotation has the following runtime characteristics:
-
-   - It does nothing when the nurse or patient object are ``None``.
-
-   - It raises an exception when the nurse object is neither
-     weak-referenceable nor an instance of a binding created via
-     :cpp:class:`nb::class_\<..\> <class_>`.
-
-   Two additional caveats regarding :cpp:class:`keep_alive <keep_alive>` are
-   noteworthy:
-
-   - It *usually* doesn't make sense to specify a ``Nurse`` or ``Patient`` for an
-     argument or return value handled by a :ref:`type caster <type_casters>`
-     (e.g., a STL vector handled via the include directive ``#include
-     <nanobind/stl/vector.h>``). That's because type casters copy-convert the
-     Python object into an equivalent C++ object, whose lifetime is decoupled
-     from the original Python object. However, the :cpp:class:`keep_alive
-     <keep_alive>` annotation *only* affects the lifetime of Python objects
-     *and not their C++ copy*.
-
-   - Dispatching a Python → C++ function call may require the :ref:`implicit
-     conversion <noconvert>` of function arguments. In this case, the objects
-     passed to the C++ function differ from the originally specified arguments.
-     The ``Nurse`` and ``Patient`` annotation always refer to the *final* object
-     following implicit conversion.
-
-.. cpp:struct:: sig
-
-   .. cpp:function:: sig(const char * value)
-
-      This is *both* a class and a function binding annotation.
-
-      1. When used in functions bindings, it provides complete control over
-         the function's type signature by replacing the automatically generated
-         version with ``value``. You can use it to add or change arguments and
-         return values, tweak how default values are rendered, and add custom
-         decorators.
-
-         Here is an example:
-
-         .. code-block:: cpp
-
-            nb::def("function_name", &function_name,
-                    nb::sig(
-                        "@decorator(decorator_args..)\n
-                        "def function_name(arg_1: type_1 = def_1, ...) -> ret"
-                    ));
-
-
-      2. When used in class bindings, the annotation enables complete control
-         over how the class is rendered by nanobind's ``stubgen`` program. You
-         can use it add decorators, specify ``typing.TypeVar``-parameterized
-         base classes, metaclasses, etc.
-
-         Here is an example:
-
-         .. code-block:: cpp
-
-            nb::class_<Class>(m, "Class",
-                              nb::sig(
-                                  "@decorator(decorator_args..)\n"
-                                  "class Class(Base1[T], Base2, meta=Meta)"
-                              ));
-
-      Deviating significantly from the nanobind-generated signature likely
-      means that the class or function declaration is a *lie*, but such lies
-      can be useful to type-check complex binding projects.
-
-      Specifying decorators isn't required---the above are just examples to
-      show that this is possible.
-
-      nanobind will internally copy the signature during function/type
-      creation, hence dynamically generated strings with a limited lifetime are
-      legal.
-
-      The provided string should be valid Python signature, but *without* a
-      trailing colon (``":"``) or trailing newline. Furthermore, nanobind
-      analyzes the string and expects to find the name of the function or class
-      on the *last line* between the ``"def"`` / ``"class"`` prefix and the
-      opening parenthesis.
-
-      For function bindings, this name must match the specified function name
-      in ``.def("name", ..)``-style binding declarations, and for class
-      bindings, the specified name must match the ``name`` argument of
-      :cpp:class:`nb::class_ <class_>`.
-
-.. cpp:enum-class:: rv_policy
-
-   A return value policy determines the question of *ownership* when a bound
-   function returns a previously unknown C++ instance that must now be
-   converted into a Python object.
-
-   Return value policies apply to functions that return values handled using
-   :ref:`class bindings <bindings>`, which means that their Python equivalent
-   was registered using :cpp:class:`class_\<...\> <class_>`. They are ignored
-   in most other cases. One exception are STL types handled using :ref:`type
-   casters <type_casters>` (e.g. ``std::vector<T>``), which contain a nested
-   type ``T`` handled using class bindings. In this case, the return value
-   policy also applies recursively.
-
-   A return value policy is unnecessary when the type itself clarifies
-   ownership (e.g., ``std::unique_ptr<T>``, ``std::shared_ptr<T>``, a type with
-   :ref:`intrusive reference counting <intrusive>`).
-
-   The following policies are available (where `automatic` is the default).
-   Please refer to the :ref:`return value policy section <rvp>` of the main
-   documentation, which clarifies the list below using concrete examples.
-
-   .. cpp:enumerator:: take_ownership
-
-      Create a Python object that wraps the existing C++ instance and takes
-      full ownership of it. No copies are made. Python will call the C++
-      destructor and ``delete`` operator when the Python wrapper is garbage
-      collected at some later point. The C++ side *must* relinquish ownership
-      and is not allowed to destruct the instance, or undefined behavior will
-      ensue.
-
-   .. cpp:enumerator:: copy
-
-      Copy-construct a new Python object from the C++ instance. The new copy
-      will be owned by Python, while C++ retains ownership of the original.
-
-   .. cpp:enumerator:: move
-
-      Move-construct a new Python object from the C++ instance. The new object
-      will be owned by Python, while C++ retains ownership of the original
-      (whose contents were likely invalidated by the move operation).
-
-   .. cpp:enumerator:: reference
-
-      Create a Python object that wraps the existing C++ instance *without
-      taking ownership* of it. No copies are made. Python will never call the
-      destructor or ``delete`` operator, even when the Python wrapper is
-      garbage collected.
-
-   .. cpp:enumerator:: reference_internal
-
-      A safe extension of the `reference` policy for methods that implement
-      some form of attribute access. It creates a Python object that wraps the
-      existing C++ instance *without taking ownership* of it. Additionally, it
-      adjusts reference counts to keeps the method's implicit ``self`` argument
-      alive until the newly created object has been garbage collected.
-
-   .. cpp:enumerator:: none
-
-      This is the most conservative policy: it simply refuses the cast unless
-      the C++ instance already has a corresponding Python object, in which case
-      the question of ownership becomes moot.
-
-   .. cpp:enumerator:: automatic
-
-      This is the default return value policy, which falls back to
-      `take_ownership` when the return value is a pointer, `move`  when it is a
-      rvalue reference, and `copy` when it is a lvalue reference.
-
-   .. cpp:enumerator:: automatic_reference
-
-      This policy matches `automatic` but falls back to `reference` when the
-      return value is a pointer.
-
-.. cpp:struct:: kw_only
-
-   Indicate that all following function parameters are keyword-only. This
-   may only be used if you supply an :cpp:struct:`arg` annotation for each
-   parameters, because keyword-only parameters are useless if they don't have
-   names. For example, if you write
-
-   .. code-block:: cpp
-
-      int some_func(int one, const char* two);
-
-      m.def("some_func", &some_func,
-            nb::arg("one"), nb::kw_only(), nb::arg("two"));
-
-   then in Python you can write ``some_func(42, two="hi")``, or
-   ``some_func(one=42, two="hi")``, but not ``some_func(42, "hi")``.
-
-   Just like in Python, any parameters appearing after variadic
-   :cpp:class:`*args <args>` are implicitly keyword-only. You don't
-   need to include the :cpp:struct:`kw_only` annotation in this case,
-   but if you do include it, it must be in the correct position:
-   immediately after the :cpp:struct:`arg` annotation for the variadic
-   :cpp:class:`*args <args>` parameter.
-
-.. cpp:struct:: template <typename T> for_getter
-
-   When defining a property with a getter and a setter, you can use this to
-   only pass a function binding attribute to the getter part. An example is
-   shown below.
-
-   .. code-block:: cpp
-
-      nb::class_<MyClass>(m, "MyClass")
-        .def_prop_rw("value", &MyClass::value,
-                nb::for_getter(nb::sig("def value(self, /) -> int")),
-                nb::for_setter(nb::sig("def value(self, value: int, /) -> None")),
-                nb::for_getter("docstring for getter"),
-                nb::for_setter("docstring for setter"));
-
-.. cpp:struct:: template <typename T> for_setter
-
-   Analogous to :cpp:struct:`for_getter`, but for setters.
-
-.. cpp:struct:: template <typename Policy> call_policy
-
-   Request that custom logic be inserted around each call to the
-   bound function, by calling ``Policy::precall(args, nargs, cleanup)`` before
-   Python-to-C++ argument conversion, and ``Policy::postcall(args, nargs, ret)``
-   after C++-to-Python return value conversion.
-
-   If multiple call policy annotations are provided for the same function, then
-   their precall and postcall hooks will both execute left-to-right according
-   to the order in which the annotations were specified when binding the
-   function.
-
-   The :cpp:struct:`nb::call_guard\<T\>() <call_guard>` annotation
-   should be preferred over ``call_policy`` unless the wrapper logic
-   depends on the function arguments or return value.
-   If both annotations are combined, then
-   :cpp:struct:`nb::call_guard\<T\>() <call_guard>` always executes on
-   the "inside" (closest to the bound function, after argument
-   conversions and before return value conversion) regardless of its
-   position in the function annotations list.
-
-   Your ``Policy`` class must define two static member functions:
-
-   .. cpp:function:: static void precall(PyObject **args, size_t nargs, detail::cleanup_list *cleanup);
-
-      A hook that will be invoked before calling the bound function. More
-      precisely, it is called after any :ref:`argument locks <argument-locks>`
-      have been obtained, but before the Python arguments are converted to C++
-      objects for the function call.
-
-      This hook may access or modify the function arguments using the
-      *args* array, which holds borrowed references in one-to-one
-      correspondence with the C++ arguments of the bound function.  If
-      the bound function is a method, then ``args[0]`` is its *self*
-      argument. *nargs* is the number of function arguments. It is actually
-      passed as ``std::integral_constant<size_t, N>()``, so you can
-      match on that type if you want to do compile-time checks with it.
-
-      The *cleanup* list may be used as it is used in type casters,
-      to cause some Python object references to be released at some point
-      after the bound function completes. (If the bound function is part
-      of an overload set, the cleanup list isn't released until all overloads
-      have been tried.)
-
-      ``precall()`` may choose to throw a C++ exception. If it does,
-      it will preempt execution of the bound function, and the
-      exception will be treated as if the bound function had thrown it.
-
-   .. cpp:function:: static void postcall(PyObject **args, size_t nargs, handle ret);
-
-      A hook that will be invoked after calling the bound function and
-      converting its return value to a Python object, but only if the
-      bound function returned normally.
-
-      *args* stores the Python object arguments, with the same semantics
-      as in ``precall()``, except that arguments that participated in
-      implicit conversions will have had their ``args[i]`` pointer updated
-      to reflect the new Python object that the implicit conversion produced.
-      *nargs* is the number of arguments, passed as a ``std::integral_constant``
-      in the same way as for ``precall()``.
-
-      *ret* is the bound function's return value. If the bound function returned
-      normally but its C++ return value could not be converted to a Python
-      object, then ``postcall()`` will execute with *ret* set to null,
-      and the Python error indicator might or might not be set to explain why.
-
-      If the bound function did not return normally -- either because its
-      Python object arguments couldn't be converted to the appropriate C++
-      types, or because the C++ function threw an exception -- then
-      ``postcall()`` **will not execute**. If you need some cleanup logic to
-      run even in such cases, your ``precall()`` can add a capsule object to the
-      cleanup list; its destructor will run eventually, but with no promises
-      as to when. A :cpp:struct:`nb::call_guard <call_guard>` might be a
-      better choice.
-
-      ``postcall()`` may choose to throw a C++ exception. If it does,
-      the result of the wrapped function will be destroyed,
-      and the exception will be raised in its place, as if the bound function
-      had thrown it just before returning.
-
-   Here is an example policy to demonstrate.
-   ``nb::call_policy<returns_references_to<I>>()`` behaves like
-   :cpp:class:`nb::keep_alive\<0, I\>() <keep_alive>`, except that the
-   return value is a treated as a list of objects rather than a single one.
-
-   .. code-block:: cpp
-
-      template <size_t I>
-      struct returns_references_to {
-          static void precall(PyObject **, size_t, nb::detail::cleanup_list *) {}
-
-          template <size_t N>
-          static void postcall(PyObject **args,
-                               std::integral_constant<size_t, N>,
-                               nb::handle ret) {
-              static_assert(I > 0 && I <= N,
-                            "I in returns_references_to<I> must be in the "
-                            "range [1, number of C++ function arguments]");
-              if (!nb::isinstance<nb::sequence>(ret)) {
-                  throw std::runtime_error("return value should be a sequence");
-              }
-              for (nb::handle nurse : ret) {
-                  nb::detail::keep_alive(nurse.ptr(), args[I - 1]);
-              }
-          }
-      };
-
-   For a more complex example (binding an object that uses trivially-copyable
-   callbacks), see ``tests/test_callbacks.cpp`` in the nanobind source
-   distribution.
-
-.. _class_binding_annotations:
-
-Class binding annotations
--------------------------
-
-The following annotations can be specified using the variable-length ``Extra``
-parameter of the constructor :cpp:func:`class_::class_`.
-
-Besides the below options, also refer to the :cpp:class:`sig` which is
-usable in both function and class bindings. It can be used to override class
-declarations in generated :ref:`stubs <stubs>`,
-
-.. cpp:struct:: is_final
-
-   Indicate that a type cannot be subclassed.
-
-.. cpp:struct:: dynamic_attr
-
-   Indicate that instances of a type require a Python dictionary to support the dynamic addition of attributes.
-
-.. cpp:struct:: is_weak_referenceable
-
-   Indicate that instances of a type require a weak reference list so that they
-   can be referenced by the Python ``weakref.*`` types.
-
-.. cpp:struct:: is_generic
-
-   If present, nanobind will add a ``__class_getitem__`` function to the newly
-   created type that permits constructing *parameterized* versions (e.g.,
-   ``MyType[int]``). The implementation of this function is equivalent to
-
-   .. code-block:: python
-
-      def __class_getitem__(cls, value):
-          import types
-          return types.GenericAlias(cls, value)
-
-   See the section on :ref:`creating generic types <typing_generics_creating>`
-   for an example.
-
-   This feature is only supported on Python 3.9+. Nanobind will ignore
-   the attribute in Python 3.8 builds.
-
-.. cpp:struct:: template <typename T> supplement
-
-   Indicate that ``sizeof(T)`` bytes of memory should be set aside to
-   store supplemental data in the type object. See :ref:`Supplemental
-   type data <supplement>` for more information.
-
-.. cpp:struct:: type_slots
-
-   .. cpp:function:: type_slots(PyType_Slot * value)
-
-   nanobind uses the ``PyType_FromSpec`` Python C API interface to construct
-   types. In certain advanced use cases, it may be helpful to append additional
-   type slots during type construction. This class binding annotation can be
-   used to accomplish this. The provided list should be followed by a
-   zero-initialized ``PyType_Slot`` element. See :ref:`Customizing type creation
-   <typeslots>` for more information about this feature.
-
-.. cpp:struct:: template <typename T> intrusive_ptr
-
-   nanobind provides a custom interface for intrusive reference-counted C++
-   types that nicely integrate with Python reference counting. See the
-   :ref:`separate section <intrusive>` on this topic. This annotation
-   marks a type as compatible with this interface.
-
-   .. cpp:function:: intrusive_ptr(void (* set_self_py)(T*, PyObject*) noexcept)
-
-      Declares a callback that will be invoked when a C++ instance is first
-      cast into a Python object.
-
-
-.. _enum_binding_annotations:
-
-Enum binding annotations
-------------------------
-
-The following annotations can be specified using the variable-length
-``Extra`` parameter of the constructor :cpp:func:`enum_::enum_`.
-
-.. cpp:struct:: is_arithmetic
-
-   Indicate that the enumeration supports arithmetic operations.  This enables
-   both unary (``-``, ``~``, ``abs()``) and binary (``+``, ``-``, ``*``,
-   ``//``, ``&``, ``|``, ``^``, ``<<``, ``>>``) operations with operands of
-   either enumeration or numeric types.
-
-   The result will be as if the operands were first converted to integers. (So
-   ``Shape(2) + Shape(1) == 3`` and ``Shape(2) * 1.5 == 3.0``.) It is
-   unspecified whether operations on mixed enum types (such as ``Shape.Circle +
-   Color.Red``) are permissible.
-
-   Passing this annotation changes the Python enumeration parent class to
-   either :py:class:`enum.IntEnum` or :py:class:`enum.IntFlag`, depending on
-   whether or not the flag enumeration attribute is also specified (see
-   :cpp:class:`is_flag`).
-
-.. cpp:struct:: is_flag
-
-   Indicate that the enumeration supports bit-wise operations.  This enables the
-   operators (``|``, ``&``, ``^``, and ``~``) with two enumerators as operands.
-
-   The result has the same type as the operands, i.e., ``Shape(2) | Shape(1)``
-   will be equivalent to ``Shape(3)``.
-
-   Passing this annotation changes the Python enumeration parent class to
-   either :py:class:`enum.IntFlag` or :py:class:`enum.Flag`, depending on
-   whether or not the enumeration is also marked to support arithmetic
-   operations (see :cpp:class:`is_arithmetic`).
-
-Function binding
-----------------
-
-.. cpp:function:: object cpp_function(Func &&f, const Extra&... extra)
-
-   Convert the function `f` into a Python callable. This function has
-   a few overloads (not shown here) to separately deal with function/method
-   pointers and lambda functions.
-
-   The variable length `extra` parameter can be used to pass a docstring and
-   other :ref:`function binding annotations <function_binding_annotations>`.
-
-.. _class_binding:
-
-Class binding
--------------
-
-.. cpp:class:: template <typename T, typename... Ts> class_ : public object
-
-   Binding helper class to expose a custom C++ type `T` (declared using either
-   the ``class`` or ``struct`` keyword) in Python.
-
-   The variable length parameter `Ts` is optional and  can be used to specify
-   the base class of `T` and/or an alias needed to realize :ref:`trampoline
-   classes <trampolines>`.
-
-   When the type ``T`` was previously already registered (either within the
-   same extension or another extension), the ``class_<..>`` declaration is
-   redundant. nanobind will print a warning message in this case:
-
-   .. code-block:: text
-
-      RuntimeWarning: nanobind: type 'MyType' was already registered!
-
-   The ``class_<..>`` instance will subsequently wrap the original type object
-   instead of creating a new one.
-
-   .. cpp:function:: template <typename... Extra> class_(handle scope, const char * name, const Extra &... extra)
-
-      Bind the type `T` to the identifier `name` within the scope `scope`. The
-      variable length `extra` parameter can be used to pass a docstring and
-      other :ref:`class binding annotations <class_binding_annotations>`.
-
-   .. cpp:function:: template <typename Func, typename... Extra> class_ &def(const char * name, Func &&f, const Extra &... extra)
-
-      Bind the function `f` and assign it to the class member `name`.
-      The variable length `extra` parameter can be used to pass a docstring and
-      other :ref:`function binding annotations <function_binding_annotations>`.
-
-      This function has two overloads (listed just below) to handle constructor
-      binding declarations.
-
-      **Example**:
-
-      .. code-block:: cpp
-
-         struct A {
-             void f() { /*...*/ }
-         };
-
-         nb::class_<A>(m, "A")
-             .def(nb::init<>()) // Bind the default constructor
-             .def("f", &A::f);  // Bind the method A::f
-
-   .. cpp:function:: template <typename... Args, typename... Extra> class_ &def(init<Args...> arg, const Extra &... extra)
-
-      Bind a constructor. The variable length `extra` parameter can be used to
-      pass a docstring and other :ref:`function binding annotations
-      <function_binding_annotations>`.
-
-   .. cpp:function:: template <typename Arg, typename... Extra> class_ &def(init_implicit<Arg> arg, const Extra &... extra)
-
-      Bind a constructor that may be used for implicit type conversions. The
-      constructor must take a single argument of an unspecified type `Arg`.
-
-      When nanobind later tries to dispatch a function call requiring an
-      argument of type `T` while `Arg` was actually provided, it will run this
-      constructor to perform the necessary conversion.
-
-      The variable length `extra` parameter can be used to pass a docstring and
-      other :ref:`function binding annotations <function_binding_annotations>`.
-
-      This constructor generates more compact code than a separate call to
-      :cpp:func:`implicitly_convertible`, but is otherwise equivalent.
-
-   .. cpp:function:: template <typename Func, typename... Extra> class_ &def(new_<Func> arg, const Extra &... extra)
-
-      Bind a C++ factory function as a Python object constructor (``__new__``).
-      This is an advanced feature; prefer :cpp:struct:`nb::init\<..\> <init>`
-      where possible. See the discussion of :ref:`customizing object creation
-      <custom_new>` for more details.
-
-   .. cpp:function:: template <typename Visitor, typename... Extra> class_ &def(def_visitor<Visitor> arg, const Extra &... extra)
-
-      Dispatch to custom user-provided binding logic implemented by the type
-      ``Visitor``, passing it the binding annotations ``extra...``.
-      See the documentation of :cpp:struct:`nb::def_visitor\<..\> <def_visitor>`
-      for details.
-
-   .. cpp:function:: template <typename C, typename D, typename... Extra> class_ &def_rw(const char * name, D C::* p, const Extra &...extra)
-
-      Bind the field `p` and assign it to the class member `name`. nanobind
-      constructs a ``property`` object with *read-write* access (hence the
-      ``rw`` suffix) to do so.
-
-      Every access from Python will read from or write to the C++ field while
-      performing a suitable conversion (using :ref:`type casters
-      <type_casters>`, :ref:`bindings <bindings>`, or :ref:`wrappers
-      <wrappers>`) as determined by its type.
-
-      The variable length `extra` parameter can be used to pass a docstring and
-      other :ref:`function binding annotations <function_binding_annotations>`
-      that are forwarded to the anonymous functions used to construct the
-      property.
-      Use the :cpp:struct:`nb::for_getter <for_getter>` and
-      :cpp:struct:`nb::for_setter <for_setter>` to pass annotations
-      specifically to the setter or getter part.
-
-      **Example**:
-
-      .. code-block:: cpp
-
-         struct A { int value; };
-
-         nb::class_<A>(m, "A")
-             .def_rw("value", &A::value); // Enable mutable access to the field A::value
-
-   .. cpp:function:: template <typename C, typename D, typename... Extra> class_ &def_ro(const char * name, D C::* p, const Extra &...extra)
-
-      Bind the field `p` and assign it to the class member `name`. nanobind
-      constructs a ``property`` object with *read only* access (hence the
-      ``ro`` suffix) to do so.
-
-      Every access from Python will read the C++ field while performing a
-      suitable conversion (using :ref:`type casters <type_casters>`,
-      :ref:`bindings <bindings>`, or :ref:`wrappers <wrappers>`) as determined
-      by its type.
-
-      The variable length `extra` parameter can be used to pass a docstring and
-      other :ref:`function binding annotations <function_binding_annotations>`
-      that are forwarded to the anonymous functions used to construct the
-      property.
-
-      **Example**:
-
-      .. code-block:: cpp
-
-         struct A { int value; };
-
-         nb::class_<A>(m, "A")
-             .def_ro("value", &A::value);  // Enable read-only access to the field A::value
-
-   .. cpp:function:: template <typename Getter, typename Setter, typename... Extra> class_ &def_prop_rw(const char * name, Getter &&getter, Setter &&setter, const Extra &...extra)
-
-      Construct a *mutable* (hence the ``rw`` suffix) Python ``property`` and
-      assign it to the class member `name`. Every read access will call the
-      function ``getter``  with the `T` instance, and every write access will
-      call the ``setter`` with the `T` instance and value to be assigned.
-
-      The variable length `extra` parameter can be used to pass a docstring and
-      other :ref:`function binding annotations <function_binding_annotations>`.
-      Use the :cpp:struct:`nb::for_getter <for_getter>` and
-      :cpp:struct:`nb::for_setter <for_setter>` to pass annotations
-      specifically to the setter or getter part.
-
-      Note that this function implicitly assigns the
-      :cpp:enumerator:`rv_policy::reference_internal` return value policy to
-      `getter` (as opposed to the usual
-      :cpp:enumerator:`rv_policy::automatic`). Provide an explicit return value
-      policy as part of the `extra` argument to override this.
-
-      **Example**: the example below uses `def_prop_rw` to expose a C++
-      setter/getter pair as a more "Pythonic" property:
-
-      .. code-block:: cpp
-
-          class A {
-          public:
-              A(int value) : m_value(value) { }
-              void set_value(int value) { m_value = value; }
-              int value() const { return m_value; }
-          private:
-              int m_value;
-          };
-
-          nb::class_<A>(m, "A")
-              .def(nb::init<int>())
-              .def_prop_rw("value",
-                  [](A &t) { return t.value() ; },
-                  [](A &t, int value) { t.set_value(value); });
-
-   .. cpp:function:: template <typename Getter, typename... Extra> class_ &def_prop_ro(const char * name, Getter &&getter, const Extra &...extra)
-
-      Construct a *read-only* (hence the ``ro`` suffix) Python ``property`` and
-      assign it to the class member `name`. Every read access will call the
-      function ``getter``  with the `T` instance.
-
-      The variable length `extra` parameter can be used to pass a docstring and
-      other :ref:`function binding annotations <function_binding_annotations>`.
-
-      Note that this function implicitly assigns the
-      :cpp:enumerator:`rv_policy::reference_internal` return value policy to
-      `getter` (as opposed to the usual
-      :cpp:enumerator:`rv_policy::automatic`). Provide an explicit return value
-      policy as part of the `extra` argument to override this.
-
-      **Example**: the example below uses `def_prop_ro` to expose a C++ getter
-      as a more "Pythonic" property:
-
-      .. code-block:: cpp
-
-          class A {
-          public:
-              A(int value) : m_value(value) { }
-              int value() const { return m_value; }
-          private:
-              int m_value;
-          };
-
-          nb::class_<A>(m, "A")
-              .def(nb::init<int>())
-              .def_prop_ro("value",
-                  [](A &t) { return t.value() ; });
-
-   .. cpp:function:: template <typename Func, typename... Extra> class_ &def_static(const char * name, Func &&f, const Extra &... extra)
-
-      Bind the *static* function `f` and assign it to the class member `name`.
-      The variable length `extra` parameter can be used to pass a docstring and
-      other :ref:`function binding annotations <function_binding_annotations>`.
-
-      **Example**:
-
-      .. code-block:: cpp
-
-         struct A {
-             static void f() { /*...*/ }
-         };
-
-         nb::class_<A>(m, "A")
-             .def_static("f", &A::f);  // Bind the static method A::f
-
-   .. cpp:function:: template <typename D, typename... Extra> class_ &def_rw_static(const char * name, D* p, const Extra &...extra)
-
-      Bind the *static* field `p` and assign it to the class member `name`. nanobind
-      constructs a class ``property`` object with *read-write* access (hence the
-      ``rw`` suffix) to do so.
-
-      Every access from Python will read from or write to the static C++ field
-      while performing a suitable conversion (using :ref:`type casters
-      <type_casters>`, :ref:`bindings <bindings>`, or :ref:`wrappers
-      <wrappers>`) as determined by its type.
-
-      The variable length `extra` parameter can be used to pass a docstring and
-      other :ref:`function binding annotations <function_binding_annotations>`
-      that are forwarded to the anonymous functions used to construct the
-      property
-      Use the :cpp:struct:`nb::for_getter <for_getter>` and
-      :cpp:struct:`nb::for_setter <for_setter>` to pass annotations
-      specifically to the setter or getter part.
-
-      **Example**:
-
-      .. code-block:: cpp
-
-         struct A { inline static int value = 5; };
-
-         nb::class_<A>(m, "A")
-             // Enable mutable access to the static field A::value
-             .def_rw_static("value", &A::value);
-
-   .. cpp:function:: template <typename D, typename... Extra> class_ &def_ro_static(const char * name, D* p, const Extra &...extra)
-
-      Bind the *static* field `p` and assign it to the class member `name`.
-      nanobind constructs a class ``property`` object with *read-only* access
-      (hence the ``ro`` suffix) to do so.
-
-      Every access from Python will read the static C++ field while performing
-      a suitable conversion (using :ref:`type casters <type_casters>`,
-      :ref:`bindings <bindings>`, or :ref:`wrappers <wrappers>`) as determined
-      by its type.
-
-      The variable length `extra` parameter can be used to pass a docstring and
-      other :ref:`function binding annotations <function_binding_annotations>`
-      that are forwarded to the anonymous functions used to construct the
-      property
-
-      **Example**:
-
-      .. code-block:: cpp
-
-         struct A { inline static int value = 5; };
-
-         nb::class_<A>(m, "A")
-             // Enable read-only access to the static field A::value
-             .def_ro_static("value", &A::value);
-
-   .. cpp:function:: template <typename Getter, typename Setter, typename... Extra> class_ &def_prop_rw_static(const char * name, Getter &&getter, Setter &&setter, const Extra &...extra)
-
-      Construct a *mutable* (hence the ``rw`` suffix) Python ``property`` and
-      assign it to the class member `name`. Every read access will call the
-      function ``getter``  with `T`'s Python type object, and every write access will
-      call the ``setter`` with `T`'s Python type object and value to be assigned.
-
-      The variable length `extra` parameter can be used to pass a docstring and
-      other :ref:`function binding annotations <function_binding_annotations>`.
-      Use the :cpp:struct:`nb::for_getter <for_getter>` and
-      :cpp:struct:`nb::for_setter <for_setter>` to pass annotations
-      specifically to the setter or getter part.
-
-      Note that this function implicitly assigns the
-      :cpp:enumerator:`rv_policy::reference` return value policy to
-      `getter` (as opposed to the usual
-      :cpp:enumerator:`rv_policy::automatic`). Provide an explicit return value
-      policy as part of the `extra` argument to override this.
-
-      **Example**: the example below uses `def_prop_rw_static` to expose a
-      static C++ setter/getter pair as a more "Pythonic" property:
-
-      .. code-block:: cpp
-
-         class A {
-         public:
-            static void set_value(int value) { s_value = value; }
-            static int value() { return s_value; }
-         private:
-            inline static int s_value = 5;
-         };
-
-         nb::class_<A>(m, "A")
-             .def_prop_rw_static("value",
-                 [](nb::handle /*unused*/) { return A::value() ; },
-                 [](nb::handle /*unused*/, int value) { A::set_value(value); });
-
-   .. cpp:function:: template <typename Getter, typename... Extra> class_ &def_prop_ro_static(const char * name, Getter &&getter, const Extra &...extra)
-
-      Construct a *read-only* (hence the ``ro`` suffix) Python ``property`` and
-      assign it to the class member `name`. Every read access will call the
-      function ``getter``  with `T`'s Python type object.
-
-      The variable length `extra` parameter can be used to pass a docstring and
-      other :ref:`function binding annotations <function_binding_annotations>`.
-
-      Note that this function implicitly assigns the
-      :cpp:enumerator:`rv_policy::reference` return value policy to
-      `getter` (as opposed to the usual
-      :cpp:enumerator:`rv_policy::automatic`). Provide an explicit return value
-      policy as part of the `extra` argument to override this.
-
-      **Example**: the example below uses `def_prop_ro_static` to expose a
-      static C++ getter as a more "Pythonic" property:
-
-      .. code-block:: cpp
-
-         class A {
-         public:
-            static int value() { return s_value; }
-         private:
-            inline static int s_value = 5;
-         };
-
-         nb::class_<A>(m, "A")
-             .def_prop_ro_static("value",
-                 [](nb::handle /*unused*/) { return A::value() ; });
-
-   .. cpp:function:: template <detail::op_id id, detail::op_type ot, typename L, typename R, typename... Extra> class_ &def(const detail::op_<id, ot, L, R> &op, const Extra&... extra)
-
-      This interface provides convenient syntax sugar to replace relatively
-      lengthy method bindings with shorter operator bindings. To use it, you
-      will need an extra include directive:
-
-      .. code-block:: cpp
-
-         #include <nanobind/operators.h>
-
-      Below is an example type with three arithmetic operators in C++ (unary
-      negation and 2 binary subtraction overloads) along with corresponding
-      bindings.
-
-      **Example**:
-
-      .. code-block:: cpp
-
-         struct A {
-            float value;
-
-            A operator-() const { return { -value }; }
-            A operator-(const A &o) const { return { value - o.value }; }
-            A operator-(float o) const { return { value - o }; }
-         };
-
-         nb::class_<A>(m, "A")
-             .def(nb::init<float>())
-             .def(-nb::self)
-             .def(nb::self - nb::self)
-             .def(nb::self - float());
-
-
-      Bind an arithmetic or comparison operator expressed in short-hand form (e.g., ``.def(nb::self + nb::self)``).
-
-   .. cpp:function:: template <detail::op_id id, detail::op_type ot, typename L, typename R, typename... Extra> class_ &def_cast(const detail::op_<id, ot, L, R> &op, const Extra&... extra)
-
-      Like the above ``.def()`` variant, but furthermore cast the result of the operation back to `T`.
-
-
-.. cpp:class:: template <typename T> enum_ : public class_<T>
-
-   Class binding helper for scoped and unscoped C++ enumerations.
-
-   .. cpp:function:: template <typename... Extra> NB_INLINE enum_(handle scope, const char * name, const Extra &...extra)
-
-      Bind the enumeration of type `T` to the identifier `name` within the
-      scope `scope`. The variable length `extra` parameter can be used to pass
-      a docstring and other :ref:`enum binding annotations
-      <enum_binding_annotations>` (currently, only :cpp:class:`is_arithmetic` is supported).
-
-   .. cpp:function:: enum_ &value(const char * name, T value, const char * doc = nullptr)
-
-      Add the entry `value` to the enumeration using the identifier `name`,
-      potentially with a docstring provided via `doc` (optional).
-
-   .. cpp:function:: enum_ &export_values()
-
-      Export all entries of the enumeration into the parent scope.
-
-.. cpp:class:: template <typename T> exception : public object
-
-   Class binding helper for declaring new Python exception types
-
-   .. cpp:function:: exception(handle scope, const char * name, handle base = PyExc_Exception)
-
-      Create a new exception type identified by `name` that derives from
-      `base`, and install it in `scope`. The constructor also calls
-      :cpp:func:`register_exception_translator()` to register a new exception
-      translator that converts caught C++ exceptions of type `T` into the
-      newly created Python equivalent.
-
-.. cpp:struct:: template <typename... Args> init
-
-   nanobind uses this simple helper class to capture the signature of a
-   constructor. It is only meant to be used in binding declarations done via
-   :cpp:func:`class_::def()`.
-
-   Sometimes, it is necessary to bind constructors that don't exist in the
-   underlying C++ type (meaning that they are specific to the Python bindings).
-   Because `init` only works for existing C++ constructors, this requires
-   a manual workaround noting that
-
-   .. code-block:: cpp
-
-      nb::class_<MyType>(m, "MyType")
-          .def(nb::init<const char*, int>());
-
-   is syntax sugar for the following lower-level implementation using
-   "`placement new <https://en.wikipedia.org/wiki/Placement_syntax>`_":
-
-   .. code-block:: cpp
-
-      nb::class_<MyType>(m, "MyType")
-          .def("__init__",
-               [](MyType* t, const char* arg0, int arg1) {
-                   new (t) MyType(arg0, arg1);
-               });
-
-   The provided lambda function will be called with a pointer to uninitialized
-   memory that has already been allocated (this memory region is co-located
-   with the Python object for reasons of efficiency). The lambda function can
-   then either run an in-place constructor and return normally (in which case
-   the instance is assumed to be correctly constructed) or fail by raising an
-   exception.
-
-.. cpp:struct:: template <typename Arg> init_implicit
-
-   See :cpp:class:`init` for detail on binding constructors. The main
-   difference between :cpp:class:`init`  and `init_implicit` is that the latter
-   only supports constructors taking a single argument `Arg`, and that it marks
-   the constructor as usable for implicit conversions from `Arg`.
-
-   Sometimes, it is necessary to bind implicit conversion-capable constructors
-   that don't exist in the underlying C++ type (meaning that they are specific
-   to the Python bindings). This can be done manually noting that
-
-   .. code-block:: cpp
-
-      nb::class_<MyType>(m, "MyType")
-          .def(nb::init_implicit<const char*>());
-
-   can be replaced by the lower-level code
-
-   .. code-block:: cpp
-
-       nb::class_<MyType>(m, "MyType")
-           .def("__init__",
-                [](MyType* t, const char* arg0) {
-                    new (t) MyType(arg0);
-                });
-
-       nb::implicitly_convertible<const char*, MyType>();
-
-.. cpp:struct:: template <typename Func> new_
-
-   This is a small helper class that indicates to :cpp:func:`class_::def()`
-   that a particular lambda or static method provides a Python object
-   constructor (``__new__``) for the class being bound. Normally, you would
-   use :cpp:class:`init` instead if possible, in order to cooperate with
-   nanobind's usual object creation process. Using :cpp:class:`new_`
-   replaces that process entirely. This is principally useful when some
-   C++ type of interest can only provide pointers to its instances,
-   rather than allowing them to be constructed directly.
-
-   Like :cpp:class:`init`, the only use of a :cpp:class:`new_` object is
-   as an argument to :cpp:func:`class_::def()`.
-
-   Example use:
-
-   .. code-block:: cpp
-
-      class MyType {
-      private:
-          MyType();
-      public:
-          static std::shared_ptr<MyType> create();
-          int value = 0;
-      };
-
-      nb::class_<MyType>(m, "MyType")
-          .def(nb::new_(&MyType::create));
-
-   Given this example code, writing ``MyType()`` in Python would
-   produce a Python object wrapping the result of ``MyType::create()``
-   in C++. If multiple calls to ``create()`` return pointers to the
-   same C++ object, these will turn into references to the same Python
-   object as well.
-
-   See the discussion of :ref:`customizing Python object creation <custom_new>`
-   for more information.
-
-.. cpp:struct:: template <typename Visitor> def_visitor
-
-   An empty base object which serves as a tag to allow :cpp:func:`class_::def()`
-   to dispatch to custom logic implemented by the type ``Visitor``. This is the
-   same mechanism used by :cpp:class:`init`, :cpp:class:`init_implicit`, and
-   :cpp:class:`new_`; it's exposed publicly so that you can create your own
-   reusable abstractions for binding logic.
-
-   To define a ``def_visitor``, you would write something like:
-
-   .. code-block:: cpp
-
-      struct my_ops : nb::def_visitor<my_ops> {
-          template <typename Class, typename... Extra>
-          void execute(Class &cl, const Extra&... extra) {
-              /* series of def() statements on `cl`, which is a nb::class_ */
-          }
-      };
-
-   Then use it like:
-
-   .. code-block:: cpp
-
-      nb::class_<MyType>(m, "MyType")
-          .def("some_method", &MyType::some_method)
-          .def(my_ops())
-          ... ;
-
-   Any arguments to :cpp:func:`class_::def()` after the ``def_visitor`` object
-   get passed through as the ``Extra...`` parameters to ``execute()``.
-   As with any other C++ object, data needed by the ``def_visitor`` can be passed
-   through template arguments or ordinary constructor arguments.
-   The ``execute()`` method may be static if it doesn't need to access anything
-   in ``*this``.
-
-
-GIL Management
---------------
-
-These two `RAII
-<https://en.wikipedia.org/wiki/Resource_acquisition_is_initialization>`_ helper
-classes acquire and release the *Global Interpreter Lock* (GIL) in a given
-scope. The :cpp:struct:`gil_scoped_release` helper is often combined with the
-:cpp:struct:`call_guard`, as in
-
-.. code-block:: cpp
-
-    m.def("expensive", &expensive, nb::call_guard<nb::gil_scoped_release>());
-
-This releases the interpreter lock while `expensive` is running, which permits
-running it in parallel from multiple Python threads.
-
-.. cpp:struct:: gil_scoped_acquire
-
-   .. cpp:function:: gil_scoped_acquire()
-
-      Acquire the GIL
-
-   .. cpp:function:: ~gil_scoped_acquire()
-
-      Release the GIL
-
-.. cpp:struct:: gil_scoped_release
-
-   .. cpp:function:: gil_scoped_release()
-
-      Release the GIL (**must** be currently held)
-
-      In :ref:`free-threaded extensions <free-threaded>`, this operation also
-      temporarily releases all :ref:`argument locks <argument-locks>` held by
-      the current thread.
-
-   .. cpp:function:: ~gil_scoped_release()
-
-      Reacquire the GIL
-
-Free-threading
---------------
-
-Nanobind provides abstractions to implement *additional* locking that is
-needed to ensure the correctness of free-threaded Python extensions.
-
-.. cpp:struct:: ft_mutex
-
-   Object-oriented wrapper representing a `PyMutex
-   <https://docs.python.org/3.13/c-api/init.html#c.PyMutex>`__. It can be
-   slightly more efficient than OS/language-provided primitives (e.g.,
-   ``std::thread``, ``pthread_mutex_t``) and should generally be preferred when
-   adding critical sections to Python bindings.
-
-   In Python builds *without* free-threading, this class does nothing. It has
-   no attributes and the :cpp:func:`lock` and :cpp:func:`unlock` functions
-   return immediately.
-
-   .. cpp:function:: ft_mutex()
-
-      Create a new (unlocked) mutex.
-
-   .. cpp:function:: void lock()
-
-      Acquire the mutex.
-
-   .. cpp:function:: void unlock()
-
-      Release the mutex.
-
-.. cpp:struct:: ft_lock_guard
-
-   This class provides a RAII lock guard analogous to ``std::lock_guard`` and
-   ``std::unique_lock``.
-
-   .. cpp:function:: ft_lock_guard(ft_mutex &mutex)
-
-      Call :cpp:func:`mutex.lock() <ft_mutex::lock>` (no-op in non-free-threaded builds).
-
-   .. cpp:function:: ~ft_lock_guard()
-
-      Call :cpp:func:`mutex.unlock() <ft_mutex::unlock>` (no-op in non-free-threaded builds).
-
-.. cpp:struct:: ft_object_guard
-
-   This class provides a RAII guard that locks a single Python object within a
-   local scope (in contrast to :cpp:class:`ft_lock_guard`, which locks a
-   mutex).
-
-   It is a thin wrapper around the Python `critical section API
-   <https://docs.python.org/3.13/c-api/init.html#c.Py_BEGIN_CRITICAL_SECTION>`__.
-   Please refer to the Python documentation for details on the semantics of
-   this relaxed form of critical section (in particular, Python critical sections
-   may release previously held locks).
-
-   In Python builds *without* free-threading, this class does nothing---the
-   constructor and destructor return immediately.
-
-   .. cpp:function:: ft_object_guard(handle h)
-
-      Lock the object ``h`` (no-op in non-free-threaded builds)
-
-   .. cpp:function:: ~ft_object_guard()
-
-      Unlock the object ``h`` (no-op in non-free-threaded builds)
-
-.. cpp:struct:: ft_object2_guard
-
-   This class provides a RAII guard that locks *two* Python object within a
-   local scope (in contrast to :cpp:class:`ft_lock_guard`, which locks a
-   mutex).
-
-   It is a thin wrapper around the Python `critical section API
-   <https://docs.python.org/3.13/c-api/init.html#c.Py_BEGIN_CRITICAL_SECTION2>`__.
-   Please refer to the Python documentation for details on the semantics of
-   this relaxed form of critical section (in particular, Python critical sections
-   may release previously held locks).
-
-   In Python builds *without* free-threading, this class does nothing---the
-   constructor and destructor return immediately.
-
-   .. cpp:function:: ft_object2_guard(handle h1, handle h2)
-
-      Lock the objects ``h1`` and ``h2`` (no-op in non-free-threaded builds)
-
-   .. cpp:function:: ~ft_object2_guard()
-
-      Unlock the objects ``h1`` and ``h2`` (no-op in non-free-threaded builds)
-
-Low-level type and instance access
-----------------------------------
-
-nanobind exposes a low-level interface to provide fine-grained control over
-the sequence of steps that instantiates a Python object wrapping a C++
-instance. A thorough explanation of these features is provided in a
-:ref:`separate section <lowlevel>`.
-
-Type objects
-^^^^^^^^^^^^
-
-.. cpp:function:: bool type_check(handle h)
-
-   Returns ``true`` if ``h`` is a type that was previously bound via
-   :cpp:class:`class_`.
-
-.. cpp:function:: size_t type_size(handle h)
-
-   Assuming that `h` represents a bound type (see :cpp:func:`type_check`),
-   return its size in bytes.
-
-.. cpp:function:: size_t type_align(handle h)
-
-   Assuming that `h` represents a bound type (see :cpp:func:`type_check`),
-   return its alignment in bytes.
-
-.. cpp:function:: const std::type_info& type_info(handle h)
-
-   Assuming that `h` represents a bound type (see :cpp:func:`type_check`),
-   return its C++ RTTI record.
-
-.. cpp:function:: template <typename T> T &type_supplement(handle h)
-
-   Return a reference to supplemental data stashed in a type object.
-   The type ``T`` must exactly match the type specified in the
-   :cpp:class:`nb::supplement\<T\> <supplement>` annotation used when
-   creating the type; no type check is performed, and invalid supplement
-   accesses may crash the interpreter. Also refer to
-   :cpp:class:`nb::supplement\<T\> <supplement>`.
-
-.. cpp:function:: str type_name(handle h)
-
-   Return the full (module-qualified) name of a type object as a Python string.
-
-.. cpp:function:: void * type_get_slot(handle h, int slot_id)
-
-   On Python 3.10+, this function is a simple wrapper around the Python C API
-   function ``PyType_GetSlot`` that provides stable API-compatible access to
-   type object members. On Python 3.9 and earlier, the official function did
-   not work on non-heap types. The nanobind version consistently works on heap
-   and non-heap types across Python versions.
-
-Instances
-^^^^^^^^^
-
-The documentation below refers to two per-instance flags with the following meaning:
-
-- *ready*: is the instance fully constructed? nanobind will not permit passing
-  the instance to a bound C++ function when this flag is unset.
-
-- *destruct*: should nanobind call the C++ destructor when the instance is
-  garbage-collected?
-
-.. cpp:function:: bool inst_check(handle h)
-
-   Returns ``true`` if `h` represents an instance of a type that was
-   previously bound via :cpp:class:`class_`.
-
-.. cpp:function:: template <typename T> T * inst_ptr(handle h)
-
-   Assuming that `h` represents an instance of a type that was previously bound
-   via :cpp:class:`class_`, return a pointer to the underlying C++ instance.
-
-   The function *does not check* that `h` actually contains an instance with
-   C++ type `T`.
-
-.. cpp:function:: object inst_alloc(handle h)
-
-   Assuming that `h` represents a type object that was previously created via
-   :cpp:class:`class_` (see :cpp:func:`type_check`), allocate an unitialized
-   object of type `h` and return it. The *ready* and *destruct* flags of the
-   returned instance are both set to ``false``.
-
-.. cpp:function:: object inst_alloc_zero(handle h)
-
-   Assuming that `h` represents a type object that was previously created via
-   :cpp:class:`class_` (see :cpp:func:`type_check`), allocate a zero-initialized
-   object of type `h` and return it. The *ready* and *destruct* flags of the
-   returned instance are both set to ``true``.
-
-   This operation is equivalent to calling :cpp:func:`inst_alloc` followed by
-   :cpp:func:`inst_zero`.
-
-.. cpp:function:: object inst_reference(handle h, void * p, handle parent = handle())
-
-   Assuming that `h` represents a type object that was previously created via
-   :cpp:class:`class_` (see :cpp:func:`type_check`) create an object of type
-   `h` that wraps an existing C++ instance `p`.
-
-   The *ready* and *destruct* flags of the returned instance are respectively
-   set to ``true`` and ``false``.
-
-   This is analogous to casting a C++ object with return value policy
-   :cpp:enumerator:`rv_policy::reference`.
-
-   If a `parent` object is specified, the instance keeps this parent alive
-   while the newly created object exists. This is analogous to casting a C++
-   object with return value policy
-   :cpp:enumerator:`rv_policy::reference_internal`.
-
-.. cpp:function:: object inst_take_ownership(handle h, void * p)
-
-   Assuming that `h` represents a type object that was previously created via
-   :cpp:class:`class_` (see :cpp:func:`type_check`) create an object of type
-   `h` that wraps an existing C++ instance `p`.
-
-   The *ready* and *destruct* flags of the returned instance are both set to
-   ``true``.
-
-   This is analogous to casting a C++ object with return value policy
-   :cpp:enumerator:`rv_policy::take_ownership`.
-
-.. cpp:function:: void inst_zero(handle h)
-
-   Zero-initialize the contents of `h`. Sets the *ready* and *destruct* flags
-   to ``true``.
-
-.. cpp:function:: bool inst_ready(handle h)
-
-   Query the *ready* flag of the instance `h`.
-
-.. cpp:function:: std::pair<bool, bool> inst_state(handle h)
-
-   Separately query the *ready* and *destruct* flags of the instance `h`.
-
-.. cpp:function:: void inst_mark_ready(handle h)
-
-   Simultaneously set the *ready* and *destruct* flags of the instance `h` to ``true``.
-
-.. cpp:function:: void inst_set_state(handle h, bool ready, bool destruct)
-
-   Separately set the *ready* and *destruct* flags of the instance `h`.
-
-.. cpp:function:: void inst_destruct(handle h)
-
-   Destruct the instance `h`. This entails calling the C++ destructor if the
-   *destruct* flag is set and then setting the *ready* and *destruct* fields to
-   ``false``.
-
-.. cpp:function:: void inst_copy(handle dst, handle src)
-
-   Copy-construct the contents of `src` into `dst` and set the *ready* and
-   *destruct* flags of `dst` to ``true``.
-
-   `dst` should be an uninitialized instance of the same type. Note that
-   setting the *destruct* flag may be problematic if `dst` is an offset into an
-   existing object created using :cpp:func:`inst_reference` (the destructor
-   will be called multiple times in this case). If so, you must use
-   :cpp:func:`inst_set_state` to disable the flag following the call to
-   :cpp:func:`inst_copy`.
-
-   *New in nanobind v2.0.0*: The function is a no-op when ``src`` and ``dst``
-   refer to the same object.
-
-.. cpp:function:: void inst_move(handle dst, handle src)
-
-   Analogous to :cpp:func:`inst_copy`, except that the move constructor
-   is used instead of the copy constructor.
-
-.. cpp:function:: void inst_replace_copy(handle dst, handle src)
-
-   Destruct the contents of `dst` (even if the *destruct* flag is ``false``).
-   Next, copy-construct the contents of `src` into `dst` and set the *ready*
-   flag of ``dst``. The value of the *destruct* flag is subsequently set to its
-   value prior to the call.
-
-   This operation is useful to replace the contents of one instance with that
-   of another regardless of whether `dst` has been created using
-   :cpp:func:`inst_alloc`, :cpp:func:`inst_reference`, or
-   :cpp:func:`inst_take_ownership`.
-
-   *New in nanobind v2.0.0*: The function is a no-op when ``src`` and ``dst``
-   refer to the same object.
-
-.. cpp:function:: void inst_replace_move(handle dst, handle src)
-
-   Analogous to :cpp:func:`inst_replace_copy`, except that the move constructor
-   is used instead of the copy constructor.
-
-.. cpp:function:: str inst_name(handle h)
-
-   Return the full (module-qualified) name of the instance's type object as a
-   Python string.
-
-Global flags
-------------
-
-.. cpp:function:: bool leak_warnings() noexcept
-
-   Returns whether nanobind warns if any nanobind instances, types, or
-   functions are still alive when the Python interpreter shuts down.
-
-.. cpp:function:: bool implicit_cast_warnings() noexcept
-
-   Returns whether nanobind warns if an implicit conversion was not successful.
-
-.. cpp:function:: void set_leak_warnings(bool value) noexcept
-
-   By default, nanobind loudly complains when any nanobind instances, types, or
-   functions are still alive when the Python interpreter shuts down. Call this
-   function to disable or re-enable leak warnings.
-
-.. cpp:function:: void set_implicit_cast_warnings(bool value) noexcept
-
-   By default, nanobind loudly complains when it attempts to perform an
-   implicit conversion, and when that conversion is not successful. Call this
-   function to disable or re-enable the warnings.
-
-.. cpp:function:: inline bool is_alive() noexcept
-
-   The function returns ``true`` when nanobind is initialized and ready for
-   use. It returns ``false`` when the Python interpreter has shut down, causing
-   the destruction various nanobind-internal data structures. Having access to
-   this liveness status can be useful to avoid operations that are illegal in
-   the latter context.
-
-Miscellaneous
--------------
-
-.. cpp:function:: str repr(handle h)
-
-   Return a stringified version of the provided Python object.
-   Equivalent to ``repr(h)`` in Python.
-
-.. cpp:function:: void print(handle value, handle end = handle(), handle file = handle())
-
-   Invoke the Python ``print()`` function to print the object `value`. If desired,
-   a line ending `end` and file handle `file` can be specified.
-
-.. cpp:function:: void print(const char * str, handle end = handle(), handle file = handle())
-
-   Invoke the Python ``print()`` function to print the null-terminated C-style
-   string `str` that is encoded using UTF-8 encoding.  If desired, a line
-   ending `end` and file handle `file` can be specified.
-
-.. cpp:function:: iterator iter(handle h)
-
-   Equivalent to ``iter(h)`` in Python.
-
-.. cpp:function:: object none()
-
-   Return an object representing the value ``None``.
-
-.. cpp:function:: dict builtins()
-
-   Return the ``__builtins__`` dictionary.
-
-.. cpp:function:: dict globals()
-
-   Return the ``globals()`` dictionary.
-
-.. cpp:function:: Py_hash_t hash(handle h)
-
-   Hash the given argument like ``hash()`` in pure Python. The type of the
-   return value (``Py_hash_t``) is an implementation-specific signed integer
-   type.
-
-.. cpp:function:: template <typename Source, typename Target> void implicitly_convertible()
-
-   Indicate that the type `Source` is implicitly convertible into `Target`
-   (which must refer to a type that was previously bound via
-   :cpp:class:`class_`).
-
-   *Note*: the :cpp:struct:`init_implicit` interface generates more compact
-   code and should be preferred, i.e., use
-
-   .. code-block:: cpp
-
-      nb::class_<Target>(m, "Target")
-          .def(nb::init_implicit<Source>());
-
-   instead of
-
-   .. code-block:: cpp
-
-      nb::class_<Target>(m, "Target")
-          .def(nb::init<Source>());
-
-      nb::implicitly_convertible<Source, Target>();
-
-   The function is provided for reasons of compatibility with pybind11, and as
-   an escape hatch to enable use cases where :cpp:struct:`init_implicit`
-   is not available (e.g., for custom binding-specific constructors that don't
-   exist in `Target` type).
-
-.. cpp:class:: template <typename T, typename... Ts> typed
-
-    This helper class provides an interface to parameterize generic types to
-    improve generated Python function signatures (e.g., to turn ``list`` into
-    ``list[MyType]``).
-
-    Consider the following binding that iterates over a Python list.
-
-    .. code-block:: cpp
-
-       m.def("f", [](nb::list l) {
-           for (handle h : l) {
-               // ...
-           }
-       });
-
-    Suppose that ``f`` expects a list of ``MyType`` objects, which is not clear
-    from the signature. To make this explicit, use the ``nb::typed<T, Ts...>``
-    wrapper to pass additional type parameters. This has no effect besides
-    clarifying the signature---in particular, nanobind does *not* insert
-    additional runtime checks! At runtime, a ``nb::typed<T, Ts...>`` behaves
-    exactly like a ``T``.
-
-    .. code-block:: cpp
-
-       m.def("f", [](nb::typed<nb::list, MyType> l) {
-           for (nb::handle h : l) {
-               // ...
-           }
-       });
-
-    ``nb::typed<nb::object, T>`` and ``nb::typed<nb::handle, T>`` are
-    treated specially: they generate a signature that refers just to ``T``,
-    rather than to the nonsensical ``object[T]`` that would otherwise
-    be produced. This can be useful if you want to replace the type of
-    a parameter instead of augmenting it. Note that at runtime these
-    perform no checks at all, since ``nb::object`` and ``nb::handle``
-    can refer to any Python object.
-
-    To support callable types, you can specify a C++ function signature in
-    ``nb::typed<nb::callable, Sig>`` and nanobind will attempt to convert
-    it to a Python callable signature.
-    ``nb::typed<nb::callable, int(float, std::string)>`` becomes
-    ``Callable[[float, str], int]``, while
-    ``nb::typed<nb::callable, int(...)>`` becomes ``Callable[..., int]``.
-    Type checkers will verify that any callable passed for such an argument
-    has a compatible signature. (At runtime, any sort of callable object
-    will be accepted.)
diff --git a/src/nanobind/docs/api_extra.rst b/src/nanobind/docs/api_extra.rst
deleted file mode 100644
index 903aa58..0000000
--- a/src/nanobind/docs/api_extra.rst
+++ /dev/null
@@ -1,1562 +0,0 @@
-C++ API Reference (Extras)
-==========================
-
-.. cpp:namespace:: nanobind
-
-Operator overloading
---------------------
-
-The following optional include directive imports the special value :cpp:var:`self`.
-
-.. code-block:: cpp
-
-   #include <nanobind/operators.h>
-
-The underlying type exposes various C++ operators that enable a shorthand
-notation to bind operators to python. See the :ref:`operator overloading
-<operator_overloading>` example in the main documentation for details.
-
-
-.. cpp:class:: detail::self_t
-
-   This is an internal class that should be accessed through the singleton
-   :cpp:var:`self` value.
-
-   It supports the overloaded operators listed below. Depending on whether
-   :cpp:var:`self` is the left or right argument of a binary operation,
-   the binding will map to different Python methods as shown below.
-
-   .. list-table::
-      :header-rows: 1
-      :widths: 50 50
-
-      * - C++ operator
-        - Python method (left or right)
-      * - ``operator-``
-        - ``__sub__``, ``__rsub__``
-      * - ``operator+``
-        - ``__add__``, ``__radd__``
-      * - ``operator*``
-        - ``__mul__``, ``__rmul__``
-      * - ``operator/``
-        - ``__truediv__``, ``__rtruediv__``
-      * - ``operator%``
-        - ``__mod__``, ``__rmod__``
-      * - ``operator<<``
-        - ``__lshift__``, ``__rlshift__``
-      * - ``operator>>``
-        - ``__rshift__``, ``__rrshift__``
-      * - ``operator&``
-        - ``__and__``, ``__rand__``
-      * - ``operator^``
-        - ``__xor__``, ``__rxor__``
-      * - ``operator|``
-        - ``__or__``, ``__ror__``
-      * - ``operator>``
-        - ``__gt__``, ``__lt__``
-      * - ``operator>=``
-        - ``__ge__``, ``__le__``
-      * - ``operator<``
-        - ``__lt__``, ``__gt__``
-      * - ``operator<=``
-        - ``__le__``, ``__ge__``
-      * - ``operator==``
-        - ``__eq__``
-      * - ``operator!=``
-        - ``__ne__``
-      * - ``operator+=``
-        - ``__iadd__``
-      * - ``operator-=``
-        - ``__isub__``
-      * - ``operator*=``
-        - ``__mul__``
-      * - ``operator/=``
-        - ``__itruediv__``
-      * - ``operator%=``
-        - ``__imod__``
-      * - ``operator<<=``
-        - ``__ilrshift__``
-      * - ``operator>>=``
-        - ``__ilrshift__``
-      * - ``operator&=``
-        - ``__iand__``
-      * - ``operator^=``
-        - ``__ixor__``
-      * - ``operator|=``
-        - ``__ior__``
-      * - ``operator-`` (unary)
-        - ``__neg__``
-      * - ``operator+`` (unary)
-        - ``__pos__``
-      * - ``operator~``  (unary)
-        - ``__invert__``
-      * - ``operator!``  (unary)
-        - ``__bool__`` (with extra negation)
-      * - ``nb::abs(..)``
-        - ``__abs__``
-      * - ``nb::hash(..)``
-        - ``__hash__``
-
-.. cpp:var:: detail::self_t self
-
-Trampolines
------------
-
-The following macros to implement trampolines that forward virtual function
-calls to Python require an additional include directive:
-
-.. code-block:: cpp
-
-   #include <nanobind/trampoline.h>
-
-See the section on :ref:`trampolines <trampolines>` for further detail.
-
-.. c:macro:: NB_TRAMPOLINE(base, size)
-
-   Install a trampoline in an alias class to enable dispatching C++ virtual
-   function calls to a Python implementation. Refer to the documentation on
-   :ref:`trampolines <trampolines>` to see how this macro can be used.
-
-.. c:macro:: NB_OVERRIDE(func, ...)
-
-   Dispatch the call to a Python method named ``"func"`` if it is overloaded on
-   the Python side, and forward the function arguments specified in the
-   variable length argument ``...``. Otherwise, call the C++ implementation
-   `func` in the base class.
-
-   Refer to the documentation on :ref:`trampolines <trampolines>` to see how
-   this macro can be used.
-
-.. c:macro:: NB_OVERRIDE_PURE(func, ...)
-
-   Dispatch the call to a Python method named ``"func"`` if it is overloaded on
-   the Python side, and forward the function arguments specified in the
-   variable length argument ``...``. Otherwise, raise an exception. This macro
-   should be used when the C++ function is pure virtual.
-
-   Refer to the documentation on :ref:`trampolines <trampolines>` to see how
-   this macro can be used.
-
-.. c:macro:: NB_OVERRIDE_NAME(name, func, ...)
-
-   Dispatch the call to a Python method named ``name`` if it is overloaded on
-   the Python side, and forward the function arguments specified in the
-   variable length argument ``...``. Otherwise, call the C++ function `func` in
-   the base class.
-
-   This function differs from :c:macro:`NB_OVERRIDE() <NB_OVERRIDE>` in that
-   C++ and Python functions can be named differently (e.g., ``operator+`` and
-   ``__add__``). Refer to the documentation on :ref:`trampolines <trampolines>`
-   to see how this macro can be used.
-
-.. c:macro:: NB_OVERRIDE_PURE_NAME(name, func, ...)
-
-   Dispatch the call to a Python method named ``name`` if it is overloaded on
-   the Python side, and forward the function arguments specified in the
-   variable length argument ``...``. Otherwise, raise an exception. This macro
-   should be used when the C++ function is pure virtual.
-
-   This function differs from :c:macro:`NB_OVERRIDE_PURE() <NB_OVERRIDE_PURE>`
-   in that C++ and Python functions can be named differently (e.g.,
-   ``operator+`` and ``__add__``). Although the C++ base implementation cannot
-   be called, its name is still important since nanobind uses it to infer the
-   return value type. Refer to the documentation on :ref:`trampolines
-   <trampolines>` to see how this macro can be used.
-
-.. _vector_bindings:
-
-STL vector bindings
--------------------
-
-The following function can be used to expose ``std::vector<...>`` variants
-in Python. It is not part of the core nanobind API and requires an additional
-include directive:
-
-.. code-block:: cpp
-
-   #include <nanobind/stl/bind_vector.h>
-
-.. cpp:function:: template <typename Vector, rv_policy Policy = rv_policy::automatic_reference, typename... Args> class_<Vector> bind_vector(handle scope, const char * name, Args &&...args)
-
-   Bind the STL vector-derived type `Vector` to the identifier `name` and
-   place it in `scope` (e.g., a :cpp:class:`module_`). The variable argument
-   list can be used to pass a docstring and other :ref:`class binding
-   annotations <class_binding_annotations>`.
-
-   The type includes the following methods resembling ``list``:
-
-   .. list-table::
-      :header-rows: 1
-      :widths: 50 50
-
-      * - Signature
-        - Documentation
-      * - ``__init__(self)``
-        - Default constructor
-      * - ``__init__(self, arg: Vector)``
-        - Copy constructor
-      * - ``__init__(self, arg: typing.Sequence)``
-        - Construct from another sequence type
-      * - ``__len__(self) -> int``
-        - Return the number of elements
-      * - ``__repr__(self) -> str``
-        - Generate a string representation
-      * - ``__contains__(self, arg: Value)``
-        - Check if the vector contains ``arg``
-      * - ``__eq__(self, arg: Vector)``
-        - Check if the vector is equal to ``arg``
-      * - ``__ne__(self, arg: Vector)``
-        - Check if the vector is not equal to ``arg``
-      * - ``__bool__(self) -> bool``
-        - Check whether the vector is empty
-      * - ``__iter__(self) -> iterator``
-        - Instantiate an iterator to traverse the elements
-      * - ``__getitem__(self, arg: int) -> Value``
-        - Return an element from the list (supports negative indexing)
-      * - ``__setitem__(self, arg0: int, arg1: Value)``
-        - Assign an element in the list (supports negative indexing)
-      * - ``__delitem__(self, arg: int)``
-        - Delete an item from the list (supports negative indexing)
-      * - ``__getitem__(self, arg: slice) -> Vector``
-        - Slice-based getter
-      * - ``__setitem__(self, arg0: slice, arg1: Value)``
-        - Slice-based assignment
-      * - ``__delitem__(self, arg: slice)``
-        - Slice-based deletion
-      * - ``clear(self)``
-        - Remove all items from the list
-      * - ``append(self, arg: Value)``
-        - Append a list item
-      * - ``insert(self, arg0: int, arg1: Value)``
-        - Insert a list item (supports negative indexing)
-      * - ``pop(self, index: int = -1)``
-        - Pop an element at position ``index`` (the end by default)
-      * - ``extend(self, arg: Vector)``
-        - Extend ``self`` by appending elements from ``arg``.
-      * - ``count(self, arg: Value)``
-        - Count the number of times that ``arg`` is contained in the vector
-      * - ``remove(self, arg: Value)``
-        - Remove all occurrences of ``arg``.
-
-   In contrast to ``std::vector<...>``, all bound functions perform range
-   checks to avoid undefined behavior. When the type underlying the vector is
-   not comparable or copy-assignable, some of these functions will not be
-   generated.
-
-   The binding operation is a no-op if the vector type has already been
-   registered with nanobind.
-
-   .. warning::
-
-      While this function creates a type resembling a Python ``list``, it has a
-      major caveat: the item accessor ``__getitem__`` copies the accessed
-      element by default (the bottom of this paragraph explains how this copy
-      can be avoided).
-
-      Consequently, writes to elements may not propagate in the expected way.
-      Consider the following C++ bindings:
-
-      .. code-block:: cpp
-
-         struct A {
-             int value;
-         };
-
-         nb::class_<A>(m, "A")
-             .def(nb::init<int>())
-             .def_rw("value", &A::value);
-
-         nb::bind_vector<std::vector<A>>(m, "VecA");
-
-      On the Python end, they yield the following surprising behavior:
-
-      .. code-block:: python
-
-         from my_ext import A, VecA
-
-         va = VecA()
-         va.append(A(123))
-         va[0].value = 456
-         assert va[0].value == 456 # <-- assertion fails!
-
-      To actually modify ``va``, another write is needed.
-
-      .. code-block:: python
-
-         v = va[0]
-         v.value = 456
-         va[0] = v
-
-      This may seem like a strange design, so it is worth explaining why the
-      implementation works in this way.
-
-      The key issue is that any particular value (e.g., ``va[0]``) lies within
-      a memory buffer managed by the ``std::vector``. It is not safe for
-      nanobind to refer to objects within this buffer using their absolute or
-      relative memory address. For example, inserting an element at position 0
-      will rearrange the buffer's contents and shift all subsequent ``A``
-      instances. If nanobind ``A`` objects could be "views" into the
-      ``std::vector``, then an insertion would cause the contents of unrelated
-      ``A`` Python objects to change unexpectedly. Insertion may also require
-      reallocation of the buffer, invalidating all current addresses, and this
-      could lead to undefined behavior (use-after-free) if nanobind did not
-      make a copy.
-
-      There are three situations in which the surprising behavior is avoided:
-
-      1. If the modification of the array is performed using in-place
-         operations like
-
-         .. code-block:: python
-
-            v[i] += 5
-
-         In-place operators automatically perform an array assignment, causing
-         the issue to disappear. This means that if you work with a vector type
-         like ``std::vector<int>`` or ``std::vector<std::string>`` with an
-         immutable element type like ``int`` or ``str`` on the Python end, it
-         will behave completely naturally in Python.
-
-      2. If the array contains STL shared pointers (e.g.,
-         ``std::vector<std::shared_ptr<T>>``), the added
-         indirection and ownership tracking removes the need for extra copies.
-
-      3. If the array contains pointers to reference-counted objects (e.g.,
-         ``std::vector<ref<T>>`` via the :cpp:class:`ref` wrapper) and ``T``
-         uses the intrusive reference counting approach explained :ref:`here
-         <intrusive>`, the added indirection and ownership tracking removes the
-         need for extra copies.
-
-         (It is usually unsafe to use this class to bind pointer-valued
-         vectors ``std::vector<T*>`` when ``T`` does not use intrusive
-         reference counting, because then there is nothing to prevent the Python
-         objects returned by ``__getitem__`` from outliving the C++ ``T``
-         objects that they point to. But if you are able to guarantee through
-         other means that the ``T`` objects will live long enough, the intrusive
-         reference counting is not strictly required.)
-
-   .. note::
-
-      Previous versions of nanobind (before 2.0) and pybind11 return Python
-      objects from ``__getitem__`` that wrap *references* (i.e., views),
-      meaning that they are only safe to use until the next insertion or
-      deletion in the vector they were drawn from. As discussed above, any use
-      after that point could **corrupt memory or crash your program**, which is
-      why reference semantics are no longer the default.
-
-      If you truly need the unsafe reference semantics, and if you
-      can guarantee that all use of your bindings will respect
-      the memory layout and reference-invalidation rules of the
-      underlying C++ container type, you can request the old behavior
-      by passing a second template argument of
-      :cpp:enumerator:`rv_policy::reference_internal` to
-      :cpp:func:`bind_vector`. This will override nanobind's usual
-      choice of :cpp:enumerator:`rv_policy::copy` for ``__getitem__``.
-
-      .. code-block:: cpp
-
-         nb::bind_vector<std::vector<MyType>,
-                         nb::rv_policy::reference_internal>(m, "ExampleVec");
-
-      Again, please avoid this if at all possible.
-      It is *very* easy to cause problems if you're not careful, as the
-      following example demonstrates.
-
-      .. code-block:: python
-
-         def looks_fine_but_crashes(vec: ext.ExampleVec) -> None:
-             # Trying to remove all the elements too much older than the last:
-             last = vec[-1]
-             # Even being careful to iterate backwards so we visit each
-             # index only once...
-             for idx in range(len(vec) - 2, -1, -1):
-                 if last.timestamp - vec[idx].timestamp > 5:
-                     del vec[idx]
-                     # Oops! After the first deletion, 'last' now refers to
-                     # uninitialized memory.
-
-
-.. _map_bindings:
-
-STL map bindings
-----------------
-
-The following function can be used to expose ``std::map<...>`` or
-``std::unordered_map<...>`` variants in Python. It is not part of the core
-nanobind API and requires an additional include directive:
-
-.. code-block:: cpp
-
-   #include <nanobind/stl/bind_map.h>
-
-.. cpp:function:: template <typename Map, rv_policy Policy = rv_policy::automatic_reference, typename... Args> class_<Map> bind_map(handle scope, const char * name, Args &&...args)
-
-   Bind the STL map-derived type `Map` (ordered or unordered) to the identifier
-   `name` and place it in `scope` (e.g., a :cpp:class:`module_`). The variable
-   argument list can be used to pass a docstring and other :ref:`class binding
-   annotations <class_binding_annotations>`.
-
-   The type includes the following methods resembling ``dict``:
-
-   .. list-table::
-      :header-rows: 1
-      :widths: 50 50
-
-      * - Signature
-        - Documentation
-      * - ``__init__(self)``
-        - Default constructor
-      * - ``__init__(self, arg: Map)``
-        - Copy constructor
-      * - ``__init__(self, arg: dict)``
-        - Construct from a Python dictionary
-      * - ``__len__(self) -> int``
-        - Return the number of elements
-      * - ``__repr__(self) -> str``
-        - Generate a string representation
-      * - ``__contains__(self, arg: Key)``
-        - Check if the map contains ``arg``
-      * - ``__eq__(self, arg: Map)``
-        - Check if the map is equal to ``arg``
-      * - ``__ne__(self, arg: Map)``
-        - Check if the map is not equal to ``arg``
-      * - ``__bool__(self) -> bool``
-        - Check whether the map is empty
-      * - ``__iter__(self) -> iterator``
-        - Instantiate an iterator to traverse the set of map keys
-      * - ``__getitem__(self, arg: Key) -> Value``
-        - Return an element from the map
-      * - ``__setitem__(self, arg0: Key, arg1: Value)``
-        - Assign an element in the map
-      * - ``__delitem__(self, arg: Key)``
-        - Delete an item from the map
-      * - ``clear(self)``
-        - Remove all items from the list
-      * - ``update(self, arg: Map)``
-        - Update the map with elements from ``arg``.
-      * - ``keys(self, arg: Map) -> Map.KeyView``
-        - Returns an iterable view of the map's keys
-      * - ``values(self, arg: Map) -> Map.ValueView``
-        - Returns an iterable view of the map's values
-      * - ``items(self, arg: Map) -> Map.ItemView``
-        - Returns an iterable view of the map's items
-
-   The binding operation is a no-op if the map type has already been
-   registered with nanobind.
-
-   The binding routine ideally expects the involved types to be:
-
-   - copy-constructible
-   - copy-assignable
-   - equality-comparable
-
-   If not all of these properties are available, then a subset of the above
-   methods will be omitted. Please refer to ``bind_map.h`` for details on the
-   logic.
-
-   .. warning::
-
-      While this function creates a type resembling a Python ``dict``, it has a
-      major caveat: the item accessor ``__getitem__`` copies the accessed
-      element by default.
-
-      Please refer to the :ref:`STL vector bindings <vector_bindings>` for a
-      discussion of the problem and possible solutions. Everything applies
-      equally to the map case.
-
-   .. note::
-
-      Unlike ``std::vector``, the ``std::map`` and ``std::unordered_map``
-      containers are *node-based*, meaning their elements do have a
-      consistent address for as long as they're stored in the map.
-      (Note that this is generally *not* true of third-party containers
-      with similar interfaces, such as ``absl::flat_hash_map``.)
-
-      If you are binding a node-based container type, and you want
-      ``__getitem__`` to return a reference to the accessed element
-      rather than copying it, it is *somewhat* safer than it would
-      be with :cpp:func:`bind_vector` to use the unsafe workaround
-      discussed there:
-
-      .. code-block:: cpp
-
-         nb::bind_map<std::map<std::string, SomeValue>,
-                      nb::rv_policy::reference_internal>(m, "ExampleMap");
-
-      With a node-based container, the only situation where a reference
-      returned from ``__getitem__`` would be invalidated is if the individual
-      element that it refers to were removed from the map. Unlike with
-      ``std::vector``, additions and removals of *other* elements would
-      not present a danger.
-
-      It is still easy to cause problems if you're not careful, though:
-
-      .. code-block:: python
-
-         def unsafe_pop(map: ext.ExampleMap, key: str) -> ext.SomeValue:
-             value = map[key]
-             del map[key]
-             # Oops! `value` now points to a dangling element. Anything you
-             # do with it now is liable to crash the interpreter.
-             return value  # uh-oh...
-
-
-Unique pointer deleter
-----------------------
-
-The following *deleter* should be used to gain maximal flexibility in combination with
-``std::unique_ptr<..>``. It requires the following additional include directive:
-
-.. code-block:: cpp
-
-   #include <nanobind/stl/unique_ptr.h>
-
-See the two documentation sections on unique pointers for further detail
-(:ref:`#1 <unique_ptr>`, :ref:`#2 <unique_ptr_adv>`).
-
-.. cpp:struct:: template <typename T> deleter
-
-   .. cpp:function:: deleter() = default
-
-      Create a deleter that destroys the object using a ``delete`` expression.
-
-   .. cpp:function:: deleter(handle h)
-
-      Create a deleter that destroys the object by reducing the Python reference count.
-
-   .. cpp:function:: bool owned_by_python() const
-
-      Check if the object is owned by Python.
-
-   .. cpp:function:: bool owned_by_cpp() const
-
-      Check if the object is owned by C++.
-
-   .. cpp:function:: void operator()(void * p) noexcept
-
-      Destroy the object at address `p`.
-
-.. _iterator_bindings:
-
-Iterator bindings
------------------
-
-The following functions can be used to expose existing C++ iterators in
-Python. They are not part of the core nanobind API and require an additional
-include directive:
-
-.. code-block:: cpp
-
-   #include <nanobind/make_iterator.h>
-
-.. cpp:function:: template <rv_policy Policy = rv_policy::automatic_reference, typename Iterator, typename Sentinel, typename... Extra> auto make_iterator(handle scope, const char * name, Iterator first, Sentinel last, Extra &&...extra)
-
-   Create a Python iterator wrapping the C++ iterator represented by the range
-   ``[first, last)``. The `Extra` parameter can be used to pass additional
-   function binding annotations.
-
-   This function lazily creates a new Python iterator type identified by
-   `name`, which is stored in the given `scope`. Usually, some kind of
-   :cpp:class:`keep_alive` annotation is needed to tie the lifetime of the
-   parent container to that of the iterator.
-
-   The return value is a typed iterator (:cpp:class:`iterator` wrapped using
-   :cpp:class:`typed`), whose template parameter is given by the type of
-   ``*first``.
-
-   Here is an example of what this might look like for a STL vector:
-
-   .. code-block:: cpp
-
-      using IntVec = std::vector<int>;
-
-      nb::class_<IntVec>(m, "IntVec")
-         .def("__iter__",
-              [](const IntVec &v) {
-                  return nb::make_iterator(nb::type<IntVec>(), "iterator",
-                                           v.begin(), v.end());
-              }, nb::keep_alive<0, 1>());
-
-   .. note::
-
-      Pre-2.0 versions of nanobind and pybind11 return *references* (views)
-      into the underlying sequence.
-
-      This is convenient when
-
-      1. Iterated elements are used to modify the underlying container.
-
-      2. Iterated elements should reflect separately made changes to
-         the underlying container.
-
-      But this strategy is *unsafe* if the allocated memory region or layout
-      of the container could change (e.g., through insertion of removal of
-      elements).
-
-      Because of this, iterators now copy by default. There are two
-      ways to still obtain references to the target elements:
-
-      1. If the iterator is over STL shared pointers, the added indirection and
-         ownership tracking removes the need for extra copies.
-
-      2. If the iterator is over reference-counted objects (e.g., ``ref<T>``
-         via the :cpp:class:`ref` wrapper) and ``T`` uses the intrusive
-         reference counting approach explained :ref:`here <intrusive>`,
-         the added indirection and ownership tracking removes the need
-         for extra copies.
-
-      If you truly need the unsafe reference semantics, and if you can
-      guarantee that all use of your bindings will respect the memory layout
-      and reference-invalidation rules of the underlying C++ container type,
-      you can request the old behavior by passing
-      :cpp:enumerator:`rv_policy::reference_internal` to the ``Policy``
-      template argument of this function.
-
-
-.. cpp:function:: template <rv_policy Policy = rv_policy::automatic_reference, typename Type, typename... Extra> auto make_iterator(handle scope, const char * name, Type &value, Extra &&...extra)
-
-   This convenience wrapper calls the above :cpp:func:`make_iterator` variant with
-   ``first`` and ``last`` set to ``std::begin(value)`` and ``std::end(value)``,
-   respectively.
-
-.. cpp:function:: template <rv_policy Policy = rv_policy::automatic_reference, typename Iterator, typename Sentinel, typename... Extra> iterator make_key_iterator(handle scope, const char * name, Iterator first, Sentinel last, Extra &&...extra)
-
-   :cpp:func:`make_iterator` specialization for C++ iterators that return
-   key-value pairs. `make_key_iterator` returns the first pair element to
-   iterate over keys.
-
-   The return value is a typed iterator (:cpp:class:`iterator` wrapped using
-   :cpp:class:`typed`), whose template parameter is given by the type of
-   ``(*first).first``.
-
-
-.. cpp:function:: template <rv_policy Policy = rv_policy::automatic_reference, typename Iterator, typename Sentinel, typename... Extra> iterator make_value_iterator(handle scope, const char * name, Iterator first, Sentinel last, Extra &&...extra)
-
-   :cpp:func:`make_iterator` specialization for C++ iterators that return
-   key-value pairs. `make_value_iterator` returns the second pair element to
-   iterate over values.
-
-   The return value is a typed iterator (:cpp:class:`iterator` wrapped using
-   :cpp:class:`typed`), whose template parameter is given by the type of
-   ``(*first).second``.
-
-N-dimensional array type
-------------------------
-
-The following type can be used to exchange n-dimension arrays with frameworks
-like NumPy, PyTorch, Tensorflow, JAX, CuPy, and others. It requires an
-additional include directive:
-
-.. code-block:: cpp
-
-   #include <nanobind/ndarray.h>
-
-Detailed documentation including example code is provided in a :ref:`separate
-section <ndarrays>`.
-
-.. cpp:function:: bool ndarray_check(handle h) noexcept
-
-   Test whether the Python object represents an ndarray.
-
-   Objects with a ``__dlpack__`` attribute or objects that implement the buffer
-   protocol are considered as ndarray objects. In addition, arrays from NumPy,
-   PyTorch, TensorFlow and XLA are also regarded as ndarrays.
-
-.. cpp:class:: template <typename... Args> ndarray
-
-   .. cpp:type:: Scalar
-
-      The scalar type underlying the array (or ``void`` if not specified)
-
-   .. cpp:var:: static constexpr bool ReadOnly
-
-      A ``constexpr`` Boolean value that is ``true`` if the ndarray template
-      arguments (`Args... <Args>`) include the ``nb::ro`` annotation or a
-      ``const``-qualified scalar type.
-
-   .. cpp:var:: static constexpr char Order
-
-      A ``constexpr`` character value set based on the ndarray template
-      arguments (`Args... <Args>`). It equals
-
-      - ``'C'`` if :cpp:class:`c_contig` is specified,
-      - ``'F'`` if :cpp:class:`f_contig` is specified,
-      - ``'A'`` if :cpp:class:`any_contig` is specified,
-      - ``'\0'`` otherwise.
-
-   .. cpp:var:: static constexpr int DeviceType
-
-      A ``constexpr`` integer value set to the device type ID extracted from
-      the ndarray template arguments (`Args... <Args>`), or
-      :cpp:struct:`device::none::value <device::none>` when none was specified.
-
-   .. cpp:type:: VoidPtr = std::conditional_t<ReadOnly, const void *, void *>
-
-      A potentially ``const``-qualified ``void*`` pointer type used by some
-      of the ``ndarray`` constructors.
-
-   .. cpp:function:: ndarray() = default
-
-      Create an invalid array.
-
-   .. cpp:function:: template <typename... Args2> explicit ndarray(const ndarray<Args2...> &other)
-
-      Reinterpreting constructor that wraps an existing nd-array (parameterized
-      by `Args... <Args>`) into a new ndarray (parameterized by `Args2...
-      <Args2>`). No copy or conversion is made.
-
-      Dropping parameters is always safe. For example, a function that
-      returns different array types could call it to convert ``ndarray<T>`` to
-      ``ndarray<>``.  When adding constraints, the constructor is only safe to
-      use following a runtime check to ensure that newly created array actually
-      possesses the advertised properties.
-
-   .. cpp:function:: ndarray(const ndarray &)
-
-      Copy constructor. Increases the reference count of the referenced array.
-
-   .. cpp:function:: ndarray(ndarray &&)
-
-      Move constructor. Steals the referenced array without changing reference counts.
-
-   .. cpp:function:: ~ndarray()
-
-      Decreases the reference count of the referenced array and potentially destroy it.
-
-   .. cpp:function:: ndarray& operator=(const ndarray &)
-
-      Copy assignment operator. Increases the reference count of the referenced array.
-      Decreases the reference count of the previously referenced array and potentially destroy it.
-
-   .. cpp:function:: ndarray& operator=(ndarray &&)
-
-      Move assignment operator. Steals the referenced array without changing reference counts.
-      Decreases the reference count of the previously referenced array and potentially destroy it.
-
-   .. _ndarray_dynamic_constructor:
-
-   .. cpp:function:: ndarray(VoidPtr data, const std::initializer_list<size_t> shape = { }, handle owner = { }, std::initializer_list<int64_t> strides = { }, dlpack::dtype dtype = nanobind::dtype<Scalar>(), int32_t device_type = DeviceType, int32_t device_id = 0, char order = Order)
-
-      Create an array wrapping an existing memory allocation.
-
-      Only the `data` parameter is strictly required, while some other
-      parameters can be be inferred from static :cpp:class:`nb::ndarray\<...\>
-      <ndarray>` template parameters.
-
-      The parameters have the following meaning:
-
-      - `data`: a CPU/GPU/.. pointer to the memory region storing the array
-        data.
-
-        When the array is parameterized by a ``const`` scalar type, or when it
-        has a :cpp:class:`nb::ro <ro>` read-only annotation, a ``const``
-        pointer can be passed here.
-
-      - `shape`: an initializer list that simultaneously specifies the number
-        of dimensions and the size along each axis. If left at its default
-        ``{}``, the :cpp:class:`nb::shape <nanobind::shape>` template parameter
-        will take precedence (if present).
-
-      - `owner`: if provided, the array will hold a reference to this object
-        until its destruction. This makes it possible to create zero-copy views
-        into other data structures, while guaranteeing the memory safety of
-        array accesses.
-
-      - `strides`: an initializer list explaining the layout of the data in
-        memory. Each entry denotes the number of elements to jump over to
-        advance to the next item along the associated axis.
-
-        `strides` must either have the same size as `shape` or be empty. In the
-        latter case, strides are automatically computed according to the
-        `order` parameter.
-
-        Note that strides in nanobind express *element counts* rather than
-        *byte counts*. This convention differs from other frameworks (e.g.,
-        NumPy) and is a consequence of the underlying `DLPack
-        <https://github.com/dmlc/dlpack>`_ protocol.
-
-      - `dtype` describes the numeric data type of array elements (e.g.,
-        floating point, signed/unsigned integer) and their bit depth.
-
-        You can use the :cpp:func:`nb::dtype\<T\>() <nanobind::dtype>` function to obtain the right
-        value for a given type.
-
-      - `device_type` and `device_id` specify where the array data is stored.
-        The `device_type` must be an enumerant like
-        :cpp:class:`nb::device::cuda::value <device::cuda>`, while the meaning
-        of the device ID is unspecified and platform-dependent.
-
-        Note that the `device_id` is set to ``0`` by default and cannot be
-        inferred by nanobind. If your extension creates arrays on multiple
-        different compute accelerators, you *must* provide this parameter.
-
-      - The `order` parameter denotes the coefficient order in memory and is only
-        relevant when `strides` is empty. Specify ``'C'`` for C-style or ``'F'``
-        for Fortran-style. When this parameter is not explicitly specified, the
-        implementation uses the order specified as an ndarray template
-        argument, or C-style order as a fallback.
-
-      Both ``strides`` and ``shape`` will be copied by the constructor, hence
-      the targets of these initializer lists do not need to remain valid
-      following the constructor call.
-
-      .. warning::
-
-         The Python *global interpreter lock* (GIL) must be held when calling
-         this function.
-
-   .. cpp:function:: ndarray(VoidPtr data, size_t ndim, const size_t * shape, handle owner, const int64_t * strides = nullptr, dlpack::dtype dtype = nanobind::dtype<Scalar>(), int device_type = DeviceType, int device_id = 0, char order = Order)
-
-      Alternative form of the above constructor, which accepts the `shape`
-      and `strides` arguments using pointers instead of initializer lists.
-      The number of dimensions must be specified via the `ndim` parameter
-      in this case.
-
-      See the previous constructor for details, the remaining behavior is
-      identical.
-
-   .. cpp:function:: dlpack::dtype dtype() const
-
-      Return the data type underlying the array
-
-   .. cpp:function:: size_t ndim() const
-
-      Return the number of dimensions.
-
-   .. cpp:function:: size_t size() const
-
-      Return the size of the array (i.e. the product of all dimensions).
-
-   .. cpp:function:: size_t itemsize() const
-
-      Return the size of a single array element in bytes. The returned value
-      is rounded up to the next full byte in case of bit-level representations
-      (query :cpp:member:`dtype::bits` for bit-level granularity).
-
-   .. cpp:function:: size_t nbytes() const
-
-      Return the size of the entire array bytes. The returned value is rounded
-      up to the next full byte in case of bit-level representations.
-
-   .. cpp:function:: size_t shape(size_t i) const
-
-      Return the size of dimension `i`.
-
-   .. cpp:function:: int64_t stride(size_t i) const
-
-      Return the stride (in number of elements) of dimension `i`.
-
-   .. cpp:function:: const int64_t* shape_ptr() const
-
-      Return a pointer to the shape array. Note that the return type is
-      ``const int64_t*``, which may be unexpected as the scalar version
-      :cpp:func:`shape()` casts its result to a ``size_t``.
-
-      This is a consequence of the DLPack tensor representation that uses
-      signed 64-bit integers for all of these fields.
-
-   .. cpp:function:: const int64_t* stride_ptr() const
-
-      Return pointer to the stride array.
-
-   .. cpp:function:: bool is_valid() const
-
-      Check whether the array is in a valid state.
-
-   .. cpp:function:: int device_type() const
-
-      ID denoting the type of device hosting the array. This will match the
-      ``value`` field of a device class, such as :cpp:class:`device::cpu::value
-      <device::cpu>` or :cpp:class:`device::cuda::value <device::cuda>`.
-
-   .. cpp:function:: int device_id() const
-
-      In a multi-device/GPU setup, this function returns the ID of the device
-      storing the array.
-
-   .. cpp:function:: Scalar * data() const
-
-      Return a pointer to the array data.
-      If :cpp:var:`ReadOnly` is true, a pointer-to-const is returned.
-
-   .. cpp:function:: template <typename... Args2> auto& operator()(Args2... indices)
-
-      Return a reference to the element stored at the provided index/indices.
-      If :cpp:var:`ReadOnly` is true, a reference-to-const is returned.
-      Note that ``sizeof...(Args2)`` must match :cpp:func:`ndim()`.
-
-      This accessor is only available when the scalar type and array dimension
-      were specified as template parameters.
-
-      This function should only be used when the array storage is accessible
-      through the CPU's virtual memory address space.
-
-   .. cpp:function:: template <typename... Extra> auto view()
-
-      Returns an nd-array view that is optimized for fast array access on the
-      CPU. You may optionally specify additional ndarray constraints via the
-      `Extra` parameter (though a runtime check should first be performed to
-      ensure that the array possesses these properties).
-
-      The returned view provides the operations ``data()``, ``ndim()``,
-      ``shape()``, ``stride()``, and ``operator()`` following the conventions
-      of the `ndarray` type.
-
-   .. cpp:function:: auto cast(rv_policy policy = rv_policy::automatic_reference, handle parent = {})
-
-      The expression ``array.cast(policy, parent)`` is almost equivalent to
-      :cpp:func:`nb::cast(array, policy, parent) <cast>`.
-
-      The main difference is that the return type of :cpp:func:`nb::cast
-      <cast>` is :cpp:class:`nb::object <object>`, which renders as a rather
-      non-descriptive ``object`` in Python bindings. The ``.cast()`` method
-      returns a custom wrapper type that still derives from
-      :cpp:class:`nb::object <object>`, but whose type signature in bindings
-      reproduces that of the original nd-array.
-
-Data types
-^^^^^^^^^^
-
-Nanobind uses the `DLPack <https://github.com/dmlc/dlpack>`_ ABI to represent
-metadata describing n-dimensional arrays (even when they are exchanged using
-the buffer protocol). Consequently, the set of possible dtypes is :ref:`more
-restricted <dtype_restrictions>` than that of other nd-array libraries (e.g.,
-NumPy). Relevant data structures are located in the ``nanobind::dlpack``
-sub-namespace.
-
-
-.. cpp:enum-class:: dlpack::dtype_code : uint8_t
-
-   This enumeration characterizes the elementary array data type regardless of
-   bit depth.
-
-   .. cpp:enumerator:: Int = 0
-
-      Signed integer format
-
-   .. cpp:enumerator:: UInt = 1
-
-      Unsigned integer format
-
-   .. cpp:enumerator:: Float = 2
-
-      IEEE-754 floating point format
-
-   .. cpp:enumerator:: Bfloat = 4
-
-      "Brain" floating point format
-
-   .. cpp:enumerator:: Complex = 5
-
-      Complex numbers parameterized by real and imaginary component
-
-.. cpp:struct:: dlpack::dtype
-
-   Represents the data type underlying an n-dimensional array. Use the
-   :cpp:func:`dtype\<T\>() <::nanobind::dtype>` function to return a populated
-   instance of this data structure given a scalar C++ arithmetic type.
-
-   .. cpp:member:: uint8_t code = 0;
-
-      This field must contain the value of one of the
-      :cpp:enum:`dlpack::dtype_code` enumerants.
-
-   .. cpp:member:: uint8_t bits = 0;
-
-      Number of bits per entry (e.g., 32 for a C++ single precision ``float``)
-
-   .. cpp:member:: uint16_t lanes = 0;
-
-      Number of SIMD lanes (typically ``1``)
-
-.. cpp:function:: template <typename T> dlpack::dtype dtype()
-
-   Returns a populated instance of the :cpp:class:`dlpack::dtype` structure
-   given a scalar C++ arithmetic type.
-
-Array annotations
-^^^^^^^^^^^^^^^^^
-
-The :cpp:class:`ndarray\<..\> <ndarray>` class admits optional template
-parameters. They constrain the type of array arguments that may be passed to a
-function.
-
-The following are supported:
-
-Data type
-+++++++++
-
-The data type of the underlying scalar element. The following are supported.
-
-- ``[u]int8_t`` up to ``[u]int64_t`` and other variations (``unsigned long long``, etc.)
-- ``float``, ``double``
-- ``bool``
-
-Annotate the data type with ``const`` to indicate a read-only array. Note that
-only the buffer protocol/NumPy interface considers ``const``-ness at the
-moment; data exchange with other array libraries will ignore this annotation.
-
-When the is unspecified (e.g., to accept arbitrary input arrays), the
-:cpp:class:`ro` annotation can instead be used to denote read-only access:
-
-.. cpp:class:: ro
-
-   Indicate read-only access (use only when no data type is specified.)
-
-
-nanobind does not support non-standard types as documented in the section on
-:ref:`dtype limitations <dtype_restrictions>`.
-
-Shape
-+++++
-
-.. cpp:class:: template <ssize_t... Is> shape
-
-   Require the array to have ``sizeof...(Is)`` dimensions. Each entry of `Is`
-   specifies a fixed size constraint for that specific dimension. An entry
-   equal to ``-1`` indicates that *any* size should be accepted for this
-   dimension.
-
-   (An alias named ``nb::any`` representing ``-1`` was removed in nanobind 2).
-
-.. cpp:class:: template <size_t N> ndim
-
-   Alternative to the above that only constrains the array dimension.
-   ``nb::ndim<2>`` is equivalent to ``nb::shape<-1, -1>``.
-
-Contiguity
-++++++++++
-
-.. cpp:class:: c_contig
-
-   Request that the array storage uses a C-contiguous representation.
-
-.. cpp:class:: f_contig
-
-   Request that the array storage uses a F (Fortran)-contiguous representation.
-
-.. cpp:class:: any_contig
-
-   Accept both C- and F-contiguous arrays.
-
-If you prefer not to require contiguity, simply do not provide any of the
-``*_contig`` template parameters listed above.
-
-Device type
-+++++++++++
-
-.. cpp:class:: device
-
-   The following helper classes can be used to constrain the device and
-   address space of an array. Each class has a ``static constexpr int32_t
-   value`` field that will then match up with
-   :cpp:func:`ndarray::device_id()`.
-
-   .. cpp:class:: cpu
-
-      CPU heap memory
-
-   .. cpp:class:: cuda
-
-      NVIDIA CUDA device memory
-
-   .. cpp:class:: cuda_host
-
-      NVIDIA CUDA host-pinned memory
-
-   .. cpp:class:: cuda_managed
-
-      NVIDIA CUDA managed memory
-
-   .. cpp:class:: vulkan
-
-      Vulkan device memory
-
-   .. cpp:class:: metal
-
-      Apple Metal device memory
-
-   .. cpp:class:: rocm
-
-      AMD ROCm device memory
-
-   .. cpp:class:: rocm_host
-
-      AMD ROCm host memory
-
-   .. cpp:class:: oneapi
-
-      Intel OneAPI device memory
-
-Framework
-+++++++++
-
-Framework annotations cause :cpp:class:`nb::ndarray <ndarray>` objects to
-convert into an equivalent representation in one of the following frameworks:
-
-.. cpp:class:: numpy
-
-.. cpp:class:: tensorflow
-
-.. cpp:class:: pytorch
-
-.. cpp:class:: jax
-
-.. cpp:class:: cupy
-
-Eigen convenience type aliases
-------------------------------
-
-The following helper type aliases require an additional include directive:
-
-.. code-block:: cpp
-
-   #include <nanobind/eigen/dense.h>
-
-.. cpp:type:: DStride = Eigen::Stride<Eigen::Dynamic, Eigen::Dynamic>
-
-   This type alias refers to an Eigen stride object that is sufficiently flexible
-   so that can be easily called with NumPy arrays and array slices.
-
-.. cpp:type:: template <typename T> DRef = Eigen::Ref<T, 0, DStride>
-
-   This templated type alias creates an ``Eigen::Ref<..>`` with flexible strides for
-   zero-copy data exchange between Eigen and NumPy.
-
-.. cpp:type:: template <typename T> DMap = Eigen::Map<T, 0, DStride>
-
-   This templated type alias creates an ``Eigen::Map<..>`` with flexible strides for
-   zero-copy data exchange between Eigen and NumPy.
-
-.. _chrono_conversions:
-
-Timestamp and duration conversions
-----------------------------------
-
-nanobind supports bidirectional conversions of timestamps and
-durations between their standard representations in Python
-(:py:class:`datetime.datetime`, :py:class:`datetime.timedelta`) and in C++
-(``std::chrono::time_point``, ``std::chrono::duration``).
-A few unidirectional conversions from other Python types to these
-C++ types are also provided and explained below.
-
-These type casters require an additional include directive:
-
-.. code-block:: cpp
-
-   #include <nanobind/stl/chrono.h>
-
-.. The rest of this section is adapted from pybind11/docs/advanced/cast/chrono.rst
-
-An overview of clocks in C++11
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-The C++11 standard defines three different clocks, and users can
-define their own. Each ``std::chrono::time_point`` is defined relative
-to a particular clock. When using the ``chrono`` type caster, you must be
-aware that only ``std::chrono::system_clock`` is guaranteed to convert
-to a Python :py:class:`~datetime.datetime` object; other clocks may convert to
-:py:class:`~datetime.timedelta` if they don't represent calendar time.
-
-The first clock defined by the standard is ``std::chrono::system_clock``.
-This clock measures the current date and time, much like the Python
-:py:func:`time.time` function. It can change abruptly due to
-administrative actions, daylight savings time transitions, or
-synchronization with an external time server. That makes this clock a
-poor choice for timing purposes, but a good choice for wall-clock time.
-
-The second clock defined by the standard is ``std::chrono::steady_clock``.
-This clock ticks at a steady rate and is never adjusted, like
-:py:func:`time.monotonic` in Python. That makes it excellent for timing
-purposes, but the value in this clock does not correspond to the
-current date and time. Often this clock will measure the amount of
-time your system has been powered on. This clock will never be
-the same clock as the system clock, because the system clock can
-change but steady clocks cannot.
-
-The third clock defined in the standard is ``std::chrono::high_resolution_clock``.
-This clock is the clock that has the highest resolution out of all the
-clocks in the system. It is normally an alias for either ``system_clock``
-or ``steady_clock``, but can be its own independent clock. Due
-to this uncertainty, conversions of time measured on the
-``high_resolution_clock`` to Python produce platform-dependent types:
-you'll get a :py:class:`~datetime.datetime` if ``high_resolution_clock`` is
-an alias for ``system_clock`` on your system, or a :py:class:`~datetime.timedelta`
-value otherwise.
-
-Provided conversions
-^^^^^^^^^^^^^^^^^^^^
-
-The C++ types described in this section may be instantiated with any
-precision. Conversions to a less-precise type will round towards zero.
-Since Python's built-in date and time objects support only microsecond
-precision, any precision beyond that on the C++ side will be lost when
-converting to Python.
-
-.. rubric:: C++ to Python
-
-- ``std::chrono::system_clock::time_point`` → :py:class:`datetime.datetime`
-    A system clock time will be converted to a Python
-    :py:class:`~datetime.datetime` instance.  The result describes a time in the
-    local timezone, but does not have any timezone information
-    attached to it (it is a naive datetime object).
-
-- ``std::chrono::duration`` → :py:class:`datetime.timedelta`
-    A duration will be converted to a Python :py:class:`~datetime.timedelta`.
-    Any precision beyond microseconds is lost by rounding towards zero.
-
-- ``std::chrono::[other_clock]::time_point`` → :py:class:`datetime.timedelta`
-    A time on any clock except the system clock will be converted to a Python
-    :py:class:`~datetime.timedelta`, which measures the number of seconds between
-    the clock's epoch and the time point of interest.
-
-.. rubric:: Python to C++
-
-- :py:class:`datetime.datetime` or :py:class:`datetime.date` or :py:class:`datetime.time` → ``std::chrono::system_clock::time_point``
-    A Python date, time, or datetime object can be converted into a
-    system clock timepoint.  A :py:class:`~datetime.time` with no date
-    information is treated as that time on January 1, 1970. A
-    :py:class:`~datetime.date` with no time information is treated as midnight
-    on that date. **Any timezone information is ignored.**
-
-- :py:class:`datetime.timedelta` → ``std::chrono::duration``
-    A Python time delta object can be converted into a duration
-    that describes the same number of seconds (modulo precision limitations).
-
-- :py:class:`datetime.timedelta` → ``std::chrono::[other_clock]::time_point``
-    A Python time delta object can be converted into a timepoint on a
-    clock other than the system clock. The resulting timepoint will be
-    that many seconds after the target clock's epoch time.
-
-- ``float`` → ``std::chrono::duration``
-    A floating-point value can be converted into a duration. The input is
-    treated as a number of seconds, and fractional seconds are supported
-    to the extent representable.
-
-- ``float`` → ``std::chrono::[other_clock]::time_point``
-    A floating-point value can be converted into a timepoint on a
-    clock other than the system clock. The input is treated as a
-    number of seconds, and fractional seconds are supported to the
-    extent representable. The resulting timepoint will be that many
-    seconds after the target clock's epoch time.
-
-
-Evaluating Python expressions from strings
-------------------------------------------
-
-The following functions can be used to evaluate Python functions and
-expressions. They require an additional include directive:
-
-.. code-block:: cpp
-
-   #include <nanobind/eval.h>
-
-Detailed documentation including example code is provided in a :ref:`separate
-section <utilities_eval>`.
-
-.. cpp:enum-class:: eval_mode
-
-   This enumeration specifies how the content of a string should be
-   interpreted. Used in Py_CompileString().
-
-   .. cpp:enumerator:: eval_expr = Py_eval_input
-
-      Evaluate a string containing an isolated expression
-
-   .. cpp:enumerator:: eval_single_statement = Py_single_input
-
-      Evaluate a string containing a single statement. Returns \c None
-
-   .. cpp:enumerator:: eval_statements = Py_file_input
-
-      Evaluate a string containing a sequence of statement. Returns \c None
-
-.. cpp:function:: template <eval_mode start = eval_expr, size_t N> object eval(const char (&s)[N], handle global = handle(), handle local = handle())
-
-   Evaluate the given Python code in the given global/local scopes, and return
-   the value.
-
-.. cpp:function:: inline void exec(const str &expr, handle global = handle(), handle local = handle())
-
-   Execute the given Python code in the given global/local scopes.
-
-Intrusive reference counting helpers
-------------------------------------
-
-The following functions and classes can be used to augment user-provided
-classes with intrusive reference counting that greatly simplifies shared
-ownership in larger C++/Python binding projects.
-
-This functionality requires the following include directives:
-
-.. code-block:: cpp
-
-   #include <nanobind/intrusive/counter.h>
-   #include <nanobind/intrusive/ref.h>
-
-These headers reference several functions, whose implementation must be
-provided. You can do so by including the following file from a single ``.cpp``
-file of your project:
-
-.. code-block:: cpp
-
-   #include <nanobind/intrusive/counter.inl>
-
-The functionality in these files consist of the following classes and
-functions:
-
-.. cpp:class:: intrusive_counter
-
-   Simple atomic reference counter that can optionally switch over to
-   Python-based reference counting.
-
-   The various copy/move assignment/constructors intentionally don't transfer
-   the reference count. This is so that the contents of classes containing an
-   ``intrusive_counter`` can be copied/moved without disturbing the reference
-   counts of the associated instances.
-
-   .. cpp:function:: intrusive_counter() noexcept = default
-
-      Initialize with a reference count of zero.
-
-   .. cpp:function:: intrusive_counter(const intrusive_counter &o)
-
-      Copy constructor, which produces a zero-initialized counter.
-      Does *not* copy the reference count from `o`.
-
-   .. cpp:function:: intrusive_counter(intrusive_counter &&o)
-
-      Move constructor, which produces a zero-initialized counter.
-      Does *not* copy the reference count from `o`.
-
-   .. cpp:function:: intrusive_counter &operator=(const intrusive_counter &o)
-
-      Copy assignment operator. Does *not* copy the reference count from `o`.
-
-   .. cpp:function:: intrusive_counter &operator=(intrusive_counter &&o)
-
-      Move assignment operator. Does *not* copy the reference count from `o`.
-
-   .. cpp:function:: void inc_ref() const noexcept
-
-      Increase the reference count. When the counter references an object
-      managed by Python, the operation calls ``Py_INCREF()`` to increase
-      the reference count of the Python object instead.
-
-      The :cpp:func:`inc_ref() <nanobind::inc_ref>` top-level function
-      encapsulates this logic for subclasses of :cpp:class:`intrusive_base`.
-
-   .. cpp:function:: bool dec_ref() const noexcept
-
-      Decrease the reference count. When the counter references an object
-      managed by Python, the operation calls ``Py_DECREF()`` to decrease
-      the reference count of the Python object instead.
-
-      When the C++-managed reference count reaches zero, the operation returns
-      ``true`` to signal to the caller that it should use a *delete expression*
-      to destroy the instance.
-
-      The :cpp:func:`dec_ref() <nanobind::dec_ref>` top-level function
-      encapsulates this logic for subclasses of :cpp:class:`intrusive_base`.
-
-   .. cpp:function:: void set_self_py(PyObject * self)
-
-      Set the Python object associated with this instance. This operation
-      is usually called by nanobind when ownership is transferred to the
-      Python side.
-
-      Any references from prior calls to
-      :cpp:func:`intrusive_counter::inc_ref()` are converted into Python
-      references by calling ``Py_INCREF()`` repeatedly.
-
-   .. cpp:function:: PyObject * self_py()
-
-      Return the Python object associated with this instance (or ``nullptr``).
-
-.. cpp:class:: intrusive_base
-
-   Simple polymorphic base class for a intrusively reference-counted object
-   hierarchy. The member functions expose corresponding functionality of
-   :cpp:class:`intrusive_counter`.
-
-   .. cpp:function:: void inc_ref() const noexcept
-
-      See :cpp:func:`intrusive_counter::inc_ref()`.
-
-   .. cpp:function:: bool dec_ref() const noexcept
-
-      See :cpp:func:`intrusive_counter::dec_ref()`.
-
-   .. cpp:function:: void set_self_py(PyObject * self)
-
-      See :cpp:func:`intrusive_counter::set_self_py()`.
-
-   .. cpp:function:: PyObject * self_py()
-
-      See :cpp:func:`intrusive_counter::self_py()`.
-
-.. cpp:function:: void intrusive_init(void (* intrusive_inc_ref_py)(PyObject * ) noexcept, void (* intrusive_dec_ref_py)(PyObject * ) noexcept)
-
-   Function to register reference counting hooks with the intrusive reference
-   counter class. This allows its implementation to not depend on Python.
-
-   You would usually call this function as follows from the initialization
-   routine of a Python extension:
-
-   .. code-block:: cpp
-
-      NB_MODULE(my_ext, m) {
-          nb::intrusive_init(
-              [](PyObject * o) noexcept {
-                  nb::gil_scoped_acquire guard;
-                  Py_INCREF(o);
-              },
-              [](PyObject * o) noexcept {
-                  nb::gil_scoped_acquire guard;
-                  Py_DECREF(o);
-              });
-
-          // ...
-      }
-
-.. cpp:function:: inline void inc_ref(intrusive_base * o) noexcept
-
-   Reference counting helper function that calls ``o->inc_ref()`` if ``o`` is
-   not equal to ``nullptr``.
-
-.. cpp:function:: inline void dec_ref(intrusive_base * o) noexcept
-
-   Reference counting helper function that calls ``o->dec_ref()`` if ``o`` is
-   not equal to ``nullptr`` and ``delete o`` when the reference count reaches
-   zero.
-
-.. cpp:class:: template <typename T> ref
-
-   RAII scoped reference counting helper class
-
-   :cpp:class:`ref\<T\> <ref>` is a simple RAII wrapper class that encapsulates a
-   pointer to an instance with intrusive reference counting.
-
-   It takes care of increasing and decreasing the reference count as needed and
-   deleting the instance when the count reaches zero.
-
-   For this to work, compatible functions :cpp:func:`inc_ref()` and
-   :cpp:func:`dec_ref()` must be defined before including the file
-   ``nanobind/intrusive/ref.h``. Default implementations for subclasses of the
-   type :cpp:class:`intrusive_base` are already provided as part of the file
-   ``counter.h``.
-
-   .. cpp:function:: ref() = default
-
-      Create a null reference
-
-   .. cpp:function:: ref(T * ptr)
-
-      Create a reference from a pointer. Increases the reference count of the
-      object (if not ``nullptr``).
-
-   .. cpp:function:: ref(const ref &r)
-
-      Copy a reference. Increase the reference count of the object (if not
-      ``nullptr``).
-
-   .. cpp:function:: ref(ref &&r) noexcept
-
-      Move a reference. Object reference counts are unaffected by this operation.
-
-   .. cpp:function:: ~ref()
-
-      Destroy a reference. Decreases the reference count of the object (if not
-      ``nullptr``).
-
-   .. cpp:function:: ref& operator=(ref &&r) noexcept
-
-      Move-assign another reference into this one.
-
-   .. cpp:function:: ref& operator=(const ref &r)
-
-      Copy-assign another reference into this one.
-
-   .. cpp:function:: ref& operator=(const T * ptr)
-
-      Overwrite this reference with a pointer to another object
-
-   .. cpp:function:: void reset()
-
-      Clear the reference and reduces the reference count of the object (if not
-      ``nullptr``)
-
-   .. cpp:function:: bool operator==(const ref &r) const
-
-      Compare this reference with another reference (pointer equality)
-
-   .. cpp:function:: bool operator!=(const ref &r) const
-
-      Compare this reference with another reference (pointer inequality)
-
-   .. cpp:function:: bool operator==(const T * ptr) const
-
-      Compare this reference with another object (pointer equality)
-
-   .. cpp:function:: bool operator!=(const T * ptr) const
-
-      Compare this reference with another object (pointer inequality)
-
-   .. cpp:function:: T * operator->()
-
-      Access the object referenced by this reference
-
-   .. cpp:function:: const T * operator->() const
-
-      Access the object referenced by this reference (const version)
-
-   .. cpp:function:: T& operator*()
-
-      Return a C++ reference to the referenced object
-
-   .. cpp:function:: const T& operator*() const
-
-      Return a C++ reference to the referenced object (const version)
-
-   .. cpp:function:: T* get()
-
-      Return a C++ pointer to the referenced object
-
-   .. cpp:function:: const T* get() const
-
-      Return a C++ pointer to the referenced object (const version)
-
-Typing
-------
-
-The following functions for typing-related functionality require an additional
-include directive:
-
-.. code-block:: cpp
-
-   #include <nanobind/typing.h>
-
-.. cpp:function:: template <typename... Args> object type_var(Args&&... args)
-
-   Create a `type variable
-   <https://docs.python.org/3/library/typing.html#typing.TypeVar>`__ (i.e., an
-   instance of ``typing.TypeVar``). All arguments of the original Python
-   construction are supported, e.g.:
-
-   .. code-block:: cpp
-
-        m.attr("T") = nb::type_var("T",
-                                   "contravariant"_a = true,
-                                   "covariant"_a = false,
-                                   "bound"_a = nb::type<MyClass>());
-
-
-.. cpp:function:: template <typename... Args> object type_var_tuple(Args&&... args)
-
-   Analogousto :cpp:func:`type_var`, create a `type variable tuple
-   <https://docs.python.org/3/library/typing.html#typing.TypeVarTuple>`__
-   (i.e., an instance of ``typing.TypeVarTuple``).
-
-.. cpp:function:: object any_type()
-
-   Convenience wrapper, which returns ``typing.Any``.
diff --git a/src/nanobind/docs/basics.rst b/src/nanobind/docs/basics.rst
deleted file mode 100644
index 0deafe5..0000000
--- a/src/nanobind/docs/basics.rst
+++ /dev/null
@@ -1,481 +0,0 @@
-.. _basics:
-
-.. cpp:namespace:: nanobind
-
-Creating your first extension
-#############################
-
-This section assumes that you have followed the instructions to :ref:`install
-<installing>` nanobind and set up a basic :ref:`build system <building>`.
-
-We are now ready to define a first basic extension that wraps a function
-to add two numbers. Create a new file ``my_ext.cpp`` with the following
-contents (the meaning of this code will be explained shortly):
-
-.. code-block:: cpp
-
-   #include <nanobind/nanobind.h>
-
-   int add(int a, int b) { return a + b; }
-
-   NB_MODULE(my_ext, m) {
-       m.def("add", &add);
-   }
-
-Afterwards, you should be able to compile and run the extension.
-
-Building using CMake
---------------------
-
-Launch ``cmake`` in the project directory to set up a build system that will
-write all output into a separate ``build`` subdirectory.
-
-.. code-block:: bash
-
-   cmake -S . -B build
-
-.. note::
-
-   If this step fails with an error message saying that Python cannot be
-   found, you will need to install a suitable Python 3 development package.
-
-   For example, on Ubuntu you would run:
-
-   .. code-block:: bash
-
-       apt install libpython3-dev
-
-   On Windows, you we recommend downloading and running one of the `installers
-   <https://www.python.org/downloads>`_ provided by the Python foundation.
-
-.. note::
-
-   If you have multiple versions of Python on your system, the CMake build
-   system may not find the specific version you had in mind. This is
-   problematic: extension built for one version of Python usually won't run on
-   another version. You can provide a hint to the build system to help it find
-   a specific version.
-
-   In this case, delete the ``build`` folder (if you already created one) and
-   re-run `cmake` while specifying the command line parameter ``-DPython_EXECUTABLE=<path to python executable>``.
-
-   .. code-block:: bash
-
-      rm -Rf build
-      cmake -S . -B build -DPython_EXECUTABLE=<path to python executable>
-
-Assuming the ``cmake`` ran without issues, you can now compile the extension using
-the following command:
-
-.. code-block:: bash
-
-   cmake --build build
-
-Finally, navigate into the ``build`` directory and launch an interactive Python
-session:
-
-.. code-block:: bash
-
-   cd build
-   python3
-
-(The default build output directory is different on Windows: use ``cd build\Debug`` and ``python`` instead of the above.)
-
-You should be able to import the extension and call the newly defined function ``my_ext.add()``.
-
-.. code-block:: pycon
-
-   Python 3.11.1 (main, Dec 23 2022, 09:28:24) [Clang 14.0.0 (clang-1400.0.29.202)] on darwin
-   Type "help", "copyright", "credits" or "license" for more information.
-   >>> import my_ext
-   >>> my_ext.add(1, 2)
-   3
-
-
-Binding functions
------------------
-
-Let's step through the example binding code to understand what each line does.
-The directive on the first line includes the core parts of nanobind:
-
-.. code-block:: cpp
-
-    #include <nanobind/nanobind.h>
-
-nanobind also provides many optional add-on components that are aren't
-included by default. They are discussed throughout this documentation along
-with pointers to the header files that must be included when using them.
-
-Next is the function to be exposed in Python, followed by the
-mysterious-looking :c:macro:`NB_MODULE` macro.
-
-.. code-block:: cpp
-
-   int add(int a, int b) { return a + b; }
-
-   NB_MODULE(my_ext, m) {
-       m.def("add", &add);
-   }
-
-:c:macro:`NB_MODULE(my_ext, m) <NB_MODULE>` declares the extension with the
-name ``my_ext``. This name **must** match the extension name provided to the
-``nanobind_add_module()`` function in the CMake build system---otherwise,
-importing the extension will fail with an obscure error about a missing
-symbol. The second argument (``m``) names a variable of
-type :cpp:class:`nanobind::module_` that represents the created module.
-
-The part within curly braces (``{``, ``}``) consists of a sequence of
-statements that initialize the desired function and class bindings. It is best
-thought of as the ``main()`` function that will run when a user imports the
-extension into a running Python session.
-
-In this case, there is only one binding declaration that wraps the ``add``
-referenced using the ampersand (``&``) operator. nanobind determines the
-function's type signature and generates the necessary binding code. All of
-this happens automatically at compile time.
-
-.. note::
-
-    Notice how little code was needed to expose our function to Python: all
-    details regarding the function’s parameters and return value were
-    automatically inferred using template metaprogramming. This overall
-    approach and the used syntax go back to `Boost.Python
-    <https://github.com/boostorg/python>`_, though the implementation in
-    nanobind is very different.
-
-.. _keyword_and_default_args:
-
-Keyword and default arguments
------------------------------
-
-There are limits to what nanobind can determine at compile time. For example,
-the argument names were lost and calling ``add()`` in Python using keyword
-arguments fails:
-
-.. code-block:: pycon
-
-   >>> my_ext.add(a=1, b=2)
-   TypeError: add(): incompatible function arguments. The following argument types are supported:
-       1. add(arg0: int, arg1: int, /) -> int
-
-   Invoked with types: kwargs = { a: int, b: int }
-
-Let's improve the bindings to fix this. We will also add a docstring and a
-default ``b`` argument so that ``add()`` increments when only one value is
-provided. The modified binding code looks as follows:
-
-.. code-block:: cpp
-
-   #include <nanobind/nanobind.h>
-
-   namespace nb = nanobind;
-   using namespace nb::literals;
-
-   int add(int a, int b = 1) { return a + b; }
-
-   NB_MODULE(my_ext, m) {
-       m.def("add", &add, "a"_a, "b"_a = 1,
-             "This function adds two numbers and increments if only one is provided.");
-   }
-
-Let's go through all of the changed lines. The first sets up a short
-namespace alias named ``nb``:
-
-.. code-block:: cpp
-
-   namespace nb = nanobind;
-
-This is convenient because binding code usually ends up referencing many
-classes and functions from this namespace. The subsequent ``using``
-declaration is optional and enables a convenient syntax for annotating
-function arguments:
-
-.. code-block:: cpp
-
-   using namespace nb::literals;
-
-Without it, you would have to change every occurrence of the pattern ``"..."_a``
-to the more verbose ``nb::arg("...")``.
-
-The function binding declaration includes several changes. It is common to pile
-on a few attributes and modifiers in :cpp:func:`.def(...) <module_::def()>`
-binding declarations, which can be specified in any order.
-
-.. code-block:: cpp
-
-   m.def("add", &add, "a"_a, "b"_a = 1,
-         "This function adds two numbers and increments if only one is provided.");
-
-The string at the end is a `docstring <https://peps.python.org/pep-0257/>`_
-that will later show up in generated documentation. The argument annotations
-(``"a"_a, "b"_a``) associate parameters with names for keyword-based
-argument passing.
-
-Besides argument names, nanobind also cannot infer *default arguments*---you
-*must repeat them* in the binding declaration. In the above snippet, the
-``"b"_a = 1`` annotation informs nanobind about the value of the default
-argument.
-
-Exporting values
-----------------
-
-To export a value, use the :cpp:func:`attr() <nanobind::detail::api::attr>`
-function to register it in the module as shown below. Bound classes and
-built-in types are automatically converted when they are assigned in this
-way.
-
-.. code-block:: cpp
-
-    m.attr("the_answer") = 42;
-
-.. _docstrings:
-
-Docstrings
-----------
-
-Let's add one more bit of flourish by assigning a docstring to the extension
-module itself. Include the following line anywhere in the body of the
-``NB_MODULE() {...}`` declaration:
-
-.. code-block:: cpp
-
-    m.doc() = "A simple example python extension";
-
-After recompiling the extension, you should be able to view the associated
-documentation using the ``help()`` builtin or the ``?`` operator in
-IPython.
-
-.. code-block:: pycon
-
-   >>> import my_ext
-   >>> help(my_ext)
-
-   Help on module my_ext:
-
-   NAME
-       my_ext - A simple example python extension
-
-   DATA
-       add = <nanobind.nb_func object>
-           add(a: int, b: int = 1) -> int
-
-           This function adds two numbers and increments if only one is provided
-
-       the_answer = 42
-
-   FILE
-       /Users/wjakob/my_ext/my_ext.cpython-311-darwin.so
-
-The automatically generated documentation covers functions, classes,
-parameter and return value type information, argument names, and default
-arguments.
-
-
-.. _binding_types:
-
-Binding a custom type
----------------------
-
-Let's now turn to an object oriented example. We will create bindings for a
-simple C++ type named ``Dog`` defined as follows:
-
-.. code-block:: cpp
-
-   #include <string>
-
-   struct Dog {
-       std::string name;
-
-       std::string bark() const {
-           return name + ": woof!";
-       }
-   };
-
-The ``Dog`` bindings look as follows:
-
-.. code-block:: cpp
-
-   #include <nanobind/nanobind.h>
-   #include <nanobind/stl/string.h>
-
-   namespace nb = nanobind;
-
-   NB_MODULE(my_ext, m) {
-       nb::class_<Dog>(m, "Dog")
-           .def(nb::init<>())
-           .def(nb::init<const std::string &>())
-           .def("bark", &Dog::bark)
-           .def_rw("name", &Dog::name);
-   }
-
-Let's look at selected lines of this example, starting with the added include directive:
-
-.. code-block:: cpp
-
-   #include <nanobind/stl/string.h>
-
-nanobind has a minimal core and initially doesn't know how to deal with STL
-types like ``std::string``. This line imports a *type caster* that realizes a
-bidirectional conversion (C++ ``std::string`` ↔ Python ``str``) to make the
-example usable. An upcoming :ref:`documentation section <type_casters>` will
-provide more detail on type casters and other alternatives.
-
-The class binding declaration :class:`nb::class_\<T\>() <class_>` supports both
-``class`` and ``struct``-style data structures.
-
-.. code-block:: cpp
-
-   nb::class_<Dog>(m, "Dog")
-
-Here, it associates the C++ type ``Dog`` with a new Python type named ``"Dog"``
-and installs it in the :cpp:class:`nb::module_ <module_>` ``m``.
-
-Initially, this type is completely empty---it has no members and cannot be
-instantiated. The subsequent chain of binding declarations binds two
-constructor overloads (via :cpp:class:`nb::init\<...\>() <init>`), a method,
-and the mutable ``name`` field (via :cpp:func:`.def_rw(..)
-<class_::def_rw>`, where ``rw`` stands for read/write access).
-
-.. code-block:: cpp
-
-   .def(nb::init<>())
-   .def(nb::init<const std::string &>())
-   .def("bark", &Dog::bark)
-   .def_rw("name", &Dog::name);
-
-An interactive Python session demonstrating this example is shown below:
-
-.. code-block:: pycon
-
-   Python 3.11.1 (main, Dec 23 2022, 09:28:24) [Clang 14.0.0 (clang-1400.0.29.202)] on darwin
-   Type "help", "copyright", "credits" or "license" for more information.
-   >>> import my_ext
-   >>> d = my_ext.Dog('Max')
-   >>> print(d)
-   <my_ext.Dog object at 0x1044540f0>
-   >>> d.name
-   'Max'
-   >>> d.name = 'Charlie'
-   >>> d.bark()
-   'Charlie: woof!'
-
-The example showed how to bind constructors, methods, and mutable fields. Many
-other things can be bound using analogous :cpp:class:`nb::class_\<...\>
-<class_>` methods:
-
-.. list-table::
-  :widths: 40 60
-  :header-rows: 1
-
-  * - Type
-    - Method
-  * - Methods & constructors
-    - :cpp:func:`.def() <class_::def>`
-  * - Fields
-    - :cpp:func:`.def_ro() <class_::def_ro>`,
-      :cpp:func:`.def_rw() <class_::def_rw>`
-  * - Properties
-    - :cpp:func:`.def_prop_ro() <class_::def_prop_ro>`,
-      :cpp:func:`.def_prop_rw() <class_::def_prop_rw>`
-  * - Static methods
-    - :cpp:func:`.def_static() <class_::def_static>`
-  * - Static fields
-    - :cpp:func:`.def_ro_static() <class_::def_ro_static>`,
-      :cpp:func:`.def_rw_static() <class_::def_rw_static>`
-  * - Static properties
-    - :cpp:func:`.def_prop_ro_static() <class_::def_prop_ro_static>`,
-      :cpp:func:`.def_prop_rw_static() <class_::def_prop_rw_static>`
-
-.. note::
-
-    All of these binding declarations support :ref:`docstrings <docstrings>`,
-    :ref:`keyword, and default argument <keyword_and_default_args>` annotations
-    as before.
-
-.. _binding_lambdas:
-
-Binding lambda functions
-------------------------
-
-Note how ``print(d)`` produced a rather useless summary in the example above:
-
-.. code-block:: pycon
-
-    >>> print(d)
-    <my_ext.Dog object at 0x1044540f0>
-
-To address this, we can add a special Python method named ``__repr__`` that
-returns a human-readable summary. Unfortunately, a corresponding function with
-such functionality does not currently exist in the C++ type, and it would be
-nice if we did not have to modify it. We can bind a *lambda function* to
-achieve both goals:
-
-.. code-block:: cpp
-
-   nb::class_<Dog>(m, "Dog")
-       // ... skipped ...
-       .def("__repr__",
-            [](const Dog &p) { return "<my_ext.Dog named '" + p.name + "'>"; });
-
-nanobind supports both stateless [#f1]_ and stateful lambda closures.
-
-Higher order functions
-----------------------
-
-nanobind's support for higher-order functions [#f2]_ further blurs the language
-boundary. The snippet below extends the ``Dog`` class with higher-order
-function ``bark_later()`` that calls :cpp:func:`nb::cpp_function()
-<cpp_function>` to convert and return a *stateful* C++ lambda function
-(``callback``) as a Python function object.
-
-.. code-block:: cpp
-
-   nb::class_<Dog>(m, "Dog")
-       // ... skipped ...
-       .def("bark_later", [](const Dog &p) {
-           auto callback = [name = p.name] {
-               nb::print(nb::str("{}: woof!").format(name));
-           };
-           return nb::cpp_function(callback);
-       });
-
-The lambda function captures the ``Dog::name()`` property (a C++
-``std::string``) and in turn calls Python functions (:cpp:func:`nb::print()
-<print>`, :cpp:func:`nb::str::format() <str::format>`) to print onto the
-console. Here is an example use of the binding in Python:
-
-.. code-block:: pycon
-
-   >>> f = d.bark_later()
-   >>> f
-   <nanobind.nb_func object at 0x10537c140>
-   >>> f()
-   Charlie: woof!
-
-Wrap-up
--------
-
-This concludes the basic part of the documentation, which provided a first
-taste of nanobind and typical steps needed to create a custom extension.
-
-The upcoming intermediate-level material covers performance and
-safety-critical points:
-
-- C++ and Python can exchange information in various different ways. 
-
-  *Which one is best for a particular task?*
-
-- A bound object can simultaneously exist in both C++ and Python.
-
-  *Who owns it?*
-  *When is it safe to delete it?*
-
-Following these topics, the documentation revisits function and class
-bindings in full detail.
-
-.. [#f1] Stateless closures are those with an empty pair of brackets ``[]`` as
-   the capture object.
-
-.. [#f2] Higher-order functions are functions that take functions as arguments
-   and/or return them.
-
diff --git a/src/nanobind/docs/bazel.rst b/src/nanobind/docs/bazel.rst
deleted file mode 100644
index 40172a8..0000000
--- a/src/nanobind/docs/bazel.rst
+++ /dev/null
@@ -1,198 +0,0 @@
-.. _bazel:
-
-Building extensions using Bazel
-===============================
-
-If you prefer the Bazel build system to CMake, you can build extensions using
-the `nanobind-bazel <https://github.com/nicholasjng/nanobind-bazel>`__ project.
-
-.. note::
-
-    This project is a community contribution maintained by
-    `Nicholas Junge <https://github.com/nicholasjng>`__, please report issues
-    directly in the nanobind-bazel repository linked above.
-
-.. _bazel-setup:
-
-Adding nanobind-bazel to your Bazel project
--------------------------------------------
-
-To use nanobind-bazel in your project, you need to add it to your project's
-dependency graph. Using bzlmod, the de-facto dependency management system
-in Bazel starting with version 7.0, you can simply specify it as a ``bazel_dep``
-in your MODULE.bazel file:
-
-.. code-block:: python
-
-    # Place this in your MODULE.bazel file.
-    # The major version of nanobind-bazel is equal to the version
-    # of the internally used nanobind.
-    # In this case, we are building bindings with nanobind v2.7.0.
-    bazel_dep(name = "nanobind_bazel", version = "2.7.0")
-
-To instead use a development version from GitHub, you can declare the
-dependency as a ``git_override()`` in your MODULE.bazel:
-
-.. code-block:: python
-
-    # MODULE.bazel
-    bazel_dep(name = "nanobind_bazel", version = "")
-    git_override(
-        module_name = "nanobind_bazel",
-        commit = COMMIT_SHA, # replace this with the actual commit you want.
-        remote = "https://github.com/nicholasjng/nanobind-bazel",
-    )
-
-In local development scenarios, you can clone nanobind-bazel to your machine,
-and then declare it as a ``local_path_override()`` dependency:
-
-.. code-block:: python
-
-    # MODULE.bazel
-    bazel_dep(name = "nanobind_bazel", version = "")
-    local_path_override(
-        module_name = "nanobind_bazel",
-        path = "/path/to/nanobind-bazel/", # replace this with the actual path.
-    )
-
-.. note::
-
-    At minimum, Bazel version 7.0.0 is required to use nanobind-bazel.
-
-
-.. _bazel-build:
-
-Declaring and building nanobind extension targets
--------------------------------------------------
-
-The main tool to build nanobind C++ extensions for your Python bindings is the
-:py:func:`nanobind_extension` rule.
-
-Like all public nanobind-bazel APIs, it resides in the ``build_defs`` submodule.
-To import it into a BUILD file, use the builtin ``load`` command:
-
-.. code-block:: python
-
-    # In a BUILD file, e.g. my_project/BUILD
-    load("@nanobind_bazel//:build_defs.bzl", "nanobind_extension")
-
-    nanobind_extension(
-        name = "my_ext",
-        srcs = ["my_ext.cpp"],
-    )
-
-In this short snippet, a nanobind Python module called ``my_ext`` is declared,
-with its contents coming from the C++ source file of the same name.
-Conveniently, only the actual module name must be declared - its place in your
-Python project hierarchy is automatically determined by the location of your
-build file.
-
-For a comprehensive list of all available build rules in nanobind-bazel, refer
-to the rules section in the :ref:`nanobind-bazel API reference <rules-bazel>`.
-
-.. _bazel-stable-abi:
-
-Building against the stable ABI
--------------------------------
-
-As in nanobind's CMake config, you can build bindings targeting Python's
-stable ABI, starting from version 3.12. To do this, specify the target
-version using the ``@nanobind_bazel//:py-limited-api`` flag. For example,
-to build extensions against the CPython 3.12 stable ABI, pass the option
-``@nanobind_bazel//:py-limited-api="cp312"`` to your ``bazel build`` command.
-
-For more information about available flags, refer to the flags section in the
-:ref:`nanobind-bazel API reference <flags-bazel>`.
-
-Generating stubs for built extensions
--------------------------------------
-
-You can also use Bazel to generate stubs for an extension directly at build
-time with the ``nanobind_stubgen`` macro. Here is an example of a nanobind
-extension with a stub file generation target declared directly alongside it:
-
-.. code-block:: python
-
-    # Same as before in a BUILD file
-    load(
-        "@nanobind_bazel//:build_defs.bzl",
-        "nanobind_extension",
-        "nanobind_stubgen",
-    )
-
-    nanobind_extension(
-        name = "my_ext",
-        srcs = ["my_ext.cpp"],
-    )
-
-    nanobind_stubgen(
-        name = "my_ext_stubgen",
-        module = ":my_ext",
-    )
-
-You can then generate stubs on an extension by invoking
-``bazel run //my_project:my_ext_stubgen``. Note that this requires actually
-running the target instead of only building it via ``bazel build``, since a
-Python script needs to be executed for stub generation.
-
-Naturally, since stub generation relies on the given shared object files, the
-actual extensions are built in the process before invocation of the stub
-generation script.
-
-Building extensions for free-threaded Python
---------------------------------------------
-
-Starting from CPython 3.13, bindings extensions can be built for a free-threaded
-CPython interpreter. This requires two things: First, an eligible toolchain must
-be defined in your MODULE.bazel file, e.g. like so:
-
-.. code-block:: python
-
-    bazel_dep(name = "rules_python", version = "1.0.0")
-
-    python = use_extension("@rules_python//python/extensions:python.bzl", "python")
-    python.toolchain(python_version = "3.13")
-
-And secondly, the ``@rules_python//python/config_settings:py_freethreaded`` flag must
-be set to "yes" when building your nanobind extension target, e.g. as
-``bazel build //path/to:my_ext --@rules_python//python/config_settings:py_freethreaded=yes``.
-
-Then, ``rules_python`` will bootstrap a free-threaded version of your target interpreter,
-and ``nanobind_bazel`` will define the ``NB_FREE_THREADED`` macro for the libnanobind
-build, indicating that nanobind should be built with free-threading support.
-For a comprehensive overview on nanobind with free-threaded Python, refer to the
-:ref:`free-threading documentation <free-threaded>`.
-
-nanobind-bazel and Python packaging
------------------------------------
-
-Unlike CMake, which has a variety of projects supporting PEP517-style
-Python package builds, Bazel does not currently have a fully featured
-PEP517-compliant packaging backend available.
-
-To produce Python wheels containing bindings built with nanobind-bazel,
-you have various options, with two of the most prominent strategies being
-
-1. Using a wheel builder script with the facilities provided by a Bazel
-support package for Python, such as ``py_binary`` or ``py_wheel`` from
-`rules_python <https://github.com/bazelbuild/rules_python/>`__. This is
-a lower-level, more complex workflow, but it provides more granular
-control of how your Python wheel is built.
-
-2. Building all extensions with Bazel through a subprocess, by extending
-a Python build backend such as ``setuptools``. This allows you to stick to
-those well-established build tools, like ``setuptools``, at the expense
-of more boilerplate Python code and slower build times, since Bazel is
-only invoked to build the bindings extensions (and their dependencies).
-
-In general, while the latter method requires less setup and customization,
-its drawbacks weigh more severely for large projects with more extensions.
-
-.. note::
-
-    An example of packaging with the mentioned setuptools customization method
-    can be found in the
-    `nanobind_example <https://github.com/wjakob/nanobind_example/tree/bazel>`__
-    repository, specifically, on the ``bazel`` branch. It also contains an
-    example of how to customize flag names and set default build options across
-    platforms with a ``.bazelrc`` file.
diff --git a/src/nanobind/docs/benchmark.rst b/src/nanobind/docs/benchmark.rst
deleted file mode 100644
index 92fe88b..0000000
--- a/src/nanobind/docs/benchmark.rst
+++ /dev/null
@@ -1,174 +0,0 @@
-.. _benchmarks:
-
-Benchmarks
-==========
-
-.. note::
-
-   **TL;DR**: nanobind bindings compile up to **~4× faster** and produce **~5×
-   smaller** binaries with **~10× lower** runtime overheads compared to
-   pybind11.
-
-   nanobind also outperforms Cython in important metrics (**3-12×** binary size
-   reduction, **1.6-4×** compilation time reduction, similar runtime performance).
-
-The following experiments analyze the performance of a large function-heavy
-(``func``) and class-heavy (``class``) binding microbenchmark compiled using
-`Boost.Python <https://github.com/boostorg/python>`__, `Cython
-<https://cython.org>`__, `pybind11 <https://github.com/pybind/pybind11>`__. The
-``pybind11 + smart_holder`` results below refer to a `special branch
-<https://github.com/pybind/pybind11/tree/smart_holder>`__ that addresses
-long-standing issues related to holder types in pybind11.
-
-Each experiment is shown twice: light gray ``[debug]`` columns provide data for
-a debug build, and ``[opt]`` shows a size-optimized build that is representative
-of a deployment scenario. The former is included to show that nanobind
-performance is also good during a typical development workflow.
-
-A comparison with `cppyy <https://cppyy.readthedocs.io/en/latest/>`_, which
-uses dynamic compilation, is also shown later. Details on the experimental
-setup can be found :ref:`below <benchmark_details>`.
-
-Compilation time
-----------------
-
-The first plot contrasts the compilation time, where “*number* ×”
-annotations denote the amount of time spent relative to nanobind. As
-shown below, nanobind achieves a ~\ **2.7-4.4× improvement**
-compared to pybind11 and a **1.6-4.4x improvement** compared to Cython.
-
-
-.. image:: images/times.svg
-   :width: 800
-   :alt: Compilation time benchmark
-
-Binary size
------------
-
-The extremely large size of generated binaries has been a persistent problem of
-many prior binding libraries. nanobind significantly improves this metric in
-size-optimized builds. There is a ~\ **11× improvement** compared to
-Boost.Python, a **3-5× improvement** compared to pybind11, and a **3-12×
-improvement** compared to Cython.
-
-.. image:: images/sizes.svg
-   :width: 800
-   :alt: Compilation size benchmark
-
-Performance
------------
-
-The last experiment compares the runtime performance overheads by calling a
-bound function many times in a loop. Here, it is also interesting to
-additionally compare against `cppyy
-<https://cppyy.readthedocs.io/en/latest/>`__ (green bar) and a pure Python
-implementation that runs bytecode without binding overheads (hatched gray bar).
-The `smart_holder` branch of pybind11 is not explicitly listed since its
-runtime performance matches the base version.
-
-.. image:: images/perf.svg
-   :width: 850
-   :alt: Runtime performance benchmark
-
-This data shows that the overhead of calling a nanobind function is
-lower than that of an equivalent function call done within CPython. The
-functions benchmarked here don’t perform CPU-intensive work, so this
-this mainly measures the overheads of performing a function call,
-boxing/unboxing arguments and return values, etc.
-
-The difference to pybind11 is **significant**: a ~\ **3× improvement**
-for simple functions, and an **~10× improvement** when classes are being
-passed around. Complexities in pybind11 related to overload
-resolution, multiple inheritance, and holders are the main reasons for
-this difference. Those features were either simplified or completely
-removed in nanobind.
-
-The runtime performance of Cython and nanobind are similar (Cython leads in one
-experiment and trails in another one). Cython generates specialized binding
-code for every function and class, which is highly redundant (long compile
-times, large binaries) but can also be beneficial for performance.
-
-Finally, there is a **~1.6-2.1× improvement** in both experiments compared to
-cppyy (please ignore the two ``[debug]`` columns—I did not feel comfortable
-adjusting the JIT compilation flags; all cppyy bindings are therefore
-optimized.)
-
-Discussion
-----------
-
-Performance improvements compared to pybind11 are the result of optimizations
-discussed in the :ref:`previous section <perf_improvements>`.
-
-`cppyy <https://cppyy.readthedocs.io/en/latest/>`_ also achieves good
-performance in the comparison above. It is based on dynamic parsing of C++ code
-and *just-in-time* (JIT) compilation of bindings via the LLVM compiler
-infrastructure. The authors of cppyy report that their tool produces bindings
-with much lower overheads compared to pybind11, and the above plots show that
-this is indeed true.
-
-While nanobind retakes the performance lead, there are other qualitative
-factors make these two tools appropriate to different audiences: cppyy has its
-origin in CERN's ROOT mega-project and must be highly dynamic to work with that
-codebase: it can parse header files to generate bindings as needed. cppyy works
-particularly well together with PyPy and can avoid boxing/unboxing overheads
-with this combination. The main downside of cppyy is that it depends on
-Cling/Clang/LLVM that must be deployed on the user's side and then run there.
-There isn't a way of pre-generating bindings and then shipping just the output
-of this process.
-
-nanobind is relatively static in comparison: you must tell it which functions
-to expose via binding declarations. These declarations offer a high degree of
-flexibility that users will typically use to create bindings that feel
-*pythonic*. At compile-time, those declarations turn into a sequence of CPython
-API calls, which produces self-contained bindings that are easy to redistribute
-via `PyPI <https://pypi.org>`_ or elsewhere. Tools like `cibuildwheel
-<https://cibuildwheel.readthedocs.io/en/stable/>`_ and `scikit-build
-<https://scikit-build.readthedocs.io/en/latest/index.html>`_ can fully automate
-the process of generating *Python wheels* for each target platform. A `minimal
-example project <https://github.com/wjakob/nanobind_example>`_ shows how to do
-this automatically via `GitHub Actions <https://github.com/features/actions>`_.
-
-.. _benchmark_details:
-
-Details
--------
-
-The microbenchmark wraps a *large* number of trivial functions that only
-perform a few additions. The objective of this is to quantify the overhead of
-bindings on compilation time, binary size, and runtime performance. The
-function-heavy benchmark (``func_*``) consists of 720 declarations of the form
-(with permuted integer types)
-
-.. code-block:: cpp
-
-   m.def("test_0050", [](uint16_t a, int64_t b, int32_t c, uint64_t d, uint32_t e, float f) {
-       return a+b+c+d+e+f;
-   });
-
-while the latter (``class_*``) does exactly the same computation but packaged
-up in ``struct``\ s with bindings.
-
-.. code-block:: cpp
-
-   struct Struct50 {
-       uint16_t a; int64_t b; int32_t c; uint64_t d; uint32_t e; float f;
-       Struct50(uint16_t a, int64_t b, int32_t c, uint64_t d, uint32_t e, float f)
-           : a(a), b(b), c(c), d(d), e(e), f(f) { }
-       float sum() const { return a+b+c+d+e+f; }
-   };
-
-   py::class_<Struct50>(m, "Struct50")
-       .def(py::init<uint16_t, int64_t, int32_t, uint64_t, uint32_t, float>())
-       .def("sum", &Struct50::sum);
-
-
-The code to generate the plots shown above is available `here
-<https://github.com/wjakob/nanobind/blob/master/docs/microbenchmark.ipynb>`_.
-
-Each test was compiled in debug mode (``debug``) and with optimizations
-(``opt``) that minimize size (i.e., ``-Os``). Benchmarking was performed on a
-AMD Ryzen 9 7950X workstation running Ubuntu 22.04.2 LTS. CPU boost was
-disabled, and all core clock frequencies were pinned. Reported timings are the
-median of five runs. Compilation used clang++ 15.0.7 with consistent compilation flags for
-all experiments (see the referenced notebook file for detail). The used package
-versions were Python 3.10.6, cppyy 1.12.13, Cython 0.29.28, and nanobind 1.2.0.
diff --git a/src/nanobind/docs/building.rst b/src/nanobind/docs/building.rst
deleted file mode 100644
index 346ef5f..0000000
--- a/src/nanobind/docs/building.rst
+++ /dev/null
@@ -1,118 +0,0 @@
-.. _building:
-
-Setting up a build system
-#########################
-
-This section assumes that you have followed the instructions to :ref:`install
-<installing>` nanobind. The easiest way to compile a nanobind-based extension
-involves a CMake-based build system. Other build systems can likely be used as
-well, but they are not officially supported.
-(The first section of the :ref:`CMake API reference <api_cmake>` mentions
-some alternatives.)
-
-Here, we will create a new package from scratch. If you already have an
-existing CMake build system, it should be straightforward to merge some of the
-following snippets into it.
-
-Preliminaries
--------------
-
-Begin by creating a new file named ``CMakeLists.txt`` in the root directory of
-your project. It should start with the following lines that declare a project
-name and tested CMake version range. The third line line searches for Python >=
-3.8 including the ``Development.Module`` component required by nanobind. The
-name of this module changed across CMake versions, hence the additional
-conditional check.
-
-.. code-block:: cmake
-
-    cmake_minimum_required(VERSION 3.15...3.27)
-    project(my_project) # Replace 'my_project' with the name of your project
-
-    if (CMAKE_VERSION VERSION_LESS 3.18)
-      set(DEV_MODULE Development)
-    else()
-      set(DEV_MODULE Development.Module)
-    endif()
-
-    find_package(Python 3.8 COMPONENTS Interpreter ${DEV_MODULE} REQUIRED)
-
-Add the following lines below. They configure CMake to perform an optimized
-*release* build by default unless another build type is specified. Without this
-addition, binding code may run slowly and produce large binaries.
-
-.. code-block:: cmake
-
-   if (NOT CMAKE_BUILD_TYPE AND NOT CMAKE_CONFIGURATION_TYPES)
-     set(CMAKE_BUILD_TYPE Release CACHE STRING "Choose the type of build." FORCE)
-     set_property(CACHE CMAKE_BUILD_TYPE PROPERTY STRINGS "Debug" "Release" "MinSizeRel" "RelWithDebInfo")
-   endif()
-
-Finding nanobind
-----------------
-
-Next, we must inform CMake about the presence of nanobind so that it can load
-the functionality needed to compile extension modules. The details of this
-step depend on *how you installed* nanobind, in the :ref:`previous section
-<installing>`.
-
-1. If you installed nanobind as a Pip or Conda package, append the following
-   lines at the end of ``CMakeLists.txt``. They query the package to determine
-   its installation path and then import it.
-
-   .. code-block:: cmake
-
-       # Detect the installed nanobind package and import it into CMake
-       execute_process(
-         COMMAND "${Python_EXECUTABLE}" -m nanobind --cmake_dir
-         OUTPUT_STRIP_TRAILING_WHITESPACE OUTPUT_VARIABLE nanobind_ROOT)
-       find_package(nanobind CONFIG REQUIRED)
-
-2. If you installed nanobind as a `Git submodule
-   <https://git-scm.com/book/en/v2/Git-Tools-Submodules>`_, append the
-   following lines at the end of ``CMakeLists.txt`` to point CMake to the
-   directory where nanobind is checked out.
-
-   .. code-block:: cmake
-
-       add_subdirectory(${CMAKE_CURRENT_SOURCE_DIR}/ext/nanobind)
-
-Building an extension
----------------------
-
-Finally, we are ready to build an extension! Append the following line at the end of
-``CMakeLists.txt``. It will compile a new extension named ``my_ext`` from the
-source code contained in the file ``my_ext.cpp``.
-
-.. code-block:: cmake
-
-   nanobind_add_module(my_ext my_ext.cpp)
-
-:cmake:command:`nanobind_add_module` resembles standard CMake commands like
-``add_executable()`` and ``add_library()``. Any number of source code and
-header files can be declared when the extension is more complex and spread out
-over multiple files.
-
-.. note::
-
-   One opinionated choice of :cmake:command:`nanobind_add_module` is that it
-   optimizes the *size* of the extension by default (i.e., ``-Os`` is passed to
-   the compiler regardless of the project-wide settings). You must specify the
-   ``NOMINSIZE`` parameter to the command to disable this behavior and, e.g.,
-   optimize extension code for speed (i.e., ``-O3``):
-
-   .. code-block:: cmake
-
-      nanobind_add_module(my_ext NOMINSIZE my_ext.cpp)
-
-   The default is chosen this way since extension code usually wraps existing
-   C++ libraries, in which the main computation takes place. Optimizing the
-   bindings for speed does not measurably improve performance, but it does make
-   the bindings *significantly* larger.
-
-   If you observe slowdowns when porting a pybind11 extension, or if your
-   extension performs significant amounts of work within the binding layer,
-   then you may want to experiment with passing the ``NOMINSIZE`` parameter.
-
-The :ref:`next section <basics>` will review the contents of example module
-implementation in ``my_ext.cpp``.
diff --git a/src/nanobind/docs/changelog.rst b/src/nanobind/docs/changelog.rst
deleted file mode 100644
index 2d64ffc..0000000
--- a/src/nanobind/docs/changelog.rst
+++ /dev/null
@@ -1,1587 +0,0 @@
-.. _changelog:
-
-.. cpp:namespace:: nanobind
-
-Changelog
-#########
-
-nanobind uses a `semantic versioning <http://semver.org>`__ policy for its API.
-It also has a separate ABI version that is *not* subject to semantic
-versioning.
-
-The ABI version is relevant whenever a type binding from one extension module
-should be visible in another nanobind-based extension module. In this
-case, both modules must use the same nanobind ABI version, or they will be
-isolated from each other. Releases that don't explicitly mention an ABI version
-below inherit that of the preceding release.
-
-Version TBD (unreleased)
-------------------------
-
-- Added :cpp:class:`nb::fallback <fallback>` wrapper type, which is a
-  :cpp:class:`nb::handle <handle>` that always requires implicit conversion
-  during casting. This is convenient when adding catch-all overloads that must
-  handle arbitrary Python objects, without interfering with implicit conversion
-  of arguments in other overloads.
-
-- The ``nanobind::literals`` namespace now includes ``_s`` to create a Python string
-  from source code literals. (PR `#1051
-  <https://github.com/wjakob/nanobind/pull/1051>`__).
-
-- Nanobind now uses multi-phase (as opposed to single-phase) initialization API
-  when registering modules. However, multi-interpreter extensions remain
-  unsupported. (PR `#1059 <https://github.com/wjakob/nanobind/pull/1059>`__).
-
-- Added :cpp:func:`nb::dict::empty() <dict::empty>`,
-  :cpp:func:`nb::list::empty() <list::empty>`, :cpp:func:`nb::set::empty()
-  <set::empty>`, and :cpp:func:`nb::tuple::empty() <tuple::empty>` convenience
-  methods.
-
-- Nanobind now uses multi-phase (as opposed to single-phase) initialization API
-  when registering modules. However, multi-interpreter extensions remain
-  unsupported. (PR `#1059 <https://github.com/wjakob/nanobind/pull/1059>`__).
-
-- Miscellaneous fixes and improvements (
-  commits
-  `d4b245 <https://github.com/wjakob/nanobind/commit/d4b245ad69f729c3d2095be4c1cb5b94810dae26>`__,
-  `667451 <https://github.com/wjakob/nanobind/commit/667451fb4566dcd7151d64d81e118f9ba194a889>`__,
-  `62fc99 <https://github.com/wjakob/nanobind/commit/62fc996018d9ea4d51af9c86cf008c2562b4eeab>`__).
-
-
-- Added :cpp:class:`nb::frozenset` that wraps the Python ``frozenset`` type.
-
-Version 2.7.0 (Apr 18, 2025)
-----------------------------
-
-- nanobind now provides a zero-copy type caster for
-  ``Eigen::Map<Eigen::SparseMatrix>``. (PRs `#1003
-  <https://github.com/wjakob/nanobind/pull/1003>`__, `#782
-  <https://github.com/wjakob/nanobind/pull/782>`__).
-
-- Made handling of return value policies in Eigen type casters more consistent
-  with the rest of nanobind. (Issue `#971
-  <https://github.com/wjakob/nanobind/issues/971>`__, commit `5cdf59
-  <https://github.com/wjakob/nanobind/commit/5cdf58984e7a8b520935c3771029fe0e87edee73>`__).
-
-- The Eigen sparse matrix caster now correctly handles ``scipy.sparse`` objects
-  with unsorted indices. (PR `#981
-  <https://github.com/wjakob/nanobind/pull/981>`__).
-
-- Nanobind's CMake stub generation command :cmake:command:`nanobind_add_stub`
-  now detects when an extension uses sanitizers (TSAN, ASAN, UBSAN). It then
-  injects the sanitizer library into the Python process ahead of time so that
-  the extension can be loaded. Previously, stub generation failed in
-  such cases. (PR `#1000 <https://github.com/wjakob/nanobind/pull/1000>`__).
-
-- The entries of stub files are now sorted in their original definition order.
-  Previously, they were alphabetically sorted, which caused issues with
-  external tooling. (PR `#938
-  <https://github.com/wjakob/nanobind/pull/938>`__).
-
-- Fixed detection and handling of imports and types in external modules in
-  stubgen that could lead to incorrect declarations in some cases. (PRs `#939
-  <https://github.com/wjakob/nanobind/pull/939>`__, `#940
-  <https://github.com/wjakob/nanobind/pull/940>`__).
-
-- The stub generator now detects method aliases and preserves this information
-  instead of duplicating the definition. (PR `#735
-  <https://github.com/wjakob/nanobind/pull/735>`__).
-
-- Corrected a flaw in the recommended implementation of ``tp_traverse`` in
-  garbage-collected bindings. (PRs `#1015
-  <https://github.com/wjakob/nanobind/pull/1015>`__).
-
-- Added support for binding functions that accept a ``std::variant<...>`` that
-  is not default-constructible (because its first alternative isn't). (PR `#987
-  <https://github.com/wjakob/nanobind/pull/987>`__).
-
-- Added support for casting const-qualified ``std::unique_ptr<T>`` values. (PR
-  `#988 <https://github.com/wjakob/nanobind/pull/988>`__).
-
-- ``nb::typed<T, ...>`` now supports construction from ``T``, making it more
-  ergonomic to return values with type annotations. (PR `#1012
-  <https://github.com/wjakob/nanobind/pull/1012>`__
-
-- Miscellaneous fixes and improvements (PRs
-  `#1014 <https://github.com/wjakob/nanobind/pull/1014>`__,
-  `#1005 <https://github.com/wjakob/nanobind/pull/1005>`__,
-  `#1004 <https://github.com/wjakob/nanobind/pull/1004>`__,
-  `#990 <https://github.com/wjakob/nanobind/pull/990>`__,
-  `#997 <https://github.com/wjakob/nanobind/pull/997>`__, commits
-  `f2b08c <https://github.com/wjakob/nanobind/commit/f2b08c936ec4b1dd06d374fef2637d89daa905f4>`__,
-  `eef931 <https://github.com/wjakob/nanobind/commit/eef93122ad49ea6ef02d645497d426a4dfc303bd>`__,
-  `f1b2f5 <https://github.com/wjakob/nanobind/commit/f1b2f579adb538671c985c9c86a878f6e82de597>`__,
-  `dbd602 <https://github.com/wjakob/nanobind/commit/dbdb602cfa00d46600e048f992cd3f81540c777d>`__,
-  `2c83fb <https://github.com/wjakob/nanobind/commit/2c83fbbbed3b82edc6491efbdc83e56f98da0db2>`__,
-  `87de84 <https://github.com/wjakob/nanobind/commit/87de84d3afad270c02099af82132240b3216ac3b>`__).
-
-Version 2.6.1 (Mar 28, 2025)
-----------------------------
-
-- nanobind assigns an ABI tag to compiled extensions and uses it to isolate
-  incompatible extensions from each other. This tag was unnecessarily
-  fine-grained, often causing isolation where an actual ABI compatibility was
-  not present. This release updates the tagging scheme to address this
-  long-standing inconvenience. (PR `#778
-  <https://github.com/wjakob/nanobind/pull/778>`__).
-
-- Added specialized function dispatchers to accelerate calls to 0 and
-  1-argument functions. (PR `#944
-  <https://github.com/wjakob/nanobind/pull/944>`__).
-
-- Improved the efficiency of :cpp:func:`nb::getattr(obj, key,
-  default) <getattr>` in cases where ``obj[key]`` does not exist. (commit
-  `bb05f5
-  <https://github.com/wjakob/nanobind/commit/bb05f5503aef9b70498302bf30bf958e8cc605c7>`__).
-
-- ABI version 16.
-
-- Miscellaneous fixes and improvements (PRs `#913
-  <https://github.com/wjakob/nanobind/pull/913>`__, `#914
-  <https://github.com/wjakob/nanobind/pull/914>`__, `#916
-  <https://github.com/wjakob/nanobind/pull/916>`__, `#931
-  <https://github.com/wjakob/nanobind/pull/931>`__, `#978
-  <https://github.com/wjakob/nanobind/pull/978>`__, commit `1595d2
-  <https://github.com/wjakob/nanobind/commit/1595d2d40717d65835ed984b06cfc2b4da0e4858>`__).
-
-Version 2.6.0 (Mar 28, 2025)
-----------------------------
-
-- This release was yanked due to a regression.
-
-Version 2.5.0 (Feb 2, 2025)
----------------------------
-
-- Added :cpp:class:`nb::def_visitor\<..\> <def_visitor>`, which can be used to
-  define your own binding logic that operates on a :cpp:class:`nb::class_\<..\>
-  <class_>` when an instance of the visitor object is passed to
-  :cpp:func:`class_::def()`. This generalizes the mechanism used by
-  :cpp:class:`init`, :cpp:class:`new_`, etc, so that you can create binding
-  abstractions that "feel like" the built-in ones. (PR `#884
-  <https://github.com/wjakob/nanobind/pull/884>`__)
-
-- Added some special forms for :cpp:class:`nb::typed\<T, Ts...\> <typed>`
-  (PR `#835 <https://github.com/wjakob/nanobind/pull/835>`__):
-
-  - ``nb::typed<nb::object, T>`` or ``nb::typed<nb::handle, T>`` produces
-    a parameter or return value that will be described like ``T`` in function
-    signatures but accepts any Python object at runtime.
-
-  - ``nb::typed<nb::callable, R(Args...)>`` produces a Python callable signature
-    ``Callable[[Args...], R]``; similarly, ``nb::typed<nb::callable, R(...)>``
-    (with a literal ellipsis) produces the Python ``Callable[..., R]``.
-
-- It is now possible to create Python subclasses of C++ classes that define
-  their constructor bindings using :cpp:struct:`nb::new_() <new_>`. Previously,
-  attempting to instantiate such a Python subclass would instead produce an
-  instance of the base C++ type. Note that it is still not possible to override
-  virtual methods in such a Python subclass, because the object returned by the
-  :cpp:struct:`new_() <new_>` constructor will generally not be an instance of
-  the alias/trampoline type. (PR `#859
-  <https://github.com/wjakob/nanobind/pull/859>`__)
-
-- Fixed the :cpp:class:`nb::int_ <int_>` constructor so that it casts to
-  an integer when invoked with a floating point argument.
-
-- Multi-level inheritance (e.g., ``A → B → C``) previously did not work on Python
-  3.12+ when a base class (e.g., ``A``) provided a trampoline implementation.
-  This is now fixed. (commit `92d9cb
-  <https://github.com/wjakob/nanobind/commit/92d9cb3d62b743a9eca2d9d9d8e5fb14a1e00a2a>`__).
-
-- A new ``NB_SUPPRESS_WARNINGS`` parameter of
-  :cmake:command:`nanobind_add_module` that marks the nanobind and Python
-  include directories as
-  `SYSTEM <https://cmake.org/cmake/help/latest/command/include_directories.html>`__
-  include directories, which suppresses any potential warning messages
-  originating there. This is mainly of relevance for projects that artificially
-  raise the warning level using flags like ``-pedantic``, ``-Wcast-qual``,
-  ``-Wsign-conversion``. (PR `#868
-  <https://github.com/wjakob/nanobind/pull/868>`__).
-
-- Fixed (benign) reference leaks that could occur when ``std::shared_ptr<T>``
-  instances were still alive at interpreter shutdown time. (commit `fb8157
-  <https://github.com/wjakob/nanobind/commit/fb815762fdb8476cfd293e3717ca41c8bb890437>`__).
-
-- The floating-point type caster now only performs value-changing narrowing
-  conversions during the implicit conversion phase. They can be entirely
-  avoided by passing the :cpp:func:`.noconvert() <arg::noconvert>` argument
-  annotation. (PR `#829 <https://github.com/wjakob/nanobind/pull/829>`__)
-
-- The ``std::complex`` type caster now only performs value-changing narrowing
-  conversions during the implicit conversion phase.  They can be entirely
-  avoided by passing the :cpp:func:`.noconvert() <arg::noconvert>` argument
-  annotation.  Also, during the implicit conversion phase, if the Python object
-  is not a complex number object but has a ``__complex__()`` method, it will be
-  called. (PR `#854 <https://github.com/wjakob/nanobind/pull/854>`__)
-
-- Fixed an overly strict check that could cause a function taking an
-  :cpp:class:`nb::ndarray\<...\> <ndarray>` to refuse specific types of
-  column-major input without implicit conversion. (PR `#847
-  <https://github.com/wjakob/nanobind/pull/847>`__, commit `b95eb7
-  <https://github.com/wjakob/nanobind/commit/b95eb755b5a651a40562002be9ca8a4c6bf0acb9>`__).
-
-Fixes for free-threaded builds
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-- Fixed a race condition in free-threaded extensions that could occur when
-  :cpp:func:`nb::make_iterator <make_iterator>` was concurrently used by
-  multiple threads. (PR `#832 <https://github.com/wjakob/nanobind/pull/832>`__).
-
-- Fixed a race condition in free-threaded extensions that could occur when
-  multiple threads access the Python object associated with the same C++
-  instance, which does not exist yet and therefore must be created. (issue
-  `#867 <https://github.com/wjakob/nanobind/issues/867>`__, PR `#887
-  <https://github.com/wjakob/nanobind/pull/887>`__).
-
-- Removed double-checked locking patterns in accesses to internal data
-  structures to ensure correct free-threaded behavior on architectures with
-  weak memory ordering such as ARM (PR `#819
-  <https://github.com/wjakob/nanobind/pull/819>`__).
-
-Version 2.4.0 (Dec 6, 2024)
----------------------------
-
-- Added a function annotation :cpp:class:`nb::call_policy\<Policy\>()
-  <call_policy>` which supports custom function wrapping logic,
-  calling ``Policy::precall()`` before the bound function and
-  ``Policy::postcall()`` after. This is a low-level interface intended
-  for advanced users. The precall and postcall hooks are able to
-  observe the Python objects forming the function arguments and return
-  value, and the precall hook can change the arguments.  See the linked
-  documentation for more details, important caveats, and an example policy.
-  (PR `#767 <https://github.com/wjakob/nanobind/pull/767>`__)
-
-- :cpp:func:`nb::make_iterator <make_iterator>` now accepts its iterator
-  arguments by value, rather than by forwarding reference, in order to
-  eliminate the hazard of storing a dangling C++ iterator reference in the
-  returned Python iterator object. (PR `#788
-  <https://github.com/wjakob/nanobind/pull/788>`__)
-
-- The ``std::variant`` type_caster now does two passes when converting from Python.
-  The first pass is done without implicit conversions. This fixes an issue where
-  ``std::variant<U, T>`` might cast a Python object wrapping a ``T`` to a ``U`` if
-  there is an implicit conversion available from ``T`` to ``U``.
-  (issue `#769 <https://github.com/wjakob/nanobind/issues/769>`__)
-
-- Restored support for constructing types with an overloaded ``__new__`` that
-  takes no arguments, which regressed with the constructor vector call
-  acceleration that was added in nanobind 2.2.0.
-  (issue `#786 <https://github.com/wjakob/nanobind/issues/786>`__)
-
-- Bindings for augmented assignment operators (as generated, for example, by
-  ``.def(nb::self += nb::self)``) now return the same object in Python in the
-  typical case where the C++ operator returns a reference to ``*this``.
-  Previously, after ``a += b``, ``a`` would be replaced with a copy.
-  (PR `#803 <https://github.com/wjakob/nanobind/pull/803>`__)
-
-- Added an overload to :cpp:func:`nb::isinstance <isinstance>` which tests if a
-  Python object is an instance of a Python class. This is in addition to the
-  existing overload, which tests if a Python object is an instance of a bound
-  C++ class. (PR `#805 <https://github.com/wjakob/nanobind/pull/805>`__).
-
-- Added support for overriding static properties, such as those defined using
-  ``def_prop_ro_static``, in subclasses. Previously this would fail with an
-  error. (PR `#806 <https://github.com/wjakob/nanobind/pull/806>`__).
-
-- Other minor fixes and improvements. (PRs `#771
-  <https://github.com/wjakob/nanobind/pull/771>`__, `#772
-  <https://github.com/wjakob/nanobind/pull/772>`__, `#748
-  <https://github.com/wjakob/nanobind/pull/748>`__, and `#753
-  <https://github.com/wjakob/nanobind/pull/753>`__)
-
-Version 2.3.0
--------------
-
-There is no version 2.3.0 due to a deployment mishap.
-
-- Added casters for `Eigen::Map<Eigen::SparseMatrix<...>` types from the `Eigen library
-  <https://eigen.tuxfamily.org/index.php?title=Main_Page>`__. (PR `#782
-  <https://github.com/wjakob/nanobind/pull/782>`_).
-
-Version 2.2.0 (October 3, 2024)
--------------------------------
-
-- nanobind can now target `free-threaded Python
-  <https://py-free-threading.github.io>`__, which replaces the `Global
-  Interpreter Lock (GIL)
-  <https://en.wikipedia.org/wiki/Global_interpreter_lock>`__ with a
-  fine-grained locking scheme (see `PEP 703
-  <https://peps.python.org/pep-0703/>`__) to better leverage multi-core
-  parallelism. A :ref:`separate documentation page <free-threaded>` explains this in
-  detail (PRs `#695 <https://github.com/wjakob/nanobind/pull/695>`__, `#720
-  <https://github.com/wjakob/nanobind/pull/720>`__)
-
-- nanobind has always used `PEP 590 vector calls
-  <https://www.python.org/dev/peps/pep-0590>`__ to efficiently dispatch calls
-  to function and method bindings, but it lacked the ability to do so for
-  constructors (e.g., ``MyType(arg1, arg2, ...)``).
-
-  Version 2.2.0 adds this missing part, which accelerates object
-  construction by up to a factor of 2×. The difference is
-  especially pronounced when passing keyword arguments to
-  constructors. Note that this improvement only applies to
-  Python version 3.9 and newer (PR
-  `#706 <https://github.com/wjakob/nanobind/pull/706>`__, commits
-  `#e24d7f <https://github.com/wjakob/nanobind/commit/e24d7f3434a6bbcc33cd8965632dc47f943fb2f8>`__,
-  `#0acecb <https://github.com/wjakob/nanobind/commit/0acecb474874f286119dce2b97b84142b6ada1a8>`__,
-  `#77f910 <https://github.com/wjakob/nanobind/commit/77f910f2a92c88f2c5512f3c375b4fe94369558e>`__,
-  `#2c96d5 <https://github.com/wjakob/nanobind/commit/2c96d5ae2fdbca030dccb1d01c457c7c5df29a0d>`__).
-
-* A new :cpp:class:`nb::is_flag() <is_flag>` annotation in
-  :cpp:class:`nb::enum_\<T\>() <enum_>` produces enumeration
-  bindings deriving from :py:class:`enum.Flag`, which enables
-  bit-wise combination using compatible operators (``&``, ``|``,
-  ``^``, and ``~``). Further combining the annotation with
-  :cpp:class:`nb::is_arithmetic() <is_flag>` creates
-  enumerations deriving from :py:class:`enum.IntFlag`. (PRs
-  `#599 <https://github.com/wjakob/nanobind/pull/599>`__,
-  `#688 <https://github.com/wjakob/nanobind/pull/688>`__,
-  `#688 <https://github.com/wjakob/nanobind/pull/688>`__,
-  `#727 <https://github.com/wjakob/nanobind/pull/727>`__,
-  `#732 <https://github.com/wjakob/nanobind/pull/732>`__)
-
-* A refactor of :cpp:class:`nb::ndarray\<...\> <ndarray>` was an opportunity to
-  realize three usability improvements:
-
-  1. The constructor used to return new nd-arrays from C++ now considers
-     all template arguments:
-
-     - **Memory order**: :cpp:class:`c_contig`, :cpp:class:`f_contig`.
-     - **Shape**: :cpp:class:`nb::shape\<3, 4, 5\> <shape>`, etc.
-     - **Device type**: :cpp:class:`nb::device::cpu <device::cpu>`,
-       :cpp:class:`nb::device::cuda <device::cuda>`, etc.
-     - **Framework**: :cpp:class:`nb::numpy <numpy>`,
-       :cpp:class:`nb::pytorch <pytorch>`, etc.
-     - **Data type**: ``uint64_t``, ``std::complex<double>``, etc.
-
-     Previously, only the **framework** and **data type** annotations were
-     taken into account when returning nd-arrays, while all of them were
-     examined when *accepting* arrays during overload resolution. This
-     inconsistency was a repeated source of confusion among users.
-
-     To give an example, the following now works out of the box without the
-     need to redundantly specify the shape and strides to the ``Array``
-     constructor below:
-
-     .. code-block:: cpp
-
-        using Array = nb::ndarray<float, nb::numpy, nb::shape<4, 4>, nb::f_contig>;
-
-        struct Matrix4f {
-            float m[4][4];
-            Array data() { return Array(m); }
-        };
-
-        nb::class_<Matrix4f>(m, "Matrix4f")
-            .def("data", &Matrix4f::data, nb::rv_policy::reference_internal);
-
-  2. A new nd-array :cpp:func:`.cast() <ndarray::cast>` method forces the
-     immediate creation of a Python object with the specified target framework
-     and return value policy, while preserving the type signature in return
-     values. This is useful to :ref:`return temporaries (e.g. stack-allocated
-     memory) <ndarray-temporaries>` from functions.
-
-  3. Added a new and more general mechanism ``nanobind::detail::dtype_traits<T>``
-     to declare custom ndarray data types like ``float16`` or ``bfloat16``. The old
-     interface (``nanobind::ndarray_traits<T>``) still exists but is deprecated
-     and will be removed in the next major release. See the :ref:`documentation
-     <ndarray-nonstandard>` for details.
-
-  There are two minor but potentially breaking changes:
-
-  1. The nd-array type caster now interprets the
-     :cpp:enumerator:`nb::rv_policy::automatic_reference
-     <rv_policy::automatic_reference>` return value policy analogously to the
-     :cpp:enumerator:`nb::rv_policy::automatic <rv_policy::automatic>`, which
-     means that it references a memory region when the user specifies an
-     ``owner``, and it otherwise copies. This makes it safe to use the
-     :cpp:func:`nb::cast() <cast>` and :cpp:func:`nb::ndarray::cast()
-     <ndarray::cast>` functions that use this policy as a default.
-
-  2. The :cpp:class:`nb::any_contig <any_contig>` memory order annotation,
-     which previously did nothing, now accepts C- or F-contiguous arrays and
-     rejects non-contiguous ones.
-
-  For further details on the nd-array changes, see PR `#721
-  <https://github.com/wjakob/nanobind/pull/721>`__, For further details on the
-  nd-array changes, see PR `#742
-  <https://github.com/wjakob/nanobind/pull/742>`__, and commit `4647ef
-  <https://github.com/wjakob/nanobind/commit/4647efcc45d96e530d41a3461cd9727656bc2ca3>`__.
-
-- The NVIDIA CUDA compiler (``nvcc``) is now explicitly supported and included
-  in nanobind's CI test suite (PR `#710
-  <https://github.com/wjakob/nanobind/pull/710>`__).
-
-* Added support for return value policy customization to the type casters of
-  ``Eigen::Ref<...>`` and ``Eigen::Map<...>`` (commit `67316e
-  <https://github.com/wjakob/nanobind/commit/67316eb88955a15e8e89a57ce9a53d8d66263287>`__).
-
-* Added the :cpp:class:`bytearray` wrapper type. (PR `#654
-  <https://github.com/wjakob/nanobind/pull/654>`__)
-
-* The :cpp:class:`nb::ellipsis <ellipsis>` type now renders as ``...`` when
-  used in :cpp:class:`nb::typed\<...\> <typed>` (PR `#705
-  <https://github.com/wjakob/nanobind/pull/705>`__).
-
-* The :cpp:class:`nb::sig("...") <sig>` annotation now supports `inline type
-  parameter lists
-  <https://docs.python.org/3/reference/compound_stmts.html#type-params>`__ such
-  as ``def first[T](l: Sequence[T]) -> T`` (PR `#704
-  <https://github.com/wjakob/nanobind/pull/704>`__).
-
-* Fixed implicit conversion of complex nd-arrays. (issue `#709
-  <https://github.com/wjakob/nanobind/issues/709>`__)
-
-* Casting via :cpp:func:`nb::cast <cast>` can now specify an owner object for
-  use with the :cpp:enumerator:`nb::rv_policy::reference_internal
-  <rv_policy::reference_internal>` return value policy (PR `#667
-  <https://github.com/wjakob/nanobind/pull/667>`__).
-
-* The ``std::optional<T>`` type caster is now implemented in such a way that it
-  can also accommodate non-STL frameworks, such as Boost, Abseil, etc. (PR
-  `#675 <https://github.com/wjakob/nanobind/pull/675>`__)
-
-* ABI version 15.
-
-* Minor fixes and improvements (PRs
-  `#703 <https://github.com/wjakob/nanobind/pull/703>`__,
-  `#724 <https://github.com/wjakob/nanobind/pull/724>`__,
-  `#723 <https://github.com/wjakob/nanobind/pull/723>`__,
-  `#722 <https://github.com/wjakob/nanobind/pull/722>`__,
-  `#715 <https://github.com/wjakob/nanobind/pull/715>`__,
-  `#696 <https://github.com/wjakob/nanobind/pull/696>`__,
-  `#693 <https://github.com/wjakob/nanobind/pull/693>`__,
-  commit `75d259 <https://github.com/wjakob/nanobind/commit/75d259c7c16db9586e5cd3aa4715e09a25e76d83>`__).
-
-Version 2.1.0 (Aug 11, 2024)
-----------------------------
-
-* Temporary workaround for a internal compiler error in version 17.10 of the MSVC
-  compiler. This workaround will be removed once fixed versions are deployed on
-  GitHub actions. (issue `#613
-  <https://github.com/wjakob/nanobind/issues/613>`__, commit `f2438b
-  <https://github.com/wjakob/nanobind/commit/f2438bb73a1673e4ad9d0c84d353a88cf54e55bf>`__).
-
-* nanobind no longer prevents casting to a C++ container of pointers ``T*``
-  where ``T`` is a type with a user-defined type caster if the caster seems to
-  operate by extracting a ``T*`` from the Python object rather than a ``T``.
-  This change was prompted by discussion `#605
-  <https://github.com/wjakob/nanobind/discussions/605>`__.
-
-* Switched nanobind wheel generation from `setuptools
-  <https://github.com/pypa/setuptools>`__ to `scikit-build-core
-  <https://github.com/scikit-build/scikit-build-core>`__ (PR `#618
-  <https://github.com/wjakob/nanobind/discussions/618>`__).
-
-* Improved handling of ``const``-ness in :cpp:class:`nb::ndarray <ndarray>` (PR
-  `#491 <https://github.com/wjakob/nanobind/discussions/491>`__).
-
-* Keyword argument annotations are now properly supported with
-  :cpp:struct:`nb::new_ <new_>`, passed in the same way they would be with
-  :cpp:struct:`nb::init <init>`. (issue `#668
-  <https://github.com/wjakob/nanobind/issues/668>`__)
-
-* Ability to use :cpp:func:`nb::cast <cast>` to create object with the
-  :cpp:enumerator:`nb::rv_policy::reference_internal
-  <rv_policy::reference_internal>` return value policy (PR `#667
-  <https://github.com/wjakob/nanobind/pull/667>`__).
-
-* Enable ``char`` type caster to produce ``'\0'`` (PR `#661
-  <https://github.com/wjakob/nanobind/pull/661>`__).
-
-* Added ``.def_static()`` member to :cpp:class:`nb::enum_ <enum_>`, which had
-  been lost in a redesign of the enumeration implementation in nanobind version
-  2.0.0. (commit `38990e
-  <https://github.com/wjakob/nanobind/commit/38990ea33bb499bcc23607147555bf5bb00dcf62>`__).
-
-* Fixes for two minor sources of memory leaks (PR
-  `#595 <https://github.com/wjakob/nanobind/pull/595>`__,
-  `#647 <https://github.com/wjakob/nanobind/pull/647>`__).
-
-* The nd-array wrapper :cpp:class:`nb::ndarray <ndarray>` now properly handles
-  CuPy arrays (`#594 <https://github.com/wjakob/nanobind/pull/594>`__).
-
-* Added :cpp:func:`nb::hash() <hash>`, a wrapper for the Python ``hash()``
-  function (commit `91fafa5
-  <https://github.com/wjakob/nanobind/commit/01fafa5b9e1de0f1ab2a9d108cd0fce20ab9568f>`__).
-
-* Various minor ``stubgen`` fixes (PRs
-  `#667 <https://github.com/wjakob/nanobind/pull/667>`__,
-  `#658 <https://github.com/wjakob/nanobind/pull/658>`__,
-  `#632 <https://github.com/wjakob/nanobind/pull/632>`__,
-  `#620 <https://github.com/wjakob/nanobind/pull/620>`__,
-  `#592 <https://github.com/wjakob/nanobind/pull/592>`__).
-
-Version 2.0.0 (May 23, 2024)
-----------------------------
-
-The 2.0.0 release of nanobind is entirely dedicated to *types* [#f1]_! The
-project has always advertised seamless Python ↔ C++ interoperability, and this
-release tries to bring a similar level of interoperability to static type
-checkers like `MyPy <https://github.com/python/mypy>`__, `PyRight
-<https://github.com/microsoft/pyright>`__, `PyType
-<https://github.com/google/pytype>`__, and editors with interactive
-autocompletion like `Visual Studio Code <https://code.visualstudio.com>`__,
-`PyCharm <https://www.jetbrains.com/pycharm/>`__, and many other `LSP
-<https://en.wikipedia.org/wiki/Language_Server_Protocol>`__-compatible IDEs.
-
-This required work on three fronts:
-
-1. **Stub generation**: the above tools all analyze Python code statically
-   without running it. Because the import mechanism of compiled extensions
-   depends the Python interpreter, these tools weren't able to inspect the
-   contents of nanobind-based extensions.
-
-   The usual solution involves writing `stubs
-   <https://typing.readthedocs.io/en/latest/source/stubs.html>`__ that expose
-   the module contents to static analysis tools. However, writing stubs by hand
-   is tedious and error-prone.
-
-   This release adds tooling to automatically extract stubs from existing
-   extensions. The process is fully integrated into the CMake-based build
-   system and explained in a :ref:`new documentation section <stubs>`.
-
-2. **Better default annotations**: once stubs were available, this revealed the
-   next problem: the default nanobind-provided function and class signatures
-   were too rudimentary, and this led to a user poor experience.
-
-   The release therefore improves many builtin type caster so that they produce
-   more accurate type signatures. For example, the STL ``std::vector<T>``
-   caster now renders as ``collections.abc.Sequence[T]`` in stubs when it is
-   used as an *input*, and ``list[T]`` when it is used as part of a return
-   value. The :cpp:func:`nb::make_*_iterator() <make_iterator>` family of
-   functions return typed iterators, etc.
-
-3. **Advanced customization**: a subset of the type signatures in larger
-   binding projects will generally require further customization. The features
-   listed below aim to enable precisely this:
-
-   * In Python, many built-in types are *generic* and can be *parameterized* (e.g.,
-     ``list[int]``). The :cpp:class:`nb::typed\<T, Ts...\> <typed>` wrapper
-     enables such parameterization within C++ (for example, the
-     ``int``-specialized list would be written as ``nb::typed<nb::list,
-     int>``). :ref:`Read more <typing_generics_parameterizing>`.
-
-   * The opposite is also possible: passing :cpp:class:`nb::is_generic()
-     <is_generic>` to the class binding constructor
-
-     .. code-block:: cpp
-
-        nb::class_<MyType>(m, "MyType", nb::is_generic())
-
-     produces a *generic* type that can be parameterized in Python (e.g.
-     ``MyType[int]``). :ref:`Read more <typing_generics_creating>`.
-
-   * The :cpp:class:`nb::sig <sig>` annotation overrides the
-     signature of a function or method, e.g.:
-
-     .. code-block:: cpp
-
-        m.def("f", &f, nb::sig("def f(x: Foo = Foo(0)) -> None"), "docstring");
-
-     Each binding of an overloaded function can be customized separately. This
-     feature can be used to add decorators or control how default arguments are
-     rendered. :ref:`Read more <typing_signature_functions>`.
-
-   * The :cpp:class:`nb::sig <sig>` annotation can also override *class
-     signatures* in generated stubs. Stubs often take certain liberties in
-     deviating somewhat from the precise type signature of the underlying
-     implementation. For example, the following annotation adds an abstract
-     base class advertising that the class implements a typed iterator.
-
-     .. code-block:: cpp
-
-        using IntVec = std::vector<int>;
-
-        nb::class_<IntVec>(m, "IntVec",
-                           nb::sig("class IntVec(collections.abc.Iterable[int])"));
-
-     Nanobind can't subclass Python types, hence this declaration is
-     technically untrue. On the flipside, such a declaration can assist static
-     checkers and improve auto-completion in visual IDEs. This is fine since
-     these tools only perform a static analysis and never import the actual
-     extension. :ref:`Read more <typing_signature_classes>`.
-
-   * The :cpp:struct:`nb::for_setter <for_setter>` and
-     :cpp:struct:`nb::for_getter <for_getter>` annotations enable passing
-     function binding annotations (e.g., signature overrides) specifically to
-     the setter or the getter part of a property.
-
-   * The :cpp:class:`nb::arg("name") <arg>` argument annotation (and
-     ``"name"_a`` shorthand) now have a :cpp:func:`.sig("signature")
-     <arg::sig>` member to control how a default value is rendered in the stubs
-     and docstrings. This provides more targeted control compared to overriding
-     the entire function signature.
-
-   * Finally, nanobind's stub generator supports :ref:`pattern files
-     <pattern_files>` containing custom stub replacement rules. This catch-all
-     solution addresses the needs of advanced binding projects, for which the
-     above list of features may still not be sufficient.
-
-Most importantly, it was possible to support these improvements with minimal
-changes to the core parts of nanobind.
-
-These release breaks API and ABI compatibility, requiring a new major version
-according to `SemVer <http://semver.org>`__. The following changes are
-noteworthy:
-
-* The :cpp:class:`nb::enum_\<T\>() <enum_>` binding declaration is now a
-  wrapper that creates either a :py:class:`enum.Enum` or :py:class:`enum.IntEnum`-derived type.
-  Previously, nanobind relied on a custom enumeration base class that was a
-  frequent source of friction for users.
-
-  This change may break code that casts entries to integers, which now only
-  works for arithmetic (:py:class:`enum.IntEnum`-derived) enumerations. Replace
-  ``int(my_enum_entry)`` with ``my_enum_entry.value`` to work around the issue.
-
-* The :cpp:func:`nb::bind_vector\<T\>() <bind_vector>` and
-  :cpp:func:`nb::bind_map\<T\>() <bind_map>` interfaces were found to be
-  severely flawed since element access (``__getitem__``) created views into the
-  internal state of the STL type that were not stable across subsequent
-  modifications.
-
-  This could lead to unexpected changes to array elements and undefined
-  behavior when the underlying storage was reallocated (i.e., use-after-free).
-
-  nanobind 2.0.0 improves these types so that they are safe to use, but this
-  means that element access must now copy by default, potentially making them
-  less convenient. The documentation of :cpp:func:`nb::bind_vector\<T\>()
-  <bind_vector>` discusses the issue at length and presents alternative
-  solutions.
-
-* The functions :cpp:func:`nb::make_iterator() <make_iterator>`,
-  :cpp:func:`nb::make_value_iterator() <make_value_iterator>` and
-  :cpp:func:`nb::make_key_iterator() <make_key_iterator>` suffer from the same
-  issue as :cpp:func:`nb::bind_vector() <bind_vector>` explained above.
-
-  nanobind 2.0.0 improves these operations so that they are safe to use, but
-  this means that iterator access must now copy by default, potentially making
-  them less convenient. The documentation of :cpp:func:`nb::make_iterator()
-  <make_iterator>` discusses the issue and presents alternative solutions.
-
-* The ``nb::raw_doc`` annotation was found to be too inflexible and was
-  removed in this version.
-
-* The ``nb::typed`` wrapper listed above actually already existed in previous
-  nanobind versions but was awkward to use, as it required the user to provide
-  a custom type formatter. This release makes the interface more convenient.
-
-* The ``nb::any`` placeholder to specify an unconstrained
-  :cpp:class:`nb::ndarray <ndarray>` axis was removed. This name was given to a
-  new wrapper type :cpp:class:`nb::any` indicating ``typing.Any``-typed
-  values.
-
-  All use of ``nb::any`` in existing code must be replaced with ``-1`` (for
-  example, ``nb::shape<3, nb::any, 4>`` → ``nb::shape<3, -1, 4>``).
-
-* :ref:`Keyword-only arguments <kw_only>` are now supported, and can be
-  indicated using the new :cpp:struct:`nb::kw_only() <kw_only>` function
-  annotation. (PR `#448 <https://github.com/wjakob/nanobind/pull/448>`__).
-
-* nanobind classes now permit overriding ``__new__``, in order to
-  support C++ singletons, caches, and other types that expose factory
-  functions rather than ordinary constructors. Read the section on
-  :ref:`customizing Python object creation <custom_new>` for more details.
-  (PR `#473 <https://github.com/wjakob/nanobind/pull/473>`__).
-
-* When binding methods on a class ``T``, nanobind will now produce a Python
-  function that expects a self argument of type ``T``. Previously, it would
-  use the type of the member pointer to determine the Python function
-  signature, which could be a base of ``T``, which would create problems
-  if nanobind did not know about that base.
-  (PR `#471 <https://github.com/wjakob/nanobind/pull/471>`__).
-
-* nanobind can now handle keyword arguments that are not interned, which avoids
-  spurious ``TypeError`` exceptions in constructs like
-  ``fn(**pickle.loads(...))``. The speed of normal function calls (which
-  generally do have interned keyword arguments) should be unaffected. (PR `#469
-  <https://github.com/wjakob/nanobind/pull/469>`__).
-
-* The ``owner=nb::handle()`` default value of the :cpp:class:`nb::ndarray
-  <ndarray>` constructor was removed since it was bug-prone. You now have to
-  specify the owner explicitly. The previous default (``nb::handle()``)
-  continues to be a valid argument.
-
-* There have been some changes to the API for type casters in order to
-  avoid undefined behavior in certain cases. (PR `#549
-  <https://github.com/wjakob/nanobind/pull/549>`__).
-
-  * Type casters that implement custom cast operators must now define a
-    member function template ``can_cast<T>()``, which returns false if
-    ``operator cast_t<T>()`` would raise an exception and true otherwise.
-    ``can_cast<T>()`` will be called only after a successful call to
-    ``from_python()``, and might not be called at all if the caller of
-    ``operator cast_t<T>()`` can cope with a raised exception.
-    (Users of the ``NB_TYPE_CASTER()`` convenience macro need not worry
-    about this; it produces cast operators that never raise exceptions,
-    and therefore provides a ``can_cast<T>()`` that always returns true.)
-
-  * Many type casters for container types (``std::vector<T>``,
-    ``std::optional<T>``, etc) implement their ``from_python()`` methods
-    by delegating to another, "inner" type caster (``T`` in these examples)
-    that is allocated on the stack inside ``from_python()``. Container casters
-    implemented in this way should make two changes in order to take advantage
-    of the new safety features:
-
-    * Wrap your ``flags`` (received as an argument of the outer caster's
-      ``from_python`` method) in ``flags_for_local_caster<T>()`` before
-      passing them to ``inner_caster.from_python()``. This allows nanobind
-      to prevent some casts that would produce dangling pointers or references.
-
-    * If ``inner_caster.from_python()`` succeeds, then also verify
-      ``inner_caster.template can_cast<T>()`` before you execute
-      ``inner_caster.operator cast_t<T>()``. A failure of
-      ``can_cast()`` should be treated the same as a failure of
-      ``from_python()``.  This avoids the possibility of an exception
-      being raised through the noexcept ``load_python()`` method,
-      which would crash the interpreter.
-
-  The previous ``cast_flags::none_disallowed`` flag has been removed;
-  it existed to avoid one particular source of exceptions from a cast
-  operator, but ``can_cast<T>()`` now handles that problem more generally.
-
-* ABI version 14.
-
-.. rubric:: Footnote
-
-.. [#f1] The author of this library had somewhat of a revelation after
-   switching to a `new editor <https://neovim.io>`__ and experiencing the
-   benefits of interactive Python code completion and type checking for the
-   first time. This experience also showed how nanobind-based extension were
-   previously a second-class citizen in this typed world, prompting the changes
-   in this release.
-
-Version 1.9.2 (Feb 23, 2024)
-----------------------------
-
-* Nanobind instances can now be :ref:`made weak-referenceable <weak_refs>` by
-  specifying the :cpp:class:`nb::is_weak_referenceable <is_weak_referenceable>` tag
-  in the :cpp:class:`nb::class_\<..\> <class_>` constructor. (PR `#335
-  <https://github.com/wjakob/nanobind/pull/335>`__, commits `fc7709
-  <https://github.com/wjakob/nanobind/commit/fc770930468313e5a69364cfd1bbdab9bc0ab208>`__,
-  `3562f6 <https://github.com/wjakob/nanobind/commit/3562f692409f29bd9cef0d9eec2ee7e26e53a055>`__).
-
-* Added a :cpp:class:`nb::bool_ <bool_>` wrapper type. (PR `#382
-  <https://github.com/wjakob/nanobind/pull/382>`__, commit `90dfba
-  <https://github.com/wjakob/nanobind/commit/90dfbaf4c8c410d819cb9be44a3455898c8c2638>`__).
-
-* Ensure that the GIL is held when releasing :cpp:class:`nb::ndarray
-  <ndarray>`. (issue `#377 <https://github.com/wjakob/nanobind/issues/377>`__,
-  commit `a968e8
-  <https://github.com/wjakob/nanobind/commit/a958e8d966f5af64c84412ca801a405042bbcc0b>`__).
-
-* :cpp:func:`nb::try_cast() <try_cast>` no longer crashes the interpreter when
-  attempting to cast a Python ``None`` to a C++ type that was bound using
-  :cpp:class:`nb::class_\<...\> <class_>`. Previously this would raise an
-  exception from the cast operator, which would result in a call to
-  ``std::terminate()`` because :cpp:func:`try_cast() <try_cast>` is declared
-  ``noexcept``. (PR `#386 <https://github.com/wjakob/nanobind/pull/386>`__).
-
-* Fixed memory corruption in a PyPy-specific code path in
-  :cpp:func:`nb::module_::def_submodule() <module_::def_submodule>` (commit
-  `21eaff
-  <https://github.com/wjakob/nanobind/commit/21eaffc263c13a5373546d8957e4152e65b1e8ac>`__).
-
-* Don't implicitly convert complex to non-complex nd-arrays. (issue `#364
-  <https://github.com/wjakob/nanobind/issues/364>`__, commit `ea2569
-  <https://github.com/wjakob/nanobind/commit/ea2569f705b9d12185eea67db399a373d37c75aa>`__).
-
-* Support for non-assignable types in the ``std::optional<T>`` type caster (PR
-  `#358 <https://github.com/wjakob/nanobind/pull/358>`__, commit `9c9b64
-  <https://github.com/wjakob/nanobind/commit/0c9b6489cd3fe8a0a5a858e364983e99b06101ce>`__).
-
-* nanobind no longer assumes that docstrings provided to function binding (of
-  type ``const char *``) have an infinite lifetime and it makes copy. (issue
-  `#393 <https://github.com/wjakob/nanobind/pull/393>`__, commit `b3b6f4
-  <https://github.com/wjakob/nanobind/commit/b3b6f44e55948986e02cdbf67e04d9cdd11c4aa4>`__).
-
-* Don't pass compiler flags if they may be unsupported by the used compiler.
-  This gets NVCC to work out of the box (that said, this change does not
-  elevate NVCC to being an *officially* supported compiler). (issue `#383
-  <https://github.com/wjakob/nanobind/pull/383>`__, commit `a307ea
-  <https://github.com/wjakob/nanobind/commit/a307eacaa9902daa190adc428168cf64007dff9e>`__).
-
-* Added a CMake install target to the nanobind build system. (PR `#356
-  <https://github.com/wjakob/nanobind/pull/356>`__, commit `6bde65
-  <https://github.com/wjakob/nanobind/commit/5bde6527dc43535982a36ffa02d41275c5e484d9>`__,
-  commit `978dbb
-  <https://github.com/wjakob/nanobind/commit/978dbb1d6aaeee7530d57cf3e8d558e099a4eec6>`__,
-  commit `f5d8de
-  <https://github.com/wjakob/nanobind/commit/f5d8defc68a5c6a79b0e64de016ee52dde6ea54d>`__).
-
-* ABI version 13.
-
-* Minor fixes and improvements.
-
-Version 1.9.0-1.9.1 (Feb 18, 2024)
-----------------------------------
-
-Releases withdrawn because of a regression. The associated changes are
-listed above in the 1.9.2 release notes.
-
-Version 1.8.0 (Nov 2, 2023)
----------------------------
-
-* nanobind now considers two C++ ``std::type_info`` instances to be equal when
-  their mangled names match. The previously used pointer comparison was fast
-  but fragile and often caused multi-part extensions to not recognize each
-  other's types. This version introduces a two-level caching scheme (search by
-  pointer, then by name) to fix such problems once and for all, while avoiding
-  the cost of constantly comparing very long mangled names. (commit `b515b1
-  <https://github.com/wjakob/nanobind/commit/b515b1f7f2f4ecc0357818e6201c94a9f4cbfdc2>`__).
-
-* Fixed casting of complex-valued constant :cpp:class:`nb::ndarray\<T\>
-  <ndarray>` instances. (PR `#338
-  <https://github.com/wjakob/nanobind/pull/338>`__, commit `ba8c7f
-  <https://github.com/wjakob/nanobind/commit/ba8c7fa55f2d0ad748cad1dd4af2b22979ebc46a>`__).
-
-* Added a type caster for ``std::nullopt_t`` (PR `#350
-  <https://github.com/wjakob/nanobind/pull/350>`__).
-
-* Added the missing C++ → Python portion of the type caster for
-  ``Eigen::Ref<..>`` (PR `#334
-  <https://github.com/wjakob/nanobind/pull/334>`__).
-
-* Minor fixes and improvements.
-
-* ABI version 12.
-
-
-Version 1.7.0 (Oct 19, 2023)
-----------------------------
-
-New features
-^^^^^^^^^^^^
-
-* The nd-array class :cpp:class:`nb::ndarray\<T\> <ndarray>` now supports
-  complex-valued ``T`` (e.g., ``std::complex<double>``). For this, the header
-  file ``nanobind/stl/complex.h`` must be included. (PR `#319
-  <https://github.com/wjakob/nanobind/pull/319>`__, commit `6cbd13
-  <https://github.com/wjakob/nanobind/commit/6cbd1387753ea8f519ac0fe2242f0a54dd670ede>`__).
-
-* Added the function :cpp:func:`nb::del() <del>`, which takes an arbitrary
-  accessor object as input and tries to delete the associated entry.
-  The C++ statement
-
-  .. code-block:: cpp
-
-     nb::del(o[key]);
-
-  is equivalent to ``del o[key]`` in Python. (commit `4dd745
-  <https://github.com/wjakob/nanobind/commit/4dd74596ac7b0f850cb0144f42a438124b91720c>`__).
-
-* Exposed several convenience functions for raising exceptions as public API:
-  :cpp:func:`nb::raise <raise>`, :cpp:func:`nb::raise_type_error
-  <raise_type_error>`, and :cpp:func:`nb::raise_python_error
-  <raise_python_error>`. (commit `0b7f3b
-  <https://github.com/wjakob/nanobind/commit/0b7f3b1d2a182bda8b95826a3f98cc3e2d0402db>`__).
-
-* Added :cpp:func:`nb::globals() <globals>`. (PR `#311
-  <https://github.com/wjakob/nanobind/pull/311>`__, commit `f0a9eb
-  <https://github.com/wjakob/nanobind/commit/f0a9ebd9cd384ac554312247526b120102563e53>`__).
-
-* The ``char*`` type caster now accepts ``nullptr`` and converts it into a
-  Python ``None`` object. (PR `#318
-  <https://github.com/wjakob/nanobind/pull/317>`__, commit `30a6ba
-  <https://github.com/wjakob/nanobind/commit/30a6bac97a89bfafad82c2c5b6ef4516c00c35d6>`__).
-
-* Added the function :cpp:func:`nb::is_alive() <is_alive>`, which returns
-  ``false`` when nanobind was destructed by Python (e.g., during interpreter
-  shutdown) making further use of the API illegal. (commit `b431d0
-  <https://github.com/wjakob/nanobind/commit/b431d040f7b0585e9901856ee6c9b72281a37fa8>`__).
-
-* Minor fixes and improvements.
-
-* ABI version 11.
-
-Bugfixes
-^^^^^^^^
-
-* The behavior of the :cpp:class:`nb::keep_alive\<Nurse, Patient\>
-  <keep_alive>` function binding annotation was changed as follows: when the
-  function call requires the implicit conversion of an argument, the lifetime
-  constraint now applies to the newly produced argument instead of the original
-  object. The change was rolled into a minor release since the former behavior
-  is arguably undesirable and dangerous. (commit `9d4b2e
-  <https://github.com/wjakob/nanobind/commit/9d4b2e317dbf32efab4ed41b6c275f9dbbbcf29f>`__).
-
-* STL type casters previously raised an exception when casting a Python container
-  containing a ``None`` element into a C++ container that was not able to
-  represent ``nullptr`` (e.g., ``std::vector<T>`` instead of
-  ``std::vector<T*>``). However, this exception was raised in a context where
-  exceptions were not allowed, causing the process to be ``abort()``-ed, which
-  is very bad. This issue is now fixed, and such conversions are refused. (PR
-  `#318 <https://github.com/wjakob/nanobind/pull/318>`__, commits `d1ad3b
-  <https://github.com/wjakob/nanobind/commit/d1ad3b91346a1566f42fdf194a3ed9c3eeec5858>`__
-  and `5f25ae
-  <https://github.com/wjakob/nanobind/commit/5f25ae0eb9691fbe03a20bcb9f604277ccc1884b>`__).
-
-* The STL sequence casters (``std::vector<T>``, etc.) now refuse to unpack
-  ``str`` and ``bytes`` objects analogous to pybind11. (commit `7e4a88
-  <https://github.com/wjakob/nanobind/commit/7e4a88b7ccc047ce34ae8ae99492d46b1acf341a>`__).
-
-
-Version 1.6.2 (Oct 3, 2023)
----------------------------
-
-* Added a missing include file used by the new intrusive reference counting
-  sample implementation from v1.6.0. (commit `31d115
-  <https://github.com/wjakob/nanobind/commit/31d115fce310475fed0f539b9446cc41ba9ff4d4>`__).
-
-Version 1.6.1 (Oct 2, 2023)
----------------------------
-
-* Added missing namespace declaration to the :cpp:class:`ref` intrusive
-  reference counting RAII helper class added in version 1.6.0. (commit `3ba352
-  <https://github.com/wjakob/nanobind/commit/3ba3522e99c8f1f4bcc7c172abd2006eeaa8eaf8>`__).
-
-
-Version 1.6.0 (Oct 2, 2023)
----------------------------
-
-New features
-^^^^^^^^^^^^
-
-* Several :cpp:class:`nb::ndarray\<..\> <ndarray>` improvements:
-
-  1. CPU loops involving nanobind nd-arrays weren't getting properly vectorized.
-     This release of nanobind adds *views*, which provide an efficient
-     abstraction that enables better code generation. See the documentation
-     section on :ref:`array views <ndarray-views>` for details.
-     (commit `8f602e
-     <https://github.com/wjakob/nanobind/commit/8f602e187b0634e1df13ba370352cf092e9042c0>`__).
-
-  2. Added support for nonstandard arithmetic types (e.g., ``__int128`` or
-     ``__fp16``) in nd-arrays. See the :ref:`documentation section
-     <ndarray-nonstandard>` for details. (commit `49eab2
-     <https://github.com/wjakob/nanobind/commit/49eab2845530f84a1f029c5c1c5541ab3c1f9adc>`__).
-
-  3. Shape constraints like :cpp:class:`nb::shape\<nb::any, nb::any, nb::any\>
-     <shape>` are tedious to write. Now, there is a shorter form:
-     :cpp:class:`nb::ndim\<3\> <ndim>`. (commit `1350a5
-     <https://github.com/wjakob/nanobind/commit/1350a5e15b28e80ffc2130a779f3b8c559ddb620>`__).
-
-  4. Added an explicit constructor that can be used to add or remove nd-array
-     constraints. (commit `a1ac207
-     <https://github.com/wjakob/nanobind/commit/a1ac207ab82206b8e50fe456f577c02270014fb3>`__).
-
-* Added the wrapper class :cpp:class:`nb::weakref <weakref>`. (commit `78887f
-  <https://github.com/wjakob/nanobind/commit/78887fc167196a7568a5cef8f8dfbbee09aa7dc4>`__).
-
-* Added the methods :cpp:func:`nb::dict::contains() <dict::contains>` and
-  :cpp:func:`nb::mapping::contains() <mapping::contains>` to the Python type
-  wrappers. (commit `64d87a
-  <https://github.com/wjakob/nanobind/commit/64d87ae01355c247123613f140cef8e71bc98fc7>`__).
-
-* Added :cpp:func:`nb::exec() <exec>` and :cpp:func:`nb:eval() <eval>`. (PR `#299
-  <https://github.com/wjakob/nanobind/pull/299>`__).
-
-* Added a type caster for ``std::complex<T>``. (PR `#292
-  <https://github.com/wjakob/nanobind/pull/292>`__, commit `dcbed4
-  <https://github.com/wjakob/nanobind/commit/dcbed4fe1500383ad1f4dff47cacbf0f2e6b1d3f>`__).
-
-* Added an officially supported sample implementation of :ref:`intrusive
-  reference counting <intrusive>` via the :cpp:class:`intrusive_counter`
-  :cpp:class:`intrusive_base`, and :cpp:class:`ref` classes. (commit `3fa1af
-  <https://github.com/wjakob/nanobind/commit/3fa1af5e9e6fd0b08d13e16bb425a18963854829>`__).
-
-Bugfixes
-^^^^^^^^
-
-* Fixed a serious issue involving combinations of bound types (e.g., ``T``) and
-  type casters (e.g., ``std::vector<T>``), where nanobind was too aggressive in
-  its use of *move semantics*. Calling a bound function from Python taking such
-  a list (e.g., ``f([t1, t2, ..])``) would destruct ``t1, t2, ..`` if the type
-  ``T`` exposed a move constructor, which is highly non-intuitive and no
-  longer happens as of this fix.
-
-  Further investigation also revealed inefficiencies in the previous
-  implementation where moves were actually possible but not done (e.g., for
-  functions taking an STL vector by value). Some binding projects may see
-  speedups as a consequence of this change. (issue `#307
-  <https://github.com/wjakob/nanobind/issues/307>`__, commit `122015
-  <https://github.com/wjakob/nanobind/commit/1220156961ce2d0c96a525f3c27b88e824b997ce>`__).
-
-
-Version 1.5.2 (Aug 24, 2023)
-----------------------------
-
-* Fixed a severe issue with inheritance of the ``Py_TPFLAGS_HAVE_GC`` flag
-  affecting classes that derive from other classes with a
-  :cpp:class:`nb::dynamic_attr <dynamic_attr>` annotation. (issue `#279
-  <https://github.com/wjakob/nanobind/issues/279>`__, commit `dbedad
-  <https://github.com/wjakob/nanobind/commit/dbedadc294a7529bf401f01dbc97d4b47b677bc9>`__).
-* Implicit conversion of nd-arrays to conform to contiguity constraints such as
-  :cpp:class:`c_contig` and :cpp:class:`f_contig` previously failed in some
-  cases that are now addressed. (issue `#278
-  <https://github.com/wjakob/nanobind/issues/278>`__ commit `ed929b
-  <https://github.com/wjakob/nanobind/commit/ed929b7c6789e7d5e1760d515bc23ce6f7cedf8c>`__).
-
-Version 1.5.1 (Aug 23, 2023)
-----------------------------
-
-* Fixed serious reference counting issue introduced in nanobind version 1.5.0,
-  which affected the functions :cpp:func:`python_error::traceback()` and
-  :cpp:func:`python_error::what()`, causing undefined behavior via
-  use-after-free. Also addressed an unrelated minor UB sanitizer warning.
-  (issue `#277 <https://github.com/wjakob/nanobind/issues/277>`__, commits
-  `30d30c
-  <https://github.com/wjakob/nanobind/commit/30d30caaa3e834122944b28833b9c0315ef19a5d>`__
-  and `c48b18
-  <https://github.com/wjakob/nanobind/commit/c48b180834b4929f2f77ce658f2a50ee78482fb7>`__).
-* Extended the internal data structure tag so that it isolates different MSVC
-  versions from each other (they are often not ABI compatible, see pybind11
-  issue `#4779 <https://github.com/pybind/pybind11/pull/4779>`__). This means
-  that nanobind 1.5.1 effectively bumps the ABI version to "10.5" when
-  compiling for MSVC, and the internals will be isolated from extensions built
-  with nanobind v1.5.0 or older. (commit `c7f3cd
-  <https://github.com/wjakob/nanobind/commit/c7f3cd6a7023dec55c63b995ba50c9f5d4b9147a>`__).
-* Incorporated fixes so that nanobind works with PyPy 3.10. (commits `fb5508
-  <https://github.com/wjakob/nanobind/commit/fb5508955e1b1455adfe1372b49748ba706b4d87>`__
-  and `2ed10a
-  <https://github.com/wjakob/nanobind/commit/2ed108a73bd5fbe0e1c43a8db07e40a165fc265f>`__).
-* Fixed type caster for ``std::vector<bool>``. (PR `#256
-  <https://github.com/wjakob/nanobind/pull/256>`__).
-* Fixed compilation in debug mode on MSVC. (PR `#253
-  <https://github.com/wjakob/nanobind/pull/253>`__).
-
-Version 1.5.0 (Aug 7, 2023)
----------------------------
-
-* Support for creating :ref:`chained exceptions <exception_chaining>` via the
-  :cpp:func:`nb::raise_from() <chain_error>` and :cpp:func:`nb::chain_error()
-  <chain_error>` functions. (commits `041520
-  <https://github.com/wjakob/nanobind/commit/0415208e83885dba038516d86c2f4cca5f81df5f>`__
-  and `beb699
-  <https://github.com/wjakob/nanobind/commit/beb6999b7ce92ba5e3aaea60cd7f2acc9ba3cdc3>`__).
-* Many improvements to the handling of return value policies in
-  :cpp:class:`nb::ndarray\<..\> <ndarray>` to avoid unnecessary copies. (commit `ffd22b
-  <https://github.com/wjakob/nanobind/commit/ffd22b069ba95a546baeca0bdb6711fb9059cad8>`__,
-  `a79575
-  <https://github.com/wjakob/nanobind/commit/a79575165134c72c0a26e46772290d0404eae7a3>`__,
-  and `6f0c3f
-  <https://github.com/wjakob/nanobind/commit/6f0c3feaf088e78c75f2abee90164f20446eba08>`__).
-* The :cpp:class:`nb::ndarray\<..\> <ndarray>` class now has an additional
-  convenience constructor that takes the shape and (optionally) strides using
-  ``std::initializer_list``. (commit `de1117
-  <https://github.com/wjakob/nanobind/commit/de111766b21fe893a41cd4614a346b0da251f7f2>`__).
-* Added a non-throwing function :cpp:func:`nb::try_cast() <try_cast>` as an
-  alternative to :cpp:func:`nb::cast() <cast>`. (commit `6ca852
-  <https://github.com/wjakob/nanobind/commit/6ca852cc881ee7cd35b674135030709a6b57b8f6>`__).
-* The ``nb::list`` and ``nb::tuple`` default constructors now construct an empty list/tuple instead
-  of an invalid null-initialized handle.
-  (commit `506185 <https://github.com/wjakob/nanobind/commit/506185dca821c9cc1268c33b4cc867ae20f0fc4b>`__)
-* New low-level interface for wrapping existing C++ instances via
-  :cpp:func:`nb::inst_take_ownership() <inst_take_ownership>`
-  :cpp:func:`nb::inst_reference() <inst_reference>`. Also added convenience
-  functions to replace the contents of an instance with that of another.
-  :cpp:func:`nb::inst_replace_copy() <inst_replace_copy>` along with
-  :cpp:func:`nb::inst_replace_move() <inst_replace_move>` (commit `1c462d
-  <https://github.com/wjakob/nanobind/commit/1c462d6e3a112e49686acf33c9cb6e34f996dd6b>`__).
-* Added a low-level abstraction around :cpp:func:`nb::type_get_slot()
-  <type_get_slot>` around ``PyType_GetSlot``, but with more consistent behavior
-  across Python versions. (commit `d555e9
-  <https://github.com/wjakob/nanobind/commit/d555e9de1c45394f5be5d62dc999c603d651c8c4>`__).
-* The :cpp:func:`nb::list::append() <list::append>` method now performs perfect
-  forwarding. (commit `2219d0
-  <https://github.com/wjakob/nanobind/commit/2219d0b0fec5e6cc4fce96bc3dbad6bfa148a57d>`__).
-* Inference of ``automatic*`` return value policy was entirely moved to the
-  base C++ class type caster. (commit `1ff9df
-  <https://github.com/wjakob/nanobind/commit/1ff9df03fb56a16f56854b4cecd1f388f73d3b53>`__).
-* Switch to the new Python 3.12 error status API if available. (commit `36751c
-  <https://github.com/wjakob/nanobind/commit/36751cb05994a96a3801bf511c846a7bc68e2f09>`__).
-* Various minor fixes and improvements.
-* ABI version 10.
-
-Version 1.4.0 (June 8, 2023)
-----------------------------
-
-* Improved the efficiency of the function dispatch loop. (PR `#227
-  <https://github.com/wjakob/nanobind/pull/227>`__).
-* Significant improvements to the Eigen type casters (generalized stride
-  handling to avoid unnecessary copies, support for conversion via
-  ``nb::cast()``, many refinements to the  ``Eigen::Ref<T>`` interface). (PR
-  `#215 <https://github.com/wjakob/nanobind/pull/215>`__).
-* Added a ``NB_DOMAIN`` parameter to :cmake:command:`nanobind_add_module` which
-  can isolate extensions from each other to avoid binding clashes. See the
-  associated :ref:`FAQ entry <type-visibility>` for details. (commit `977119
-  <https://github.com/wjakob/nanobind/commit/977119c4797db7decf8064cf118afde768ff8fab>`__).
-* Reduced the severity of nanobind encountering a duplicate type binding
-  (commits `f3b0e6
-  <https://github.com/wjakob/nanobind/commit/f3b0e6cbd69a4adcdc31dbe0b844370b1b60dbcf>`__,
-  and `2c9124
-  <https://github.com/wjakob/nanobind/commit/2c9124bbbe736881fa8f9f33ea7817c98b43bf8b>`__).
-* Support for pickling/unpickling nanobind objects. (commit `59843e
-  <https://github.com/wjakob/nanobind/commit/59843e09bc6e8f2b0338829a44cf71e25f76cba3>`__).
-* ABI version 9.
-
-Version 1.3.2 (June 2, 2023)
-----------------------------
-
-* Fixed compilation on 32 bit processors (only ``i686`` tested so far).
-  (PR `#224 <https://github.com/wjakob/nanobind/pull/224>`__).
-* Fixed compilation on PyPy 3.8. (commit `cd8135
-  <https://github.com/wjakob/nanobind/commit/cd8135baa1da1213252272b5c9ecbf909e947597>`__).
-* Reduced binary bloat of musllinux wheels. (commit `f52513
-  <https://github.com/wjakob/nanobind/commit/f525139a80d173feaea5518e842aceeb6ceec5cf>`__).
-
-Version 1.3.1 (May 31, 2023)
-----------------------------
-
-* CMake build system improvements for stable ABI wheel generation.
-  (PR `#222 <https://github.com/wjakob/nanobind/pull/222>`__).
-
-Version 1.3.0 (May 31, 2023)
-----------------------------
-
-This is a big release. The sections below cover added features, efficiency
-improvements, and miscellaneous fixes and improvements.
-
-New features
-^^^^^^^^^^^^
-* nanobind now supports binding types that inherit from
-  ``std::enable_shared_from_this<T>``. See the :ref:`advanced section
-  on object ownership <enable_shared_from_this>` for more details.
-  (PR `#212 <https://github.com/wjakob/nanobind/pull/212>`__).
-* Added a type caster between Python ``datetime``/``timedelta`` objects and
-  C++ ``std::chrono::duration``/``std::chrono::time_point``, ported
-  from pybind11. (PR `#175 <https://github.com/wjakob/nanobind/pull/175>`__).
-* The :cpp:class:`nb::ndarray\<..\> <ndarray>` class can now use the buffer
-  protocol to receive and return arrays representing read-only memory. (PR
-  `#217 <https://github.com/wjakob/nanobind/pull/217>`__).
-* Added :cpp:func:`nb::python_error::discard_as_unraisable()
-  <python_error::discard_as_unraisable>` as a wrapper around
-  ``PyErr_WriteUnraisable()``. (PR `#175
-  <https://github.com/wjakob/nanobind/pull/175>`__).
-
-Efficiency improvements:
-^^^^^^^^^^^^^^^^^^^^^^^^
-
-* Reduced the per-instance overhead of nanobind by 1 pointer and simplified the
-  internal hash table types to crunch ``libnanobind``. (commit `de018d
-  <https://github.com/wjakob/nanobind/commit/de018db2d17905564703f1ade4aa201a22f8551f>`__).
-* Supplemental type data specified via :cpp:class:`nb::supplement\<T\>()
-  <supplement>` is now stored directly within the type object instead of being
-  referenced through an indirection. (commit `d82ca9
-  <https://github.com/wjakob/nanobind/commit/d82ca9c14191e74dd35dd5bf15fc90f5230319fb>`__).
-* Reduced the number of exception-related exports to further crunch
-  ``libnanobind``. (commit `763962
-  <https://github.com/wjakob/nanobind/commit/763962b8ce76414148089ef6a68cff97d7cc66ce>`__).
-* Reduced the size of nanobind type objects by 5 pointers. (PR `#194
-  <https://github.com/wjakob/nanobind/pull/194>`__, `#195
-  <https://github.com/wjakob/nanobind/pull/195>`__, and commit `d82ca9
-  <https://github.com/wjakob/nanobind/commit/d82ca9c14191e74dd35dd5bf15fc90f5230319fb>`__).
-* Internal nanobind types (``nb_type``, ``nb_static_property``, ``nb_ndarray``)
-  are now constructed on demand. This reduces the size of the ``libnanobind``
-  component in static (``NB_STATIC``) builds when those features are not used.
-  (commits `95e45a
-  <https://github.com/wjakob/nanobind/commit/95e45a4027dcbce935091533f7d41bf59e3e5fe1>`__,
-  `375083
-  <https://github.com/wjakob/nanobind/commit/37508386a1f8c346d17a0353c8152940aacde9c2>`__,
-  and `e033c8
-  <https://github.com/wjakob/nanobind/commit/e033c8fab4a14cbb9c5b0e08b1bdf49af2a9cb22>`__).
-* Added a small function cache to improve code generation in limited API
-  builds. (commit `f0f4aa
-  <https://github.com/wjakob/nanobind/commit/f0f42a564995ba3bd573282674d1a6d636a048c8>`__).
-* Refined compiler and linker flags across platforms to ensure compact binaries
-  especially in ``NB_STATIC`` builds. (commit `5ead9f
-  <https://github.com/wjakob/nanobind/commit/5ead9ff348a2ef0df8231e6480607a5b0623a16b>`__)
-* nanobind enums now take advantage of :ref:`supplemental data <supplement>`
-  to improve the speed of object and name lookups. Note that this prevents
-  use of ``nb::supplement<T>()`` with enums for other purposes.
-  (PR `#195 <https://github.com/wjakob/nanobind/pull/195>`__).
-
-Miscellaneous fixes and improvements
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-* Use the new `PEP-697 <https://peps.python.org/pep-0697/>`__ interface to
-  access data in type objects when compiling stable ABI3 wheels. This improves
-  forward compatibility (the Python team may at some point significantly
-  refactor the layout and internals of type objects). (PR `#211
-  <https://github.com/wjakob/nanobind/pull/211>`__):
-* Added introspection attributes ``__self__`` and ``__func__`` to nanobind
-  bound methods, to make them more like regular Python bound methods.
-  Fixed a bug where ``some_obj.method.__call__()`` would behave differently
-  than ``some_obj.method()``.
-  (PR `#216 <https://github.com/wjakob/nanobind/pull/216>`__).
-* Updated the implementation of :cpp:class:`nb::enum_ <enum_>` so it does
-  not take advantage of any private nanobind type details. As a side effect,
-  the construct ``nb::class_<T>(..., nb::is_enum(...))`` is no longer permitted;
-  use ``nb::enum_<T>(...)`` instead.
-  (PR `#195 <https://github.com/wjakob/nanobind/pull/195>`__).
-* Added the :cpp:class:`nb::type_slots_callback` class binding annotation,
-  similar to :cpp:class:`nb::type_slots` but allowing more dynamic choices.
-  (PR `#195 <https://github.com/wjakob/nanobind/pull/195>`__).
-* nanobind type objects now treat attributes specially whose names
-  begin with ``@``. These attributes can be set once, but not
-  rebound or deleted.  This safeguard allows a borrowed reference to
-  the attribute value to be safely stashed in the type supplement,
-  allowing arbitrary Python data associated with the type to be accessed
-  without a dictionary lookup while keeping this data visible to the
-  garbage collector.  (PR `#195 <https://github.com/wjakob/nanobind/pull/195>`__).
-* Fixed surprising behavior in enumeration comparisons and arithmetic
-  (PR `#207 <https://github.com/wjakob/nanobind/pull/207>`__):
-
-  * Enum equality comparisons (``==`` and ``!=``) now can only be true
-    if both operands have the same enum type, or if one is an enum and
-    the other is an ``int``. This resolves some confusing
-    results and ensures that enumerators of different types have a
-    distinct identity, which is important if they're being put into
-    the same set or used as keys in the same dictionary. All of the
-    following were previously true but will now evaluate as false:
-
-    * ``FooEnum(1) == BarEnum(1)``
-    * ``FooEnum(1) == 1.2``
-    * ``FooEnum(1) == "1"``
-
-  * Enum ordering comparisons (``<``, ``<=``, ``>=``, ``>``) and
-    arithmetic operations (when using the :cpp:struct:`is_arithmetic`
-    annotation) now require that any non-enum operand be a Python number
-    (an object that defines ``__int__``, ``__float__``, and/or ``__index__``)
-    and will avoid truncating non-integer operands to integers. Note that
-    unlike with equality comparisons, ordering and arithmetic operations
-    *do* still permit two operands that are enums of different types.
-    Some examples of changed behavior:
-
-    * ``FooEnum(1) < 1.2`` is now true (used to be false)
-    * ``FooEnum(2) * 1.5`` is now 3.0 (used to be 2)
-    * ``FooEnum(3) - "2"`` now raises an exception (used to be 1)
-
-  * Enum comparisons and arithmetic operations with unsupported types
-    now return `NotImplemented` rather than raising an exception.
-    This means equality comparisons such as ``some_enum == None`` will
-    return unequal rather than failing; order comparisons such as
-    ``some_enum < None`` will still fail, but now with a more
-    informative error.
-
-* ABI version 8.
-
-Version 1.2.0 (April 24, 2023)
-------------------------------
-
-* Improvements to the internal C++ → Python instance map data structure to improve
-  performance and address type confusion when returning previously registered instances.
-  (commit `716354 <https://github.com/wjakob/nanobind/commit/716354f0ed6123d6a19fcabb077b72a17b4ddf79>`__,
-  discussion `189 <https://github.com/wjakob/nanobind/discussions/189>`__).
-* Added up-to-date nanobind benchmarks on Linux including comparisons to Cython.
-  (commit `834cf3
-  <https://github.com/wjakob/nanobind/commit/834cf36ce12ffe6470dcffecd21341377c56cee1>`__
-  and `39e163
-  <https://github.com/wjakob/nanobind/commit/e9e163ec55de995a68a34fafda2e96ff06532658>`__).
-* Removed the superfluous ``nb_enum`` metaclass.
-  (commit `9c1985 <https://github.com/wjakob/nanobind/commit/9c19850471be70a22114826f6c0edceee99ff40b>`__).
-* Fixed a corner case that prevented ``nb::cast<char>`` from working.
-  (commit `9ae320 <https://github.com/wjakob/nanobind/commit/9ae32054d9a6ad17af15994dc51138eb88f71f92>`__).
-
-Version 1.1.1 (April 6, 2023)
------------------------------
-
-* Added documentation on packaging and distributing nanobind modules. (commit
-  `0715b2
-  <https://github.com/wjakob/nanobind/commit/0715b278ba806cf13cf63e41d62438481e7b73b8>`__).
-* Made the conversion :cpp:func:`handle::operator bool() <handle::operator
-  bool>` explicit. (PR `#173 <https://github.com/wjakob/nanobind/pull/173>`__).
-* Support :cpp:class:`nb::typed\<..\> <typed>` in return values. (PR `#174
-  <https://github.com/wjakob/nanobind/pull/174>`__).
-* Tweaks to definitions in ``nb_types.h`` to improve compatibility with further
-  C++ compilers (that said, there is no change about the official set of
-  supported compilers). (commit `b8bd10
-  <https://github.com/wjakob/nanobind/commit/b8bd1086e9b20da8a81a954f03e7947bee5422fd>`__)
-
-Version 1.1.0 (April 5, 2023)
------------------------------
-
-* Added :cpp:func:`size <ndarray::size>`, :cpp:func:`shape_ptr
-  <ndarray::shape_ptr>`, :cpp:func:`stride_ptr <ndarray::stride_ptr>` members
-  to to the :cpp:class:`nb::ndarray\<..\> <ndarray>` class. (PR `#161
-  <https://github.com/wjakob/nanobind/pull/161>`__).
-* Allow macros in :c:macro:`NB_MODULE(..) <NB_MODULE>` name parameter. (PR
-  `#168 <https://github.com/wjakob/nanobind/pull/168>`__).
-* The :cpp:class:`nb::ndarray\<..\> <ndarray>` interface is more tolerant when
-  converting Python (PyTorch/NumPy/..) arrays with a size-0 dimension that have
-  mismatched strides. (PR `#162
-  <https://github.com/wjakob/nanobind/pull/162>`__).
-* Removed the ``<anonymous>`` label from docstrings of anonymous functions,
-  which caused issues in MyPy. (PR `#172
-  <https://github.com/wjakob/nanobind/pull/172>`__).
-* Fixed an issue in the propagation of return value policies that broke
-  user-provided/custom policies in properties (PR `#170
-  <https://github.com/wjakob/nanobind/pull/170>`__).
-* The Eigen interface now converts 1x1 matrices to 1x1 NumPy arrays instead of
-  scalars. (commit `445781
-  <https://github.com/wjakob/nanobind/commit/445781fc2cf2fa326cc22e8fd483e8e4a7bf6cf5>`__).
-* The ``nanobind`` package now has a simple command line interface. (commit
-  `d5ccc8
-  <https://github.com/wjakob/nanobind/commit/d5ccc8844b29ca6cd5188ffd8d16e034bcee9f73>`__).
-
-Version 1.0.0 (March 28, 2023)
-------------------------------
-
-* Nanobind now has a logo. (commit `b65d31
-  <https://github.com/wjakob/nanobind/commit/b65d3b134d8b9f8d153b51d87751d09a12e4235b>`__).
-* Fixed a subtle issue involving function/method properties and the IPython
-  command line interface. (PR `#151
-  <https://github.com/wjakob/nanobind/pull/151>`__).
-* Added a boolean type to the :cpp:class:`nb::ndarray\<..\> <ndarray>`
-  interface. (PR `#150 <https://github.com/wjakob/nanobind/pull/150>`__).
-* Minor fixes and improvements.
-
-
-Version 0.3.1 (March 8, 2023)
------------------------------
-
-* Added a type caster for ``std::filesystem::path``. (PR `#138
-  <https://github.com/wjakob/nanobind/pull/138>`__ and commit `0b05cd
-  <https://github.com/wjakob/nanobind/commit/0b05cde8bd8685ab42328660da03cc4ee66e3ba2>`__).
-* Fixed technical issues involving implicit conversions (commits `022935
-  <https://github.com/wjakob/nanobind/commit/022935cbb92dfb1d02f90546bf6b34013f90e9e5>`__
-  and `5aefe3
-  <https://github.com/wjakob/nanobind/commit/5aefe36e3e07b5b98a6be7c0f3ce28a236fe2330>`__)
-  and construction of type hierarchies with custom garbage collection hooks
-  (commit `022935
-  <https://github.com/wjakob/nanobind/commit/7b3e893e1c14d95f7b3fc838657e6f9ce520d609>`__).
-* Re-enabled the 'chained fixups' linker optimization for recent macOS
-  deployment targets. (commit `2f29ec
-  <https://github.com/wjakob/nanobind/commit/2f29ec7d5fbebd5f55fb52da297c8d197279f659>`__).
-
-Version 0.3.0 (March 8, 2023)
------------------------------
-
-* Botched release, replaced by 0.3.1 on the same day.
-
-Version 0.2.0 (March 3, 2023)
------------------------------
-* Nanobind now features documentation on `readthedocs
-  <https://nanobind.readthedocs.io>`__.
-* The documentation process revealed a number of inconsistencies in the
-  :cpp:func:`class_\<T\>::def* <class_::def>` naming scheme. nanobind will from
-  now on use the following shortened and more logical interface:
-
-  .. list-table::
-    :widths: 40 60
-    :header-rows: 1
-
-    * - Type
-      - method
-    * - Methods & constructors
-      - :cpp:func:`.def() <class_::def>`
-    * - Fields
-      - :cpp:func:`.def_ro() <class_::def_ro>`,
-        :cpp:func:`.def_rw() <class_::def_rw>`
-    * - Properties
-      - :cpp:func:`.def_prop_ro() <class_::def_prop_ro>`,
-        :cpp:func:`.def_prop_rw() <class_::def_prop_rw>`
-    * - Static methods
-      - :cpp:func:`.def_static() <class_::def_static>`
-    * - Static fields
-      - :cpp:func:`.def_ro_static() <class_::def_ro_static>`,
-        :cpp:func:`.def_rw_static() <class_::def_rw_static>`
-    * - Static properties
-      - :cpp:func:`.def_prop_ro_static() <class_::def_prop_ro_static>`,
-        :cpp:func:`.def_prop_rw_static() <class_::def_prop_rw_static>`
-
-  Compatibility wrappers with deprecation warnings were also added to help port
-  existing code. They will be removed when nanobind reaches version 1.0.
-  (commits `cb0dc3
-  <https://github.com/wjakob/nanobind/commit/cb0dc392b656fd9d0c85c56dc51a9be1de06e176>`__
-  and `b5ed96
-  <https://github.com/wjakob/nanobind/commit/b5ed696a7a68c9c9adc4d3aa3c6f4adb5b7defeb>`__)
-* The ``nb::tensor<..>`` class has been renamed to :cpp:class:`nb::ndarray\<..\> <ndarray>`,
-  and it is now located in a different header file (``nanobind/ndarray.h``). A
-  compatibility wrappers with a deprecation warning was retained in the
-  original header file. It will be removed when nanobind reaches version 1.0.
-  (commit `a6ab8b
-  <https://github.com/wjakob/nanobind/commit/a6ab8b06dd3316ac53fbed143c346c2b73c31b75>`__).
-* Dropped the first two arguments of the :c:macro:`NB_OVERRIDE_*()
-  <NB_OVERRIDE>` macros that turned out to be unnecessary in nanobind. (commit
-  `22bc21
-  <https://github.com/wjakob/nanobind/commit/22bc21b97cd2bbe060d7fb42d374bde72d973ada>`__).
-* Added casters for dense matrix/array types from the `Eigen library
-  <https://eigen.tuxfamily.org/index.php?title=Main_Page>`__. (PR `#120
-  <https://github.com/wjakob/nanobind/pull/120>`__).
-* Added casters for sparse matrix/array types from the `Eigen library
-  <https://eigen.tuxfamily.org/index.php?title=Main_Page>`__. (PR `#126
-  <https://github.com/wjakob/nanobind/pull/126>`_).
-* Implemented `nb::bind_vector\<T\>() <bind_vector>` analogous to similar
-  functionality in pybind11. (commit `f2df8a
-  <https://github.com/wjakob/nanobind/commit/f2df8a90fbfb06ee03a79b0dd85fa0e266efeaa9>`__).
-* Implemented :cpp:func:`nb::bind_map\<T\>() <bind_map>` analogous to
-  similar functionality in pybind11. (PR `#114
-  <https://github.com/wjakob/nanobind/pull/114>`__).
-* nanobind now :ref:`automatically downcasts <automatic_downcasting>`
-  polymorphic objects in return values analogous to pybind11. (commit `cab96a
-  <https://github.com/wjakob/nanobind/commit/cab96a9160e0e1a626bc3e4f9fcddcad31e0f727>`__).
-* nanobind now supports :ref:`tag-based polymorphism <tag_based_polymorphism>`.
-  (commit `6ade94
-  <https://github.com/wjakob/nanobind/commit/6ade94b8e5a2388d66fc9df6f81603c65108cbcc>`__).
-* Updated tuple/list iterator to satisfy the ``std::forward_iterator`` concept.
-  (PR `#117 <https://github.com/wjakob/nanobind/pull/117>`__).
-* Fixed issues with non-writeable tensors in NumPy. (commit `25cc3c
-  <https://github.com/wjakob/nanobind/commit/25cc3ccbd1174e7cfc4eef1d1e7206cc38e854ca>`__).
-* Removed use of some C++20 features from the codebase. This now makes it
-  possible to use nanobind on  Visual Studio 2017 and GCC 7.3.1 (used on RHEL 7).
-  (PR `#115 <https://github.com/wjakob/nanobind/pull/115>`__).
-* Added the :cpp:class:`nb::typed\<...\> <typed>` wrapper to override the type signature of an
-  argument in a bound function in the generated docstring. (commit `b3404c4
-  <https://github.com/wjakob/nanobind/commit/b3404c4f347981bce7f4c7a9bac762656bed8385>`__).
-* Added an :cpp:func:`nb::implicit_convertible\<A, B\>() <implicitly_convertible>` function analogous to the one in
-  pybind11. (commit `aba4af
-  <https://github.com/wjakob/nanobind/commit/aba4af06992f14e21e5b7b379e7986e939316da4>`__).
-* Updated :cpp:func:`nb::make_*_iterator\<..\>() <make_iterator>` so that it returns references of elements, not
-  copies. (commit `8916f5
-  <https://github.com/wjakob/nanobind/commit/8916f51ad1a25318b5c9fcb07c153f6b72a43bd2>`__).
-* Changed the CMake build system so that the library component
-  (``libnanobind``) is now compiled statically by default. (commit `8418a4
-  <https://github.com/wjakob/nanobind/commit/8418a4aa93d19d7b9714b8d9473539b46cbed508>`__).
-* Switched shared library linking on macOS back to a two-level namespace.
-  (commit `fe4965
-  <https://github.com/wjakob/nanobind/commit/fe4965369435bf7c0925bddf610553d0bb516e27>`__).
-* Various minor fixes and improvements.
-* ABI version 7.
-
-Version 0.1.0 (January 3, 2023)
--------------------------------
-
-* Allow nanobind methods on non-nanobind) classes. (PR `#104
-  <https://github.com/wjakob/nanobind/pull/104>`__).
-* Fix dangling `tp_members` pointer in type initialization. (PR `#99
-  <https://github.com/wjakob/nanobind/pull/99>`__).
-* Added a runtime setting to suppress leak warnings. (PR `#109
-  <https://github.com/wjakob/nanobind/pull/109>`__).
-* Added the ability to hash ``nb::enum_<..>`` instances (PR `#106
-  <https://github.com/wjakob/nanobind/pull/106>`__).
-* Fixed the signature of ``nb::enum_<..>::export_values()``. (commit `714d17
-  <https://github.com/wjakob/nanobind/commit/714d17e71aa405c7633e0bd798a8bdb7b8916fa1>`__).
-* Double-check GIL status when performing reference counting operations in
-  debug mode. (commit `a1b245
-  <https://github.com/wjakob/nanobind/commit/a1b245fcf210fbfb10d7eb19dc2dc31255d3f561>`__).
-* Fixed a reference leak that occurred when module initialization fails.
-  (commit `adfa9e
-  <https://github.com/wjakob/nanobind/commit/adfa9e547be5575f025d92abeae2e649a690760a>`__).
-* Improved robustness of ``nb::tensor<..>`` caster. (commit `633672
-  <https://github.com/wjakob/nanobind/commit/633672cd154c0ef13f96fee84c2291562f4ce3d3>`__).
-* Upgraded the internally used ``tsl::robin_map<>`` hash table to address a
-  rare `overflow issue <https://github.com/Tessil/robin-map/issues/52>`__
-  discovered in this codebase. (commit `3b81b1
-  <https://github.com/wjakob/nanobind/commit/3b81b18577e243118a659b524d4de9500a320312>`__).
-* Various minor fixes and improvements.
-* ABI version 6.
-
-Version 0.0.9 (Nov 23, 2022)
-----------------------------
-
-* PyPy 7.3.10 or newer is now supported subject to `certain limitations
-  <https://github.com/wjakob/nanobind/blob/master/docs/pypy.rst>`__. (commits
-  `f935f93
-  <https://github.com/wjakob/nanobind/commit/f935f93b9d532a5ef1f385445f328d61eb2af97f>`__
-  and `b343bbd
-  <https://github.com/wjakob/nanobind/commit/b343bbd11c12b55bbc00492445c743cae18b298f>`__).
-* Three changes that reduce the binary size and improve runtime performance of
-  binding libraries. (commits `07b4e1fc
-  <https://github.com/wjakob/nanobind/commit/07b4e1fc9e94eeaf5e9c2f4a63bdb275a25c82c6>`__,
-  `9a803796
-  <https://github.com/wjakob/nanobind/commit/9a803796cb05824f9df7593edb984130d20d3755>`__,
-  and `cba4d285
-  <https://github.com/wjakob/nanobind/commit/cba4d285f4e23b888dfcccc656c221414138a2b7>`__).
-* Fixed a reference leak in ``python_error::what()`` (commit `61393ad
-  <https://github.com/wjakob/nanobind/commit/61393ad3ce3bc68d195a1496422df43d5fb45ec0>`__).
-* Adopted a new policy for function type annotations. (commit `c855c90 <https://github.com/wjakob/nanobind/commit/c855c90fc91d180f7c904c612766af6a84c017e3>`__).
-* Improved the effectiveness of link-time-optimization when building extension modules
-  with the ``NB_STATIC`` flag. This leads to smaller binaries. (commit `f64d2b9
-  <https://github.com/wjakob/nanobind/commit/f64d2b9bb558afe28cf6909e4fa47ebf720f62b3>`__).
-* Nanobind now relies on standard mechanisms to inherit the ``tp_traverse`` and
-  ``tp_clear`` type slots instead of trying to reimplement the underlying
-  CPython logic (commit `efa09a6b
-  <https://github.com/wjakob/nanobind/commit/efa09a6bf6ac27f790b2c96389c2da42d4bc176b>`__).
-* Moved nanobind internal data structures from ``builtins`` to Python
-  interpreter state dictionary. (issue `#96
-  <https://github.com/wjakob/nanobind/issues/96>`__, commit `ca23da7
-  <https://github.com/wjakob/nanobind/commit/ca23da72ce71a45318f1e59474c9c2906fce5154>`__).
-* Various minor fixes and improvements.
-
-
-Version 0.0.8 (Oct 27, 2022)
-----------------------------
-
-* Caster for ``std::array<..>``. (commit `be34b16
-  <https://github.com/wjakob/nanobind/commit/be34b165c6a0bed08e477755644f96759b9ed69a>`__).
-* Caster for ``std::set<..>`` and ``std::unordered_set`` (PR `#87
-  <https://github.com/wjakob/nanobind/pull/87>`__).
-* Ported ``nb::make[_key_,_value]_iterator()`` from pybind11. (commit `34d0be1
-  <https://github.com/wjakob/nanobind/commit/34d0be1bbeb54b8265456fd3a4a50e98f93fe6d4>`__).
-* Caster for untyped ``void *`` pointers. (commit `6455fff
-  <https://github.com/wjakob/nanobind/commit/6455fff7be5be2867063ea8138cf10e1d9f3065f>`__).
-* Exploit move constructors in ``nb::class_<T>::def_readwrite()`` and
-  ``nb::class_<T>::def_readwrite_static()`` (PR `#94
-  <https://github.com/wjakob/nanobind/pull/94>`__).
-* Redesign of the ``std::function<>`` caster to enable cyclic garbage collector
-  traversal through inter-language callbacks (PR `#95
-  <https://github.com/wjakob/nanobind/pull/95>`__).
-* New interface for specifying custom type slots during Python type
-  construction. (commit `38ba18a
-  <https://github.com/wjakob/nanobind/commit/38ba18a835cfcd561efb4b4c640ee5c6d525decb>`__).
-* Fixed potential undefined behavior related to ``nb_func`` garbage collection by
-  Python's cyclic garbage collector. (commit `662e1b9
-  <https://github.com/wjakob/nanobind/commit/662e1b9311e693f84c58799a67064d4a44bb706a>`__).
-* Added a workaround for spurious reference leak warnings caused by other
-  extension modules in conjunction with ``typing.py`` (commit `5e11e80
-  <https://github.com/wjakob/nanobind/commit/5e11e8032f777c0a34abd437dc6e84a909907c91>`__).
-* Various minor fixes and improvements.
-* ABI version 5.
-
-Version 0.0.7 (Oct 14, 2022)
-----------------------------
-
-* Fixed a regression involving function docstrings in ``pydoc``. (commit
-  `384f4a
-  <https://github.com/wjakob/nanobind/commit/384f4ada1f3f08486fb03427227878ddbbcaad43>`__).
-
-Version 0.0.6 (Oct 14, 2022)
-----------------------------
-
-* Fixed undefined behavior that could lead to crashes when nanobind types were
-  freed. (commit `39266e
-  <https://github.com/wjakob/nanobind/commit/39266ef0b0ccd7fa3e9237243a6c97ba8db2cd2a>`__).
-* Refactored nanobind so that it works with ``Py_LIMITED_API`` (PR `#37 <https://github.com/wjakob/nanobind/pull/37>`__).
-* Dynamic instance attributes (PR `#38 <https://github.com/wjakob/nanobind/pull/38>`__).
-* Intrusive pointer support (PR `#43 <https://github.com/wjakob/nanobind/pull/43>`__).
-* Byte string support (PR `#62 <https://github.com/wjakob/nanobind/pull/62>`__).
-* Casters for ``std::variant<..>`` and ``std::optional<..>`` (PR `#67 <https://github.com/wjakob/nanobind/pull/67>`__).
-* Casters for ``std::map<..>`` and ``std::unordered_map<..>`` (PR `#73 <https://github.com/wjakob/nanobind/pull/73>`__).
-* Caster for ``std::string_view<..>`` (PR `#68 <https://github.com/wjakob/nanobind/pull/68>`__).
-* Custom exception support (commit `41b7da <https://github.com/wjakob/nanobind/commit/41b7da33f1bc5c583bb98df66bdac2a058ec5c15>`__).
-* Register nanobind functions with Python's cyclic garbage collector (PR `#86 <https://github.com/wjakob/nanobind/pull/86>`__).
-* Various minor fixes and improvements.
-* ABI version 3.
-
-Version 0.0.5 (May 13, 2022)
-----------------------------
-
-* Enumeration export.
-* Implicit number conversion for NumPy scalars.
-* Various minor fixes and improvements.
-
-Version 0.0.4 (May 13, 2022)
-----------------------------
-
-* Botched release, replaced by 0.0.5 on the same day.
-
-Version 0.0.3 (Apr 14, 2022)
-----------------------------
-
-* DLPack support.
-* Iterators for various Python type wrappers.
-* Low-level interface to instance creation.
-* Docstring generation improvements.
-* Various minor fixes and improvements.
-
-Version 0.0.2 (Mar 10, 2022)
-----------------------------
-
-* Initial release of the nanobind codebase.
-* ABI version 1.
-
-Version 0.0.1 (Feb 21, 2022)
-----------------------------
-
-* Placeholder package on PyPI.
diff --git a/src/nanobind/docs/classes.rst b/src/nanobind/docs/classes.rst
deleted file mode 100644
index fb6fc8a..0000000
--- a/src/nanobind/docs/classes.rst
+++ /dev/null
@@ -1,1143 +0,0 @@
-.. _classes:
-
-.. cpp:namespace:: nanobind
-
-Classes
-=======
-
-The material below builds on the section on :ref:`binding custom types
-<binding_types>` and reviews advanced scenarios involving object-oriented code.
-
-Frequently used
----------------
-Click on the following :cpp:class:`nb::class_\<..\>::def_* <class_>` members for
-examples on how to bind various different kinds of methods, fields, etc.
-
-.. list-table::
-  :widths: 40 60
-  :header-rows: 1
-
-  * - Type
-    - method
-  * - Methods & constructors
-    - :cpp:func:`.def() <class_::def>`
-  * - Fields
-    - :cpp:func:`.def_ro() <class_::def_ro>`,
-      :cpp:func:`.def_rw() <class_::def_rw>`
-  * - Properties
-    - :cpp:func:`.def_prop_ro() <class_::def_prop_ro>`,
-      :cpp:func:`.def_prop_rw() <class_::def_prop_rw>`
-  * - Static methods
-    - :cpp:func:`.def_static() <class_::def_static>`
-  * - Static fields
-    - :cpp:func:`.def_ro_static() <class_::def_ro_static>`,
-      :cpp:func:`.def_rw_static() <class_::def_rw_static>`
-  * - Static properties
-    - :cpp:func:`.def_prop_ro_static() <class_::def_prop_ro_static>`,
-      :cpp:func:`.def_prop_rw_static() <class_::def_prop_rw_static>`
-
-.. _inheritance:
-
-Subclasses
-----------
-
-Consider the following two data structures with an inheritance relationship:
-
-.. code-block:: cpp
-
-   struct Pet {
-       std::string name;
-   };
-
-   struct Dog : Pet {
-       std::string bark() const { return name + ": woof!"; }
-   };
-
-To indicate the inheritance relationship to nanobind, specify the C++ base
-class as an extra template parameter of :cpp:class:`nb::class_\<..\> <class_>`:
-
-.. code-block:: cpp
-   :emphasize-lines: 8
-
-   #include <nanobind/stl/string.h>
-
-   NB_MODULE(my_ext, m) {
-       nb::class_<Pet>(m, "Pet")
-          .def(nb::init<const std::string &>())
-          .def_rw("name", &Pet::name);
-
-       nb::class_<Dog, Pet /* <- C++ parent type */>(m, "Dog")
-           .def(nb::init<const std::string &>())
-           .def("bark", &Dog::bark);
-   }
-
-Alternatively, you can also pass the type object as an ordinary parameter.
-
-.. code-block:: cpp
-   :emphasize-lines: 5
-
-   auto pet = nb::class_<Pet>(m, "Pet")
-      .def(nb::init<const std::string &>())
-      .def_rw("name", &Pet::name);
-
-   nb::class_<Dog>(m, "Dog", pet /* <- Parent type object */)
-       .def(nb::init<const std::string &>())
-       .def("bark", &Dog::bark);
-
-Instances expose fields and methods of both types as expected:
-
-.. code-block:: pycon
-
-    >>> d = my_ext.Dog("Molly")
-    >>> d.name
-    'Molly'
-    >>> d.bark()
-    'Molly: woof!'
-
-.. _automatic_downcasting:
-
-Automatic downcasting
----------------------
-
-nanobind obeys signatures when returning regular non-polymorphic C++ objects
-from functions: building on the :ref:`previous example <inheritance>`, consider
-the following function that returns a ``Dog`` object as a ``Pet`` base pointer.
-
-.. code-block:: cpp
-
-   m.def("pet_store", []() { return (Pet *) new Dog{"Molly"}; });
-
-nanobind cannot safely determine that this is in fact an instance of the
-``Dog`` subclass. Consequently, only fields and methods of the base type remain
-accessible:
-
-.. code-block:: pycon
-
-   >>> p = my_ext.pet_store()
-   >>> type(p)
-   <class 'my_ext.Pet'>
-   >>> p.bark()
-   AttributeError: 'Pet' object has no attribute 'bark'
-
-In C++, a type is only considered `polymorphic
-<https://en.wikipedia.org/wiki/Dynamic_dispatch>`_ if it (or one of its base
-classes) has at least one *virtual function*. Let's add a virtual default
-destructor to make ``Pet`` and its subtypes polymorphic.
-
-.. code-block:: cpp
-
-   struct Pet {
-       virtual ~Pet() = default;
-       std::string name;
-   };
-
-With this change, nanobind is able to inspect the returned C++ instance's
-`virtual table <https://en.wikipedia.org/wiki/Virtual_method_table>`_ and infer
-that it can be represented by a more specialized Python object of type
-``my_ext.Dog``.
-
-.. code-block:: pycon
-
-   >>> p = my_ext.pet_store()
-   >>> type(p)
-   <class 'my_ext.Dog'>
-   >>> p.bark()
-   'Molly: woof!'
-
-.. note::
-
-   Automatic downcasting of polymorphic instances is only supported when the
-   subtype has been registered using :cpp:class:`nb::class_\<..\> <class_>`.
-   Otherwise, the return type listed in the function signature takes
-   precedence.
-
-.. _overloaded_methods:
-
-Overloaded methods
-------------------
-
-Sometimes there are several overloaded C++ methods with the same name taking
-different kinds of input arguments:
-
-.. code-block:: cpp
-
-    struct Pet {
-        Pet(const std::string &name, int age) : name(name), age(age) { }
-
-        void set(int age_) { age = age_; }
-        void set(const std::string &name_) { name = name_; }
-
-        std::string name;
-        int age;
-    };
-
-Attempting to bind ``Pet::set`` will cause an error since the compiler does not
-know which method the user intended to select. We can disambiguate by casting
-them to function pointers. Binding multiple functions to the same Python name
-automatically creates a chain of function overloads that will be tried in
-sequence.
-
-.. code-block:: cpp
-
-   nb::class_<Pet>(m, "Pet")
-      .def(nb::init<const std::string &, int>())
-      .def("set", nb::overload_cast<int>(&Pet::set), "Set the pet's age")
-      .def("set", nb::overload_cast<const std::string &>(&Pet::set), "Set the pet's name");
-
-Here, :cpp:func:`nb::overload_cast <overload_cast>` only requires the parameter
-types to be specified, and it deduces the return type.
-
-.. note::
-
-   In cases where a function overloads by ``const``-ness, an additional
-   ``nb::const_`` parameter is needed to select the right overload, e.g.,
-   ``nb::overload_cast<int>(&Pet::get, nb::const_)``.
-
-   To define overloaded constructors, simply declare one after the other using
-   the normal :cpp:class:`.def(nb::init\<...\>()) <init>` syntax.
-
-The overload signatures are also visible in the method's docstring:
-
-.. code-block:: pycon
-
-   >>> help(my_ext.Pet)
-   class Pet(builtins.object)
-    |  Methods defined here:
-    |
-    |  __init__(...)
-    |      __init__(self, arg0: str, arg1: int, /) -> None
-    |
-    |  set(...)
-    |      set(self, arg: int, /) -> None
-    |      set(self, arg: str, /) -> None
-    |
-    |      Overloaded function.
-    |
-    |      1. ``set(self, arg: int, /) -> None``
-    |
-    |      Set the pet's age
-    |
-    |      2. ``set(self, arg: str, /) -> None``
-    |
-    |      Set the pet's name
-
-The format of the docstring with a leading overload list followed by a repeated
-list with details is designed to be compatible with the `Sphinx
-<https://www.sphinx-doc.org/en/master/>`_ documentation generator.
-
-.. _enumerations_and_internal:
-
-Enumerations and internal types
--------------------------------
-
-Let's now suppose that the example class contains internal types like enumerations, e.g.:
-
-.. code-block:: cpp
-
-   struct Pet {
-       enum Kind {
-           Dog = 0,
-           Cat
-       };
-
-       struct Attributes {
-           float age = 0;
-       };
-
-       Pet(const std::string &name, Kind type) : name(name), type(type) { }
-
-       std::string name;
-       Kind type;
-       Attributes attr;
-   };
-
-The binding code for this example looks as follows:
-
-.. code-block:: cpp
-
-   nb::class_<Pet> pet(m, "Pet");
-
-   pet.def(nb::init<const std::string &, Pet::Kind>())
-       .def_rw("name", &Pet::name)
-       .def_rw("type", &Pet::type)
-       .def_rw("attr", &Pet::attr);
-
-   nb::enum_<Pet::Kind>(pet, "Kind")
-       .value("Dog", Pet::Kind::Dog)
-       .value("Cat", Pet::Kind::Cat)
-       .export_values();
-
-   nb::class_<Pet::Attributes>(pet, "Attributes")
-       .def(nb::init<>())
-       .def_rw("age", &Pet::Attributes::age);
-
-To ensure that the nested types ``Kind`` and ``Attributes`` are created within
-the scope of ``Pet``, the ``pet`` type object is passed as the ``scope``
-argument of the subsequent :cpp:class:`nb::enum_\<T\> <enum_>` and
-:cpp:class:`nb::class_\<T\> <class_>` binding declarations. The
-:cpp:func:`.export_values() <enum_::export_values>` function exports the
-enumeration entries into the parent scope, which should be skipped for newer
-C++11-style strongly typed enumerations.
-
-.. code-block:: pycon
-
-   >>> from my_ext import Pet
-   >>> p = Pet("Lucy", Pet.Cat)
-   >>> p.attr.age = 3
-   >>> p.type
-   my_ext.Kind.Cat
-   >>> p.type.__name__
-   'Cat'
-   >>> int(p.type)
-   1
-
-.. note::
-
-   When the annotation :cpp:class:`nb::is_arithmetic() <is_arithmetic>` is
-   passed to :cpp:class:`nb::enum_\<T\> <enum_>`, the resulting Python type
-   will support arithmetic and bit-level operations (and, or,
-   xor, negation).  The operands of these operations may be either enumerators.
-   When the annotation :cpp:class:`nb::is_flag() <is_flag>` is passed to
-   :cpp:class:`nb::enum_\<T\> <enum_>`, the resulting Python type will be a class
-   derived from ``enum.Flag``, meaning its enumerators can be combined using bit-wise
-   operators in a type-safe way: the result will have the same enumeration type
-   as the operands, and only enumerators of the same type can be combined.
-   When passing both ``is_arithmetic`` and ``is_flag``, the resulting Python type
-   will be ``enum.IntFlag``, supporting both arithmetic and bit-wise operations.
-
-   .. code-block:: cpp
-
-       nb::enum_<Pet::Kind>(pet, "Kind", nb::is_arithmetic())
-          ...
-
-   By default, these are omitted.
-
-.. _dynamic_attributes:
-
-Dynamic attributes
-------------------
-
-Native Python classes can pick up new attributes dynamically:
-
-.. code-block:: pycon
-
-   >>> class Pet:
-   ...     name = "Molly"
-   ...
-   >>> p = Pet()
-   >>> p.name = "Charly"  # overwrite existing
-   >>> p.age = 2  # dynamically add a new attribute
-
-By default, classes exported from C++ do not support this and the only writable
-attributes are the ones explicitly defined using :func:`class_::def_rw`
-or :func:`class_::def_prop_rw`.
-
-.. code-block:: cpp
-
-   nb::class_<Pet>(m, "Pet")
-       .def(nb::init<>())
-       .def_rw("name", &Pet::name);
-
-Trying to set any other attribute results in an error:
-
-.. code-block:: pycon
-
-   >>> p = my_ext.Pet()
-   >>> p.name = "Charly"  # OK, attribute defined in C++
-   >>> p.age = 2  # fail
-   AttributeError: 'Pet' object has no attribute 'age'
-
-To enable dynamic attributes for C++ classes, the :class:`nb::dynamic_attr
-<dynamic_attr>` tag must be added to the :class:`nb::class_ <class_>`
-constructor:
-
-.. code-block:: cpp
-
-   nb::class_<Pet>(m, "Pet", nb::dynamic_attr())
-       .def(nb::init<>())
-       .def_rw("name", &Pet::name);
-
-Now everything works as expected:
-
-.. code-block:: pycon
-
-   >>> p = my_ext.Pet()
-   >>> p.name = "Charly"  # OK, overwrite value in C++
-   >>> p.age = 2  # OK, dynamically add a new attribute
-
-Note that there is a small runtime cost for a class with dynamic attributes.
-Not only because of the addition of an instance dictionary, but also because of
-more expensive garbage collection tracking which must be activated to resolve
-possible circular references. Native Python classes incur this same cost by
-default, so this is not anything to worry about. By default, nanobind classes
-are more efficient than native Python classes. Enabling dynamic attributes just
-brings them on par.
-
-.. _weak_refs:
-
-Weak references
----------------
-
-By default, nanobind instances cannot be referenced via Python's ``weakref``
-class, and attempting to do so will raise an exception.
-
-To support this, add the :class:`nb::is_weak_referenceable
-<is_weak_referenceable>` tag to the :class:`nb::class_ <class_>` constructor.
-Note that this will increase the size of every instance by ``sizeof(void*)``
-due to the need to store a weak reference list.
-
-.. code-block:: cpp
-
-   nb::class_<Pet>(m, "Pet", nb::is_weak_referenceable());
-
-.. _inheriting_in_python:
-
-Extending C++ classes in Python
--------------------------------
-
-Bound C++ types can be extended within Python, which is helpful to dynamically
-extend compiled code with further fields and other functionality. Bind classes
-with the :cpp:class:`is_final` annotation to forbid subclassing.
-
-Consider the following example bindings of a ``Dog`` and ``DogHouse`` class.
-
-.. code-block:: cpp
-
-   #include <nanobind/stl/string.h>
-
-   namespace nb = nanobind;
-
-   struct Dog {
-       std::string name;
-       std::string bark() const { return name + ": woof!"; }
-   };
-
-   struct DogHouse {
-       Dog dog;
-   };
-
-   NB_MODULE(my_ext, m) {
-       nb::class_<Dog>(m, "Dog")
-          .def(nb::init<const std::string &>())
-          .def("bark", &Dog::bark)
-          .def_rw("name", &Dog::name);
-
-       nb::class_<DogHouse>(m, "DogHouse")
-          .def(nb::init<Dog>())
-          .def_rw("dog", &DogHouse::dog);
-   }
-
-The following Python snippet creates a new ``GuardDog`` type that extends
-``Dog`` with an ``.alarm()`` method.
-
-.. code-block:: pycon
-
-   >>> import my_ext
-   >>> class GuardDog(my_ext.Dog):
-   ...     def alarm(self, count = 3):
-   ...         for i in range(count):
-   ...             print(self.bark())
-   ...
-   >>> gd = GuardDog("Max")
-   >>> gd.alarm()
-   Max: woof!
-   Max: woof!
-   Max: woof!
-
-This Python subclass is best thought of as a "rich wrapper" around an existing
-C++ base object. By default, that wrapper will disappear when nanobind makes a
-copy or transfers ownership to C++.
-
-.. code-block:: pycon
-
-   >>> d = my_ext.DogHouse()
-   >>> d.dog = gd
-   >>> d.dog.alarm()
-   AttributeError: 'Dog' object has no attribute 'alarm'
-
-To preserve it, adopt a shared ownership model using :ref:`shared pointers
-<shared_ptr>` or :ref:`intrusive reference counting <intrusive_intro>`. For
-example, updating the code as follows fixes the problem:
-
-.. code-block:: cpp
-
-   #include <nanobind/stl/shared_ptr.h>
-
-   struct DogHouse {
-       std::shared_ptr<Dog> dog;
-   };
-
-.. code-block:: pycon
-
-   >>> d = my_ext.DogHouse()
-   >>> d.dog = gd
-   >>> d.dog.alarm()
-   Max: woof!
-   Max: woof!
-   Max: woof!
-
-.. _trampolines:
-
-Overriding virtual functions in Python
---------------------------------------
-
-Building on the previous example on :ref:`inheriting C++ types in Python
-<inheriting_in_python>`, let's investigate how a C++ *virtual function* can be
-overridden in Python. In the code below, the virtual method ``bark()`` is
-called by a global ``alarm()`` function (now written in C++).
-
-.. code-block:: cpp
-   :emphasize-lines: 6
-
-   #include <iostream>
-
-   struct Dog {
-       std::string name;
-       Dog(const std::string &name) : name(name) { }
-       virtual std::string bark() const { return name + ": woof!"; }
-   };
-
-   void alarm(Dog *dog, size_t count = 3) {
-       for (size_t i = 0; i < count; ++i)
-           std::cout << dog->bark() << std::endl;
-   }
-
-Normally, the binding code would look as follows:
-
-.. code-block:: cpp
-
-   #include <nanobind/stl/string.h>
-
-   namespace nb = nanobind;
-   using namespace nb::literals;
-
-   NB_MODULE(my_ext, m) {
-       nb::class_<Dog>(m, "Dog")
-          .def(nb::init<const std::string &>())
-          .def("bark", &Dog::bark)
-          .def_rw("name", &Dog::name);
-
-       m.def("alarm", &alarm, "dog"_a, "count"_a = 3);
-   }
-
-However, this don't work as expected. We can subclass and override without
-problems, but virtual function calls originating from C++ aren't being
-propagated to Python:
-
-.. code-block:: pycon
-
-   >>> class ShihTzu(my_ext.Dog):
-   ...     def bark(self):
-   ...         return self.name + ": yip!"
-   ...
-
-   >>> dog = ShihTzu("Mr. Fluffles")
-
-   >>> dog.bark()
-   Mr. Fluffles: yip!
-
-   >>> my_ext.alarm(dog)
-   Mr. Fluffles: woof!     # <-- oops, alarm() is calling the base implementation
-   Mr. Fluffles: woof!
-   Mr. Fluffles: woof!
-
-To fix this behavior, you must implement a *trampoline class*. A trampoline has
-the sole purpose of capturing virtual function calls in C++ and forwarding them
-to Python.
-
-.. code-block:: cpp
-
-   #include <nanobind/trampoline.h>
-
-   struct PyDog : Dog {
-       NB_TRAMPOLINE(Dog, 1);
-
-       std::string bark() const override {
-           NB_OVERRIDE(bark);
-       }
-   };
-
-This involves an additional include directive and the line
-:c:macro:`NB_TRAMPOLINE(Dog, 1) <NB_TRAMPOLINE>` to mark the class as a
-trampoline for the ``Dog`` base type. The count (``1``) denotes to the total
-number of virtual method slots that can be overridden within Python.
-
-.. note::
-
-   The number of virtual method slots is used to preallocate memory.
-   Trampoline declarations with an insufficient size may eventually trigger a
-   Python ``RuntimeError`` exception with a descriptive label, e.g.:
-
-   .. code-block:: text
-
-      nanobind::detail::get_trampoline('PyDog::bark()'): the trampoline ran out of
-      slots (you will need to increase the value provided to the NB_TRAMPOLINE() macro)
-
-The macro :c:macro:`NB_OVERRIDE(bark) <NB_OVERRIDE>` intercepts the virtual
-function call, checks if a Python override exists, and forwards the call in
-that case. If no override was found, it falls back to the base class
-implementation. You will need to replicate this pattern for every method that
-should support overriding in Python.
-
-The macro accepts an variable argument list to pass additional parameters. For
-example, suppose that the virtual function ``bark()`` had an additional ``int
-volume`` parameter---in that case, the syntax would need to be adapted as follows:
-
-.. code-block:: cpp
-
-       std::string bark(int volume) const override {
-           NB_OVERRIDE(bark, volume);
-       }
-
-The macro :c:macro:`NB_OVERRIDE_PURE() <NB_OVERRIDE_PURE>` should be used for
-pure virtual functions, and :c:macro:`NB_OVERRIDE() <NB_OVERRIDE>` should be
-used for functions which have a default implementation.  There are also two
-alternate macros :c:macro:`NB_OVERRIDE_PURE_NAME() <NB_OVERRIDE_PURE_NAME>` and
-:c:macro:`NB_OVERRIDE_NAME() <NB_OVERRIDE_NAME>` which take a string as first
-argument to specify the name of function in Python. This is useful when the C++
-and Python versions of the function have different names (e.g., ``operator+``
-vs ``__add__``).
-
-The binding code needs a tiny adaptation (highlighted) to inform nanobind of
-the trampoline that will be used whenever Python code extends the C++ class.
-
-.. code-block:: cpp
-
-   nb::class_<Dog, PyDog /* <-- trampoline */>(m, "Dog")
-
-If the :cpp:class:`nb::class_\<..\> <class_>` declaration also specifies a base
-class, you may specify it and the trampoline in either order. Also, note that
-binding declarations should be made against the actual class, not the
-trampoline:
-
-.. code-block:: cpp
-
-    nb::class_<Dog, PyDog>(m, "Dog")
-       .def(nb::init<const std::string &>())
-       .def("bark", &PyDog::bark); /* <--- THIS IS WRONG, use &Dog::bark */
-
-With the trampoline in place, our example works as expected:
-
-.. code-block:: pycon
-
-   >>> my_ext.alarm(dog)
-   Mr. Fluffles: yip!
-   Mr. Fluffles: yip!
-   Mr. Fluffles: yip!
-
-The following special case needs to be mentioned: you *may not* implement a
-Python trampoline for a method that returns a reference or pointer to a
-type requiring :ref:`type casting <type_casters>`. For example, attempting to
-expose a hypothetical virtual method ``const std::string &get_name() const``
-as follows
-
-.. code-block:: cpp
-
-       const std::string &get_name() const override {
-           NB_OVERRIDE(get_name);
-       }
-
-will fail with a static assertion failure:
-
-.. code-block:: text
-
-   include/nanobind/nb_cast.h:352:13: error: static_assert failed due to requirement '...'
-   "nanobind::cast(): cannot return a reference to a temporary."
-
-This is not a fluke. The Python would return a ``str`` object that nanobind can
-easily type-cast into a temporary ``std::string`` instance. However, when the
-virtual function call returns on the C++ side, that temporary will already have
-expired. There isn't a good solution to this problem, and nanobind therefore
-simply refuses to do it. You will need to change your approach by either using
-:ref:`bindings <bindings>` instead of :ref:`type casters <type_casters>` or
-changing your virtual method interfaces to return by value.
-
-.. _operator_overloading:
-
-Operator overloading
---------------------
-
-Suppose that we're given the following ``Vector2`` class with a vector addition
-and scalar multiplication operation, all implemented using overloaded operators
-in C++.
-
-.. code-block:: cpp
-
-   class Vector2 {
-   public:
-       Vector2(float x, float y) : x(x), y(y) { }
-
-       Vector2 operator+(const Vector2 &v) const { return Vector2(x + v.x, y + v.y); }
-       Vector2 operator*(float value) const { return Vector2(x * value, y * value); }
-       Vector2 operator-() const { return Vector2(-x, -y); }
-       Vector2& operator+=(const Vector2 &v) { x += v.x; y += v.y; return *this; }
-       Vector2& operator*=(float v) { x *= v; y *= v; return *this; }
-
-       friend Vector2 operator*(float f, const Vector2 &v) {
-           return Vector2(f * v.x, f * v.y);
-       }
-
-       std::string to_string() const {
-           return "[" + std::to_string(x) + ", " + std::to_string(y) + "]";
-       }
-   private:
-       float x, y;
-   };
-
-The following snippet shows how the above operators can be conveniently exposed
-to Python.
-
-.. code-block:: cpp
-
-    #include <nanobind/operators.h>
-
-    NB_MODULE(my_ext, m) {
-        nb::class_<Vector2>(m, "Vector2")
-            .def(nb::init<float, float>())
-            .def(nb::self + nb::self)
-            .def(nb::self += nb::self)
-            .def(nb::self *= float())
-            .def(float() * nb::self)
-            .def(nb::self * float())
-            .def(-nb::self)
-            .def("__repr__", &Vector2::to_string);
-    }
-
-Note that a line involving :cpp:var:`nb::self <self>` like
-
-.. code-block:: cpp
-
-   .def(nb::self * float())
-
-is really just short hand notation for
-
-.. code-block:: cpp
-
-   .def("__mul__", [](const Vector2 &a, float b) {
-       return a * b;
-   }, nb::is_operator())
-
-This can be useful for exposing additional operators that don't exist on the
-C++ side, or to perform other types of customization. The
-:cpp:class:`nb::is_operator() <is_operator>` flag marker is needed to inform
-nanobind that this is an operator, which returns ``NotImplemented`` when
-invoked with incompatible arguments rather than throwing a type error.
-
-When binding *in-place* operators such as ``operator+=``, and when their
-implementation is guaranteed to end with ``return *this``, it is recommended
-that you set a return value policy of :cpp:enumerator:`rv_policy::none`, i.e.,
-
-.. code-block:: cpp
-
-   .def(nb::self += nb::self, nb::rv_policy::none)
-
-Otherwise, the function binding will return a new copy of the object, which is
-usually not desired.
-
-Binding protected member functions
-----------------------------------
-
-It's normally not possible to expose ``protected`` member functions to Python:
-
-.. code-block:: cpp
-
-    class A {
-    protected:
-        int foo() const { return 42; }
-    };
-
-    nb::class_<A>(m, "A")
-        .def("foo", &A::foo); // error: 'foo' is a protected member of 'A'
-
-On one hand, this is good because non-``public`` members aren't meant to be
-accessed from the outside. But we may want to make use of ``protected``
-functions in derived Python classes.
-
-The following pattern makes this possible:
-
-.. code-block:: cpp
-
-    class A {
-    protected:
-        int foo() const { return 42; }
-    };
-
-    class Publicist : public A { // helper type for exposing protected functions
-    public:
-        using A::foo; // inherited with different access modifier
-    };
-
-    nb::class_<A>(m, "A") // bind the primary class
-        .def("foo", &Publicist::foo); // expose protected methods via the publicist
-
-This works because ``&Publicist::foo`` is exactly the same function as
-``&A::foo`` (same signature and address), just with a different access
-modifier. The only purpose of the ``Publicist`` helper class is to make
-the function name ``public``.
-
-If the intent is to expose ``protected`` ``virtual`` functions which can be
-overridden in Python, the publicist pattern can be combined with the previously
-described trampoline:
-
-.. code-block:: cpp
-
-    class A {
-    public:
-        virtual ~A() = default;
-
-    protected:
-        virtual int foo() const { return 42; }
-    };
-
-    class Trampoline : public A {
-    public:
-        NB_TRAMPOLINE(A, 1);
-        int foo() const override { NB_OVERRIDE(foo); }
-    };
-
-    class Publicist : public A {
-    public:
-        using A::foo;
-    };
-
-    nb::class_<A, Trampoline>(m, "A") // <-- `Trampoline` here
-        .def("foo", &Publicist::foo); // <-- `Publicist` here, not `Trampoline`!
-
-Binding classes with template parameters
-----------------------------------------
-
-nanobind can also wrap classes that have template parameters. Consider these classes:
-
-.. code-block:: cpp
-
-    struct Cat {};
-    struct Dog {};
-
-    template <typename PetType> struct PetHouse {
-        PetHouse(PetType& pet);
-        PetType& get();
-    };
-
-C++ templates may only be instantiated at compile time, so nanobind can only
-wrap instantiated templated classes. You cannot wrap a non-instantiated template:
-
-.. code-block:: cpp
-
-    // BROKEN (this will not compile)
-    nb::class_<PetHouse>(m, "PetHouse");
-        .def("get", &PetHouse::get);
-
-You must explicitly specify each template/type combination that you want to
-wrap separately.
-
-.. code-block:: cpp
-
-    // ok
-    nb::class_<PetHouse<Cat>>(m, "CatHouse")
-        .def("get", &PetHouse<Cat>::get);
-
-    // ok
-    nb::class_<PetHouse<Dog>>(m, "DogHouse")
-        .def("get", &PetHouse<Dog>::get);
-
-If your class methods have template parameters you can wrap those as well,
-but once again each instantiation must be explicitly specified:
-
-.. code-block:: cpp
-
-    typename <typename T> struct MyClass {
-        template <typename V> T fn(V v);
-    };
-
-    nb::class_<MyClass<int>>(m, "MyClassT")
-        .def("fn", &MyClass<int>::fn<std::string>);
-
-.. _tag_based_polymorphism:
-
-Tag-based polymorphism
-----------------------
-
-The section on :ref:`automatic downcasting <automatic_downcasting>` explained
-how nanobind can infer the type of polymorphic C++ objects at runtime. It can
-be desirable to extend this automatic downcasting behavior to non-polymorphic
-classes, for example to support *tag-based polymorphism*. In this case,
-instances expose a method or field to identify their type.
-
-For example, consider the following class hierarchy where ``Pet::kind``
-serves this purpose:
-
-.. code-block:: cpp
-
-   #include <nanobind/nanobind.h>
-
-   namespace nb = nanobind;
-
-   enum class PetKind { Cat, Dog };
-
-   struct Pet { const PetKind kind; };
-   struct Dog : Pet { Dog() : Pet{PetKind::Dog} { } };
-   struct Cat : Pet { Cat() : Pet{PetKind::Cat} { } };
-
-   namespace nb = nanobind;
-
-   NB_MODULE(my_ext, m) {
-       nb::class_<Pet>(m, "Pet");
-       nb::class_<Dog>(m, "Dog");
-       nb::class_<Cat>(m, "Cat");
-
-       nb::enum_<PetKind>(m, "PetKind")
-           .value("Cat", PetKind::Cat)
-           .value("Dog", PetKind::Dog);
-
-       m.def("make_pet", [](PetKind kind) -> Pet* {
-           switch (kind) {
-               case PetKind::Dog: return new Dog();
-               case PetKind::Cat: return new Cat();
-           }
-       });
-   }
-
-This code initially doesn't work as expected (the ``make_pet`` function binding
-always creates instances of the ``Pet`` base class).
-
-.. code-block:: pycon
-
-   >>> my_ext.make_pet(my_ext.PetKind.Cat)
-   <my_ext.Pet object at 0x10305ee10>
-
-   >>> my_ext.make_pet(my_ext.PetKind.Dog)
-   <my_ext.Pet object at 0x10328e530>
-
-To fix this, partially specialize the ``type_hook`` class to provide the
-``type_hook<T>::get()`` method:
-
-.. code-block:: cpp
-
-   namespace nanobind::detail {
-       template <> struct type_hook<Pet> {
-           static const std::type_info *get(Pet *p) {
-               if (p) {
-                   switch (p->kind) {
-                       case PetKind::Dog: return &typeid(Dog);
-                       case PetKind::Cat: return &typeid(Cat);
-                   }
-               }
-               return &typeid(Pet);
-           }
-       };
-   } // namespace nanobind::detail
-
-The method will be invoked whenever nanobind needs to convert a C++ pointer of
-type ``T*`` to a Python object. It should inspect the instance and return a
-pointer to a suitable RTTI record. With this override, downcasting works as
-expected:
-
-.. code-block:: pycon
-
-    >>> my_ext.make_pet(my_ext.PetKind.Cat)
-    <my_ext.Cat object at 0x104da6e10>
-
-    >>> my_ext.make_pet(my_ext.PetKind.Dog)
-    <my_ext.Dog object at 0x104da6ef0>
-
-Binding unions
---------------
-
-:cpp:class:`nb::class_\<..\> <class_>` can also be used to provide bindings
-for `unions <https://en.cppreference.com/w/cpp/language/union>`__.
-A basic and useless example:
-
-.. code-block:: cpp
-
-   union Example {
-       int ival;
-       double dval;
-
-       std::string to_string(size_t active_idx) const {
-           return active_idx == 1 ? std::to_string(dval) : std::to_string(ival);
-       }
-   };
-   static_assert(sizeof(Example) == sizeof(double));
-
-   nb::class_<Example>(m, "Example")
-       .def_rw("ival", &Example::ival)
-       .def_rw("dval", &Example::dval)
-       .def("to_string", &Example::to_string);
-
-.. code-block:: pycon
-
-   >>> u = my_ext.Example()
-   >>> u.ival = 42
-   >>> u.to_string(0)
-   '42'
-   >>> u.dval = 1.25
-   >>> u.to_string(1)
-   '1.250000'
-
-Direct binding of union variant members is only safe if all members of the
-union are trivially copyable types (as in this example), but more complex
-unions can also be supported by binding lambdas or member functions that
-enforce the necessary invariants.
-
-This is a low-level feature and should be used with care; even when all
-members are trivially copyable, reading from a union member
-other than the most recently written one produces undefined behavior
-in C++. Unless you need to bind an existing API that uses union types,
-you're probably better off using ``std::variant<..>``, which knows what
-member is active and can thus enforce all the ncessary invariants for you.
-
-Pickling
---------
-
-To pickle and unpickle objects bound using nanobind, expose the
-``__getstate__`` and ``__setstate__`` methods. They should return and retrieve
-the internal instance state using representations that themselves support
-pickling. The example below, e.g., does this using a tuple.
-
-The ``__setstate__`` method should construct the object in-place analogous to
-custom ``__init__``-style constructors.
-
-.. code-block:: cpp
-
-   #include <nanobind/stl/tuple.h>
-
-   struct Pet {
-        std::string name;
-        int age;
-        Pet(const std::string &name, int age) : name(name), age(age) { }
-   };
-
-   NB_MODULE(my_ext, m) {
-       nb::class_<Pet>(m, "Pet")
-          // ...
-          .def("__getstate__", [](const Pet &pet) { return std::make_tuple(pet.name, pet.age); })
-          .def("__setstate__", [](Pet &pet, const std::tuple<std::string, int> &state) {
-                new (&pet) Pet(
-                    std::get<0>(state),
-                    std::get<1>(state)
-                );
-          });
-    }
-
-.. _custom_new:
-
-Customizing Python object creation
-----------------------------------
-
-Sometimes you might need to bind a class that can't be constructed in the
-usual way:
-
-.. code-block:: cpp
-
-   class Pet {
-     private:
-       Pet(/* ... */);
-     public:
-       static std::unique_ptr<Pet> make(std::string name, int age);
-       void speak();
-   };
-
-You can use :cpp:func:`.def_static() <class_::def_static>` to
-produce bindings that let you write ``Pet.make("Fido", 2)`` in Python,
-just like you would write ``Pet::make("Fido", 2)`` in C++. But sometimes it's
-nice to provide a more Pythonic interface than that, like ``Pet("Fido", 2)``.
-To do that, nanobind lets you override ``__new__``.
-
-Since this is a rarely-used feature in Python, let's recap. Object
-initialization in Python occurs in two phases:
-
-* the *constructor*, ``__new__``, allocates memory for the object;
-
-* the *initializer*, ``__init__``, sets up the object's initial state.
-
-So far, all the ways we've seen of binding C++ constructors
-(:cpp:struct:`nb::init\<..\>() <init>`, ``.def("__init__", ...)``)
-produce Python object *initializers*. nanobind augments these with its own
-Python object constructor, which allocates a Python object that has
-space in its memory layout for the C++ object to slot in.
-The ``__init__`` method then fills in that space by calling a C++ constructor.
-
-This split between ``__new__`` and ``__init__`` has a lot of benefits,
-including a reduction in unnecessary allocations, but it does mean that
-anything created from Python must be able to control where its
-C++ innards are stored. Sometimes, as with the example of ``Pet`` above,
-that's not feasible. In such cases, you can go down one level and override
-``__new__`` directly:
-
-.. code-block:: cpp
-
-   nb::class_<Pet>(m, "Pet")
-       .def(nb::new_(&Pet::make), "name"_a, "age"_a)
-       .def("speak", &Pet::speak);
-
-Passing :cpp:struct:`nb::new_ <new_>` to :cpp:func:`.def() <class_::def>`
-here creates two magic methods on ``Pet``:
-
-* A ``__new__`` that uses the given function to produce a new ``Pet``.
-  It is converted to a Python object in the same way as the return value
-  of any other function you might write bindings for. In particular,
-  you can pass a :cpp:enum:`nb::rv_policy <rv_policy>` as an additional
-  argument to :cpp:func:`.def() <class_::def>` to control how this conversion
-  occurs.
-
-* A ``__init__`` that takes the same arguments as ``__new__`` but
-  performs no operation.  This is necessary because Python automatically
-  calls ``__init__`` on the object returned by ``__new__`` in most cases.
-
-You can provide a lambda as the argument of :cpp:struct:`nb::new_ <new_>`.
-This is most useful when the lambda returns a pointer or smart pointer;
-if it's returning a value, then ``.def("__init__", ...)`` will have better
-performance. Additionally, you can chain multiple calls to
-``.def(nb::new_(...))`` in order to create an overload set.
-The following example demonstrates both of these capabilities:
-
-.. code-block:: cpp
-
-   nb::class_<Pet>(m, "Pet")
-       .def(nb::new_([]() { return Pet::make(getRandomName(), 0); }))
-       .def(nb::new_(&Pet::make), "name"_a, "age"_a)
-       .def("speak", &Pet::speak);
-
-If you need even more control, perhaps because you need to access the
-type object that Python passes as the first argument of ``__new__``
-(which :cpp:struct:`nb::new_ <new_>` discards), you can write a
-``.def_static("__new__", ...)`` and matching ``.def("__init__", ...)``
-yourself.
-
-Two limitations of :cpp:struct:`nb::new_ <new_>` are worth noting:
-
-* The possibilities for Python-side inheritance from C++ classes that
-  are bound using :cpp:struct:`nb::new_ <new_>` constructors are substantially
-  reduced. Simple inheritance situations (``class PyPet(Pet): ...``) should
-  work OK, but you can't :ref:`override virtual functions <trampolines>`
-  in Python (because the C++ object returned by :cpp:struct:`new_ <new_>`
-  doesn't contain the Python trampoline glue), and if :cpp:struct:`new_ <new_>`
-  is used to implement a polymorphic factory (like if ``Pet::make()`` could
-  return an instance of ``Cat``) then Python-side inheritance won't work at all.
-
-* A given C++ class must expose all of its constructors via ``__new__`` or
-  all via ``__init__``, rather than a mixture of the two.
-  The only case where a class should bind both of these methods is
-  if the ``__init__`` methods are all stubs that do nothing.
-  This is because nanobind internally optimizes object instantiation by
-  caching the method that should be used for constructing instances of each
-  given type, and that optimization doesn't support trying both methods.
-  If you really need to combine nontrivial ``__new__`` and nontrivial
-  ``__init__`` in the same type, you can disable the optimization by
-  defining a :ref:`custom type slot <typeslots>` of ``Py_tp_new`` or
-  ``Py_tp_init``.
-
-.. note::
-
-   Unpickling an object of type ``Foo`` normally requires that
-   ``Foo.__new__(Foo)`` produce something that ``__setstate__`` can be
-   called on. Any custom :cpp:struct:`nb::new_ <new_>` methods will
-   not satisfy this requirement, because they return a
-   fully-constructed object. In order to maintain pickle
-   compatibility, nanobind by default will add an additional
-   ``__new__`` overload that takes no extra arguments and calls the nanobind
-   built-in :cpp:func:`inst_alloc`. This won't make your class constructible
-   with no arguments, because there's no corresponding ``__init__``; it
-   just helps unpickling work. If your first :cpp:struct:`nb::new_ <new_>`
-   method is one that takes no arguments, then nanobind won't add its own,
-   and you'll have to deal with unpickling some other way.
diff --git a/src/nanobind/docs/conf.py b/src/nanobind/docs/conf.py
deleted file mode 100644
index 3ec328a..0000000
--- a/src/nanobind/docs/conf.py
+++ /dev/null
@@ -1,250 +0,0 @@
-#!/usr/bin/env python3
-#
-
-import os
-import re
-
-# -- General configuration ------------------------------------------------
-
-# If your documentation needs a minimal Sphinx version, state it here.
-# needs_sphinx = '1.0'
-
-# Add any Sphinx extension module names here, as strings. They can be
-# extensions coming with Sphinx (named 'sphinx.ext.*') or your custom
-# ones.
-extensions = [
-    "sphinx_copybutton",
-    "sphinxcontrib.rsvgconverter",
-    "sphinxcontrib.moderncmakedomain",
-    "sphinx.ext.intersphinx",
-]
-
-intersphinx_mapping = {
-    "python": ("https://docs.python.org/3", None),
-}
-
-# Add any paths that contain templates here, relative to this directory.
-templates_path = [".templates"]
-
-# The suffix(es) of source filenames.
-# You can specify multiple suffix as a list of string:
-# source_suffix = ['.rst', '.md']
-source_suffix = ".rst"
-
-# The encoding of source files.
-# source_encoding = 'utf-8-sig'
-
-# The master toctree document.
-master_doc = "index"
-
-# General information about the project.
-project = "nanobind"
-copyright = "2023, Wenzel Jakob"
-author = "Wenzel Jakob"
-
-# The version info for the project you're documenting, acts as replacement for
-# |version| and |release|, also used in various other places throughout the
-# built documents.
-
-# Read the listed version
-VERSION_REGEX = re.compile(
-    r"^\s*#\s*define\s+NB_VERSION_([A-Z]+)\s+(.*)$", re.MULTILINE)
-
-this_directory = os.path.abspath(os.path.dirname(os.path.dirname(__file__)))
-
-with open(os.path.join(this_directory, "include/nanobind/nanobind.h")) as f:
-    matches = dict(VERSION_REGEX.findall(f.read()))
-    version = "{MAJOR}.{MINOR}.{PATCH}".format(**matches)
-
-# The language for content autogenerated by Sphinx. Refer to documentation
-# for a list of supported languages.
-#
-# This is also used if you do content translation via gettext catalogs.
-# Usually you set "language" from the command line for these cases.
-language = "en"
-
-# There are two options for replacing |today|: either, you set today to some
-# non-false value, then it is used:
-# today = ''
-# Else, today_fmt is used as the format for a strftime call.
-# today_fmt = '%B %d, %Y'
-
-# List of patterns, relative to source directory, that match files and
-# directories to ignore when looking for source files.
-exclude_patterns = [".build", "release.rst"]
-
-# The reST default role (used for this markup: `text`) to use for all
-# documents.
-default_role = "any"
-
-# If true, '()' will be appended to :func: etc. cross-reference text.
-# add_function_parentheses = True
-
-# If true, the current module name will be prepended to all description
-# unit titles (such as .. function::).
-# add_module_names = True
-
-# If true, sectionauthor and moduleauthor directives will be shown in the
-# output. They are ignored by default.
-# show_authors = False
-
-# The name of the Pygments (syntax highlighting) style to use.
-# pygments_style = 'monokai'
-
-# A list of ignored prefixes for module index sorting.
-# modindex_common_prefix = []
-
-# If true, keep warnings as "system message" paragraphs in the built documents.
-# keep_warnings = False
-
-# If true, `todo` and `todoList` produce output, else they produce nothing.
-todo_include_todos = False
-
-
-# -- Options for HTML output ----------------------------------------------
-
-# The theme to use for HTML and HTML Help pages.  See the documentation for
-# a list of builtin themes.
-
-html_theme = "furo"
-
-# Theme options are theme-specific and customize the look and feel of a theme
-# further.  For a list of options available for each theme, see the
-# documentation.
-# html_theme_options = {}
-
-# Add any paths that contain custom themes here, relative to this directory.
-# html_theme_path = []
-
-# The name for this set of Sphinx documents.  If None, it defaults to
-# "<project> v<version> documentation".
-# html_title = None
-
-# A shorter title for the navigation bar.  Default is the same as html_title.
-# html_short_title = None
-
-# The name of an image file (relative to this directory) to place at the top
-# of the sidebar.
-# html_logo = None
-
-# The name of an image file (within the static path) to use as favicon of the
-# docs.  This file should be a Windows icon file (.ico) being 16x16 or 32x32
-# pixels large.
-# html_favicon = None
-
-# Add any paths that contain custom static files (such as style sheets) here,
-# relative to this directory. They are copied after the builtin static files,
-# so a file named "default.css" will overwrite the builtin "default.css".
-#  html_static_path = ["_static"]
-
-#  html_css_files = [ ]
-
-# Add any extra paths that contain custom files (such as robots.txt or
-# .htaccess) here, relative to this directory. These files are copied
-# directly to the root of the documentation.
-# html_extra_path = []
-
-# If not '', a 'Last updated on:' timestamp is inserted at every page bottom,
-# using the given strftime format.
-# html_last_updated_fmt = '%b %d, %Y'
-
-# If true, SmartyPants will be used to convert quotes and dashes to
-# typographically correct entities.
-# html_use_smartypants = True
-
-# Custom sidebar templates, maps document names to template names.
-# html_sidebars = {}
-
-# Additional templates that should be rendered to pages, maps page names to
-# template names.
-# html_additional_pages = {}
-
-# If false, no module index is generated.
-# html_domain_indices = True
-
-# If false, no index is generated.
-# html_use_index = True
-
-# If true, the index is split into individual pages for each letter.
-# html_split_index = False
-
-# If true, links to the reST sources are added to the pages.
-# html_show_sourcelink = True
-
-# If true, "Created using Sphinx" is shown in the HTML footer. Default is True.
-# html_show_sphinx = True
-
-# If true, "(C) Copyright ..." is shown in the HTML footer. Default is True.
-# html_show_copyright = True
-
-# If true, an OpenSearch description file will be output, and all pages will
-# contain a <link> tag referring to it.  The value of this option must be the
-# base URL from which the finished HTML is served.
-# html_use_opensearch = ''
-
-# This is the file name suffix for HTML files (e.g. ".xhtml").
-# html_file_suffix = None
-
-# Language to be used for generating the HTML full-text search index.
-# Sphinx supports the following languages:
-#   'da', 'de', 'en', 'es', 'fi', 'fr', 'h', 'it', 'ja'
-#   'nl', 'no', 'pt', 'ro', 'r', 'sv', 'tr'
-# html_search_language = 'en'
-
-# A dictionary with options for the search language support, empty by default.
-# Now only 'ja' uses this config value
-# html_search_options = {'type': 'default'}
-
-# The name of a javascript file (relative to the configuration directory) that
-# implements a search results scorer. If empty, the default will be used.
-# html_search_scorer = 'scorer.js'
-
-# Output file base name for HTML help builder.
-htmlhelp_basename = "nanobind_doc"
-
-# -- Options for LaTeX output ---------------------------------------------
-
-latex_engine = "pdflatex"
-
-latex_elements = {
-    'papersize': 'a4paper',
-    'pointsize': '10pt',
-    "classoptions": ",openany,oneside",
-    "preamble": r"""
-\usepackage{MnSymbol}
-\DeclareUnicodeCharacter{25CB}{\ensuremath{\circ}}
-\DeclareUnicodeCharacter{25CF}{\ensuremath{\bullet}}
-\DeclareUnicodeCharacter{21B5}{\ensuremath{\rhookswarrow}}
-\DeclareUnicodeCharacter{2194}{\ensuremath{\leftrightarrow}}
-""",
-}
-
-# Grouping the document tree into LaTeX files. List of tuples
-# (source start file, target name, title,
-#  author, documentclass [howto, manual, or own class]).
-latex_documents = [
-    (master_doc, "nanobind.tex", "nanobind Documentation", author, "manual"),
-]
-
-# The name of an image file (relative to this directory) to place at the top of
-# the title page.
-# latex_logo = 'nanobind-logo.png'
-
-# For "manual" documents, if this is true, then toplevel headings are parts,
-# not chapters.
-# latex_use_parts = False
-
-# If true, show page references after internal links.
-# latex_show_pagerefs = False
-
-# If true, show URL addresses after external links.
-# latex_show_urls = False
-
-# Documents to append as an appendix to all manuals.
-# latex_appendices = []
-
-# If false, no module index is generated.
-# latex_domain_indices = True
-
-primary_domain = "cpp"
-highlight_language = "cpp"
diff --git a/src/nanobind/docs/cppyy.h b/src/nanobind/docs/cppyy.h
deleted file mode 100644
index 4d7e861..0000000
--- a/src/nanobind/docs/cppyy.h
+++ /dev/null
@@ -1,16 +0,0 @@
-float test_0000(uint16_t a, int32_t b, uint32_t c, int64_t d, uint64_t e,
-                float f) {
-    return a + b + c + d + e + f;
-}
-
-struct Struct0 {
-    uint16_t a;
-    int32_t b;
-    uint32_t c;
-    int64_t d;
-    uint64_t e;
-    float f;
-    Struct0(uint16_t a, int32_t b, uint32_t c, int64_t d, uint64_t e, float f)
-        : a(a), b(b), c(c), d(d), e(e), f(f) {}
-    float sum() const { return a + b + c + d + e + f; }
-};
diff --git a/src/nanobind/docs/eigen.rst b/src/nanobind/docs/eigen.rst
deleted file mode 100644
index 4dcd63c..0000000
--- a/src/nanobind/docs/eigen.rst
+++ /dev/null
@@ -1,180 +0,0 @@
-.. cpp:namespace:: nanobind
-
-.. _eigen:
-
-The *Eigen* linear algebra library
-==================================
-
-`Eigen <http://eigen.tuxfamily.org>`__ is a header-only C++ library for linear
-algebra that offers dense and sparse matrix types along with a host of
-algorithms that operate on them. Owing to its widespread use in many scientific
-projects, nanobind includes custom type casters that enable bidirectional
-conversion between Eigen and Python array programming libraries.
-
-These casters build on the previously discussed :ref:`n-dimensional array
-<ndarray_class>` class. You can therefore think of this section as an easier
-interface to the same features that is preferable if your project uses Eigen.
-
-Dense matrices and vectors
---------------------------
-
-Add the following include directive to your binding code to exchange dense
-Eigen types:
-
-.. code-block:: cpp
-
-   #include <nanobind/eigen/dense.h>
-
-Following this, you should be able to bind functions that accept and return
-values of type ``Eigen::Matrix<..>``, ``Eigen::Array<..>``,
-``Eigen::Vector<..>``, ``Eigen::Ref<..>``, ``Eigen::Map<..>``, and their
-various specializations.  Unevaluated expression templates are also supported.
-
-nanobind may need to evaluate or copy the matrix/vector contents during type
-casting, which is sometimes undesirable. The following cases explain when
-copying is needed, and how it can be avoided.
-
-C++ → Python
-^^^^^^^^^^^^
-
-Consider the following C++ function returning a dense Eigen type
-(``Eigen::MatrixXf`` in this example). The bound Python version of ``f()``
-returns this data in the form of a ``numpy.ndarray``.
-
-.. code-block:: cpp
-
-   Eigen::MatrixXf f() { ... }
-
-If the C++ function returns *by value*, and when the Eigen type represents an
-evaluated expression, nanobind will capture and wrap it in a NumPy array
-without making a copy. All other cases (returning by reference, returning an
-unevaluated expression template) either evaluate or copy the array.
-
-.. warning::
-
-   It can be tempting to bind functions that directly return Eigen expressions,
-   such as such the innocent-looking vector sum below:
-
-   .. code-block:: cpp
-
-      m.def("sum", [](Eigen::Vector3f a, Eigen::Vector3d b) { return a + b; });
-
-   However, note that this example triggers undefined behavior. The problem is
-   that the sum ``a + b`` is an *expression template*, which provides the means
-   to evaluate the expression at some later point. The expression references
-   variables on the stack that no longer exist when when the expression is
-   evaluated by the caller. The issue is not related to nanobind (i.e., this is
-   also a bug in pure Eigen code).
-
-   To fix this you can
-
-   1. Specify a return type, e.g.,
-
-      .. code-block:: cpp
-
-         m.def("sum", [](Eigen::Vector3f a, Eigen::Vector3d b) -> Eigen::Vector3d { return a + b; });
-
-      This forces an evaluation of the expression into a container that *owns*
-      the underlying storage.
-
-   2. Invoke ``Eigen::DenseBase::eval()``, which is equivalent and potentially
-      more compact and flexible.
-
-      .. code-block:: cpp
-
-         m.def("sum", [](Eigen::Vector3f a, Eigen::Vector3d b) { return (a + b).eval(); });
-
-   3. If the expression to be returned only references function arguments,
-      then you can turn the arguments themselves into references:
-
-      .. code-block:: cpp
-
-         m.def("sum", [](const Eigen::Vector3f &a, const Eigen::Vector3d &b) { return a + b; });
-
-      This is safe, because the nanobind type casters keep the referenced
-      objects alive until the expression has been evaluated.
-
-Python → C++
-^^^^^^^^^^^^
-
-The reverse direction is more tricky. Consider the following 3
-functions taking variations of a dense ``Eigen::MatrixXf``:
-
-.. code-block:: cpp
-
-   void f1(const Eigen::MatrixXf &x) { ... }
-   void f2(const Eigen::Ref<Eigen::MatrixXf> &x) { ... }
-   void f3(const nb::DRef<Eigen::MatrixXf> &x) { ... }
-
-The Python bindings of these three functions can be called using any of a
-number of different CPU-resident 2D array types (NumPy arrays,
-PyTorch/Tensorflow/JAX tensors, etc.). However, the following limitations
-apply:
-
-- ``f1()`` will always perform a copy of the array contents when called from
-  Python. This is because ``Eigen::MatrixXf`` is designed to *own* the
-  underlying storage, which is sadly incompatible with the idea of creating a
-  view of an existing Python array.
-
-- ``f2()`` very likely copies as well! This may seem non-intuitive, since
-  ``Eigen::Ref<..>`` exists to avoid this exact problem.
-
-  The problem is that Eigen normally expects a very specific memory layout
-  (Fortran/column-major layout), while Python array frameworks actually use the
-  *opposite* by default (C/row-major layout). Array slices are even more
-  problematic and always require a copy.
-
-- ``f3()`` uses :cpp:type:`nb::DRef <DRef>` to support *any* memory layout
-  (row-major, column-major, slices) without copying. It may still perform an
-  implicit conversion when called with the *wrong data type*---for example, the
-  function expects a single precision array, but NumPy matrices often use
-  double precision.
-
-  If that is undesirable, you may bind the function as follows, in which case
-  nanobind will report a ``TypeError`` if an implicit conversion would be
-  needed.
-
-  .. code-block:: cpp
-
-     m.def("f1", &f1, nb::arg("x").noconvert());
-
-  This parameter passing convention can also be used to mutate function
-  parameters, e.g.:
-
-  .. code-block:: cpp
-
-     void f4(nb::DRef<Eigen::MatrixXf> x) { x *= 2; }
-
-Maps
-----
-
-Besides ``Eigen::Ref<...>``, nanobind also supports binding functions that take
-and return ``Eigen::Map<...>``. The underlying map type caster strictly
-prevents conversion of incompatible inputs into an ``Eigen::Map<...>`` when
-this would require implicit layout or type conversion. This restriction exists
-because the primary purpose of this interface is to efficiently access existing
-memory without conversion overhead. When binding functions that return
-``Eigen::Map<...>``, you must ensure that the mapped memory remains valid
-throughout the map's lifetime. This typically requires appropriate lifetime
-annotations (such as :cpp:enumerator:`rv_policy::reference_internal` or
-:cpp:struct:`keep_alive`) to prevent access to memory that has been deallocated
-on the C++ side.
-
-Sparse matrices
----------------
-
-Add the following include directive to your binding code to exchange sparse
-Eigen types:
-
-.. code-block:: cpp
-
-   #include <nanobind/eigen/sparse.h>
-
-The ``Eigen::SparseMatrix<..>`` and ``Eigen::Map<Eigen::SparseMatrix<..>>``
-types map to either ``scipy.sparse.csr_matrix`` or ``scipy.sparse.csc_matrix``
-depending on whether row- or column-major storage is used. The previously
-mentioned precautions related to returning dense maps also apply in the sparse
-case.
-
-There is no support for Eigen sparse vectors because an equivalent type does
-not exist as part of ``scipy.sparse``.
diff --git a/src/nanobind/docs/exceptions.rst b/src/nanobind/docs/exceptions.rst
deleted file mode 100644
index 3e97df6..0000000
--- a/src/nanobind/docs/exceptions.rst
+++ /dev/null
@@ -1,291 +0,0 @@
-.. cpp:namespace:: nanobind
-
-.. _exceptions:
-
-Exceptions
-==========
-
-.. _exception_conversion:
-
-Automatic conversion of C++ exceptions
---------------------------------------
-
-When Python calls a C++ function, that function might raise an exception
-instead of returning a result. In such a case, nanobind will capture the C++
-exception and then raise an equivalent exception within Python. This automatic
-conversion supports ``std::exception``, common subclasses, and several classes
-that convert to specific Python exceptions as shown below:
-
-.. list-table::
-  :widths: 40 60
-  :header-rows: 1
-
-  * - Exception thrown by C++
-    - Translated to Python exception type
-  * - ``std::exception``
-    - ``RuntimeError``
-  * - ``std::bad_alloc``
-    - ``MemoryError``
-  * - ``std::domain_error``
-    - ``ValueError``
-  * - ``std::invalid_argument``
-    - ``ValueError``
-  * - ``std::length_error``
-    - ``ValueError``
-  * - ``std::out_of_range``
-    - ``IndexError``
-  * - ``std::range_error``
-    - ``ValueError``
-  * - ``std::overflow_error``
-    - ``OverflowError``
-  * - :cpp:func:`nb::stop_iteration <stop_iteration>`
-    - ``StopIteration`` (used to implement custom iterator) 
-  * - :cpp:func:`nb::index_error <index_error>`
-    - ``IndexError`` (used to indicate out of bounds access in ``__getitem__``,
-      ``__setitem__``, etc.)
-  * - :cpp:func:`nb::key_error <index_error>`
-    - ``KeyError`` (used to indicate an invalid access in ``__getitem__``,
-      ``__setitem__``, etc.)
-  * - :cpp:func:`nb::value_error <value_error>`
-    - ``ValueError`` (used to indicate an invalid value in operations like
-      ``container.remove(...)``)
-  * - :cpp:func:`nb::type_error <type_error>`
-    - ``TypeError``
-  * - :cpp:func:`nb::buffer_error <type_error>`
-    - ``BufferError``
-  * - :cpp:func:`nb::import_error <import_error>`
-    - ``ImportError``
-  * - :cpp:func:`nb::attribute_error <attribute_error>`
-    - ``AttributeError``
-  * - Any other exception
-    - ``SystemError``
-
-Exception translation is not bidirectional. A C++ ``catch
-(nb::key_error)`` block will not catch a Python ``KeyError``. Use
-:cpp:class:`nb::python_error <python_error>` for this purpose (see the :ref:`example
-below <handling_python_exceptions_cpp>` for details).
-
-The is also a special exception :cpp:class:`nb::cast_error <cast_error>` that may
-be raised
-by the call operator :cpp:func:`nb::handle::operator()
-<detail::api::operator()>` and :cpp:func:`nb::cast() <cast>` when argument(s)
-cannot be converted to Python objects.
-
-.. _custom_exceptions:
-
-Handling custom exceptions
---------------------------
-
-nanobind can also expose custom exception types. The
-:cpp:class:`nb::exception\<T\> <exception>` helper resembles
-:cpp:class:`nb::class_\<T\> <class_>` and registers a new exception type within
-the provided scope.
-
-.. code-block:: cpp
-
-   NB_MODULE(my_ext, m) {
-       nb::exception<CppExp>(m, "PyExp");
-   }
-
-Here, it creates ``my_ext.PyExp``. Subsequently, any C++ exception of type
-``CppExp`` crossing the language barrier will automatically convert to
-``my_ext.PyExp``.
-
-A Python exception base class can optionally be specified. For example, the
-snippet below causes ``PyExp`` to inherit from ``RuntimeError`` (the default is
-``Exception``). The built-in Python exception classes are listed `here
-<https://docs.python.org/3/c-api/exceptions.html#standard-exceptions>`__.
-
-.. code-block:: cpp
-
-    nb::exception<CppExp>(module, "PyExp", PyExc_RuntimeError);
-
-In more complex cases, :cpp:func:`nb::register_exception_translator()
-<register_exception_translator>` can be called to register a custom exception
-translation routine. It takes a stateless callable (e.g. a function pointer or
-a lambda function without captured variables) with the call signature
-``void(const std::exception_ptr &, void*)`` and an optional payload pointer
-value that will be passed to the second parameter of the callable.
-
-When a C++ exception is captured by nanobind, all registered exception
-translators are tried in reverse order of registration (i.e. the last
-registered translator has the first chance of handling the exception). 
-
-Inside the translator, call ``std::rethrow_exception()`` within a
-``try``-``catch`` block to re-throw the exception and capture supported
-exception types. The ``catch`` block should call ``PyErr_SetString`` or
-``PyErr_Format`` (`1
-<https://docs.python.org/3/c-api/exceptions.html#c.PyErr_SetString>`__, `2
-<https://docs.python.org/3/c-api/exceptions.html#c.PyErr_Format>`__) to
-set a suitable Python error status. The following example demonstrates this
-pattern to convert ``MyCustomException`` into a Python ``IndexError``.
-
-.. code-block:: cpp
-
-    nb::register_exception_translator(
-        [](const std::exception_ptr &p, void * /* unused */) {
-            try {
-                std::rethrow_exception(p);
-            } catch (const MyCustomException &e) {
-                PyErr_SetString(PyExc_IndexError, e.what());
-            }
-        });
-
-Multiple exceptions can be handled by a single translator. nanobind captures
-unhandled exceptions and forwards them to the preceding translator. If none of
-the exception translators succeeds, it will convert according to the previously
-discussed default rules.
-
-.. note::
-
-    When the exception translator returns normally, it must have set a Python
-    error status. Otherwise, Python will crash with the message ``SystemError:
-    error return without exception set``.
-
-    Unsupported exception types should not be caught, or may be explicitly
-    (re-)thrown to delegate them to the other exception translators.
-
-.. _handling_python_exceptions_cpp:
-
-Capturing Python exceptions within C++
---------------------------------------
-
-When nanobind-based C++ code calls a Python function that raises an exception,
-it will automatically convert into a :class:`nb::python_error <python_error>`
-raised on the C++ side. This exception type can be caught and handled in C++ or
-propagate back into Python, where it will undergo reverse conversion.
-
-.. list-table::
-  :widths: 40 60
-  :header-rows: 1
-
-  * - Exception raised in Python
-    - Translated to C++ exception type
-  * - Any Python ``Exception``
-    - :cpp:class:`nb::python_error <python_error>`
-
-The class exposes various members to obtain further information about the
-exception. The :cpp:func:`.type() <python_error::type>` and :cpp:func:`.value()
-<python_error::value>` methods provide information about the exception type and
-value, while :cpp:func:`.what() <python_error::what>` generates a
-human-readable representation including a backtrace.
-
-A use of the :cpp:func:`.matches() <python_error::matches>` method to
-distinguish different exception types is shown below:
-
-.. code-block:: cpp
-
-    try {
-        nb::object file = nb::module_::import_("io").attr("open")("file.txt", "r");
-        nb::object text = file.attr("read")();
-        file.attr("close")();
-    } catch (const nb::python_error &e) {
-        if (e.matches(PyExc_FileNotFoundError)) {
-            nb::print("file.txt not found");
-        } else if (e.matches(PyExc_PermissionError)) {
-            nb::print("file.txt found but not accessible");
-        } else {
-            throw;
-        }
-    }
-
-Note that the previously discussed :ref:`automatic conversion
-<exception_conversion>` of C++ exception does not apply here. Errors raised
-from Python *always* convert to :cpp:class:`nb::python_error <python_error>`.
-
-Handling errors from the Python C API
--------------------------------------
-
-Whenever possible, use :ref:`nanobind wrappers <wrappers>` instead of calling
-the Python C API directly. Otherwise, you must carefully manage reference
-counts and adhere to the nanobind error protocol outlined below.
-
-When a Python C API call fails with an error status, you must immediately
-``throw nb::python_error();`` to capture the error and handle it using
-appropriate C++ mechanisms. This includes calls to error setting functions such
-as ``PyErr_SetString`` (:ref:`custom exception translators <custom_exceptions>`
-are excluded from this rule).
-
-.. code-block:: cpp
-
-    PyErr_SetString(PyExc_TypeError, "C API type error demo");
-    throw nb::python_error();
-
-    // But it would be easier to simply...
-    throw nb::type_error("nanobind wrapper type error");
-
-Alternately, to ignore the error, call `PyErr_Clear()
-<https://docs.python.org/3/c-api/exceptions.html#c.PyErr_Clear>`__. Any
-Python error must be thrown or cleared, or nanobind will be left in an
-invalid state.
-
-.. _exception_chaining:
-
-Chaining exceptions ('raise from')
-----------------------------------
-
-Python has a mechanism for indicating that exceptions were caused by other
-exceptions:
-
-.. code-block:: py
-
-    try:
-        print(1 / 0)
-    except Exception as exc:
-        raise RuntimeError("could not divide by zero") from exc
-
-To do a similar thing in nanobind, you can use the :cpp:func:`nb::raise_from
-<raise_from>` function, which requires a :cpp:class:`nb::python_error
-<python_error>` and re-raises it with a chained exception object.
-
-.. code-block:: cpp
-
-    nb::callable f = ...;
-    int arg = 123;
-    try {
-        f(arg);
-    } catch (nb::python_error &e) {
-        nb::raise_from(e, PyExc_RuntimeError, "Could not call 'f' with %i", arg);
-    }
-
-The function is internally based on the Python function ``PyErr_FormatV`` and
-takes ``printf``-style arguments following the format descriptor.
-
-An even lower-level interface is available via :cpp:func:`nb::chain_error
-<chain_error>`.
-
-Handling unraisable exceptions
-------------------------------
-
-If a Python function invoked from a C++ destructor or any function marked
-``noexcept(true)`` (collectively, "noexcept functions") throws an exception, there
-is no way to propagate the exception, as such functions may not throw.
-Should they throw or fail to catch any exceptions in their call graph,
-the C++ runtime calls ``std::terminate()`` to abort immediately.
-
-Similarly, Python exceptions raised in a class's ``__del__`` method do not
-propagate, but are logged by Python as an unraisable error. In Python 3.8+, a
-`system hook is triggered
-<https://docs.python.org/3/library/sys.html#sys.unraisablehook>`_
-and an auditing event is logged.
-
-Any noexcept function should have a try-catch block that traps
-:cpp:class:`nb::python_error <python_error>` (or any other exception that can
-occur). A useful approach is to convert them to Python exceptions and then
-``discard_as_unraisable`` as shown below.
-
-.. code-block:: cpp
-
-    void nonthrowing_func() noexcept(true) {
-        try {
-            // ...
-        } catch (nb::python_error &e) {
-            // Discard the Python error using Python APIs, using the C++ magic
-            // variable __func__. Python already knows the type and value and of the
-            // exception object.
-            e.discard_as_unraisable(__func__);
-        } catch (const std::exception &e) {
-            // Log and discard C++ exceptions.
-            third_party::log(e);
-        }
-    }
diff --git a/src/nanobind/docs/exchanging.rst b/src/nanobind/docs/exchanging.rst
deleted file mode 100644
index a2858fa..0000000
--- a/src/nanobind/docs/exchanging.rst
+++ /dev/null
@@ -1,423 +0,0 @@
-.. cpp:namespace:: nanobind
-
-.. _exchange:
-
-Exchanging information
-======================
-
-nanobind offers three fundamentally different ways of exchanging information
-between Python and C++. Depending on the task at hand, one will usually be
-preferable over the others, hence it is important to be aware of their
-advantages and disadvantages.
-
-.. _type_casters:
-
-Option 1: Type Casters
-----------------------
-
-A *type caster* translates C++ objects into equivalent Python
-objects and vice versa. The illustration below shows a translation between
-C++ (blue) and Python (green) worlds, where a ``std::vector<int>`` instance
-converts from/to a Python ``list`` containing ``int`` objects.
-
-.. only:: not latex
-
-   .. image:: images/caster-light.svg
-     :width: 400
-     :align: center
-     :class: only-light
-
-   .. image:: images/caster-dark.svg
-     :width: 400
-     :align: center
-     :class: only-dark
-
-.. only:: latex
-
-   .. image:: images/caster-light.svg
-     :width: 400
-     :align: center
-
-**Example**: The following function doubles the entries of an STL vector and
-returns the result.
-
-.. code-block:: cpp
-
-    using IntVector = std::vector<int>;
-
-    IntVector double_it(const IntVector &in) {
-        IntVector out(in.size());
-        for (size_t i = 0; i < in.size(); ++i)
-            out[i] = in[i] * 2;
-        return out;
-    }
-
-To expose it in Python, we can use the ``std::vector<...>`` type caster that
-is located in an optional header file named ``nanobind/stl/vector.h``:
-
-.. code-block:: cpp
-
-    #include <nanobind/stl/vector.h>
-
-    NB_MODULE(my_ext, m) {
-        m.def("double_it", &double_it);
-    }
-
-That's all there is to it. The Python version of the function features
-an automatically generated docstring, type checks, and (if needed) error reporting.
-
-.. code-block:: pycon
-
-    >>> import my_ext
-    >>> my_ext.double_it([1, 2, 3])
-    [2, 4, 6]
-
-    >>> my_ext.double_it([1, 2, 'foo'])
-    TypeError: double_it(): incompatible function arguments. The following argument types are supported:
-        1. double_it(arg: list[int], /) -> list[int]
-
-What are the implications of using type casters?
-
-**Pro**: this approach is simple and convenient, especially when standard
-(STL) types are involved. Usually, all that is needed is an ``#include``
-directive to pull in the right header file. Complex nested types (e.g.
-vectors of hash tables of strings) work automatically by combining type
-casters recursively.
-
-The following table lists the currently available type casters along with links
-to external projects that provide further casters:
-
-.. list-table::
-  :widths: 42 48
-  :header-rows: 1
-
-  * - Type
-    - Type caster header
-  * - ``char``, ``char*``, ``void*``, ``nullptr_t``, ``bool``, ``int``,
-      ``unsigned int``, ``long``, ``unsigned long``, ...
-    - Built-in (no include file needed)
-  * - ``std::array<..>``
-    - ``#include <nanobind/stl/array.h>``
-  * - ``std::chrono::duration<..>``, ``std::chrono::time_point<..>``
-      (:ref:`more details <chrono_conversions>`)
-    - ``#include <nanobind/stl/chrono.h>``
-  * - ``std::complex<..>``
-    - ``#include <nanobind/stl/complex.h>``
-  * - ``std::filesystem::path``
-    - ``#include <nanobind/stl/filesystem.h>``
-  * - ``std::function<..>``
-    - ``#include <nanobind/stl/function.h>``
-  * - ``std::list<..>``
-    - ``#include <nanobind/stl/list.h>``
-  * - ``std::map<..>``
-    - ``#include <nanobind/stl/map.h>``
-  * - ``std::optional<..>``
-    - ``#include <nanobind/stl/optional.h>``
-  * - ``std::pair<..>``
-    - ``#include <nanobind/stl/pair.h>``
-  * - ``std::set<..>``
-    - ``#include <nanobind/stl/set.h>``
-  * - ``std::string``
-    - ``#include <nanobind/stl/string.h>``
-  * - ``std::string_view``
-    - ``#include <nanobind/stl/string_view.h>``
-  * - ``std::wstring``
-    - ``#include <nanobind/stl/wstring.h>``
-  * - ``std::tuple<..>``
-    - ``#include <nanobind/stl/tuple.h>``
-  * - ``std::shared_ptr<..>``
-    - ``#include <nanobind/stl/shared_ptr.h>``
-  * - ``std::unique_ptr<..>``
-    - ``#include <nanobind/stl/unique_ptr.h>``
-  * - ``std::unordered_set<..>``
-    - ``#include <nanobind/stl/unordered_set.h>``
-  * - ``std::unordered_map<..>``
-    - ``#include <nanobind/stl/unordered_map.h>``
-  * - ``std::variant<..>``
-    - ``#include <nanobind/stl/variant.h>``
-  * - ``std::vector<..>``
-    - ``#include <nanobind/stl/vector.h>``
-  * - ``nb::ndarray<..>``
-    - ``#include <nanobind/ndarray.h>``
-  * - ``Eigen::Matrix<..>``, ``Eigen::Array<..>``, ``Eigen::Ref<..>``, ``Eigen::Map<..>``
-    - ``#include <nanobind/eigen/dense.h>``
-  * - ``Eigen::SparseMatrix<..>``
-    - ``#include <nanobind/eigen/sparse.h>``
-  * - Apache Arrow types
-    -  `https://github.com/maximiliank/nanobind_pyarrow <https://github.com/maximiliank/nanobind_pyarrow>`__
-  * - ...
-    - Please reach out if you have additions to this list.
-
-
-**Con**: Every transition between the Python and C++ side will generally require a
-conversion step (in this case, to re-create all list elements). This can be
-wasteful when the other side only needs to access a small part of the data.
-Conversely, the overhead should not be a problem when the data is fully
-"consumed" following conversion.
-
-A select few type casters (``std::unique_ptr<..>``, ``std::shared_ptr<..>``,
-:cpp:class:`nb::ndarray <ndarray>`, and ``Eigen::*``) are special in the sense
-that they can perform a type conversion *without* copying the underlying data.
-Besides those few exceptions type casting always implies that a copy is made.
-
-.. _type_caster_mutable:
-
-Mutable reference issue
-^^^^^^^^^^^^^^^^^^^^^^^
-
-Another subtle limitation of type casters is that they
-don't propagate updates through mutable references. Consider the
-following alternative implementation of the ``double_it`` function:
-
-.. code-block:: cpp
-
-    void double_it(IntVector &in) {
-        for (int &value : in)
-            value *= 2;
-    }
-
-nanobind can wrap this function without problems, but it won't behave as
-expected:
-
-.. code-block:: pycon
-
-    >>> x = [1, 2, 3]
-    >>> my_ext.double_it(x)
-    >>> x
-    [1, 2, 3]  # <-- oops, unchanged!
-
-*How could this happen?*
-The reason is that type casters convert function arguments and return values once, but further
-changes will not automatically propagate across the language barrier because
-the representations are not intrinsically linked to each other. This problem is
-not specific to STL types---for example, the following function will similarly
-not update its argument once exposed in Python.
-
-.. code-block:: cpp
-
-    void double_it(int &in) { in *= 2; }
-
-This is because builtin types like ``int``, ``str``, ``bool``, etc., are
-all handled by type casters.
-
-A simple alternative to propagate updates while retaining the convenience of
-type casters is to bind a small wrapper lambda function that returns a tuple
-with all output arguments. An example:
-
-.. code-block:: cpp
-
-    int foo(int &in) { in *= 2; return std::sqrt(in); }
-
-And the binding code
-
-.. code-block:: cpp
-
-   m.def("foo", [](int i) { int rv = foo(i); return std::make_tuple(rv, i); });
-
-In this case, a type caster (``#include <nanobind/stl/tuple.h``) must be
-included to handle the ``std::tuple<int, int>`` return value.
-
-.. _bindings:
-
-Option 2: Bindings
-------------------
-
-*Bindings* expose C++ types in Python; the ability to create them is the
-main feature of nanobind. In the list-of-integer example, they cause Python
-to interpret ``std::vector<int>`` as a new Python type called
-``my_ext.IntVector``.
-
-.. only:: not latex
-
-   .. image:: images/binding-light.svg
-     :width: 400
-     :align: center
-     :class: only-light
-
-   .. image:: images/binding-dark.svg
-     :width: 400
-     :align: center
-     :class: only-dark
-
-.. only:: latex
-
-   .. image:: images/binding-light.svg
-     :width: 400
-     :align: center
-
-**Example**: to switch the previous example to bindings, we first replace
-the type caster header (`nanobind/stl/vector.h
-<https://github.com/wjakob/nanobind/blob/master/include/nanobind/stl/vector.h>`_)
-by its binding variant (`nanobind/stl/bind_vector.h
-<https://github.com/wjakob/nanobind/blob/master/include/nanobind/stl/bind_vector.h>`_)
-and then invoke the :cpp:func:`nb::bind_vector\<T\>() <bind_vector>` function to create a *new
-Python type named* ``IntVector`` within the module ``m``.
-
-.. code-block:: cpp
-   :emphasize-lines: 1, 9
-
-    #include <nanobind/stl/bind_vector.h>
-
-    using IntVector = std::vector<int>;
-    IntVector double_it(const IntVector &in) { /* .. omitted .. */ }
-
-    namespace nb = nanobind;
-
-    NB_MODULE(my_ext, m) {
-        nb::bind_vector<IntVector>(m, "IntVector");
-        m.def("double_it", &double_it);
-    }
-
-Any function taking or returning integer vectors will now use the type
-binding. In the Python session below, nanobind performs an implicit
-conversion from the Python list ``[1, 2, 3]`` to a ``my_ext.IntVector``
-before calling the ``double_it`` function.
-
-.. code-block:: pycon
-
-    >>> import my_ext
-    >>> my_ext.double_it([1, 2, 3])
-    my_ext.IntVector([2, 4, 6])
-
-    >>> my_ext.double_it.__doc__
-    'double_it(arg: my_ext.IntVector, /) -> my_ext.IntVector'
-
-Let's go through the implications of using bindings:
-
-**Pro**: bindings don't require the costly conversion step when crossing the
-language boundary. They also support mutable references, so the :ref:`issue
-discussed in the context of type casters <type_caster_mutable>` does not
-arise. Sometimes, binding is the only available option: when a C++ type does
-not have an equivalent Python type, casting simply does not make sense.
-
-**Con**: Creating good bindings that feel natural in Python requires some
-additional work. We cheated in this example by relying on the
-:cpp:func:`nb::bind_vector\<T\>() <bind_vector>` helper function that did
-all the heavy lifting. Such helpers are currently only available for a few
-special cases (vectors, ordered/unordered maps, iterators):
-
-.. list-table::
-  :widths: 42 48
-  :header-rows: 1
-
-  * - Type
-    - Binding helper header
-  * - ``std::vector<..>``
-    - ``#include <nanobind/stl/bind_vector.h>``
-      (:ref:`docs <vector_bindings>`)
-  * - ``std::map<..>``
-    - ``#include <nanobind/stl/bind_map.h>``
-      (:ref:`docs <map_bindings>`)
-  * - ``std::unordered_map<..>``
-    - ``#include <nanobind/stl/bind_map.h>``
-      (:ref:`docs <map_bindings>`)
-  * - Forward iterators
-    - ``#include <nanobind/make_iterator.h>``
-      (:ref:`docs <iterator_bindings>`)
-  * - Other types
-    - See the previous example on :ref:`binding custom types <binding_types>`.
-
-In general, you will need to write the binding code yourself. The previous
-section on :ref:`binding custom types <binding_types>` showed an example of
-such a type binding.
-
-.. _wrappers:
-
-Option 3: Wrappers
-------------------
-
-The last option is only rarely used, but it can be powerful alternative in
-some cases. nanobind provides *wrapper* classes to use Python types within
-C++. You can think of this as a kind of *reverse binding*. For example, a
-Python list can be accessed through the :cpp:class:`nb::list <list>` type:
-
-.. only:: not latex
-
-   .. image:: images/wrapper-light.svg
-     :width: 400
-     :align: center
-     :class: only-light
-
-   .. image:: images/wrapper-dark.svg
-     :width: 400
-     :align: center
-     :class: only-dark
-
-.. only:: latex
-
-   .. image:: images/wrapper-light.svg
-     :width: 400
-     :align: center
-
-This is what the example looks like when expressed using
-:cpp:class:`nb::list <list>` and :cpp:class:`nb::int_ <int_>`.
-
-.. code-block:: cpp
-
-    #include <nanobind/nanobind.h>
-
-    namespace nb = nanobind;
-
-    nb::list double_it(nb::list l) {
-        nb::list result;
-        for (nb::handle h: l)
-            result.append(h * nb::int_(2));
-        return result;
-    }
-
-    NB_MODULE(my_ext, m) {
-        m.def("double_it", &double_it);
-    }
-
-
-The implications of using wrappers are:
-
-**Pro**: Wrappers require no copying or type conversion. With them, C++ begins
-to resemble dynamically typed Python code and can perform highly general
-operations on Python objects. Wrappers are useful to tap into the powerful
-Python software ecosystem (NumPy, Matplotlib, PyTorch, etc).
-
-**Con**: Functions based on wrappers cannot run without Python. In contrast
-to option 1 (:ref:`type casters <type_casters>`) and 2 (:ref:`bindings
-<bindings>`), we can no longer reuse an existing function and process its
-arguments and return value to interface the Python and C++ worlds: the
-entire function must be rewritten using nanobind-specific wrapper types.
-Every operation will translate into a corresponding Python C API call, which
-means that wrappers aren't suitable for performance-critical loops or
-multithreaded computations.
-
-The following wrappers are available and require no additional include
-directives:
-:cpp:class:`any`,
-:cpp:class:`bytearray`, :cpp:class:`bytes`, :cpp:class:`callable`, :cpp:class:`capsule`,
-:cpp:class:`dict`, :cpp:class:`ellipsis`, :cpp:class:`handle`,
-:cpp:class:`handle_t\<T\> <handle_t>`,
-:cpp:class:`bool_`, :cpp:class:`int_`, :cpp:class:`float_`,
-:cpp:class:`frozenset`, :cpp:class:`iterable`, :cpp:class:`iterator`,
-:cpp:class:`list`, :cpp:class:`mapping`,
-:cpp:class:`module_`, :cpp:class:`object`, :cpp:class:`set`, :cpp:class:`sequence`,
-:cpp:class:`slice`, :cpp:class:`str`, :cpp:class:`tuple`,
-:cpp:class:`weakref`,
-:cpp:class:`type_object`, :cpp:class:`type_object_t\<T\> <type_object_t>`,
-:cpp:class:`args`, :cpp:class:`kwargs`, and
-:cpp:class:`fallback <fallback>`.
-
-Discussion
-----------
-
-The choices outlined above are more fine-grained than they may appear. For
-example, it is possible to use type casters, bindings, and wrappers to handle
-multiple arguments of *a single function*.
-
-They can also be combined *within* a single function argument. For example, you
-can type cast a ``std::vector<T>`` containing bindings or wrappers.
-
-In general, we recommend that you use
-
-1. type casters for STL containers, and
-
-2. bindings for other custom types.
-
-If the former turn out to be a performance bottleneck, it is easy to replace
-them with bindings or wrappers later on. Wrappers are only rarely useful;
-you will usually know it when you need them.
diff --git a/src/nanobind/docs/faq.rst b/src/nanobind/docs/faq.rst
deleted file mode 100644
index e37c807..0000000
--- a/src/nanobind/docs/faq.rst
+++ /dev/null
@@ -1,398 +0,0 @@
-.. cpp:namespace:: nanobind
-
-.. _faq:
-
-Frequently asked questions
-==========================
-
-Importing my module fails with an ``ImportError``
--------------------------------------------------
-
-If importing the module fails as shown below, you have not specified a
-matching module name in :cmake:command:`nanobind_add_module()` and
-:c:macro:`NB_MODULE() <NB_MODULE>`.
-
-.. code-block:: pycon
-
-   >>> import my_ext
-   ImportError: dynamic module does not define module export function (PyInit_my_ext)
-
-Importing fails due to missing ``[lib]nanobind.{dylib,so,dll}``
----------------------------------------------------------------
-
-If importing the module fails as shown below, the extension cannot find the
-``nanobind`` shared library component.
-
-.. code-block:: pycon
-
-   >>> import my_ext
-   ImportError: dlopen(my_ext.cpython-311-darwin.so, 0x0002):
-   Library not loaded: '@rpath/libnanobind.dylib'
-
-This is really more of a general C++/CMake/build system issue than one of
-nanobind specifically. There are two solutions:
-
-1. Build the library component statically by specifying the ``NB_STATIC`` flag
-   in :cmake:command:`nanobind_add_module()` (this is the default starting with
-   nanobind 0.2.0).
-
-2. Ensure that the various shared libraries are installed in the right
-   destination, and that their `rpath <https://en.wikipedia.org/wiki/Rpath>`_
-   is set so that they can find each other.
-
-   You can control the build output directory of the shared library component
-   using the following CMake command:
-
-   .. code-block:: pycon
-
-      set_target_properties(nanobind
-        PROPERTIES
-        LIBRARY_OUTPUT_DIRECTORY                <path>
-        LIBRARY_OUTPUT_DIRECTORY_RELEASE        <path>
-        LIBRARY_OUTPUT_DIRECTORY_DEBUG          <path>
-        LIBRARY_OUTPUT_DIRECTORY_RELWITHDEBINFO <path>
-        LIBRARY_OUTPUT_DIRECTORY_MINSIZEREL     <path>
-      )
-
-   Depending on the flags provided to :cmake:command:`nanobind_add_module()`,
-   the shared library component may have a different name following the pattern
-   ``nanobind[-abi3][-lto]``.
-
-   The following CMake commands may be useful to adjust the build and install
-   `rpath <https://en.wikipedia.org/wiki/Rpath>`_ of the extension:
-
-   .. code-block:: cmake
-
-      set_property(TARGET my_ext APPEND PROPERTY BUILD_RPATH "$<TARGET_FILE_DIR:nanobind>")
-      set_property(TARGET my_ext APPEND PROPERTY INSTALL_RPATH ".. ?? ..")
-
-
-Why are reference arguments not updated?
-----------------------------------------
-
-Functions like the following example can be exposed in Python, but they won't
-propagate updates to mutable reference arguments.
-
-.. code-block:: cpp
-
-   void increment(int &i) {
-       i++;
-   }
-
-This isn't specific to builtin types but also applies to STL collections and
-other types when they are handled using :ref:`type casters <type_casters>`.
-Please read the full section on :ref:`information exchange between C++ and
-Python <exchange>` to understand the issue and alternatives.
-
-Why am I getting errors about leaked instances/functions/types?
----------------------------------------------------------------
-
-Please see the dedicated documentation section on :ref:`reference leaks <refleaks>`.
-
-Compilation fails with a static assertion mentioning ``NB_MAKE_OPAQUE()``
--------------------------------------------------------------------------
-
-If your compiler generates an error of the following sort, you are mixing type
-casters and bindings in a way that has them competing for the same types:
-
-.. code-block:: text
-
-   nanobind/include/nanobind/nb_class.h:207:40: error: static assertion failed: ↵
-   Attempted to create a constructor for a type that won't be  handled by the nanobind's ↵
-   class type caster. Is it possible that you forgot to add NB_MAKE_OPAQUE() somewhere?
-
-For example, the following won't work:
-
-.. code-block:: cpp
-
-   #include <nanobind/stl/vector.h>
-   #include <nanobind/stl/bind_vector.h>
-
-   namespace nb = nanobind;
-
-   NB_MODULE(my_ext, m) {
-       // The following line cannot be compiled
-       nb::bind_vector<std::vector<int>>(m, "VectorInt");
-
-       // This doesn't work either
-       nb::class_<std::vector<int>>(m, "VectorInt");
-   }
-
-This is not specific to STL vectors and will happen whenever casters and
-bindings target overlapping types.
-
-:ref:`Type casters <type_casters>` employ a pattern matching technique known as
-`partial template specialization
-<https://en.wikipedia.org/wiki/Partial_template_specialization>`_. For example,
-``nanobind/stl/vector.h`` installs a pattern that detects *any* use of
-``std::vector<T, Allocator>``, which overlaps with the above binding of a specific
-vector type.
-
-The deeper reason for this conflict is that type casters enable a
-*compile-time* transformation of nanobind code, which can conflict with
-binding declarations that are a *runtime* construct.
-
-To fix the conflict in this example, add the line :c:macro:`NB_MAKE_OPAQUE(T)
-<NB_MAKE_OPAQUE>`, which adds another partial template specialization pattern
-for ``T`` that says: "ignore ``T`` and don't use a type caster to handle it".
-
-.. code-block:: cpp
-
-   NB_MAKE_OPAQUE(std::vector<int>);
-
-.. warning::
-
-   If your extension consists of multiple source code files that involve
-   overlapping use of type casters and bindings, you are *treading on thin
-   ice*. It is easy to violate the *One Definition Rule* (ODR) [`details
-   <https://en.wikipedia.org/wiki/One_Definition_Rule>`_] in such a case, which
-   may lead to undefined behavior (miscompilations, etc.).
-
-   Here is a hypothetical example of an ODR violation: an extension
-   contains two source code files: ``src_1.cpp`` and ``src_2.cpp``.
-
-   - ``src_1.cpp`` binds a function that returns an ``std::vector<int>`` using
-     a :ref:`type caster <type_casters>` (``nanobind/stl/vector.h``).
-
-   - ``src_2.cpp`` binds a function that returns an ``std::vector<int>`` using
-     a :ref:`binding <bindings>` (``nanobind/stl/bind_vector.h``), and it also
-     installs the needed type binding.
-
-   The problem is that a partially specialized class in the nanobind
-   implementation namespace (specifically,
-   ``nanobind::detail::type_caster<std::vector<int>>``) now resolves to *two
-   different implementations* in the two compilation units. It is unclear how
-   such a conflict should be resolved at the linking stage, and you should
-   consider code using such constructions broken.
-
-   To avoid this issue altogether, we recommend that you create a single
-   include file (e.g., ``binding_core.h``) containing all of the nanobind
-   include files (binding, type casters), your own custom type casters (if
-   present), and :c:macro:`NB_MAKE_OPAQUE(T) <NB_MAKE_OPAQUE>` declarations.
-   Include this header consistently in all binding compilation units. The
-   construction shown in the example (mixing type casters and bindings for the
-   same type) is not allowed, and cannot occur when following the
-   recommendation.
-
-How can I preserve the ``const``-ness of values in bindings?
-------------------------------------------------------------
-
-This is a limitation of nanobind, which casts away ``const`` in function
-arguments and return values. This is in line with the Python language, which
-has no concept of const values. Additional care is therefore needed to avoid
-bugs that would be caught by the type checker in a traditional C++ program.
-
-How can I reduce build time?
-----------------------------
-
-Large binding projects should be partitioned into multiple files, as shown in
-the following example:
-
-:file:`example.cpp`:
-
-.. code-block:: cpp
-
-    void init_ex1(nb::module_ &);
-    void init_ex2(nb::module_ &);
-    /* ... */
-
-    NB_MODULE(my_ext, m) {
-        init_ex1(m);
-        init_ex2(m);
-        /* ... */
-    }
-
-:file:`ex1.cpp`:
-
-.. code-block:: cpp
-
-    void init_ex1(nb::module_ &m) {
-        m.def("add", [](int a, int b) { return a + b; });
-    }
-
-:file:`ex2.cpp`:
-
-.. code-block:: cpp
-
-    void init_ex2(nb::module_ &m) {
-        m.def("sub", [](int a, int b) { return a - b; });
-    }
-
-As shown above, the various ``init_ex`` functions should be contained in
-separate files that can be compiled independently from one another, and then
-linked together into the same final shared object.  Following this approach
-will:
-
-1. reduce memory requirements per compilation unit.
-
-2. enable parallel builds (if desired).
-
-3. allow for faster incremental builds. For instance, when a single class
-   definition is changed, only a subset of the binding code will generally need
-   to be recompiled.
-
-.. _type-visibility:
-
-How can I avoid conflicts with other projects using nanobind?
--------------------------------------------------------------
-
-Suppose that a type binding in your project conflicts with another extension, for
-example because both expose a common type (e.g., ``std::latch``). nanobind will
-warn whenever it detects such a conflict:
-
-.. code-block:: text
-
-  RuntimeWarning: nanobind: type 'latch' was already registered!
-
-In the worst case, this could actually break both packages (especially if the
-bindings of the two packages expose an inconsistent/incompatible API).
-
-The higher-level issue here is that nanobind will by default try to make type
-bindings visible across extensions because this is helpful to partition large
-binding projects into smaller parts. Such information exchange requires that
-the extensions:
-
-- use the same nanobind *ABI version* (see the :ref:`Changelog <changelog>` for details).
-- use the same compiler (extensions built with GCC and Clang are isolated from each other).
-- use ABI-compatible versions of the C++ library.
-- use the stable ABI interface consistently (stable and unstable builds are isolated from each other).
-- use debug/release mode consistently (debug and release builds are isolated from each other).
-
-In addition, nanobind provides a feature to intentionally scope extensions to a
-named domain to avoid conflicts with other extensions. To do so, specify the
-``NB_DOMAIN`` parameter in CMake:
-
-.. code-block:: cmake
-
-   nanobind_add_module(my_ext
-                       NB_DOMAIN my_project
-                       my_ext.cpp)
-
-In this case, inter-extension type visibility is furthermore restricted to
-extensions in the ``"my_project"`` domain.
-
-Can I use nanobind without RTTI or C++ exceptions?
---------------------------------------------------
-
-Certain environments (e.g., `Google-internal development
-<https://google.github.io/styleguide/cppguide.html>`__, embedded devices, etc.)
-require compilation without C++ runtime type information (``-fno-rtti``) and
-exceptions (``-fno-exceptions``).
-
-nanobind requires both of these features and cannot be used when they are not
-available. RTTI provides the central index to look up types of bindings.
-Exceptions are needed because Python relies on exceptions that must be
-converted into something equivalent on the C++ side. PRs that refactor nanobind
-to work without RTTI or exceptions will not be accepted.
-
-For Googlers: there is already an exemption from the internal rules that
-specifically permits the use of RTTI/exceptions when a project relies on
-pybind11. Likely, this exemption could be extended to include nanobind as well.
-
-Can I make stable ABI extensions for pre-3.12 Python?
------------------------------------------------------
-
-Stable ABI extensions are convenient because they can be reused across Python
-versions, but this unfortunately only works on Python 3.12 and newer. Nanobind
-crucially depends on several `features
-<https://docs.python.org/3/whatsnew/3.12.html#c-api-changes>`__ that were added
-in version 3.12 (specifically, ``PyType_FromMetaclass()`` and limited API
-bindings of the vector call protocol).
-
-Policy on Clang-Tidy, ``-Wpedantic``, etc.
-------------------------------------------
-
-nanobind regularly receives requests from users who run it through Clang-Tidy,
-or who compile with increased warnings levels, like ``-Wpedantic``,
-``-Wcast-qual``, ``-Wsign-conversion``, etc. (i.e., beyond the increased
-``-Wall``, ``-Wextra`` and ``/W4`` warning levels that are already enabled)
-
-Their next step is to open a big pull request needed to silence all of the
-resulting messages.
-
-My policy on this is as follows: I am always happy to fix issues in the
-codebase. However, many of the resulting change requests are in the "ritual
-purification" category: things that cause churn, decrease readability, and
-which don't fix actual problems. It's a never-ending cycle because each new
-revision of such tooling adds further warnings and purification rites.
-
-So just to have a clear policy: I do not wish to pepper this codebase with
-``const_cast`` and ``#pragmas`` or pragma-like comments to avoid warnings in
-various kinds of external tooling just so those users can have a "silent"
-build. I don't think it is reasonable for them to impose their own style on
-this project.
-
-As a workaround it is likely possible to restrict the scope of style checks to
-particular C++ namespaces or source code locations.
-
-I'd like to use this project, but with $BUILD_SYSTEM instead of CMake
----------------------------------------------------------------------
-
-A difficult aspect of C++ software development is the sheer number of competing
-build systems, including
-
-- `CMake <https://cmake.org>`__,
-- `Meson <https://mesonbuild.com>`__,
-- `xmake <https://xmake.io/#/>`__,
-- `Premake <https://premake.github.io>`__,
-- `Bazel <https://bazel.build>`__,
-- `Conan <https://docs.conan.io/2/>`__,
-- `Autotools <https://www.gnu.org/software/automake>`__,
-- and many others.
-
-The author of this project has some familiarity with CMake but lacks expertise
-with this large space of alternative tools. Maintaining and shipping support for
-other build systems is therefore considered beyond the scope of this *nano*
-project (see also the :ref:`why? <why>` part of the documentation that explains
-the rationale for being somewhat restrictive towards external contributions).
-
-If you wish to create and maintain an alternative interface to nanobind, then
-my request would be that you create and maintain separate repository (see,
-e.g., `pybind11_bazel <https://github.com/pybind/pybind11_bazel>`__ as an
-example how how this was handled in the case of pybind11). Please carefully
-review the file `nanobind-config.cmake
-<https://github.com/wjakob/nanobind/blob/master/cmake/nanobind-config.cmake>`__.
-Besides getting things to compile, it specifies a number of platform-dependent
-compiler and linker options that are needed to produce *optimal* (small and
-efficient) binaries. Nanobind uses a `complicated and non-standard
-<https://github.com/wjakob/nanobind/commit/2f29ec7d5fbebd5f55fb52da297c8d197279f659>`__
-set of linker parameters on macOS, which is the result of a `lengthy
-investigation
-<https://github.com/python/cpython/issues/97524#issuecomment-1458855301>`__.
-Other parameters like linker-level dead code elimination and size-based
-optimization were similarly added following careful analysis. The CMake build
-system provides the ability to compile ``libnanobind`` into either a shared or
-a static library, to optionally target the stable ABI, and to isolate it from
-other extensions via the ``NB_DOMAIN`` parameter. All of these are features
-that would be nice to retain in an alternative build system. If you've made a
-build system compatible with another tool that is sufficiently
-feature-complete, then please file an issue and I am happy to reference it in
-the documentation.
-
-Are there tools to generate nanobind bindings automatically?
-------------------------------------------------------------
-
-`litgen <https://pthom.github.io/litgen>`__ is an automatic Python bindings
-generator compatible with both pybind11 and nanobind, designed to create
-documented and easily discoverable bindings.
-It reproduces header documentation directly in the bindings, making the
-generated API intuitive and well-documented for Python users.
-Powered by srcML (srcml.org), a high-performance, multi-language parsing tool,
-litgen takes a developer-centric approach.
-The C++ API to be exposed to Python must be C++14 compatible, although the
-implementation can leverage more modern C++ features.
-
-How to cite this project?
--------------------------
-
-Please use the following BibTeX template to cite nanobind in scientific
-discourse:
-
-.. code-block:: bibtex
-
-    @misc{nanobind,
-       author = {Wenzel Jakob},
-       year = {2022},
-       note = {https://github.com/wjakob/nanobind},
-       title = {nanobind: tiny and efficient C++/Python bindings}
-    }
diff --git a/src/nanobind/docs/free_threaded.rst b/src/nanobind/docs/free_threaded.rst
deleted file mode 100644
index f53d54e..0000000
--- a/src/nanobind/docs/free_threaded.rst
+++ /dev/null
@@ -1,326 +0,0 @@
-.. _free-threaded:
-
-.. cpp:namespace:: nanobind
-
-Free-threaded Python
-====================
-
-**Free-threading** is an experimental new Python feature that replaces the
-`Global Interpreter Lock (GIL)
-<https://en.wikipedia.org/wiki/Global_interpreter_lock>`__ with a fine-grained
-locking scheme to better leverage multi-core parallelism. The resulting
-benefits do not come for free: extensions must explicitly opt-in and generally
-require careful modifications to ensure correctness.
-
-Nanobind can target free-threaded Python since version 2.2.0. This page
-explains how to do so and discusses a few caveats. Besides this page, make sure
-to review `py-free-threading.github.io <https://py-free-threading.github.io>`__
-for a more comprehensive discussion of free-threaded Python. `PEP 703
-<https://peps.python.org/pep-0703/>`__ explains the nitty gritty details.
-
-Opting in
----------
-
-To opt into free-threaded Python, pass the ``FREE_THREADED`` parameter to the
-:cmake:command:`nanobind_add_module()` CMake target command. For other build
-systems, refer to their respective documentation pages.
-
-.. code-block:: cmake
-
-      nanobind_add_module(
-        my_ext                   # Target name
-        FREE_THREADED            # Opt into free-threading
-        my_ext.h                 # Source code files below
-        my_ext.cpp)
-
-nanobind ignores the ``FREE_THREADED`` parameter when the registered Python
-version does not support free-threading.
-
-.. note::
-
-   **Stable ABI**: Note that there currently is no stable ABI for free-threaded
-   Python, hence the ``STABLE_ABI`` parameter will be ignored in free-threaded
-   extensions builds. It is valid to combine the ``STABLE_ABI`` and
-   ``FREE_THREADED`` arguments: the build system will choose between the two
-   depending on the detected Python version.
-
-.. warning::
-
-   Loading an Python extension that does not support free-threading disables
-   free-threading globally. In larger binding projects with multiple
-   extensions, all of them must be adapted.
-
-If free-threading was requested and is available, the build system will set the
-``NB_FREE_THREADED`` preprocessor flag. This can be helpful to specialize
-binding code with ``#ifdef`` blocks, e.g.:
-
-.. code-block:: cpp
-
-   #if !defined(NB_FREE_THREADED)
-   ... // simple GIL-protected code
-   #else
-   ... // more complex thread-aware code
-   #endif
-
-Caveats
--------
-
-Free-threading can violate implicit assumptions made by extension developers
-when previously serial operations suddenly run concurrently, producing
-undefined behavior (race conditions, crashes, etc.).
-
-Let's consider a concrete example: the binding code below defines a ``Counter``
-class with an increment operation.
-
-.. code-block:: cpp
-
-   struct Counter {
-       int value = 0;
-       void inc() { value++; }
-   };
-
-   nb::class_<Counter>(m, "Counter")
-       .def("inc", &Counter::inc)
-       .def_ro("value", &Counter::value);
-
-
-If multiple threads call the ``inc()`` method of a single ``Counter``, the
-final count will generally be incorrect, as the increment operation ``value++``
-does not execute atomically.
-
-To fix this, we could modify the C++ type so that it protects its ``value``
-member from concurrent modification, for example using an atomic number type
-(e.g., ``std::atomic<int>``) or a critical section (e.g., based on
-``std::mutex``).
-
-The race condition in the above example is relatively benign. However,
-in more complex projects, combinations of concurrency and unsafe memory
-accesses could introduce non-deterministic data corruption and crashes.
-
-Another common source of problems are *global variables* undergoing concurrent
-modification when no longer protected by the GIL. They will likewise require
-supplemental locking. The :ref:`next section <free-threaded-locks>` explains a
-Python-specific locking primitive that can be used in binding code besides
-the solutions mentioned above.
-
-Multi-threaded code that concurrently returns the same C++ instance via the
-:cpp:enumerator:`nb::rv_policy::reference` policy may observe situations, where
-multiple Python objects are created that all wrap the same C++ instance
-(however, this is harmless aside from the duplication).
-
-.. _free-threaded-locks:
-
-Python locks
-------------
-
-Nanobind provides convenience functionality encapsulating the mutex
-implementation that is part of Python ("``PyMutex``"). It is slightly more
-efficient than OS/language-provided synchronization primitives and generally
-preferable within Python extensions.
-
-The class :cpp:class:`ft_mutex` is analogous to ``std::mutex``, and
-:cpp:class:`ft_lock_guard` is analogous to ``std::lock_guard``. Note that they
-only exist to add *supplemental* critical sections needed in free-threaded
-Python, while becoming inactive (no-ops) when targeting regular GIL-protected
-Python.
-
-With these abstractions, the previous ``Counter`` implementation could be
-rewritten as:
-
-.. code-block:: cpp
-   :emphasize-lines: 3,6
-
-   struct Counter {
-       int value = 0;
-       nb::ft_mutex mutex;
-
-       void inc() {
-           nb::ft_lock_guard guard(mutex);
-           value++;
-       }
-   };
-
-These locks are very compact (``sizeof(nb::ft_mutex) == 1``), though this is a
-Python implementation detail that could change in the future.
-
-.. _argument-locks:
-
-Argument locking
-----------------
-
-Modifying class and function definitions as shown above may not always be
-possible. As an alternative, nanobind also provides a way to *retrofit*
-supplemental locking onto existing code. The idea is to lock individual
-arguments of a function *before* being allowed to invoke it. A built-in mutex
-present in every Python object enables this.
-
-To do so, call the :cpp:func:`.lock() <arg::lock>` member of
-:cpp:class:`nb::arg() <arg>` annotations to indicate that an
-argument must be locked, e.g.:
-
-- :cpp:func:`nb::arg("my_parameter").lock() <arg::lock>`
-- :cpp:func:`"my_parameter"_a.lock() <arg::lock>` (short-hand form)
-
-In methods bindings, pass :cpp:struct:`nb::lock_self() <lock_self>` to lock
-the implicit ``self`` argument. Note that at most 2 arguments can be
-locked per function, which is a limitation of the `Python locking API
-<https://docs.python.org/3.13/c-api/init.html#c.Py_BEGIN_CRITICAL_SECTION2>`__.
-
-The example below shows how this functionality can be used to protect ``inc()``
-and a new ``merge()`` function that acquires two simultaneous locks.
-
-.. code-block:: cpp
-
-   struct Counter {
-       int value = 0;
-
-       void inc() { value++; }
-       void merge(Counter &other) {
-           value += other.value;
-           other.value = 0;
-       }
-   };
-
-   nb::class_<Counter>(m, "Counter")
-       .def("inc", &Counter::inc, nb::lock_self())
-       .def("merge", &Counter::merge, nb::lock_self(), "other"_a.lock())
-       .def_ro("value", &Counter::value);
-
-The above solution has an obvious drawback: it only protects *bindings* (i.e.,
-transitions from Python to C++). For example, if some other part of a C++
-codebase calls ``merge()`` directly, the binding layer won't be involved, and
-no locking takes place. If such behavior can introduce race conditions, a
-larger-scale redesign of your project may be in order.
-
-.. note::
-
-   Adding locking annotations indiscriminately is inadvisable because locked
-   calls are more costly than unlocked ones. The :cpp:func:`.lock()
-   <arg::lock>` and :cpp:struct:`nb::lock_self() <lock_self>` annotations are
-   ignored in GIL-protected builds, hence this added cost only applies to
-   free-threaded extensions.
-
-   Furthermore, when adding locking annotations to a function, consider keeping
-   the arguments *unnamed* (i.e., :cpp:func:`nb::arg().lock() <arg::lock>`
-   instead of :cpp:func:`nb::arg("name").lock() <arg::lock>`) if the function
-   will never be called with keyword arguments. Processing named arguments
-   causes small :ref:`binding overheads <binding-overheads>` that may be
-   undesirable if a function that does very little is called at a very high
-   rate.
-
-.. note::
-
-   **Python API and locking**: When the lock-protected function performs Python
-   API calls (e.g., using :ref:`wrappers <wrappers>` like :cpp:class:`nb::dict
-   <dict>`), Python may temporarily release locks to avoid deadlocks. Here,
-   even basic reference counting such as a :cpp:class:`nb::object
-   <object>` variable expiring at the end of a scope counts as an API call.
-
-   These locks will be reacquired following the Python API call. This behavior
-   resembles ordinary (GIL-protected) Python code, where operations like
-   `Py_DECREF()
-   <https://docs.python.org/3/c-api/refcounting.html#c.Py_DECREF>`__ can cause
-   cause arbitrary Python code to execute. The semantics of this kind of
-   relaxed critical section are described in the `Python documentation
-   <https://docs.python.org/3.13/c-api/init.html#python-critical-section-api>`__.
-
-Miscellaneous notes
--------------------
-
-API
----
-
-The following API specific to free-threading has been added:
-
-- :cpp:class:`nb::ft_mutex <ft_mutex>`
-- :cpp:class:`nb::ft_lock_guard <ft_lock_guard>`
-- :cpp:class:`nb::ft_object_guard <ft_object_guard>`
-- :cpp:class:`nb::ft_object2_guard <ft_object2_guard>`
-- :cpp:func:`nb::arg::lock() <arg::lock>`
-
-API stability
-_____________
-
-The interface explained in this is excluded from the project's semantic
-versioning policy. Free-threading is still experimental, and API breaks may be
-necessary based on future experience and changes in Python itself.
-
-Wrappers
-________
-
-:ref:`Wrapper types <wrappers>` like :cpp:class:`nb::list <list>` may be used
-in multi-threaded code. Operations like :cpp:func:`nb::list::append()
-<list::append>` internally acquire locks and behave just like their ordinary
-Python counterparts. This means that race conditions can still occur without
-larger-scale synchronization, but such races won't jeopardize the memory safety
-of the program.
-
-GIL scope guards
-________________
-
-Prior to free-threaded Python, the nanobind scope guards
-:cpp:struct:`gil_scoped_acquire` and :cpp:struct:`gil_scoped_release` would
-normally be used to acquire/release the GIL and enable parallel regions.
-
-These remain useful and should not be removed from existing code: while no
-longer blocking operations, they set and unset the current Python thread
-context and inform the garbage collector.
-
-The :cpp:struct:`gil_scoped_release` RAII scope guard class plays a special
-role in free-threaded builds, since it releases all :ref:`argument locks
-<argument-locks>` held by the current thread.
-
-Immortalization
-_______________
-
-Python relies on a technique called *reference counting* to determine when an
-object is no longer needed. This approach can become a bottleneck in
-multi-threaded programs, since increasing and decreasing reference counts
-requires coordination among multiple processor cores. Python type and function
-objects are especially sensitive, since their reference counts change at a very
-high rate.
-
-Similar to free-threaded Python itself,  nanobind avoids this bottleneck by
-*immortalizing* functions (``nanobind.nb_func``, ``nanobind.nb_method``) and
-type bindings. Immortal objects don't require reference counting and therefore
-cannot cause the bottleneck mentioned above. The main downside of this approach
-is that these objects leak when the interpreter shuts down. Free-threaded
-nanobind extensions disable the internal :ref:`leak checker <refleaks>`,
-since it would produce many warning messages caused by immortal objects.
-
-Internal data structures
-________________________
-
-Nanobind maintains various internal data structures that store information
-about instances and function/type bindings. These data structures also play an
-important role to exchange type/instance data in larger projects that are split
-across several independent extension modules.
-
-The layout of these data structures differs between ordinary and free-threaded
-extensions, therefore nanobind isolates them from each other by assigning a
-different ABI version tag. This means that multi-module projects will need
-to consistently compile either free-threaded or non-free-threaded modules.
-
-Free-threaded nanobind uses thread-local and sharded data structures to avoid
-lock and atomic contention on the internal data structures, which would
-otherwise become a bottleneck in multi-threaded Python programs.
-
-Thread sanitizers
-_________________
-
-The `thread sanitizer
-<https://github.com/google/sanitizers/wiki/ThreadSanitizerCppManual>`__ (TSAN)
-offers an effective way of tracking down undefined behavior in multithreaded
-application.
-
-To use TSAN with nanonbind extensions, you *must* also create a custom Python
-build that has TSAN enabled. This is because nanobind internally builds on
-Python locks. If the implementation of the locks is not instrumented by TSAN,
-the tool will detect a large volume of false positives.
-
-To make a TSAN-instrumented Python build, download a Python source release and
-to pass the following options to its ``configure`` script:
-
-.. code-block:: bash
-
-   $ ./configure --disable-gil --with-thread-sanitizer <.. other options ..>
diff --git a/src/nanobind/docs/functions.rst b/src/nanobind/docs/functions.rst
deleted file mode 100644
index ce721aa..0000000
--- a/src/nanobind/docs/functions.rst
+++ /dev/null
@@ -1,609 +0,0 @@
-.. _functions:
-
-.. cpp:namespace:: nanobind
-
-Functions
-=========
-
-Binding annotations
--------------------
-
-Besides :ref:`keyword and default arguments <keyword_and_default_args>`,
-:ref:`docstrings <docstrings>`, and :ref:`return value policies <rvp>`, other
-function binding annotations can be specified to achieve different goals as
-described below.
-
-Default arguments revisited
----------------------------
-
-A noteworthy point about the previously discussed way of specifying
-:ref:`default arguments <keyword_and_default_args>` is that nanobind
-immediately converts them into Python objects. Consider the following example:
-
-.. code-block:: cpp
-
-   nb::class_<MyClass>(m, "MyClass")
-       .def("f", &MyClass::f, "value"_a = SomeType(123));
-
-nanobind must be set up to deal with values of the type ``SomeType`` (via a
-prior instantiation of ``nb::class_<SomeType>``), or an exception will be
-thrown.
-
-The "preview" of the default argument in the function signature is generated
-using the object's ``__str__`` method. If not available, the signature may not
-be very helpful, e.g.:
-
-.. code-block:: pycon
-
-   >> help(my_ext.MyClass)
-
-   class MyClass(builtins.object)
-    |  Methods defined here:
-    ....
-    |  f(...)
-    |      f(self, value: my_ext.SomeType = <my_ext.SomeType object at 0x1004d7230>) -> None
-
-
-In such cases, you can either refine the implementation of the type in question
-or manually override how nanobind renders the default value using the
-:cpp:func:`.sig("string") method <arg::sig>`:
-
-.. code-block:: cpp
-
-   nb::class_<MyClass>(m, "MyClass")
-       .def("f", &MyClass::f, "value"_a.sig("SomeType(123)") = SomeType(123));
-
-
-.. _noconvert:
-
-Implicit conversions, and how to suppress them
-----------------------------------------------
-
-Consider the following function taking a floating point value as input:
-
-.. code-block:: cpp
-
-   m.def("double", [](float x) { return 2.f * x; });
-
-We can call this function using a Python ``float``, but an ``int`` works just
-as well:
-
-.. code-block:: pycon
-
-   >>> my_ext.double(2)
-   4.0
-
-nanobind performed a so-called *implicit conversion* for convenience. The same
-mechanism generalizes to custom types defining a
-:cpp:class:`nb::init_implicit\<T\>() <init_implicit>`-style constructor:
-
-.. code-block:: cpp
-
-   nb::class_<A>(m, "A")
-       // Following this line, nanobind will automatically convert 'B' -> 'A' if needed
-       .def(nb::init_implicit<B>());
-
-This behavior is not always desirable---sometimes, it is better to give up or
-try another function overload. To achieve this behavior, use the
-:cpp:func:`.noconvert() <arg::noconvert>` method of the :cpp:class:`nb::arg
-<arg>` annotation to mark the argument as *non-converting*. An example:
-
-.. code-block:: cpp
-
-   m.def("double", [](float x) { return 2.f * x; }, nb::arg("x").noconvert());
-
-The same experiment now fails with a ``TypeError``:
-
-.. code-block:: pycon
-
-   >>> my_ext.double(2)
-   TypeError: double(): incompatible function arguments. The following ↵
-   argument types are supported:
-       1. double(x: float) -> float
-
-   Invoked with types: int
-
-You may, of course, combine this with the ``_a`` shorthand notation (see the
-section on :ref:`keyword arguments <keyword_and_default_args>`) or specify
-*unnamed* non-converting arguments using :cpp:func:`nb::arg().noconvert()
-<arg::noconvert>`.
-
-.. note::
-
-   The number of :cpp:class:`nb::arg <arg>` annotations must match the argument
-   count of the function. To enable no-convert behaviour for just one of
-   several arguments, you will need to specify :cpp:func:`nb::arg().noconvert()
-   <arg::noconvert>` for that argument, and :cpp:class:`nb::arg() <arg>` for
-   the remaining ones.
-
-.. _none_arguments:
-
-None arguments
---------------
-
-A common design pattern in C/C++ entails passing ``nullptr`` to pointer-typed
-arguments to indicate a missing value. Since nanobind cannot know whether a
-function uses such a convention, it refuses conversions from ``None`` to
-``nullptr`` by default. For example, consider the following binding code:
-
-.. code-block:: cpp
-
-   struct Dog { };
-   const char *bark(Dog *dog) {
-       return dog != nullptr ? "woof!" : "(no dog)";
-   }
-
-   NB_MODULE(my_ext, m) {
-       nb::class_<Dog>(m, "Dog")
-           .def(nb::init<>());
-       m.def("bark", &bark);
-   }
-
-Calling the function with ``None`` raises an exception:
-
-.. code-block:: pycon
-
-   >>> my_ext.bark(my_ext.Dog())
-   'woof!'
-   >>> my_ext.bark(None)
-   TypeError: bark(): incompatible function arguments. The following ↵
-   argument types are supported:
-       1. bark(arg: my_ext.Dog, /) -> str
-
-To switch to a more permissive behavior, call the :cpp:func:`.none()
-<arg::none>` method of the :cpp:class:`nb::arg <arg>` annotation:
-
-.. code-block:: cpp
-
-   m.def("bark", &bark, nb::arg("dog").none());
-
-With this change, the function accepts ``None``, and its signature also changes
-to reflect this fact.
-
-.. code-block:: pycon
-
-   >>> my_ext.bark(None)
-   '(no dog)'
-
-   >>> my_ext.bark.__doc__
-   'bark(dog: Optional[my_ext.Dog]) -> str'
-
-You may also specify a ``None`` default argument value, in which case the
-annotation can be omitted:
-
-.. code-block:: cpp
-
-   m.def("bark", &bark, nb::arg("dog") = nb::none());
-
-Note that passing values *by pointer* (including null pointers) is only
-supported for :ref:`bound <bindings>` types. :ref:`Type casters <type_casters>`
-and :ref:`wrappers <wrappers>` cannot be used in such cases and will produce
-compile-time errors.
-
-Alternatively, you can also use ``std::optional<T>`` to pass an optional
-argument *by value*. To use it, you must include the header file associated
-needed by its type caster:
-
-.. code-block:: cpp
-
-   #include <nanobind/stl/optional.h>
-
-   NB_MODULE(my_ext, m) {
-       m.def("bark", [](std::optional<Dog> d) { ... }, nb::arg("dog") = nb::none());
-   }
-
-
-.. _overload_resolution:
-
-Overload resolution order
--------------------------
-
-nanobind relies on a two-pass scheme to determine the right implementation when
-a bound function or method with multiple overloads is called from Python.
-
-The first pass attempts to call each overload while disabling implicit argument
-conversion---it's as if every argument had a matching
-:cpp:func:`nb::arg().noconvert() <arg::noconvert>` annotation as described
-:ref:`above <noconvert>`. The process terminates successfully when nanobind
-finds an overload that is compatible with the provided arguments.
-
-If the first pass fails, a second pass retries all overloads while enabling
-implicit argument conversion. If the second pass also fails, the function
-dispatcher raises a ``TypeError``.
-
-Within each pass, nanobind tries overloads in the order in which they were
-registered. Consequently, it prefers an overload that does not require implicit
-conversion to one that does, but otherwise prefers earlier-defined overloads to
-later-defined ones. Within the second pass, the precise number of implicit
-conversions needed does not influence the order.
-
-The special exception :cpp:class:`nb::next_overload <next_overload>` can also
-influence overload resolution. Raising this exception from an overloaded
-function causes it to be skipped, and overload resolution resumes. This can be
-helpful in complex situations where the value of a parameter must be inspected
-to see if a particular overload is eligible.
-
-.. _args_kwargs_1:
-
-Accepting \*args and \*\*kwargs
--------------------------------
-
-Python supports functions that accept an arbitrary number of positional and
-keyword arguments:
-
-.. code-block:: python
-
-   def generic(*args, **kwargs):
-       ...  # do something with args and kwargs
-
-Such functions can also be created using nanobind:
-
-.. code-block:: cpp
-
-   void generic(nb::args args, nb::kwargs kwargs) {
-       for (auto v: args)
-           nb::print(nb::str("Positional: {}").format(v));
-       for (auto kv: kwargs)
-           nb::print(nb::str("Keyword: {} -> {}").format(kv.first, kv.second));
-   }
-
-   // Binding code
-   m.def("generic", &generic);
-
-The class :cpp:class:`nb::args <args>` derives from :cpp:class:`nb::tuple
-<tuple>` and :cpp:class:`nb::kwargs <kwargs>` derives from :cpp:class:`nb::dict
-<dict>`.
-
-You may also use them individually or even combine them with ordinary
-parameters. Note that :cpp:class:`nb::kwargs <kwargs>` must be the last
-parameter if it is specified, and any parameters after
-:cpp:class:`nb::args <args>` are implicitly :ref:`keyword-only <kw_only>`,
-just like in regular Python.
-
-.. _args_kwargs_2:
-
-Expanding \*args and \*\*kwargs
--------------------------------
-
-Conversely, nanobind can also expand standard containers to add positional and
-keyword arguments to a Python call. The example below shows how to do this
-using the wrapper types :cpp:class:`nb::object <object>`,
-:cpp:class:`nb::callable <callable>`, :cpp:class:`nb::list <list>`,
-:cpp:class:`nb::dict <dict>`
-
-.. code-block:: cpp
-
-   nb::object my_call(nb::callable callable) {
-       nb::list list;
-       nb::dict dict;
-
-       list.append("positional");
-       dict["keyword"] = "value";
-
-       return callable(1, *list, **dict);
-   }
-
-   NB_MODULE(my_ext, m) {
-       m.def("my_call", &my_call);
-   }
-
-Here is an example use of the above extension in Python:
-
-.. code-block:: pycon
-
-   >>> def x(*args, **kwargs):
-   ...     print(args)
-   ...     print(kwargs)
-   ...
-   >>> import my_ext
-   >>> my_ext.my_call(x)
-   (1, 'positional')
-   {'keyword': 'value'}
-
-
-.. _kw_only:
-
-Keyword-only parameters
------------------------
-
-Python supports keyword-only parameters; these can't be filled positionally,
-thus requiring the caller to specify their name. They can be used
-to enforce more clarity at call sites if a function has
-multiple paramaters that could be confused with each other, or to accept
-named options alongside variadic ``*args``.
-
-.. code-block:: python
-
-    def example(val: int, *, check: bool) -> None:
-        # val can be passed either way; check must be given as a keyword arg
-        pass
-
-    example(val=42, check=True)   # good
-    example(check=False, val=5)   # good
-    example(100, check=True)      # good
-    example(200, False)           # TypeError:
-        # example() takes 1 positional argument but 2 were given
-
-    def munge(*args: int, invert: bool = False) -> int:
-        return sum(args) * (-1 if invert else 1)
-
-    munge(1, 2, 3)                # 6
-    munge(4, 5, 6, invert=True)   # -15
-
-nanobind provides a :cpp:struct:`nb::kw_only() <kw_only>` annotation
-that allows you to produce bindings that behave like these
-examples. It must be placed before the :cpp:struct:`nb::arg() <arg>`
-annotation for the first keyword-only parameter; you can think of it
-as equivalent to the bare ``*,`` in a Python function signature. For
-example, the above examples could be written in C++ as:
-
-.. code-block:: cpp
-
-    void example(int val, bool check);
-    int munge(nb::args args, bool invert);
-
-    m.def("example", &example,
-          nb::arg("val"), nb::kw_only(), nb::arg("check"));
-
-    // Parameters after *args are implicitly keyword-only:
-    m.def("munge", &munge,
-          nb::arg("args"), nb::arg("invert"));
-
-    // But you can be explicit about it too, as long as you put the
-    // kw_only annotation in the correct position:
-    m.def("munge", &munge,
-          nb::arg("args"), nb::kw_only(), nb::arg("invert"));
-
-.. note:: nanobind does *not* support the ``pos_only()`` argument annotation
-   provided by pybind11, which marks the parameters before it as positional-only.
-   However, a parameter can be made effectively positional-only by giving it
-   no name (using an empty :cpp:struct:`nb::arg() <arg>` specifier).
-
-
-.. _function_templates:
-
-Function templates
-------------------
-
-Consider the following function signature with a *template parameter*:
-
-.. code-block:: cpp
-
-   template <typename T> void process(T t);
-
-A template must be instantiated with concrete types to be usable, which is a
-compile-time operation. The generic version version therefore cannot be used
-in bindings:
-
-.. code-block:: cpp
-
-   m.def("process", &process); // <-- this will not compile
-
-You must bind each instantiation separately, either as a single function
-with overloads, or as separately named functions.
-
-.. code-block:: cpp
-
-   // Option 1:
-   m.def("process", &process<int>);
-   m.def("process", &process<std::string>);
-
-   // Option 2:
-   m.def("process_int", &process<int>);
-   m.def("process_string", &process<std::string>);
-
-.. _lifetime_annotations:
-
-Lifetime annotations
---------------------
-
-The :cpp:class:`nb::keep_alive\<Nurse, Patient\>() <keep_alive>` annotation
-indicates that the argument with index ``Patient`` should be kept alive at least
-until the argument with index ``Nurse`` is freed by the garbage collector.
-
-The example below applies the annotation to a hypothetical operation that
-appends an entry to a log data structure.
-
-.. code-block:: cpp
-
-    nb::class_<Log>(m, "Log")
-        .def("append",
-             [](Log &log, Entry *entry) -> void { ... },
-             nb::keep_alive<1, 2>());
-
-Here, ``Nurse = 1`` refers to the ``log`` argument, while ``Patient = 2``
-refers to ``entry``. Setting ``Nurse/Patient = 0`` would select the function
-return value (here, the function doesn't return anything, so ``0`` is not a
-valid choice).
-
-The example uses the annotation to tie the lifetime of the ``entry`` to that of
-``log``. Without it, Python could potentially delete ``entry`` *before*
-``log``, which would be problematic if the ``log.append()`` operation causes
-``log`` to reference ``entry`` through a pointer address instead of making a
-copy. Whether or not this is a good design is another question (for example,
-shared ownership via ``std::shared_ptr<T>`` or intrusive reference counting
-would avoid the problem altogether).
-
-See the definition of :cpp:class:`nb::keep_alive <keep_alive>` for further
-discussion and limitations of this method.
-
-.. _call_guards:
-
-Call guards
------------
-
-The :cpp:class:`nb::call_guard\<T\>() <call_guard>` annotation allows any scope
-guard ``T`` to be placed around the function call. For example, this
-definition:
-
-.. code-block:: cpp
-
-   m.def("foo", foo, nb::call_guard<T>());
-
-is equivalent to the following pseudocode:
-
-.. code-block:: cpp
-
-   m.def("foo", [](args...) {
-       T scope_guard;
-       return foo(args...); // forwarded arguments
-   });
-
-The only requirement is that ``T`` is default-constructible, but otherwise
-any scope guard will work. This feature is often combined with
-:cpp:class:`nb::gil_scoped_release <gil_scoped_release>` to release the
-Python *global interpreter lock* (GIL) during a long-running C++ routine
-to permit parallel execution.
-
-Multiple guards should be specified as :cpp:class:`nb::call_guard\<T1, T2,
-T3...\> <call_guard>`. Construction occurs left to right, while destruction
-occurs in reverse.
-
-If your wrapping needs are more complex than
-:cpp:class:`nb::call_guard\<T\>() <call_guard>` can handle, it is also
-possible to define a custom "call policy", which can observe or modify the
-Python object arguments and observe the return value. See the documentation of
-:cpp:class:`nb::call_policy\<Policy\> <call_policy>` for details.
-
-
-.. _higher_order_adv:
-
-Higher-order functions
-----------------------
-
-The C++11 standard introduced lambda functions and the generic polymorphic
-function wrapper ``std::function<>``, which enable powerful new ways of working
-with functions. Lambda functions come in two flavors: stateless lambda function
-resemble classic function pointers that link to an anonymous piece of code,
-while stateful lambda functions additionally depend on captured variables that
-are stored in an anonymous *lambda closure object*.
-
-Here is a simple example of a C++ function that takes an arbitrary function
-(stateful or stateless) with signature ``int -> int`` as an argument and runs
-it with the value 10.
-
-.. code-block:: cpp
-
-   int func_arg(const std::function<int(int)> &f) {
-       return f(10);
-   }
-
-The example below is more involved: it takes a function of signature ``int -> int``
-and returns another function of the same kind. The return value is a stateful
-lambda function, which stores the value ``f`` in the capture object and adds 1 to
-its return value upon execution.
-
-.. code-block:: cpp
-
-   std::function<int(int)> func_ret(const std::function<int(int)> &f) {
-       return [f](int i) {
-           return f(i) + 1;
-       };
-   }
-
-This example demonstrates using python named parameters in C++ callbacks which
-requires use of the :cpp:func:`nb::cpp_function <cpp_function>` conversion
-function. Usage is similar to defining methods of classes:
-
-.. code-block:: cpp
-
-   nb::object func_cpp() {
-       return nb::cpp_function([](int i) { return i+1; },
-          nb::arg("number"));
-   }
-
-After including the extra header file :file:`nanobind/stl/function.h`, it is almost
-trivial to generate binding code for all of these functions.
-
-.. code-block:: cpp
-
-   #include <nanobind/stl/function.h>
-
-   NB_MODULE(my_ext, m) {
-       m.def("func_arg", &func_arg);
-       m.def("func_ret", &func_ret);
-       m.def("func_cpp", &func_cpp);
-   }
-
-The following interactive session shows how to call them from Python.
-
-.. code-block:: pycon
-
-   Python 3.11.1 (main, Dec 23 2022, 09:28:24) [Clang 14.0.0 (clang-1400.0.29.202)] on darwin
-   Type "help", "copyright", "credits" or "license" for more information.
-   >>> import my_ext
-   >>> def square(i):
-   ...     return i*i
-   ...
-   >>> my_ext.func_arg(square)
-   100
-   >>> square_plus_1 = my_ext.func_ret(square)
-   >>> square_plus_1(4)
-   17
-   >>> plus_1 = my_ext.func_cpp()
-   >>> plus_1.__doc__
-   '<anonymous>(number: int) -> int'
-   >>> plus_1(number=43)
-   44
-
-.. note::
-
-   This functionality is very useful when generating bindings for callbacks in
-   C++ libraries (e.g. GUI libraries, asynchronous networking libraries,
-   etc.).
-
-.. _binding-overheads:
-
-Minimizing binding overheads
-----------------------------
-
-The code that dispatches function calls from Python to C++ is in general
-:ref:`highly optimized <benchmarks>`. When it is important to further reduce
-binding overheads to an absolute minimum, consider removing annotations for
-:ref:`keyword and default arguments <keyword_and_default_args>` along with
-other advanced binding annotations.
-
-In the snippet below, ``f1`` has lower binding overheads compared to ``f2``.
-
-.. code-block:: cpp
-
-   NB_MODULE(my_ext, m) {
-       m.def("f1", [](int) { /* no-op */ });
-       m.def("f2", [](int) { /* no-op */ }, "arg"_a);
-   }
-
-This is because ``f1``:
-
-1. Does *not* use any of the following advanced argument annotations features:
-
-   - **Named function arguments**, e.g., :cpp:class:`nb::arg("name") <arg>` or ``"name"_a``.
-
-   - **Default argument values**, e.g., :cpp:func:`nb::arg() = 0 <arg::operator=>` or ``"name"_a = false``.
-
-   - **Nullability** or **implicit conversion** flags, e.g.,
-     :cpp:func:`nb::arg().none() <arg::none>` or :cpp:func:`"name"_a.noconvert()
-     <arg::noconvert>`.
-
-2. Has no :cpp:class:`nb::keep_alive\<Nurse, Patient\>() <keep_alive>`
-   annotations.
-
-3. Takes no variable-length positional (:cpp:class:`nb::args <args>`) or keyword
-   (:cpp:class:`nb::kwargs <kwargs>`) arguments.
-
-4. Has a to total of **8 or fewer** function arguments.
-
-If all of the above conditions are satisfied, nanobind switches to a
-specialized dispatcher that is optimized to handle a small number of positional
-arguments. Otherwise, it uses the default dispatcher that works in any
-situation. It is also worth noting that functions with many overloads generally
-execute more slowly, since nanobind must first select a suitable one.
-
-These differences are mainly of interest when a function that does *very
-little* is called at a *very high rate*, in which case binding overheads can
-become noticeable.
-
-Regarding point 1 of the above list, note that **locking** is okay, as long as
-the annotation does not provide an argument name. In other words, a function
-binding with a :cpp:func:`nb::arg().lock() <arg::lock>` for some of its arguments stays on the fast
-path. This is mainly of interest for :ref:`free-threaded <free-threaded>`
-extensions.
diff --git a/src/nanobind/docs/images/binding-dark.svg b/src/nanobind/docs/images/binding-dark.svg
deleted file mode 100644
index 9d5901e..0000000
--- a/src/nanobind/docs/images/binding-dark.svg
+++ /dev/null
@@ -1,122 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<svg id="Layer_1" data-name="Layer 1" xmlns="http://www.w3.org/2000/svg" viewBox="0 0 298.8 62.36">
-  <defs>
-    <style>
-      .cls-1 {
-        stroke: #fff;
-      }
-
-      .cls-1, .cls-2, .cls-3 {
-        fill: none;
-        stroke-linecap: round;
-        stroke-linejoin: round;
-      }
-
-      .cls-4 {
-        fill: #fff;
-      }
-
-      .cls-5 {
-        fill: #dcffdf;
-      }
-
-      .cls-6 {
-        fill: #dcdcff;
-      }
-
-      .cls-7 {
-        fill: #a2a4ff;
-      }
-
-      .cls-8 {
-        fill: #919191;
-        fill-rule: evenodd;
-      }
-
-      .cls-2 {
-        stroke: #000;
-        stroke-width: .8px;
-      }
-
-      .cls-3 {
-        stroke: #919191;
-        stroke-width: 1.5px;
-      }
-    </style>
-  </defs>
-  <rect class="cls-6" x="6.35" y="5.85" width="115.87" height="50.74"/>
-  <rect class="cls-1" x="6.35" y="5.85" width="115.87" height="50.74"/>
-  <rect class="cls-5" x="176.58" y="5.85" width="115.87" height="50.74"/>
-  <rect class="cls-1" x="176.58" y="5.85" width="115.87" height="50.74"/>
-  <rect class="cls-7" x="16.68" y="28.23" width="95.21" height="18.58"/>
-  <rect class="cls-2" x="16.68" y="28.23" width="95.21" height="18.58"/>
-  <rect class="cls-7" x="186.94" y="28.23" width="95.21" height="18.58"/>
-  <rect class="cls-2" x="186.94" y="28.23" width="95.21" height="18.58"/>
-  <g>
-    <path d="m60.48,18.47c-.34.46-.77.83-1.31,1.11-.54.28-1.18.43-1.93.43-.65,0-1.25-.11-1.79-.33-.55-.22-1.02-.53-1.42-.92-.4-.4-.71-.87-.93-1.42-.22-.55-.34-1.15-.34-1.81s.11-1.27.34-1.82.54-1.02.95-1.4c.4-.39.88-.69,1.43-.91.55-.22,1.15-.32,1.8-.32.29,0,.58.03.88.08s.58.14.85.25.52.25.74.41c.22.16.42.35.58.57l-.94.72c-.21-.29-.5-.53-.88-.71-.38-.19-.79-.28-1.23-.28-.5,0-.94.09-1.34.27-.4.18-.73.43-1.01.74-.28.31-.5.67-.65,1.09s-.23.85-.23,1.31.07.93.22,1.34c.15.42.36.78.64,1.09.28.31.61.55,1.01.73.4.18.84.26,1.33.26s.92-.1,1.31-.29.72-.47.97-.84l.95.65Z"/>
-    <path d="m65.15,15.66h2.66v.98h-2.66v2.66h-.98v-2.66h-2.66v-.98h2.66v-2.66h.98v2.66Z"/>
-    <path d="m73.14,15.66h2.66v.98h-2.66v2.66h-.98v-2.66h-2.66v-.98h2.66v-2.66h.98v2.66Z"/>
-  </g>
-  <g>
-    <path class="cls-4" d="m136.99,21.05l1.28,4.34h.02l1.36-4.34h1.19l1.38,4.34h.02l1.28-4.34h1.19l-1.88,5.69h-1.18l-1.4-4.27h-.02l-1.39,4.27h-1.18l-1.9-5.69h1.22Z"/>
-    <path class="cls-4" d="m145.84,21.69c0-.24-.02-.45-.04-.64h1.07c.02.14.03.31.04.5,0,.19.01.34.01.46h.04c.16-.34.39-.61.7-.81s.65-.31,1.04-.31c.18,0,.32.02.44.05l-.05,1.04c-.16-.04-.33-.06-.52-.06-.27,0-.51.05-.71.15-.2.1-.37.23-.5.4-.13.17-.23.36-.29.58s-.1.45-.1.69v2.99h-1.13v-4.46c0-.15,0-.35-.01-.59Z"/>
-    <path class="cls-4" d="m153.58,23.05c0-.42-.13-.74-.38-.94s-.6-.31-1.02-.31c-.32,0-.62.06-.91.19-.28.12-.52.28-.71.47l-.6-.72c.28-.26.62-.47,1.03-.62.4-.15.84-.23,1.3-.23.41,0,.76.06,1.06.17.3.12.55.27.74.47.19.2.34.44.43.71.1.27.14.56.14.88v2.48c0,.19,0,.39.02.61.01.21.03.39.07.52h-1.02c-.06-.27-.1-.54-.1-.82h-.04c-.21.3-.47.54-.79.71s-.69.25-1.12.25c-.22,0-.46-.03-.7-.09-.24-.06-.47-.16-.67-.29-.2-.14-.37-.32-.5-.54-.13-.22-.2-.5-.2-.83,0-.43.12-.77.35-1.03s.54-.44.91-.58.8-.22,1.27-.26.95-.06,1.43-.06v-.16Zm-.28.97c-.28,0-.57.01-.87.04-.3.02-.57.07-.82.14-.24.07-.45.18-.61.32s-.24.34-.24.58c0,.17.03.31.1.42.07.11.16.2.27.28.11.07.24.12.37.15.14.03.28.04.42.04.53,0,.93-.16,1.22-.47.28-.32.43-.71.43-1.19v-.3h-.28Z"/>
-    <path class="cls-4" d="m157.67,29.62h-1.13v-8.57h1.1v.89h.04c.18-.3.45-.55.81-.75s.77-.29,1.24-.29c.42,0,.81.08,1.15.23.35.15.65.36.9.64.25.27.44.59.58.95.14.36.2.75.2,1.17s-.07.81-.2,1.18-.33.69-.57.96c-.25.27-.55.49-.9.64-.35.16-.75.23-1.19.23-.41,0-.79-.09-1.15-.26-.36-.18-.64-.42-.85-.74h-.04v3.73Zm3.74-5.74c0-.26-.04-.52-.12-.77-.08-.25-.2-.47-.36-.66-.16-.19-.36-.34-.59-.46-.24-.11-.51-.17-.82-.17-.29,0-.55.06-.79.17-.24.11-.44.26-.61.46-.17.19-.3.41-.39.66-.09.25-.14.51-.14.78s.05.53.14.78c.09.25.22.47.39.65.17.19.37.34.61.45.24.11.5.17.79.17.31,0,.59-.06.82-.17s.43-.27.59-.46c.16-.19.28-.41.36-.66.08-.25.12-.5.12-.77Z"/>
-  </g>
-  <g>
-    <path class="cls-4" d="m133.6,57.28c-.02-.14-.03-.31-.04-.49,0-.18-.01-.33-.01-.45h-.02c-.14.3-.39.56-.73.77-.34.21-.72.32-1.13.32-.37,0-.69-.06-.95-.18-.27-.12-.49-.29-.66-.5-.17-.21-.3-.46-.38-.74s-.13-.58-.13-.9v-3.53h1.13v3.14c0,.23.02.45.05.67s.1.4.2.56c.1.16.23.29.4.38.17.1.38.14.65.14.46,0,.82-.17,1.1-.51.28-.34.42-.79.42-1.36v-3.02h1.13v4.46c0,.15,0,.35.01.59,0,.24.02.45.04.64h-1.07Z"/>
-    <path class="cls-4" d="m137.59,51.59c.02.14.03.31.04.49s.01.33.01.45h.04c.07-.15.17-.29.29-.43s.27-.25.43-.35c.16-.1.34-.18.53-.23.19-.06.39-.08.6-.08.37,0,.68.06.95.19s.48.29.66.5c.18.21.31.45.39.73s.13.58.13.9v3.53h-1.13v-3.16c0-.23-.02-.45-.05-.66-.04-.21-.1-.39-.2-.55s-.23-.29-.4-.38-.38-.14-.65-.14c-.45,0-.81.17-1.1.51s-.43.79-.43,1.36v3.02h-1.13v-4.46c0-.15,0-.35-.01-.59s-.02-.45-.04-.64h1.07Z"/>
-    <path class="cls-4" d="m143.98,51.59l1.28,4.34h.02l1.36-4.34h1.19l1.38,4.34h.02l1.28-4.34h1.19l-1.88,5.69h-1.18l-1.4-4.27h-.02l-1.39,4.27h-1.18l-1.9-5.69h1.22Z"/>
-    <path class="cls-4" d="m152.82,52.23c0-.24-.02-.45-.04-.64h1.07c.02.14.03.31.04.5,0,.19.01.34.01.46h.04c.16-.34.39-.61.7-.81s.65-.31,1.04-.31c.18,0,.32.02.44.05l-.05,1.04c-.16-.04-.33-.06-.52-.06-.27,0-.51.05-.71.15-.2.1-.37.23-.5.4-.13.17-.23.36-.29.58s-.1.45-.1.69v2.99h-1.13v-4.46c0-.15,0-.35-.01-.59Z"/>
-    <path class="cls-4" d="m160.56,53.6c0-.42-.13-.74-.38-.94s-.6-.31-1.02-.31c-.32,0-.62.06-.91.19-.28.12-.52.28-.71.47l-.6-.72c.28-.26.62-.47,1.03-.62.4-.15.84-.23,1.3-.23.41,0,.76.06,1.06.17.3.12.55.27.74.47.19.2.34.44.43.71.1.27.14.56.14.88v2.48c0,.19,0,.39.02.61.01.21.03.39.07.52h-1.02c-.06-.27-.1-.54-.1-.82h-.04c-.21.3-.47.54-.79.71s-.69.25-1.12.25c-.22,0-.46-.03-.7-.09-.24-.06-.47-.16-.67-.29-.2-.14-.37-.32-.5-.54-.13-.22-.2-.5-.2-.83,0-.43.12-.77.35-1.03s.54-.44.91-.58.8-.22,1.27-.26.95-.06,1.43-.06v-.16Zm-.28.97c-.28,0-.57.01-.87.04-.3.02-.57.07-.82.14-.24.07-.45.18-.61.32s-.24.34-.24.58c0,.17.03.31.1.42.07.11.16.2.27.28.11.07.24.12.37.15.14.03.28.04.42.04.53,0,.93-.16,1.22-.47.28-.32.43-.71.43-1.19v-.3h-.28Z"/>
-    <path class="cls-4" d="m164.65,60.16h-1.13v-8.57h1.1v.89h.04c.18-.3.45-.55.81-.75s.77-.29,1.24-.29c.42,0,.81.08,1.15.23.35.15.65.36.9.64.25.27.44.59.58.95.14.36.2.75.2,1.17s-.07.81-.2,1.18-.33.69-.57.96c-.25.27-.55.49-.9.64-.35.16-.75.23-1.19.23-.41,0-.79-.09-1.15-.26-.36-.18-.64-.42-.85-.74h-.04v3.73Zm3.74-5.74c0-.26-.04-.52-.12-.77-.08-.25-.2-.47-.36-.66-.16-.19-.36-.34-.59-.46-.24-.11-.51-.17-.82-.17-.29,0-.55.06-.79.17-.24.11-.44.26-.61.46-.17.19-.3.41-.39.66-.09.25-.14.51-.14.78s.05.53.14.78c.09.25.22.47.39.65.17.19.37.34.61.45.24.11.5.17.79.17.31,0,.59-.06.82-.17s.43-.27.59-.46c.16-.19.28-.41.36-.66.08-.25.12-.5.12-.77Z"/>
-  </g>
-  <g>
-    <path d="m216.7,11.3h2.59c.46,0,.87.05,1.25.14.38.09.7.23.96.43.26.19.47.44.61.73s.22.65.22,1.07-.08.79-.23,1.09c-.16.3-.37.55-.65.74-.28.19-.6.33-.98.43s-.79.14-1.23.14h-1.34v3.73h-1.19v-8.5Zm1.19,3.76h1.26c.29,0,.55-.03.8-.08.24-.05.45-.13.63-.24.18-.11.31-.25.41-.43.1-.18.14-.39.14-.65s-.05-.47-.15-.64c-.1-.17-.24-.31-.41-.42-.17-.11-.38-.18-.62-.23-.24-.04-.5-.07-.78-.07h-1.28v2.75Z"/>
-    <path d="m225.45,18.57h.02l1.57-4.46h1.2l-2.76,7.03c-.1.24-.2.45-.31.64-.11.19-.24.35-.4.48s-.33.23-.53.31c-.2.07-.45.11-.73.11-.12,0-.24,0-.37-.02-.12-.01-.25-.03-.38-.07l.11-1c.19.06.38.1.56.1.3,0,.52-.08.66-.25.14-.16.28-.4.4-.7l.36-.95-2.44-5.69h1.26l1.76,4.46Z"/>
-    <path d="m232.12,15.03h-1.51v2.96c0,.34.06.59.19.74s.33.22.61.22c.1,0,.22-.01.34-.03.12-.02.23-.05.32-.1l.04.92c-.14.05-.29.08-.45.11s-.33.04-.51.04c-.54,0-.95-.15-1.23-.44-.28-.3-.43-.74-.43-1.33v-3.08h-1.09v-.92h1.09v-1.63h1.12v1.63h1.51v.92Z"/>
-    <path d="m234.46,14.97c.14-.28.37-.52.7-.72.33-.2.7-.3,1.1-.3.37,0,.68.06.95.19s.48.29.66.5c.18.21.31.45.39.73s.13.58.13.9v3.53h-1.13v-3.15c0-.23-.02-.45-.05-.66-.04-.21-.1-.39-.2-.55-.1-.16-.23-.29-.39-.39-.16-.1-.38-.14-.64-.14-.45,0-.82.17-1.1.51s-.43.8-.43,1.37v3.02h-1.13v-9.07h1.13v4.25h.02Z"/>
-    <path d="m246.05,16.94c0,.44-.08.84-.23,1.21-.16.37-.37.69-.65.95-.28.27-.6.48-.98.62-.38.15-.78.22-1.21.22s-.84-.07-1.21-.22c-.38-.15-.7-.36-.97-.62-.27-.27-.49-.59-.64-.95-.16-.37-.23-.77-.23-1.21s.08-.84.23-1.21c.16-.36.37-.68.64-.94s.6-.47.97-.62c.38-.15.78-.22,1.21-.22s.84.07,1.21.22c.38.15.7.35.98.62s.49.58.65.94c.16.36.23.77.23,1.21Zm-1.18,0c0-.27-.04-.53-.13-.78-.08-.25-.21-.46-.37-.65s-.36-.34-.6-.45c-.24-.11-.51-.17-.81-.17s-.58.06-.81.17c-.24.11-.44.26-.6.45-.16.19-.28.4-.37.65-.08.25-.13.51-.13.78s.04.53.13.78c.08.25.21.47.37.66.16.19.36.34.6.46.24.11.51.17.81.17s.58-.06.81-.17c.24-.11.44-.26.6-.46s.28-.41.37-.66c.08-.25.13-.51.13-.78Z"/>
-    <path d="m248.63,14.1c.02.14.03.31.04.49s.01.33.01.45h.04c.07-.15.17-.29.29-.43s.27-.25.43-.35c.16-.1.34-.18.53-.23.19-.06.39-.08.6-.08.37,0,.68.06.95.19s.48.29.66.5c.18.21.31.45.39.73s.13.58.13.9v3.53h-1.13v-3.16c0-.23-.02-.45-.05-.66-.04-.21-.1-.39-.2-.55s-.23-.29-.4-.38-.38-.14-.65-.14c-.45,0-.81.17-1.1.51s-.43.79-.43,1.36v3.02h-1.13v-4.46c0-.15,0-.35-.01-.59s-.02-.45-.04-.64h1.07Z"/>
-  </g>
-  <g>
-    <path d="m24.97,39.69c0,.17-.03.33-.09.46s-.14.26-.24.36c-.1.11-.22.2-.35.27s-.28.14-.43.19-.31.08-.47.11-.32.03-.47.03c-.33,0-.64-.01-.92-.04s-.55-.08-.82-.14v-.78c.29.08.57.14.85.19s.56.06.84.06c.41,0,.71-.06.9-.17s.29-.27.29-.47c0-.09-.02-.17-.05-.24-.03-.07-.09-.14-.17-.2-.08-.06-.21-.13-.38-.2s-.4-.15-.7-.23c-.22-.07-.43-.14-.61-.22-.19-.08-.35-.18-.49-.29s-.24-.25-.32-.4-.12-.33-.12-.54c0-.14.03-.29.1-.45s.17-.31.32-.45.36-.26.62-.35c.26-.09.59-.14.98-.14.19,0,.41.01.64.03.23.02.48.06.73.11v.76c-.27-.07-.52-.11-.76-.14-.24-.03-.45-.05-.62-.05-.21,0-.39.02-.53.05s-.26.08-.35.13c-.09.06-.15.12-.19.2-.04.08-.06.16-.06.25s.02.17.05.24.1.14.19.21c.09.07.22.13.39.2.17.07.38.14.65.22.29.08.53.17.73.27.2.09.36.2.48.31s.21.24.27.39.08.31.08.49Z"/>
-    <path d="m30.54,40.96c-.19.05-.39.08-.6.11-.21.02-.41.03-.62.03-.62,0-1.07-.14-1.38-.42-.3-.28-.45-.71-.45-1.28v-2.56h-1.37v-.71h1.37v-1.35l.85-.22v1.57h2.2v.71h-2.2v2.49c0,.35.09.61.28.79.19.17.46.26.83.26.16,0,.33-.01.51-.04.19-.03.38-.06.58-.12v.73Z"/>
-    <path d="m31.84,38.68c0-.42.06-.79.17-1.11.11-.32.28-.6.49-.82.21-.22.46-.39.76-.51.29-.12.62-.17.98-.17.16,0,.31,0,.46.03s.3.05.45.09v-2.06h.85v6.9h-.76l-.03-.93c-.24.34-.49.6-.77.77s-.58.25-.9.25c-.28,0-.53-.06-.74-.18s-.39-.28-.53-.5c-.14-.21-.25-.47-.32-.77s-.11-.63-.11-1Zm.87-.05c0,.59.09,1.03.26,1.33.17.29.42.44.74.44.21,0,.44-.1.68-.29s.49-.48.75-.85v-2.28c-.14-.07-.29-.11-.46-.15-.17-.03-.34-.05-.5-.05-.46,0-.82.15-1.08.45s-.39.77-.39,1.41Z"/>
-    <path d="m39.55,36.04c.1,0,.2.02.29.06.09.04.17.1.24.16s.12.15.16.24.06.19.06.29-.02.2-.06.29c-.04.09-.1.17-.16.24s-.15.12-.24.16-.19.06-.29.06-.2-.02-.29-.06-.17-.09-.24-.16-.12-.15-.16-.24c-.04-.09-.06-.19-.06-.29s.02-.2.06-.29.09-.17.16-.24.15-.12.24-.16c.09-.04.19-.06.29-.06Zm0,3.58c.1,0,.2.02.29.06.09.04.17.09.24.16s.12.15.16.24.06.19.06.29-.02.2-.06.29c-.04.09-.1.17-.16.24s-.15.12-.24.16-.19.06-.29.06-.2-.02-.29-.06-.17-.09-.24-.16-.12-.15-.16-.24c-.04-.09-.06-.19-.06-.29s.02-.2.06-.29.09-.17.16-.24.15-.12.24-.16c.09-.04.19-.06.29-.06Z"/>
-    <path d="m45.05,36.04c.1,0,.2.02.29.06.09.04.17.1.24.16s.12.15.16.24.06.19.06.29-.02.2-.06.29c-.04.09-.1.17-.16.24s-.15.12-.24.16-.19.06-.29.06-.2-.02-.29-.06-.17-.09-.24-.16-.12-.15-.16-.24c-.04-.09-.06-.19-.06-.29s.02-.2.06-.29.09-.17.16-.24.15-.12.24-.16c.09-.04.19-.06.29-.06Zm0,3.58c.1,0,.2.02.29.06.09.04.17.09.24.16s.12.15.16.24.06.19.06.29-.02.2-.06.29c-.04.09-.1.17-.16.24s-.15.12-.24.16-.19.06-.29.06-.2-.02-.29-.06-.17-.09-.24-.16-.12-.15-.16-.24c-.04-.09-.06-.19-.06-.29s.02-.2.06-.29.09-.17.16-.24.15-.12.24-.16c.09-.04.19-.06.29-.06Z"/>
-    <path d="m48.12,36.13h.97l1.2,3.24.26.79.27-.81,1.19-3.22h.93l-1.92,4.9h-.98l-1.92-4.9Z"/>
-    <path d="m58.22,38.32c0,.12,0,.22,0,.3s0,.16-.01.23h-3.44c0,.5.14.89.42,1.15.28.27.68.4,1.21.4.14,0,.29,0,.43-.02.14-.01.28-.03.42-.05s.26-.04.38-.07c.12-.02.24-.05.34-.08v.7c-.23.07-.49.12-.78.16-.29.04-.59.06-.91.06-.42,0-.78-.06-1.08-.17s-.55-.28-.74-.5c-.19-.22-.34-.48-.43-.8-.09-.31-.14-.67-.14-1.07,0-.34.05-.67.15-.98.1-.31.24-.58.43-.81.19-.23.42-.42.7-.55s.59-.21.94-.21.64.05.91.16.49.26.67.46c.18.2.32.44.41.72.09.28.14.6.14.94Zm-.88-.12c0-.22-.01-.42-.06-.6-.05-.18-.13-.34-.24-.47s-.25-.23-.41-.3c-.16-.07-.35-.11-.57-.11-.19,0-.35.04-.51.11s-.28.17-.4.3-.2.29-.27.47-.11.38-.13.6h2.58Z"/>
-    <path d="m63.38,40.85c-.22.08-.45.15-.68.19-.23.04-.47.06-.72.06-.77,0-1.37-.21-1.79-.63s-.63-1.03-.63-1.84c0-.39.06-.74.18-1.05s.29-.59.51-.81.48-.4.78-.52c.3-.12.64-.18,1-.18.25,0,.49.02.71.05s.43.09.63.18v.81c-.21-.11-.43-.19-.65-.24-.22-.05-.45-.08-.68-.08-.22,0-.42.04-.62.12-.19.08-.36.2-.51.36s-.26.35-.35.57-.13.48-.13.76c0,.59.14,1.04.43,1.33.29.29.69.44,1.2.44.23,0,.46-.03.67-.08s.43-.13.63-.23v.79Z"/>
-    <path d="m69.02,40.96c-.19.05-.39.08-.6.11-.21.02-.41.03-.62.03-.62,0-1.07-.14-1.38-.42-.3-.28-.45-.71-.45-1.28v-2.56h-1.37v-.71h1.37v-1.35l.85-.22v1.57h2.2v.71h-2.2v2.49c0,.35.09.61.28.79.19.17.46.26.83.26.16,0,.33-.01.51-.04.19-.03.38-.06.58-.12v.73Z"/>
-    <path d="m74.84,38.54c0,.38-.05.73-.16,1.05-.11.32-.26.59-.46.82-.2.23-.45.4-.74.53-.29.12-.62.19-.99.19s-.67-.05-.94-.16c-.28-.11-.51-.27-.71-.48s-.34-.47-.44-.79-.15-.67-.15-1.08c0-.38.05-.73.16-1.04.11-.31.26-.58.46-.81.2-.23.45-.4.74-.53.29-.12.62-.19.99-.19s.67.05.94.16c.28.11.51.27.71.48.19.21.34.47.44.78s.15.67.15,1.07Zm-.87.04c0-.3-.03-.57-.1-.79-.07-.23-.16-.42-.29-.57-.12-.15-.27-.27-.45-.34-.18-.08-.38-.12-.59-.12-.25,0-.47.05-.65.15-.18.1-.33.23-.44.4s-.2.36-.25.58c-.05.22-.08.45-.08.69,0,.3.03.57.1.8s.16.42.29.57c.12.15.27.26.45.34.18.08.37.11.6.11.25,0,.47-.05.65-.15.18-.1.33-.23.44-.4s.2-.36.25-.58c.05-.22.08-.45.08-.7Z"/>
-    <path d="m76.27,36.13h.78l.02.9c.29-.35.58-.6.86-.76s.57-.23.85-.23c.51,0,.89.16,1.15.49s.38.82.36,1.46h-.86c0-.43-.05-.74-.19-.93-.14-.19-.33-.29-.59-.29-.11,0-.23.02-.34.06-.12.04-.23.11-.36.2-.12.09-.25.21-.39.34s-.28.31-.44.51v3.15h-.86v-4.9Z"/>
-    <path d="m85.27,40.57l-.53.54-3.28-2.74,3.28-2.74.53.54-2.66,2.19,2.66,2.21Z"/>
-    <path d="m88.74,36.83h-1.45v-.7h2.31v4.19h1.46v.71h-3.93v-.71h1.61v-3.49Zm.3-2.76c.09,0,.18.02.26.05.08.03.15.08.21.14s.11.13.14.21c.03.08.05.17.05.26s-.02.18-.05.26-.08.15-.14.21-.13.11-.21.14c-.08.04-.17.05-.26.05s-.18-.02-.26-.05c-.08-.03-.15-.08-.21-.14s-.11-.13-.14-.21-.05-.17-.05-.26.02-.18.05-.26c.03-.08.08-.15.14-.21s.13-.11.21-.14c.08-.04.17-.05.26-.05Z"/>
-    <path d="m92.56,36.13h.76l.03.79c.14-.17.28-.31.42-.42.13-.11.26-.2.39-.27s.26-.12.39-.14c.13-.03.27-.04.42-.04.5,0,.89.15,1.15.45.26.3.39.75.39,1.34v3.2h-.85v-3.13c0-.38-.07-.67-.21-.85-.14-.18-.36-.28-.64-.28-.1,0-.21.02-.31.05-.1.03-.2.08-.31.16-.11.08-.22.18-.35.31s-.27.29-.42.49v3.25h-.85v-4.9Z"/>
-    <path d="m102.01,40.96c-.19.05-.39.08-.6.11-.21.02-.41.03-.62.03-.62,0-1.07-.14-1.38-.42-.3-.28-.45-.71-.45-1.28v-2.56h-1.37v-.71h1.37v-1.35l.85-.22v1.57h2.2v.71h-2.2v2.49c0,.35.09.61.28.79.19.17.46.26.83.26.16,0,.33-.01.51-.04.19-.03.38-.06.58-.12v.73Z"/>
-    <path d="m103.8,36.17l.53-.54,3.28,2.74-3.28,2.74-.53-.54,2.66-2.19-2.66-2.21Z"/>
-  </g>
-  <g>
-    <path d="m194.85,41.03v-3.52c0-.15,0-.28-.02-.38s-.03-.17-.05-.23c-.02-.06-.06-.1-.09-.12s-.08-.03-.14-.03c-.06,0-.13.02-.18.06s-.11.1-.18.19-.13.2-.21.35c-.08.14-.17.32-.27.53v3.15h-.78v-3.43c0-.18,0-.32-.02-.43s-.03-.2-.05-.26-.06-.1-.1-.13-.09-.03-.14-.03c-.06,0-.11.02-.17.05s-.11.09-.17.18-.13.2-.21.35-.17.33-.28.56v3.15h-.78v-4.9h.65l.04.93c.08-.19.17-.34.25-.47s.16-.24.25-.31c.08-.08.17-.14.27-.18.1-.04.2-.06.32-.06.26,0,.46.09.6.26s.21.44.21.8c.08-.17.15-.32.23-.45.07-.13.16-.24.24-.33.09-.09.18-.16.29-.21.1-.05.22-.07.36-.07.62,0,.92.47.92,1.42v3.57h-.78Z"/>
-    <path d="m201.21,36.13l-1.67,4.38c-.17.45-.35.83-.53,1.15s-.38.59-.6.79c-.22.21-.46.36-.72.46s-.55.15-.87.15c-.08,0-.16,0-.23,0s-.14,0-.22-.01v-.77c.07,0,.15.02.23.03.08,0,.17.01.27.01.16,0,.3-.02.44-.07s.26-.12.38-.22c.12-.1.24-.23.35-.4s.22-.36.32-.59l-1.96-4.9h.97l1.24,3.24.25.76.28-.78,1.15-3.22h.93Z"/>
-    <path d="m207.07,43.03h-5.5v-.7h5.5v.7Z"/>
-    <path d="m211.99,38.32c0,.12,0,.22,0,.3s0,.16-.01.23h-3.44c0,.5.14.89.42,1.15.28.27.68.4,1.21.4.14,0,.29,0,.43-.02.14-.01.28-.03.42-.05s.26-.04.38-.07c.12-.02.24-.05.34-.08v.7c-.23.07-.49.12-.78.16-.29.04-.59.06-.91.06-.42,0-.78-.06-1.08-.17s-.55-.28-.74-.5c-.19-.22-.34-.48-.43-.8-.09-.31-.14-.67-.14-1.07,0-.34.05-.67.15-.98.1-.31.24-.58.43-.81.19-.23.42-.42.7-.55s.59-.21.94-.21.64.05.91.16.49.26.67.46c.18.2.32.44.41.72.09.28.14.6.14.94Zm-.88-.12c0-.22-.01-.42-.06-.6-.05-.18-.13-.34-.24-.47s-.25-.23-.41-.3c-.16-.07-.35-.11-.57-.11-.19,0-.35.04-.51.11s-.28.17-.4.3-.2.29-.27.47-.11.38-.13.6h2.58Z"/>
-    <path d="m217.76,41.03h-1.13l-1.32-1.87-1.31,1.87h-1.1l1.9-2.46-1.81-2.44h1.09l1.29,1.88,1.26-1.88h1.05l-1.84,2.46,1.92,2.44Z"/>
-    <path d="m222.79,40.96c-.19.05-.39.08-.6.11-.21.02-.41.03-.62.03-.62,0-1.07-.14-1.38-.42-.3-.28-.45-.71-.45-1.28v-2.56h-1.37v-.71h1.37v-1.35l.85-.22v1.57h2.2v.71h-2.2v2.49c0,.35.09.61.28.79.19.17.46.26.83.26.16,0,.33-.01.51-.04.19-.03.38-.06.58-.12v.73Z"/>
-    <path d="m226.27,39.49c.11,0,.22.02.31.06s.19.1.26.18.13.16.17.26c.04.1.06.21.06.32s-.02.21-.06.31-.1.18-.17.26c-.07.07-.16.13-.26.17s-.2.06-.31.06-.22-.02-.32-.06-.18-.1-.26-.17c-.07-.07-.13-.16-.17-.26s-.06-.2-.06-.31.02-.22.06-.32c.04-.1.1-.19.17-.26s.16-.13.26-.18.2-.06.32-.06Z"/>
-    <path d="m231.37,35.38h-1.47v-.73h3.82v.73h-1.47v4.91h1.47v.74h-3.82v-.74h1.47v-4.91Z"/>
-    <path d="m235.34,36.13h.76l.03.79c.14-.17.28-.31.42-.42.13-.11.26-.2.39-.27s.26-.12.39-.14c.13-.03.27-.04.42-.04.5,0,.89.15,1.15.45.26.3.39.75.39,1.34v3.2h-.85v-3.13c0-.38-.07-.67-.21-.85-.14-.18-.36-.28-.64-.28-.1,0-.21.02-.31.05-.1.03-.2.08-.31.16-.11.08-.22.18-.35.31s-.27.29-.42.49v3.25h-.85v-4.9Z"/>
-    <path d="m244.79,40.96c-.19.05-.39.08-.6.11-.21.02-.41.03-.62.03-.62,0-1.07-.14-1.38-.42-.3-.28-.45-.71-.45-1.28v-2.56h-1.37v-.71h1.37v-1.35l.85-.22v1.57h2.2v.71h-2.2v2.49c0,.35.09.61.28.79.19.17.46.26.83.26.16,0,.33-.01.51-.04.19-.03.38-.06.58-.12v.73Z"/>
-    <path d="m251.03,34.65l-2.17,6.38h-1.17l-2.12-6.38h.98l1.38,4.3.39,1.26.4-1.26,1.38-4.3h.93Z"/>
-    <path d="m255.97,38.32c0,.12,0,.22,0,.3s0,.16-.01.23h-3.44c0,.5.14.89.42,1.15.28.27.68.4,1.21.4.14,0,.29,0,.43-.02.14-.01.28-.03.42-.05s.26-.04.38-.07c.12-.02.24-.05.34-.08v.7c-.23.07-.49.12-.78.16-.29.04-.59.06-.91.06-.42,0-.78-.06-1.08-.17s-.55-.28-.74-.5c-.19-.22-.34-.48-.43-.8-.09-.31-.14-.67-.14-1.07,0-.34.05-.67.15-.98.1-.31.24-.58.43-.81.19-.23.42-.42.7-.55s.59-.21.94-.21.64.05.91.16.49.26.67.46c.18.2.32.44.41.72.09.28.14.6.14.94Zm-.88-.12c0-.22-.01-.42-.06-.6-.05-.18-.13-.34-.24-.47s-.25-.23-.41-.3c-.16-.07-.35-.11-.57-.11-.19,0-.35.04-.51.11s-.28.17-.4.3-.2.29-.27.47-.11.38-.13.6h2.58Z"/>
-    <path d="m261.14,40.85c-.22.08-.45.15-.68.19-.23.04-.47.06-.72.06-.77,0-1.37-.21-1.79-.63s-.63-1.03-.63-1.84c0-.39.06-.74.18-1.05s.29-.59.51-.81.48-.4.78-.52c.3-.12.64-.18,1-.18.25,0,.49.02.71.05s.43.09.63.18v.81c-.21-.11-.43-.19-.65-.24-.22-.05-.45-.08-.68-.08-.22,0-.42.04-.62.12-.19.08-.36.2-.51.36s-.26.35-.35.57-.13.48-.13.76c0,.59.14,1.04.43,1.33.29.29.69.44,1.2.44.23,0,.46-.03.67-.08s.43-.13.63-.23v.79Z"/>
-    <path d="m266.78,40.96c-.19.05-.39.08-.6.11-.21.02-.41.03-.62.03-.62,0-1.07-.14-1.38-.42-.3-.28-.45-.71-.45-1.28v-2.56h-1.37v-.71h1.37v-1.35l.85-.22v1.57h2.2v.71h-2.2v2.49c0,.35.09.61.28.79.19.17.46.26.83.26.16,0,.33-.01.51-.04.19-.03.38-.06.58-.12v.73Z"/>
-    <path d="m272.59,38.54c0,.38-.05.73-.16,1.05-.11.32-.26.59-.46.82-.2.23-.45.4-.74.53-.29.12-.62.19-.99.19s-.67-.05-.94-.16c-.28-.11-.51-.27-.71-.48s-.34-.47-.44-.79-.15-.67-.15-1.08c0-.38.05-.73.16-1.04.11-.31.26-.58.46-.81.2-.23.45-.4.74-.53.29-.12.62-.19.99-.19s.67.05.94.16c.28.11.51.27.71.48.19.21.34.47.44.78s.15.67.15,1.07Zm-.87.04c0-.3-.03-.57-.1-.79-.07-.23-.16-.42-.29-.57-.12-.15-.27-.27-.45-.34-.18-.08-.38-.12-.59-.12-.25,0-.47.05-.65.15-.18.1-.33.23-.44.4s-.2.36-.25.58c-.05.22-.08.45-.08.69,0,.3.03.57.1.8s.16.42.29.57c.12.15.27.26.45.34.18.08.37.11.6.11.25,0,.47-.05.65-.15.18-.1.33-.23.44-.4s.2-.36.25-.58c.05-.22.08-.45.08-.7Z"/>
-    <path d="m274.02,36.13h.78l.02.9c.29-.35.58-.6.86-.76s.57-.23.85-.23c.51,0,.89.16,1.15.49s.38.82.36,1.46h-.86c0-.43-.05-.74-.19-.93-.14-.19-.33-.29-.59-.29-.11,0-.23.02-.34.06-.12.04-.23.11-.36.2-.12.09-.25.21-.39.34s-.28.31-.44.51v3.15h-.86v-4.9Z"/>
-  </g>
-  <polygon class="cls-8" points="179.19 31.26 184.59 33.96 179.19 36.66 179.19 31.26"/>
-  <line class="cls-3" x1="114.6" y1="33.96" x2="180.27" y2="33.96"/>
-  <polygon class="cls-8" points="120 45.73 114.6 43.03 120 40.33 120 45.73"/>
-  <line class="cls-3" x1="184.59" y1="43.03" x2="118.92" y2="43.03"/>
-</svg>
\ No newline at end of file
diff --git a/src/nanobind/docs/images/binding-light.svg b/src/nanobind/docs/images/binding-light.svg
deleted file mode 100644
index 08e623c..0000000
--- a/src/nanobind/docs/images/binding-light.svg
+++ /dev/null
@@ -1,112 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<svg id="Layer_1" data-name="Layer 1" xmlns="http://www.w3.org/2000/svg" viewBox="0 0 298.8 62.36">
-  <defs>
-    <style>
-      .cls-1, .cls-2, .cls-3 {
-        fill: none;
-        stroke: #000;
-        stroke-linecap: round;
-        stroke-linejoin: round;
-      }
-
-      .cls-4 {
-        fill: #dcffdf;
-      }
-
-      .cls-5 {
-        fill: #dcdcff;
-      }
-
-      .cls-6 {
-        fill: #a2a4ff;
-      }
-
-      .cls-2 {
-        stroke-width: .8px;
-      }
-
-      .cls-7 {
-        fill-rule: evenodd;
-      }
-
-      .cls-3 {
-        stroke-width: 1.5px;
-      }
-    </style>
-  </defs>
-  <rect class="cls-5" x="6.35" y="5.85" width="115.87" height="50.74"/>
-  <rect class="cls-1" x="6.35" y="5.85" width="115.87" height="50.74"/>
-  <rect class="cls-4" x="176.58" y="5.85" width="115.87" height="50.74"/>
-  <rect class="cls-1" x="176.58" y="5.85" width="115.87" height="50.74"/>
-  <rect class="cls-6" x="16.68" y="28.23" width="95.21" height="18.58"/>
-  <rect class="cls-2" x="16.68" y="28.23" width="95.21" height="18.58"/>
-  <rect class="cls-6" x="186.94" y="28.23" width="95.21" height="18.58"/>
-  <rect class="cls-2" x="186.94" y="28.23" width="95.21" height="18.58"/>
-  <g>
-    <path d="m60.48,18.47c-.34.46-.77.83-1.31,1.11-.54.28-1.18.43-1.93.43-.65,0-1.25-.11-1.79-.33-.55-.22-1.02-.53-1.42-.92-.4-.4-.71-.87-.93-1.42-.22-.55-.34-1.15-.34-1.81s.11-1.27.34-1.82.54-1.02.95-1.4c.4-.39.88-.69,1.43-.91.55-.22,1.15-.32,1.8-.32.29,0,.58.03.88.08s.58.14.85.25.52.25.74.41c.22.16.42.35.58.57l-.94.72c-.21-.29-.5-.53-.88-.71-.38-.19-.79-.28-1.23-.28-.5,0-.94.09-1.34.27-.4.18-.73.43-1.01.74-.28.31-.5.67-.65,1.09s-.23.85-.23,1.31.07.93.22,1.34c.15.42.36.78.64,1.09.28.31.61.55,1.01.73.4.18.84.26,1.33.26s.92-.1,1.31-.29.72-.47.97-.84l.95.65Z"/>
-    <path d="m65.15,15.66h2.66v.98h-2.66v2.66h-.98v-2.66h-2.66v-.98h2.66v-2.66h.98v2.66Z"/>
-    <path d="m73.14,15.66h2.66v.98h-2.66v2.66h-.98v-2.66h-2.66v-.98h2.66v-2.66h.98v2.66Z"/>
-  </g>
-  <g>
-    <path d="m136.99,21.05l1.28,4.34h.02l1.36-4.34h1.19l1.38,4.34h.02l1.28-4.34h1.19l-1.88,5.69h-1.18l-1.4-4.27h-.02l-1.39,4.27h-1.18l-1.9-5.69h1.22Z"/>
-    <path d="m145.84,21.69c0-.24-.02-.45-.04-.64h1.07c.02.14.03.31.04.5,0,.19.01.34.01.46h.04c.16-.34.39-.61.7-.81s.65-.31,1.04-.31c.18,0,.32.02.44.05l-.05,1.04c-.16-.04-.33-.06-.52-.06-.27,0-.51.05-.71.15-.2.1-.37.23-.5.4-.13.17-.23.36-.29.58s-.1.45-.1.69v2.99h-1.13v-4.46c0-.15,0-.35-.01-.59Z"/>
-    <path d="m153.58,23.05c0-.42-.13-.74-.38-.94s-.6-.31-1.02-.31c-.32,0-.62.06-.91.19-.28.12-.52.28-.71.47l-.6-.72c.28-.26.62-.47,1.03-.62.4-.15.84-.23,1.3-.23.41,0,.76.06,1.06.17.3.12.55.27.74.47.19.2.34.44.43.71.1.27.14.56.14.88v2.48c0,.19,0,.39.02.61.01.21.03.39.07.52h-1.02c-.06-.27-.1-.54-.1-.82h-.04c-.21.3-.47.54-.79.71s-.69.25-1.12.25c-.22,0-.46-.03-.7-.09-.24-.06-.47-.16-.67-.29-.2-.14-.37-.32-.5-.54-.13-.22-.2-.5-.2-.83,0-.43.12-.77.35-1.03s.54-.44.91-.58.8-.22,1.27-.26.95-.06,1.43-.06v-.16Zm-.28.97c-.28,0-.57.01-.87.04-.3.02-.57.07-.82.14-.24.07-.45.18-.61.32s-.24.34-.24.58c0,.17.03.31.1.42.07.11.16.2.27.28.11.07.24.12.37.15.14.03.28.04.42.04.53,0,.93-.16,1.22-.47.28-.32.43-.71.43-1.19v-.3h-.28Z"/>
-    <path d="m157.67,29.62h-1.13v-8.57h1.1v.89h.04c.18-.3.45-.55.81-.75s.77-.29,1.24-.29c.42,0,.81.08,1.15.23.35.15.65.36.9.64.25.27.44.59.58.95.14.36.2.75.2,1.17s-.07.81-.2,1.18-.33.69-.57.96c-.25.27-.55.49-.9.64-.35.16-.75.23-1.19.23-.41,0-.79-.09-1.15-.26-.36-.18-.64-.42-.85-.74h-.04v3.73Zm3.74-5.74c0-.26-.04-.52-.12-.77-.08-.25-.2-.47-.36-.66-.16-.19-.36-.34-.59-.46-.24-.11-.51-.17-.82-.17-.29,0-.55.06-.79.17-.24.11-.44.26-.61.46-.17.19-.3.41-.39.66-.09.25-.14.51-.14.78s.05.53.14.78c.09.25.22.47.39.65.17.19.37.34.61.45.24.11.5.17.79.17.31,0,.59-.06.82-.17s.43-.27.59-.46c.16-.19.28-.41.36-.66.08-.25.12-.5.12-.77Z"/>
-  </g>
-  <g>
-    <path d="m133.6,57.28c-.02-.14-.03-.31-.04-.49,0-.18-.01-.33-.01-.45h-.02c-.14.3-.39.56-.73.77-.34.21-.72.32-1.13.32-.37,0-.69-.06-.95-.18-.27-.12-.49-.29-.66-.5-.17-.21-.3-.46-.38-.74s-.13-.58-.13-.9v-3.53h1.13v3.14c0,.23.02.45.05.67s.1.4.2.56c.1.16.23.29.4.38.17.1.38.14.65.14.46,0,.82-.17,1.1-.51.28-.34.42-.79.42-1.36v-3.02h1.13v4.46c0,.15,0,.35.01.59,0,.24.02.45.04.64h-1.07Z"/>
-    <path d="m137.59,51.59c.02.14.03.31.04.49s.01.33.01.45h.04c.07-.15.17-.29.29-.43s.27-.25.43-.35c.16-.1.34-.18.53-.23.19-.06.39-.08.6-.08.37,0,.68.06.95.19s.48.29.66.5c.18.21.31.45.39.73s.13.58.13.9v3.53h-1.13v-3.16c0-.23-.02-.45-.05-.66-.04-.21-.1-.39-.2-.55s-.23-.29-.4-.38-.38-.14-.65-.14c-.45,0-.81.17-1.1.51s-.43.79-.43,1.36v3.02h-1.13v-4.46c0-.15,0-.35-.01-.59s-.02-.45-.04-.64h1.07Z"/>
-    <path d="m143.98,51.59l1.28,4.34h.02l1.36-4.34h1.19l1.38,4.34h.02l1.28-4.34h1.19l-1.88,5.69h-1.18l-1.4-4.27h-.02l-1.39,4.27h-1.18l-1.9-5.69h1.22Z"/>
-    <path d="m152.82,52.23c0-.24-.02-.45-.04-.64h1.07c.02.14.03.31.04.5,0,.19.01.34.01.46h.04c.16-.34.39-.61.7-.81s.65-.31,1.04-.31c.18,0,.32.02.44.05l-.05,1.04c-.16-.04-.33-.06-.52-.06-.27,0-.51.05-.71.15-.2.1-.37.23-.5.4-.13.17-.23.36-.29.58s-.1.45-.1.69v2.99h-1.13v-4.46c0-.15,0-.35-.01-.59Z"/>
-    <path d="m160.56,53.6c0-.42-.13-.74-.38-.94s-.6-.31-1.02-.31c-.32,0-.62.06-.91.19-.28.12-.52.28-.71.47l-.6-.72c.28-.26.62-.47,1.03-.62.4-.15.84-.23,1.3-.23.41,0,.76.06,1.06.17.3.12.55.27.74.47.19.2.34.44.43.71.1.27.14.56.14.88v2.48c0,.19,0,.39.02.61.01.21.03.39.07.52h-1.02c-.06-.27-.1-.54-.1-.82h-.04c-.21.3-.47.54-.79.71s-.69.25-1.12.25c-.22,0-.46-.03-.7-.09-.24-.06-.47-.16-.67-.29-.2-.14-.37-.32-.5-.54-.13-.22-.2-.5-.2-.83,0-.43.12-.77.35-1.03s.54-.44.91-.58.8-.22,1.27-.26.95-.06,1.43-.06v-.16Zm-.28.97c-.28,0-.57.01-.87.04-.3.02-.57.07-.82.14-.24.07-.45.18-.61.32s-.24.34-.24.58c0,.17.03.31.1.42.07.11.16.2.27.28.11.07.24.12.37.15.14.03.28.04.42.04.53,0,.93-.16,1.22-.47.28-.32.43-.71.43-1.19v-.3h-.28Z"/>
-    <path d="m164.65,60.16h-1.13v-8.57h1.1v.89h.04c.18-.3.45-.55.81-.75s.77-.29,1.24-.29c.42,0,.81.08,1.15.23.35.15.65.36.9.64.25.27.44.59.58.95.14.36.2.75.2,1.17s-.07.81-.2,1.18-.33.69-.57.96c-.25.27-.55.49-.9.64-.35.16-.75.23-1.19.23-.41,0-.79-.09-1.15-.26-.36-.18-.64-.42-.85-.74h-.04v3.73Zm3.74-5.74c0-.26-.04-.52-.12-.77-.08-.25-.2-.47-.36-.66-.16-.19-.36-.34-.59-.46-.24-.11-.51-.17-.82-.17-.29,0-.55.06-.79.17-.24.11-.44.26-.61.46-.17.19-.3.41-.39.66-.09.25-.14.51-.14.78s.05.53.14.78c.09.25.22.47.39.65.17.19.37.34.61.45.24.11.5.17.79.17.31,0,.59-.06.82-.17s.43-.27.59-.46c.16-.19.28-.41.36-.66.08-.25.12-.5.12-.77Z"/>
-  </g>
-  <g>
-    <path d="m216.7,11.3h2.59c.46,0,.87.05,1.25.14.38.09.7.23.96.43.26.19.47.44.61.73s.22.65.22,1.07-.08.79-.23,1.09c-.16.3-.37.55-.65.74-.28.19-.6.33-.98.43s-.79.14-1.23.14h-1.34v3.73h-1.19v-8.5Zm1.19,3.76h1.26c.29,0,.55-.03.8-.08.24-.05.45-.13.63-.24.18-.11.31-.25.41-.43.1-.18.14-.39.14-.65s-.05-.47-.15-.64c-.1-.17-.24-.31-.41-.42-.17-.11-.38-.18-.62-.23-.24-.04-.5-.07-.78-.07h-1.28v2.75Z"/>
-    <path d="m225.44,18.57h.02l1.57-4.46h1.2l-2.76,7.03c-.1.24-.2.45-.31.64-.11.19-.24.35-.4.48s-.33.23-.53.31c-.2.07-.45.11-.73.11-.12,0-.24,0-.37-.02-.12-.01-.25-.03-.38-.07l.11-1c.19.06.38.1.56.1.3,0,.52-.08.66-.25.14-.16.28-.4.4-.7l.36-.95-2.44-5.69h1.26l1.76,4.46Z"/>
-    <path d="m232.12,15.03h-1.51v2.96c0,.34.06.59.19.74s.33.22.61.22c.1,0,.22-.01.34-.03.12-.02.23-.05.32-.1l.04.92c-.14.05-.29.08-.45.11s-.33.04-.51.04c-.54,0-.95-.15-1.23-.44-.28-.3-.43-.74-.43-1.33v-3.08h-1.09v-.92h1.09v-1.63h1.12v1.63h1.51v.92Z"/>
-    <path d="m234.46,14.97c.14-.28.37-.52.7-.72.33-.2.7-.3,1.1-.3.37,0,.68.06.95.19s.48.29.66.5c.18.21.31.45.39.73s.13.58.13.9v3.53h-1.13v-3.15c0-.23-.02-.45-.05-.66-.04-.21-.1-.39-.2-.55-.1-.16-.23-.29-.39-.39-.16-.1-.38-.14-.64-.14-.45,0-.82.17-1.1.51s-.43.8-.43,1.37v3.02h-1.13v-9.07h1.13v4.25h.02Z"/>
-    <path d="m246.05,16.94c0,.44-.08.84-.23,1.21-.16.37-.37.69-.65.95-.28.27-.6.48-.98.62-.38.15-.78.22-1.21.22s-.84-.07-1.21-.22c-.38-.15-.7-.36-.97-.62-.27-.27-.49-.59-.64-.95-.16-.37-.23-.77-.23-1.21s.08-.84.23-1.21c.16-.36.37-.68.64-.94s.6-.47.97-.62c.38-.15.78-.22,1.21-.22s.84.07,1.21.22c.38.15.7.35.98.62s.49.58.65.94c.16.36.23.77.23,1.21Zm-1.18,0c0-.27-.04-.53-.13-.78-.08-.25-.21-.46-.37-.65s-.36-.34-.6-.45c-.24-.11-.51-.17-.81-.17s-.58.06-.81.17c-.24.11-.44.26-.6.45-.16.19-.28.4-.37.65-.08.25-.13.51-.13.78s.04.53.13.78c.08.25.21.47.37.66.16.19.36.34.6.46.24.11.51.17.81.17s.58-.06.81-.17c.24-.11.44-.26.6-.46s.28-.41.37-.66c.08-.25.13-.51.13-.78Z"/>
-    <path d="m248.63,14.1c.02.14.03.31.04.49s.01.33.01.45h.04c.07-.15.17-.29.29-.43s.27-.25.43-.35c.16-.1.34-.18.53-.23.19-.06.39-.08.6-.08.37,0,.68.06.95.19s.48.29.66.5c.18.21.31.45.39.73s.13.58.13.9v3.53h-1.13v-3.16c0-.23-.02-.45-.05-.66-.04-.21-.1-.39-.2-.55s-.23-.29-.4-.38-.38-.14-.65-.14c-.45,0-.81.17-1.1.51s-.43.79-.43,1.36v3.02h-1.13v-4.46c0-.15,0-.35-.01-.59s-.02-.45-.04-.64h1.07Z"/>
-  </g>
-  <g>
-    <path d="m24.97,39.69c0,.17-.03.33-.09.46s-.14.26-.24.36c-.1.11-.22.2-.35.27s-.28.14-.43.19-.31.08-.47.11-.32.03-.47.03c-.33,0-.64-.01-.92-.04s-.55-.08-.82-.14v-.78c.29.08.57.14.85.19s.56.06.84.06c.41,0,.71-.06.9-.17s.29-.27.29-.47c0-.09-.02-.17-.05-.24-.03-.07-.09-.14-.17-.2-.08-.06-.21-.13-.38-.2s-.4-.15-.7-.23c-.22-.07-.43-.14-.61-.22-.19-.08-.35-.18-.49-.29s-.24-.25-.32-.4-.12-.33-.12-.54c0-.14.03-.29.1-.45s.17-.31.32-.45.36-.26.62-.35c.26-.09.59-.14.98-.14.19,0,.41.01.64.03.23.02.48.06.73.11v.76c-.27-.07-.52-.11-.76-.14-.24-.03-.45-.05-.62-.05-.21,0-.39.02-.53.05s-.26.08-.35.13c-.09.06-.15.12-.19.2-.04.08-.06.16-.06.25s.02.17.05.24.1.14.19.21c.09.07.22.13.39.2.17.07.38.14.65.22.29.08.53.17.73.27.2.09.36.2.48.31s.21.24.27.39.08.31.08.49Z"/>
-    <path d="m30.54,40.96c-.19.05-.39.08-.6.11-.21.02-.41.03-.62.03-.62,0-1.07-.14-1.38-.42-.3-.28-.45-.71-.45-1.28v-2.56h-1.37v-.71h1.37v-1.35l.85-.22v1.57h2.2v.71h-2.2v2.49c0,.35.09.61.28.79.19.17.46.26.83.26.16,0,.33-.01.51-.04.19-.03.38-.06.58-.12v.73Z"/>
-    <path d="m31.84,38.68c0-.42.06-.79.17-1.11.11-.32.28-.6.49-.82.21-.22.46-.39.76-.51.29-.12.62-.17.98-.17.16,0,.31,0,.46.03s.3.05.45.09v-2.06h.85v6.9h-.76l-.03-.93c-.24.34-.49.6-.77.77s-.58.25-.9.25c-.28,0-.53-.06-.74-.18s-.39-.28-.53-.5c-.14-.21-.25-.47-.32-.77s-.11-.63-.11-1Zm.87-.05c0,.59.09,1.03.26,1.33.17.29.42.44.74.44.21,0,.44-.1.68-.29s.49-.48.75-.85v-2.28c-.14-.07-.29-.11-.46-.15-.17-.03-.34-.05-.5-.05-.46,0-.82.15-1.08.45s-.39.77-.39,1.41Z"/>
-    <path d="m39.55,36.04c.1,0,.2.02.29.06.09.04.17.1.24.16s.12.15.16.24.06.19.06.29-.02.2-.06.29c-.04.09-.1.17-.16.24s-.15.12-.24.16-.19.06-.29.06-.2-.02-.29-.06-.17-.09-.24-.16-.12-.15-.16-.24c-.04-.09-.06-.19-.06-.29s.02-.2.06-.29.09-.17.16-.24.15-.12.24-.16c.09-.04.19-.06.29-.06Zm0,3.58c.1,0,.2.02.29.06.09.04.17.09.24.16s.12.15.16.24.06.19.06.29-.02.2-.06.29c-.04.09-.1.17-.16.24s-.15.12-.24.16-.19.06-.29.06-.2-.02-.29-.06-.17-.09-.24-.16-.12-.15-.16-.24c-.04-.09-.06-.19-.06-.29s.02-.2.06-.29.09-.17.16-.24.15-.12.24-.16c.09-.04.19-.06.29-.06Z"/>
-    <path d="m45.05,36.04c.1,0,.2.02.29.06.09.04.17.1.24.16s.12.15.16.24.06.19.06.29-.02.2-.06.29c-.04.09-.1.17-.16.24s-.15.12-.24.16-.19.06-.29.06-.2-.02-.29-.06-.17-.09-.24-.16-.12-.15-.16-.24c-.04-.09-.06-.19-.06-.29s.02-.2.06-.29.09-.17.16-.24.15-.12.24-.16c.09-.04.19-.06.29-.06Zm0,3.58c.1,0,.2.02.29.06.09.04.17.09.24.16s.12.15.16.24.06.19.06.29-.02.2-.06.29c-.04.09-.1.17-.16.24s-.15.12-.24.16-.19.06-.29.06-.2-.02-.29-.06-.17-.09-.24-.16-.12-.15-.16-.24c-.04-.09-.06-.19-.06-.29s.02-.2.06-.29.09-.17.16-.24.15-.12.24-.16c.09-.04.19-.06.29-.06Z"/>
-    <path d="m48.12,36.13h.97l1.2,3.24.26.79.27-.81,1.19-3.22h.93l-1.92,4.9h-.98l-1.92-4.9Z"/>
-    <path d="m58.22,38.32c0,.12,0,.22,0,.3s0,.16-.01.23h-3.44c0,.5.14.89.42,1.15.28.27.68.4,1.21.4.14,0,.29,0,.43-.02.14-.01.28-.03.42-.05s.26-.04.38-.07c.12-.02.24-.05.34-.08v.7c-.23.07-.49.12-.78.16-.29.04-.59.06-.91.06-.42,0-.78-.06-1.08-.17s-.55-.28-.74-.5c-.19-.22-.34-.48-.43-.8-.09-.31-.14-.67-.14-1.07,0-.34.05-.67.15-.98.1-.31.24-.58.43-.81.19-.23.42-.42.7-.55s.59-.21.94-.21.64.05.91.16.49.26.67.46c.18.2.32.44.41.72.09.28.14.6.14.94Zm-.88-.12c0-.22-.01-.42-.06-.6-.05-.18-.13-.34-.24-.47s-.25-.23-.41-.3c-.16-.07-.35-.11-.57-.11-.19,0-.35.04-.51.11s-.28.17-.4.3-.2.29-.27.47-.11.38-.13.6h2.58Z"/>
-    <path d="m63.38,40.85c-.22.08-.45.15-.68.19-.23.04-.47.06-.72.06-.77,0-1.37-.21-1.79-.63s-.63-1.03-.63-1.84c0-.39.06-.74.18-1.05s.29-.59.51-.81.48-.4.78-.52c.3-.12.64-.18,1-.18.25,0,.49.02.71.05s.43.09.63.18v.81c-.21-.11-.43-.19-.65-.24-.22-.05-.45-.08-.68-.08-.22,0-.42.04-.62.12-.19.08-.36.2-.51.36s-.26.35-.35.57-.13.48-.13.76c0,.59.14,1.04.43,1.33.29.29.69.44,1.2.44.23,0,.46-.03.67-.08s.43-.13.63-.23v.79Z"/>
-    <path d="m69.02,40.96c-.19.05-.39.08-.6.11-.21.02-.41.03-.62.03-.62,0-1.07-.14-1.38-.42-.3-.28-.45-.71-.45-1.28v-2.56h-1.37v-.71h1.37v-1.35l.85-.22v1.57h2.2v.71h-2.2v2.49c0,.35.09.61.28.79.19.17.46.26.83.26.16,0,.33-.01.51-.04.19-.03.38-.06.58-.12v.73Z"/>
-    <path d="m74.84,38.54c0,.38-.05.73-.16,1.05-.11.32-.26.59-.46.82-.2.23-.45.4-.74.53-.29.12-.62.19-.99.19s-.67-.05-.94-.16c-.28-.11-.51-.27-.71-.48s-.34-.47-.44-.79-.15-.67-.15-1.08c0-.38.05-.73.16-1.04.11-.31.26-.58.46-.81.2-.23.45-.4.74-.53.29-.12.62-.19.99-.19s.67.05.94.16c.28.11.51.27.71.48.19.21.34.47.44.78s.15.67.15,1.07Zm-.87.04c0-.3-.03-.57-.1-.79-.07-.23-.16-.42-.29-.57-.12-.15-.27-.27-.45-.34-.18-.08-.38-.12-.59-.12-.25,0-.47.05-.65.15-.18.1-.33.23-.44.4s-.2.36-.25.58c-.05.22-.08.45-.08.69,0,.3.03.57.1.8s.16.42.29.57c.12.15.27.26.45.34.18.08.37.11.6.11.25,0,.47-.05.65-.15.18-.1.33-.23.44-.4s.2-.36.25-.58c.05-.22.08-.45.08-.7Z"/>
-    <path d="m76.27,36.13h.78l.02.9c.29-.35.58-.6.86-.76s.57-.23.85-.23c.51,0,.89.16,1.15.49s.38.82.36,1.46h-.86c0-.43-.05-.74-.19-.93-.14-.19-.33-.29-.59-.29-.11,0-.23.02-.34.06-.12.04-.23.11-.36.2-.12.09-.25.21-.39.34s-.28.31-.44.51v3.15h-.86v-4.9Z"/>
-    <path d="m85.27,40.57l-.53.54-3.28-2.74,3.28-2.74.53.54-2.66,2.19,2.66,2.21Z"/>
-    <path d="m88.74,36.83h-1.45v-.7h2.31v4.19h1.46v.71h-3.93v-.71h1.61v-3.49Zm.3-2.76c.09,0,.18.02.26.05.08.03.15.08.21.14s.11.13.14.21c.03.08.05.17.05.26s-.02.18-.05.26-.08.15-.14.21-.13.11-.21.14c-.08.04-.17.05-.26.05s-.18-.02-.26-.05c-.08-.03-.15-.08-.21-.14s-.11-.13-.14-.21-.05-.17-.05-.26.02-.18.05-.26c.03-.08.08-.15.14-.21s.13-.11.21-.14c.08-.04.17-.05.26-.05Z"/>
-    <path d="m92.56,36.13h.76l.03.79c.14-.17.28-.31.42-.42.13-.11.26-.2.39-.27s.26-.12.39-.14c.13-.03.27-.04.42-.04.5,0,.89.15,1.15.45.26.3.39.75.39,1.34v3.2h-.85v-3.13c0-.38-.07-.67-.21-.85-.14-.18-.36-.28-.64-.28-.1,0-.21.02-.31.05-.1.03-.2.08-.31.16-.11.08-.22.18-.35.31s-.27.29-.42.49v3.25h-.85v-4.9Z"/>
-    <path d="m102.01,40.96c-.19.05-.39.08-.6.11-.21.02-.41.03-.62.03-.62,0-1.07-.14-1.38-.42-.3-.28-.45-.71-.45-1.28v-2.56h-1.37v-.71h1.37v-1.35l.85-.22v1.57h2.2v.71h-2.2v2.49c0,.35.09.61.28.79.19.17.46.26.83.26.16,0,.33-.01.51-.04.19-.03.38-.06.58-.12v.73Z"/>
-    <path d="m103.8,36.17l.53-.54,3.28,2.74-3.28,2.74-.53-.54,2.66-2.19-2.66-2.21Z"/>
-  </g>
-  <g>
-    <path d="m194.85,41.03v-3.52c0-.15,0-.28-.02-.38s-.03-.17-.05-.23c-.02-.06-.06-.1-.09-.12s-.08-.03-.14-.03c-.06,0-.13.02-.18.06s-.11.1-.18.19-.13.2-.21.35c-.08.14-.17.32-.27.53v3.15h-.78v-3.43c0-.18,0-.32-.02-.43s-.03-.2-.05-.26-.06-.1-.1-.13-.09-.03-.14-.03c-.06,0-.11.02-.17.05s-.11.09-.17.18-.13.2-.21.35-.17.33-.28.56v3.15h-.78v-4.9h.65l.04.93c.08-.19.17-.34.25-.47s.16-.24.25-.31c.08-.08.17-.14.27-.18.1-.04.2-.06.32-.06.26,0,.46.09.6.26s.21.44.21.8c.08-.17.15-.32.23-.45.07-.13.16-.24.24-.33.09-.09.18-.16.29-.21.1-.05.22-.07.36-.07.62,0,.92.47.92,1.42v3.57h-.78Z"/>
-    <path d="m201.21,36.13l-1.67,4.38c-.17.45-.35.83-.53,1.15s-.38.59-.6.79c-.22.21-.46.36-.72.46s-.55.15-.87.15c-.08,0-.16,0-.23,0s-.14,0-.22-.01v-.77c.07,0,.15.02.23.03.08,0,.17.01.27.01.16,0,.3-.02.44-.07s.26-.12.38-.22c.12-.1.24-.23.35-.4s.22-.36.32-.59l-1.96-4.9h.97l1.24,3.24.25.76.28-.78,1.15-3.22h.93Z"/>
-    <path d="m207.06,43.03h-5.5v-.7h5.5v.7Z"/>
-    <path d="m211.99,38.32c0,.12,0,.22,0,.3s0,.16-.01.23h-3.44c0,.5.14.89.42,1.15.28.27.68.4,1.21.4.14,0,.29,0,.43-.02.14-.01.28-.03.42-.05s.26-.04.38-.07c.12-.02.24-.05.34-.08v.7c-.23.07-.49.12-.78.16-.29.04-.59.06-.91.06-.42,0-.78-.06-1.08-.17s-.55-.28-.74-.5c-.19-.22-.34-.48-.43-.8-.09-.31-.14-.67-.14-1.07,0-.34.05-.67.15-.98.1-.31.24-.58.43-.81.19-.23.42-.42.7-.55s.59-.21.94-.21.64.05.91.16.49.26.67.46c.18.2.32.44.41.72.09.28.14.6.14.94Zm-.88-.12c0-.22-.01-.42-.06-.6-.05-.18-.13-.34-.24-.47s-.25-.23-.41-.3c-.16-.07-.35-.11-.57-.11-.19,0-.35.04-.51.11s-.28.17-.4.3-.2.29-.27.47-.11.38-.13.6h2.58Z"/>
-    <path d="m217.76,41.03h-1.13l-1.32-1.87-1.31,1.87h-1.1l1.9-2.46-1.81-2.44h1.09l1.29,1.88,1.26-1.88h1.05l-1.84,2.46,1.92,2.44Z"/>
-    <path d="m222.79,40.96c-.19.05-.39.08-.6.11-.21.02-.41.03-.62.03-.62,0-1.07-.14-1.38-.42-.3-.28-.45-.71-.45-1.28v-2.56h-1.37v-.71h1.37v-1.35l.85-.22v1.57h2.2v.71h-2.2v2.49c0,.35.09.61.28.79.19.17.46.26.83.26.16,0,.33-.01.51-.04.19-.03.38-.06.58-.12v.73Z"/>
-    <path d="m226.27,39.49c.11,0,.22.02.31.06s.19.1.26.18.13.16.17.26c.04.1.06.21.06.32s-.02.21-.06.31-.1.18-.17.26c-.07.07-.16.13-.26.17s-.2.06-.31.06-.22-.02-.32-.06-.18-.1-.26-.17c-.07-.07-.13-.16-.17-.26s-.06-.2-.06-.31.02-.22.06-.32c.04-.1.1-.19.17-.26s.16-.13.26-.18.2-.06.32-.06Z"/>
-    <path d="m231.37,35.38h-1.47v-.73h3.82v.73h-1.47v4.91h1.47v.74h-3.82v-.74h1.47v-4.91Z"/>
-    <path d="m235.34,36.13h.76l.03.79c.14-.17.28-.31.42-.42.13-.11.26-.2.39-.27s.26-.12.39-.14c.13-.03.27-.04.42-.04.5,0,.89.15,1.15.45.26.3.39.75.39,1.34v3.2h-.85v-3.13c0-.38-.07-.67-.21-.85-.14-.18-.36-.28-.64-.28-.1,0-.21.02-.31.05-.1.03-.2.08-.31.16-.11.08-.22.18-.35.31s-.27.29-.42.49v3.25h-.85v-4.9Z"/>
-    <path d="m244.78,40.96c-.19.05-.39.08-.6.11-.21.02-.41.03-.62.03-.62,0-1.07-.14-1.38-.42-.3-.28-.45-.71-.45-1.28v-2.56h-1.37v-.71h1.37v-1.35l.85-.22v1.57h2.2v.71h-2.2v2.49c0,.35.09.61.28.79.19.17.46.26.83.26.16,0,.33-.01.51-.04.19-.03.38-.06.58-.12v.73Z"/>
-    <path d="m251.03,34.65l-2.17,6.38h-1.17l-2.12-6.38h.98l1.38,4.3.39,1.26.4-1.26,1.38-4.3h.93Z"/>
-    <path d="m255.97,38.32c0,.12,0,.22,0,.3s0,.16-.01.23h-3.44c0,.5.14.89.42,1.15.28.27.68.4,1.21.4.14,0,.29,0,.43-.02.14-.01.28-.03.42-.05s.26-.04.38-.07c.12-.02.24-.05.34-.08v.7c-.23.07-.49.12-.78.16-.29.04-.59.06-.91.06-.42,0-.78-.06-1.08-.17s-.55-.28-.74-.5c-.19-.22-.34-.48-.43-.8-.09-.31-.14-.67-.14-1.07,0-.34.05-.67.15-.98.1-.31.24-.58.43-.81.19-.23.42-.42.7-.55s.59-.21.94-.21.64.05.91.16.49.26.67.46c.18.2.32.44.41.72.09.28.14.6.14.94Zm-.88-.12c0-.22-.01-.42-.06-.6-.05-.18-.13-.34-.24-.47s-.25-.23-.41-.3c-.16-.07-.35-.11-.57-.11-.19,0-.35.04-.51.11s-.28.17-.4.3-.2.29-.27.47-.11.38-.13.6h2.58Z"/>
-    <path d="m261.14,40.85c-.22.08-.45.15-.68.19-.23.04-.47.06-.72.06-.77,0-1.37-.21-1.79-.63s-.63-1.03-.63-1.84c0-.39.06-.74.18-1.05s.29-.59.51-.81.48-.4.78-.52c.3-.12.64-.18,1-.18.25,0,.49.02.71.05s.43.09.63.18v.81c-.21-.11-.43-.19-.65-.24-.22-.05-.45-.08-.68-.08-.22,0-.42.04-.62.12-.19.08-.36.2-.51.36s-.26.35-.35.57-.13.48-.13.76c0,.59.14,1.04.43,1.33.29.29.69.44,1.2.44.23,0,.46-.03.67-.08s.43-.13.63-.23v.79Z"/>
-    <path d="m266.78,40.96c-.19.05-.39.08-.6.11-.21.02-.41.03-.62.03-.62,0-1.07-.14-1.38-.42-.3-.28-.45-.71-.45-1.28v-2.56h-1.37v-.71h1.37v-1.35l.85-.22v1.57h2.2v.71h-2.2v2.49c0,.35.09.61.28.79.19.17.46.26.83.26.16,0,.33-.01.51-.04.19-.03.38-.06.58-.12v.73Z"/>
-    <path d="m272.59,38.54c0,.38-.05.73-.16,1.05-.11.32-.26.59-.46.82-.2.23-.45.4-.74.53-.29.12-.62.19-.99.19s-.67-.05-.94-.16c-.28-.11-.51-.27-.71-.48s-.34-.47-.44-.79-.15-.67-.15-1.08c0-.38.05-.73.16-1.04.11-.31.26-.58.46-.81.2-.23.45-.4.74-.53.29-.12.62-.19.99-.19s.67.05.94.16c.28.11.51.27.71.48.19.21.34.47.44.78s.15.67.15,1.07Zm-.87.04c0-.3-.03-.57-.1-.79-.07-.23-.16-.42-.29-.57-.12-.15-.27-.27-.45-.34-.18-.08-.38-.12-.59-.12-.25,0-.47.05-.65.15-.18.1-.33.23-.44.4s-.2.36-.25.58c-.05.22-.08.45-.08.69,0,.3.03.57.1.8s.16.42.29.57c.12.15.27.26.45.34.18.08.37.11.6.11.25,0,.47-.05.65-.15.18-.1.33-.23.44-.4s.2-.36.25-.58c.05-.22.08-.45.08-.7Z"/>
-    <path d="m274.02,36.13h.78l.02.9c.29-.35.58-.6.86-.76s.57-.23.85-.23c.51,0,.89.16,1.15.49s.38.82.36,1.46h-.86c0-.43-.05-.74-.19-.93-.14-.19-.33-.29-.59-.29-.11,0-.23.02-.34.06-.12.04-.23.11-.36.2-.12.09-.25.21-.39.34s-.28.31-.44.51v3.15h-.86v-4.9Z"/>
-  </g>
-  <polygon class="cls-7" points="179.18 31.26 184.58 33.96 179.18 36.66 179.18 31.26"/>
-  <line class="cls-3" x1="114.6" y1="33.96" x2="180.26" y2="33.96"/>
-  <polygon class="cls-7" points="120 45.73 114.6 43.03 120 40.33 120 45.73"/>
-  <line class="cls-3" x1="184.58" y1="43.03" x2="118.92" y2="43.03"/>
-</svg>
\ No newline at end of file
diff --git a/src/nanobind/docs/images/caster-dark.svg b/src/nanobind/docs/images/caster-dark.svg
deleted file mode 100644
index 59608cc..0000000
--- a/src/nanobind/docs/images/caster-dark.svg
+++ /dev/null
@@ -1,118 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<svg id="Layer_1" data-name="Layer 1" xmlns="http://www.w3.org/2000/svg" viewBox="0 0 298.8 62.36">
-  <defs>
-    <style>
-      .cls-1 {
-        stroke: #fff;
-      }
-
-      .cls-1, .cls-2, .cls-3 {
-        fill: none;
-        stroke-linecap: round;
-        stroke-linejoin: round;
-      }
-
-      .cls-4 {
-        fill: #fff;
-      }
-
-      .cls-5 {
-        fill: #adffa2;
-      }
-
-      .cls-6 {
-        fill: #dcffdf;
-      }
-
-      .cls-7 {
-        fill: #dcdcff;
-      }
-
-      .cls-8 {
-        fill: #a2a4ff;
-      }
-
-      .cls-9 {
-        fill: #919191;
-        fill-rule: evenodd;
-      }
-
-      .cls-2 {
-        stroke: #000;
-        stroke-width: .8px;
-      }
-
-      .cls-3 {
-        stroke: #919191;
-        stroke-width: 1.5px;
-      }
-    </style>
-  </defs>
-  <rect class="cls-7" x="6.35" y="5.67" width="115.87" height="50.74"/>
-  <rect class="cls-1" x="6.35" y="5.67" width="115.87" height="50.74"/>
-  <rect class="cls-6" x="176.58" y="5.67" width="115.87" height="50.74"/>
-  <rect class="cls-1" x="176.58" y="5.67" width="115.87" height="50.74"/>
-  <rect class="cls-8" x="16.68" y="28.05" width="95.21" height="18.58"/>
-  <rect class="cls-2" x="16.68" y="28.05" width="95.21" height="18.58"/>
-  <rect class="cls-5" x="186.92" y="28.05" width="95.21" height="18.58"/>
-  <rect class="cls-2" x="186.92" y="28.05" width="95.21" height="18.58"/>
-  <g>
-    <path d="m60.48,18.29c-.34.46-.77.83-1.31,1.11-.54.28-1.18.43-1.93.43-.65,0-1.25-.11-1.79-.33-.55-.22-1.02-.53-1.42-.92-.4-.4-.71-.87-.93-1.42-.22-.55-.34-1.15-.34-1.81s.11-1.27.34-1.82.54-1.02.95-1.4c.4-.39.88-.69,1.43-.91.55-.22,1.15-.32,1.8-.32.29,0,.58.03.88.08s.58.14.85.25.52.25.74.41c.22.16.42.35.58.57l-.94.72c-.21-.29-.5-.53-.88-.71-.38-.19-.79-.28-1.23-.28-.5,0-.94.09-1.34.27-.4.18-.73.43-1.01.74-.28.31-.5.67-.65,1.09s-.23.85-.23,1.31.07.93.22,1.34c.15.42.36.78.64,1.09.28.31.61.55,1.01.73.4.18.84.26,1.33.26s.92-.1,1.31-.29.72-.47.97-.84l.95.65Z"/>
-    <path d="m65.15,15.48h2.66v.98h-2.66v2.66h-.98v-2.66h-2.66v-.98h2.66v-2.66h.98v2.66Z"/>
-    <path d="m73.14,15.48h2.66v.98h-2.66v2.66h-.98v-2.66h-2.66v-.98h2.66v-2.66h.98v2.66Z"/>
-  </g>
-  <g>
-    <path class="cls-4" d="m133.69,23.65c-.12-.18-.3-.34-.54-.46-.24-.12-.5-.19-.77-.19-.3,0-.56.06-.79.17-.23.11-.42.26-.58.45-.16.19-.28.41-.37.65s-.13.51-.13.78.04.53.13.78c.08.25.21.47.37.65.16.19.36.34.59.45.23.11.5.17.79.17s.55-.06.79-.17.43-.26.58-.46l.76.68c-.24.28-.54.5-.9.65-.36.16-.77.23-1.22.23s-.85-.07-1.22-.22c-.37-.14-.69-.35-.97-.61s-.49-.57-.64-.94c-.16-.37-.23-.78-.23-1.24s.08-.86.23-1.22c.15-.37.36-.68.64-.95.27-.26.59-.47.97-.61.37-.14.77-.22,1.21-.22.4,0,.8.08,1.19.24.4.16.71.39.94.7l-.82.66Z"/>
-    <path class="cls-4" d="m141.4,25.04c0,.44-.08.84-.23,1.21-.16.37-.37.69-.65.95-.28.27-.6.48-.98.62-.38.15-.78.22-1.21.22s-.84-.07-1.21-.22c-.38-.15-.7-.36-.97-.62-.27-.27-.49-.59-.64-.95-.16-.37-.23-.77-.23-1.21s.08-.84.23-1.21c.16-.36.37-.68.64-.94s.6-.47.97-.62c.38-.15.78-.22,1.21-.22s.84.07,1.21.22c.38.15.7.35.98.62s.49.58.65.94c.16.36.23.77.23,1.21Zm-1.18,0c0-.27-.04-.53-.13-.78-.08-.25-.21-.46-.37-.65s-.36-.34-.6-.45c-.24-.11-.51-.17-.81-.17s-.58.06-.81.17c-.24.11-.44.26-.6.45-.16.19-.28.4-.37.65-.08.25-.13.51-.13.78s.04.53.13.78c.08.25.21.47.37.66.16.19.36.34.6.46.24.11.51.17.81.17s.58-.06.81-.17c.24-.11.44-.26.6-.46s.28-.41.37-.66c.08-.25.13-.51.13-.78Z"/>
-    <path class="cls-4" d="m143.98,22.21c.02.14.03.31.04.49s.01.33.01.45h.04c.07-.15.17-.29.29-.43s.27-.25.43-.35c.16-.1.34-.18.53-.23.19-.06.39-.08.6-.08.37,0,.68.06.95.19s.48.29.66.5c.18.21.31.45.39.73s.13.58.13.9v3.53h-1.13v-3.16c0-.23-.02-.45-.05-.66-.04-.21-.1-.39-.2-.55s-.23-.29-.4-.38-.38-.14-.65-.14c-.45,0-.81.17-1.1.51s-.43.79-.43,1.36v3.02h-1.13v-4.46c0-.15,0-.35-.01-.59s-.02-.45-.04-.64h1.07Z"/>
-    <path class="cls-4" d="m152.62,27.9h-1.22l-2.32-5.69h1.25l1.67,4.48h.02l1.68-4.48h1.2l-2.28,5.69Z"/>
-    <path class="cls-4" d="m161.31,25.01v.19c0,.06,0,.13-.01.19h-4.52c0,.24.06.46.16.67.1.21.23.39.4.55.17.15.36.28.58.36.22.09.45.13.7.13.38,0,.72-.08,1-.25.28-.17.5-.37.66-.61l.79.64c-.3.4-.66.7-1.07.89-.41.19-.87.29-1.37.29-.43,0-.83-.07-1.2-.22-.37-.14-.68-.35-.95-.61-.26-.26-.47-.57-.62-.94-.15-.37-.23-.78-.23-1.22s.07-.85.22-1.22.35-.69.62-.95c.26-.26.58-.47.94-.62.36-.15.75-.22,1.17-.22s.8.07,1.14.2c.34.14.63.33.87.59.24.26.42.57.55.93.13.36.19.77.19,1.23Zm-1.15-.46c0-.22-.05-.43-.11-.63-.07-.2-.17-.37-.3-.51-.13-.14-.3-.26-.49-.34-.2-.08-.43-.13-.69-.13-.24,0-.47.04-.68.13s-.4.2-.55.34c-.16.14-.28.31-.38.51-.1.2-.16.41-.17.63h3.38Z"/>
-    <path class="cls-4" d="m162.85,22.84c0-.24-.02-.45-.04-.64h1.07c.02.14.03.31.04.5,0,.19.01.34.01.46h.04c.16-.34.39-.61.7-.81s.65-.31,1.04-.31c.18,0,.32.02.44.05l-.05,1.04c-.16-.04-.33-.06-.52-.06-.27,0-.51.05-.71.15-.2.1-.37.23-.5.4-.13.17-.23.36-.29.58s-.1.45-.1.69v2.99h-1.13v-4.46c0-.15,0-.35-.01-.59Z"/>
-    <path class="cls-4" d="m169.86,23.13h-1.51v2.96c0,.34.06.59.19.74s.33.22.61.22c.1,0,.22-.01.34-.03.12-.02.23-.05.32-.1l.04.92c-.14.05-.29.08-.45.11s-.33.04-.51.04c-.54,0-.95-.15-1.23-.44-.28-.3-.43-.74-.43-1.33v-3.08h-1.09v-.92h1.09v-1.63h1.12v1.63h1.51v.92Z"/>
-  </g>
-  <g>
-    <path class="cls-4" d="m133.69,53.21c-.12-.18-.3-.34-.54-.46-.24-.12-.5-.19-.77-.19-.3,0-.56.06-.79.17-.23.11-.42.26-.58.45-.16.19-.28.41-.37.65s-.13.51-.13.78.04.53.13.78c.08.25.21.47.37.65.16.19.36.34.59.45.23.11.5.17.79.17s.55-.06.79-.17.43-.26.58-.46l.76.68c-.24.28-.54.5-.9.65-.36.16-.77.23-1.22.23s-.85-.07-1.22-.22c-.37-.14-.69-.35-.97-.61s-.49-.57-.64-.94c-.16-.37-.23-.78-.23-1.24s.08-.86.23-1.22c.15-.37.36-.68.64-.95.27-.26.59-.47.97-.61.37-.14.77-.22,1.21-.22.4,0,.8.08,1.19.24.4.16.71.39.94.7l-.82.66Z"/>
-    <path class="cls-4" d="m141.4,54.6c0,.44-.08.84-.23,1.21-.16.37-.37.69-.65.95-.28.27-.6.48-.98.62-.38.15-.78.22-1.21.22s-.84-.07-1.21-.22c-.38-.15-.7-.36-.97-.62-.27-.27-.49-.59-.64-.95-.16-.37-.23-.77-.23-1.21s.08-.84.23-1.21c.16-.36.37-.68.64-.94s.6-.47.97-.62c.38-.15.78-.22,1.21-.22s.84.07,1.21.22c.38.15.7.35.98.62s.49.58.65.94c.16.36.23.77.23,1.21Zm-1.18,0c0-.27-.04-.53-.13-.78-.08-.25-.21-.46-.37-.65s-.36-.34-.6-.45c-.24-.11-.51-.17-.81-.17s-.58.06-.81.17c-.24.11-.44.26-.6.45-.16.19-.28.4-.37.65-.08.25-.13.51-.13.78s.04.53.13.78c.08.25.21.47.37.66.16.19.36.34.6.46.24.11.51.17.81.17s.58-.06.81-.17c.24-.11.44-.26.6-.46s.28-.41.37-.66c.08-.25.13-.51.13-.78Z"/>
-    <path class="cls-4" d="m143.98,51.77c.02.14.03.31.04.49s.01.33.01.45h.04c.07-.15.17-.29.29-.43s.27-.25.43-.35c.16-.1.34-.18.53-.23.19-.06.39-.08.6-.08.37,0,.68.06.95.19s.48.29.66.5c.18.21.31.45.39.73s.13.58.13.9v3.53h-1.13v-3.16c0-.23-.02-.45-.05-.66-.04-.21-.1-.39-.2-.55s-.23-.29-.4-.38-.38-.14-.65-.14c-.45,0-.81.17-1.1.51s-.43.79-.43,1.36v3.02h-1.13v-4.46c0-.15,0-.35-.01-.59s-.02-.45-.04-.64h1.07Z"/>
-    <path class="cls-4" d="m152.62,57.46h-1.22l-2.32-5.69h1.25l1.67,4.48h.02l1.68-4.48h1.2l-2.28,5.69Z"/>
-    <path class="cls-4" d="m161.31,54.57v.19c0,.06,0,.13-.01.19h-4.52c0,.24.06.46.16.67.1.21.23.39.4.55.17.15.36.28.58.36.22.09.45.13.7.13.38,0,.72-.08,1-.25.28-.17.5-.37.66-.61l.79.64c-.3.4-.66.7-1.07.89-.41.19-.87.29-1.37.29-.43,0-.83-.07-1.2-.22-.37-.14-.68-.35-.95-.61-.26-.26-.47-.57-.62-.94-.15-.37-.23-.78-.23-1.22s.07-.85.22-1.22.35-.69.62-.95c.26-.26.58-.47.94-.62.36-.15.75-.22,1.17-.22s.8.07,1.14.2c.34.14.63.33.87.59.24.26.42.57.55.93.13.36.19.77.19,1.23Zm-1.15-.46c0-.22-.05-.43-.11-.63-.07-.2-.17-.37-.3-.51-.13-.14-.3-.26-.49-.34-.2-.08-.43-.13-.69-.13-.24,0-.47.04-.68.13s-.4.2-.55.34c-.16.14-.28.31-.38.51-.1.2-.16.41-.17.63h3.38Z"/>
-    <path class="cls-4" d="m162.85,52.41c0-.24-.02-.45-.04-.64h1.07c.02.14.03.31.04.5,0,.19.01.34.01.46h.04c.16-.34.39-.61.7-.81s.65-.31,1.04-.31c.18,0,.32.02.44.05l-.05,1.04c-.16-.04-.33-.06-.52-.06-.27,0-.51.05-.71.15-.2.1-.37.23-.5.4-.13.17-.23.36-.29.58s-.1.45-.1.69v2.99h-1.13v-4.46c0-.15,0-.35-.01-.59Z"/>
-    <path class="cls-4" d="m169.86,52.7h-1.51v2.96c0,.34.06.59.19.74s.33.22.61.22c.1,0,.22-.01.34-.03.12-.02.23-.05.32-.1l.04.92c-.14.05-.29.08-.45.11s-.33.04-.51.04c-.54,0-.95-.15-1.23-.44-.28-.3-.43-.74-.43-1.33v-3.08h-1.09v-.92h1.09v-1.63h1.12v1.63h1.51v.92Z"/>
-  </g>
-  <g>
-    <path d="m216.7,11.12h2.59c.46,0,.87.05,1.25.14.38.09.7.23.96.43.26.19.47.44.61.73s.22.65.22,1.07-.08.79-.23,1.09c-.16.3-.37.55-.65.74-.28.19-.6.33-.98.43s-.79.14-1.23.14h-1.34v3.73h-1.19v-8.5Zm1.19,3.76h1.26c.29,0,.55-.03.8-.08.24-.05.45-.13.63-.24.18-.11.31-.25.41-.43.1-.18.14-.39.14-.65s-.05-.47-.15-.64c-.1-.17-.24-.31-.41-.42-.17-.11-.38-.18-.62-.23-.24-.04-.5-.07-.78-.07h-1.28v2.75Z"/>
-    <path d="m225.45,18.39h.02l1.57-4.46h1.2l-2.76,7.03c-.1.24-.2.45-.31.64-.11.19-.24.35-.4.48s-.33.23-.53.31c-.2.07-.45.11-.73.11-.12,0-.24,0-.37-.02-.12-.01-.25-.03-.38-.07l.11-1c.19.06.38.1.56.1.3,0,.52-.08.66-.25.14-.16.28-.4.4-.7l.36-.95-2.44-5.69h1.26l1.76,4.46Z"/>
-    <path d="m232.12,14.85h-1.51v2.96c0,.34.06.59.19.74s.33.22.61.22c.1,0,.22-.01.34-.03.12-.02.23-.05.32-.1l.04.92c-.14.05-.29.08-.45.11s-.33.04-.51.04c-.54,0-.95-.15-1.23-.44-.28-.3-.43-.74-.43-1.33v-3.08h-1.09v-.92h1.09v-1.63h1.12v1.63h1.51v.92Z"/>
-    <path d="m234.46,14.79c.14-.28.37-.52.7-.72.33-.2.7-.3,1.1-.3.37,0,.68.06.95.19s.48.29.66.5c.18.21.31.45.39.73s.13.58.13.9v3.53h-1.13v-3.15c0-.23-.02-.45-.05-.66-.04-.21-.1-.39-.2-.55-.1-.16-.23-.29-.39-.39-.16-.1-.38-.14-.64-.14-.45,0-.82.17-1.1.51s-.43.8-.43,1.37v3.02h-1.13v-9.07h1.13v4.25h.02Z"/>
-    <path d="m246.05,16.76c0,.44-.08.84-.23,1.21-.16.37-.37.69-.65.95-.28.27-.6.48-.98.62-.38.15-.78.22-1.21.22s-.84-.07-1.21-.22c-.38-.15-.7-.36-.97-.62-.27-.27-.49-.59-.64-.95-.16-.37-.23-.77-.23-1.21s.08-.84.23-1.21c.16-.36.37-.68.64-.94s.6-.47.97-.62c.38-.15.78-.22,1.21-.22s.84.07,1.21.22c.38.15.7.35.98.62s.49.58.65.94c.16.36.23.77.23,1.21Zm-1.18,0c0-.27-.04-.53-.13-.78-.08-.25-.21-.46-.37-.65s-.36-.34-.6-.45c-.24-.11-.51-.17-.81-.17s-.58.06-.81.17c-.24.11-.44.26-.6.45-.16.19-.28.4-.37.65-.08.25-.13.51-.13.78s.04.53.13.78c.08.25.21.47.37.66.16.19.36.34.6.46.24.11.51.17.81.17s.58-.06.81-.17c.24-.11.44-.26.6-.46s.28-.41.37-.66c.08-.25.13-.51.13-.78Z"/>
-    <path d="m248.63,13.92c.02.14.03.31.04.49s.01.33.01.45h.04c.07-.15.17-.29.29-.43s.27-.25.43-.35c.16-.1.34-.18.53-.23.19-.06.39-.08.6-.08.37,0,.68.06.95.19s.48.29.66.5c.18.21.31.45.39.73s.13.58.13.9v3.53h-1.13v-3.16c0-.23-.02-.45-.05-.66-.04-.21-.1-.39-.2-.55s-.23-.29-.4-.38-.38-.14-.65-.14c-.45,0-.81.17-1.1.51s-.43.79-.43,1.36v3.02h-1.13v-4.46c0-.15,0-.35-.01-.59s-.02-.45-.04-.64h1.07Z"/>
-  </g>
-  <g>
-    <path d="m24.97,39.51c0,.17-.03.33-.09.46s-.14.26-.24.36c-.1.11-.22.2-.35.27s-.28.14-.43.19-.31.08-.47.11-.32.03-.47.03c-.33,0-.64-.01-.92-.04s-.55-.08-.82-.14v-.78c.29.08.57.14.85.19s.56.06.84.06c.41,0,.71-.06.9-.17s.29-.27.29-.47c0-.09-.02-.17-.05-.24-.03-.07-.09-.14-.17-.2-.08-.06-.21-.13-.38-.2s-.4-.15-.7-.23c-.22-.07-.43-.14-.61-.22-.19-.08-.35-.18-.49-.29s-.24-.25-.32-.4-.12-.33-.12-.54c0-.14.03-.29.1-.45s.17-.31.32-.45.36-.26.62-.35c.26-.09.59-.14.98-.14.19,0,.41.01.64.03.23.02.48.06.73.11v.76c-.27-.07-.52-.11-.76-.14-.24-.03-.45-.05-.62-.05-.21,0-.39.02-.53.05s-.26.08-.35.13c-.09.06-.15.12-.19.2-.04.08-.06.16-.06.25s.02.17.05.24.1.14.19.21c.09.07.22.13.39.2.17.07.38.14.65.22.29.08.53.17.73.27.2.09.36.2.48.31s.21.24.27.39.08.31.08.49Z"/>
-    <path d="m30.54,40.78c-.19.05-.39.08-.6.11-.21.02-.41.03-.62.03-.62,0-1.07-.14-1.38-.42-.3-.28-.45-.71-.45-1.28v-2.56h-1.37v-.71h1.37v-1.35l.85-.22v1.57h2.2v.71h-2.2v2.49c0,.35.09.61.28.79.19.17.46.26.83.26.16,0,.33-.01.51-.04.19-.03.38-.06.58-.12v.73Z"/>
-    <path d="m31.84,38.5c0-.42.06-.79.17-1.11.11-.32.28-.6.49-.82.21-.22.46-.39.76-.51.29-.12.62-.17.98-.17.16,0,.31,0,.46.03s.3.05.45.09v-2.06h.85v6.9h-.76l-.03-.93c-.24.34-.49.6-.77.77s-.58.25-.9.25c-.28,0-.53-.06-.74-.18s-.39-.28-.53-.5c-.14-.21-.25-.47-.32-.77s-.11-.63-.11-1Zm.87-.05c0,.59.09,1.03.26,1.33.17.29.42.44.74.44.21,0,.44-.1.68-.29s.49-.48.75-.85v-2.28c-.14-.07-.29-.11-.46-.15-.17-.03-.34-.05-.5-.05-.46,0-.82.15-1.08.45s-.39.77-.39,1.41Z"/>
-    <path d="m39.55,35.86c.1,0,.2.02.29.06.09.04.17.1.24.16s.12.15.16.24.06.19.06.29-.02.2-.06.29c-.04.09-.1.17-.16.24s-.15.12-.24.16-.19.06-.29.06-.2-.02-.29-.06-.17-.09-.24-.16-.12-.15-.16-.24c-.04-.09-.06-.19-.06-.29s.02-.2.06-.29.09-.17.16-.24.15-.12.24-.16c.09-.04.19-.06.29-.06Zm0,3.58c.1,0,.2.02.29.06.09.04.17.09.24.16s.12.15.16.24.06.19.06.29-.02.2-.06.29c-.04.09-.1.17-.16.24s-.15.12-.24.16-.19.06-.29.06-.2-.02-.29-.06-.17-.09-.24-.16-.12-.15-.16-.24c-.04-.09-.06-.19-.06-.29s.02-.2.06-.29.09-.17.16-.24.15-.12.24-.16c.09-.04.19-.06.29-.06Z"/>
-    <path d="m45.05,35.86c.1,0,.2.02.29.06.09.04.17.1.24.16s.12.15.16.24.06.19.06.29-.02.2-.06.29c-.04.09-.1.17-.16.24s-.15.12-.24.16-.19.06-.29.06-.2-.02-.29-.06-.17-.09-.24-.16-.12-.15-.16-.24c-.04-.09-.06-.19-.06-.29s.02-.2.06-.29.09-.17.16-.24.15-.12.24-.16c.09-.04.19-.06.29-.06Zm0,3.58c.1,0,.2.02.29.06.09.04.17.09.24.16s.12.15.16.24.06.19.06.29-.02.2-.06.29c-.04.09-.1.17-.16.24s-.15.12-.24.16-.19.06-.29.06-.2-.02-.29-.06-.17-.09-.24-.16-.12-.15-.16-.24c-.04-.09-.06-.19-.06-.29s.02-.2.06-.29.09-.17.16-.24.15-.12.24-.16c.09-.04.19-.06.29-.06Z"/>
-    <path d="m48.12,35.95h.97l1.2,3.24.26.79.27-.81,1.19-3.22h.93l-1.92,4.9h-.98l-1.92-4.9Z"/>
-    <path d="m58.22,38.14c0,.12,0,.22,0,.3s0,.16-.01.23h-3.44c0,.5.14.89.42,1.15.28.27.68.4,1.21.4.14,0,.29,0,.43-.02.14-.01.28-.03.42-.05s.26-.04.38-.07c.12-.02.24-.05.34-.08v.7c-.23.07-.49.12-.78.16-.29.04-.59.06-.91.06-.42,0-.78-.06-1.08-.17s-.55-.28-.74-.5c-.19-.22-.34-.48-.43-.8-.09-.31-.14-.67-.14-1.07,0-.34.05-.67.15-.98.1-.31.24-.58.43-.81.19-.23.42-.42.7-.55s.59-.21.94-.21.64.05.91.16.49.26.67.46c.18.2.32.44.41.72.09.28.14.6.14.94Zm-.88-.12c0-.22-.01-.42-.06-.6-.05-.18-.13-.34-.24-.47s-.25-.23-.41-.3c-.16-.07-.35-.11-.57-.11-.19,0-.35.04-.51.11s-.28.17-.4.3-.2.29-.27.47-.11.38-.13.6h2.58Z"/>
-    <path d="m63.38,40.67c-.22.08-.45.15-.68.19-.23.04-.47.06-.72.06-.77,0-1.37-.21-1.79-.63s-.63-1.03-.63-1.84c0-.39.06-.74.18-1.05s.29-.59.51-.81.48-.4.78-.52c.3-.12.64-.18,1-.18.25,0,.49.02.71.05s.43.09.63.18v.81c-.21-.11-.43-.19-.65-.24-.22-.05-.45-.08-.68-.08-.22,0-.42.04-.62.12-.19.08-.36.2-.51.36s-.26.35-.35.57-.13.48-.13.76c0,.59.14,1.04.43,1.33.29.29.69.44,1.2.44.23,0,.46-.03.67-.08s.43-.13.63-.23v.79Z"/>
-    <path d="m69.02,40.78c-.19.05-.39.08-.6.11-.21.02-.41.03-.62.03-.62,0-1.07-.14-1.38-.42-.3-.28-.45-.71-.45-1.28v-2.56h-1.37v-.71h1.37v-1.35l.85-.22v1.57h2.2v.71h-2.2v2.49c0,.35.09.61.28.79.19.17.46.26.83.26.16,0,.33-.01.51-.04.19-.03.38-.06.58-.12v.73Z"/>
-    <path d="m74.84,38.36c0,.38-.05.73-.16,1.05-.11.32-.26.59-.46.82-.2.23-.45.4-.74.53-.29.12-.62.19-.99.19s-.67-.05-.94-.16c-.28-.11-.51-.27-.71-.48s-.34-.47-.44-.79-.15-.67-.15-1.08c0-.38.05-.73.16-1.04.11-.31.26-.58.46-.81.2-.23.45-.4.74-.53.29-.12.62-.19.99-.19s.67.05.94.16c.28.11.51.27.71.48.19.21.34.47.44.78s.15.67.15,1.07Zm-.87.04c0-.3-.03-.57-.1-.79-.07-.23-.16-.42-.29-.57-.12-.15-.27-.27-.45-.34-.18-.08-.38-.12-.59-.12-.25,0-.47.05-.65.15-.18.1-.33.23-.44.4s-.2.36-.25.58c-.05.22-.08.45-.08.69,0,.3.03.57.1.8s.16.42.29.57c.12.15.27.26.45.34.18.08.37.11.6.11.25,0,.47-.05.65-.15.18-.1.33-.23.44-.4s.2-.36.25-.58c.05-.22.08-.45.08-.7Z"/>
-    <path d="m76.27,35.95h.78l.02.9c.29-.35.58-.6.86-.76s.57-.23.85-.23c.51,0,.89.16,1.15.49s.38.82.36,1.46h-.86c0-.43-.05-.74-.19-.93-.14-.19-.33-.29-.59-.29-.11,0-.23.02-.34.06-.12.04-.23.11-.36.2-.12.09-.25.21-.39.34s-.28.31-.44.51v3.15h-.86v-4.9Z"/>
-    <path d="m85.27,40.39l-.53.54-3.28-2.74,3.28-2.74.53.54-2.66,2.19,2.66,2.21Z"/>
-    <path d="m88.74,36.65h-1.45v-.7h2.31v4.19h1.46v.71h-3.93v-.71h1.61v-3.49Zm.3-2.76c.09,0,.18.02.26.05.08.03.15.08.21.14s.11.13.14.21c.03.08.05.17.05.26s-.02.18-.05.26-.08.15-.14.21-.13.11-.21.14c-.08.04-.17.05-.26.05s-.18-.02-.26-.05c-.08-.03-.15-.08-.21-.14s-.11-.13-.14-.21-.05-.17-.05-.26.02-.18.05-.26c.03-.08.08-.15.14-.21s.13-.11.21-.14c.08-.04.17-.05.26-.05Z"/>
-    <path d="m92.56,35.95h.76l.03.79c.14-.17.28-.31.42-.42.13-.11.26-.2.39-.27s.26-.12.39-.14c.13-.03.27-.04.42-.04.5,0,.89.15,1.15.45.26.3.39.75.39,1.34v3.2h-.85v-3.13c0-.38-.07-.67-.21-.85-.14-.18-.36-.28-.64-.28-.1,0-.21.02-.31.05-.1.03-.2.08-.31.16-.11.08-.22.18-.35.31s-.27.29-.42.49v3.25h-.85v-4.9Z"/>
-    <path d="m102.01,40.78c-.19.05-.39.08-.6.11-.21.02-.41.03-.62.03-.62,0-1.07-.14-1.38-.42-.3-.28-.45-.71-.45-1.28v-2.56h-1.37v-.71h1.37v-1.35l.85-.22v1.57h2.2v.71h-2.2v2.49c0,.35.09.61.28.79.19.17.46.26.83.26.16,0,.33-.01.51-.04.19-.03.38-.06.58-.12v.73Z"/>
-    <path d="m103.8,35.99l.53-.54,3.28,2.74-3.28,2.74-.53-.54,2.66-2.19-2.66-2.21Z"/>
-  </g>
-  <g>
-    <path d="m225.98,34.65h-1.45v-.7h2.31v6.19h1.46v.71h-3.93v-.71h1.61v-5.49Z"/>
-    <path d="m231.48,36.65h-1.45v-.7h2.31v4.19h1.46v.71h-3.93v-.71h1.61v-3.49Zm.3-2.76c.09,0,.18.02.26.05.08.03.15.08.21.14s.11.13.14.21c.03.08.05.17.05.26s-.02.18-.05.26-.08.15-.14.21-.13.11-.21.14c-.08.04-.17.05-.26.05s-.18-.02-.26-.05c-.08-.03-.15-.08-.21-.14s-.11-.13-.14-.21-.05-.17-.05-.26.02-.18.05-.26c.03-.08.08-.15.14-.21s.13-.11.21-.14c.08-.04.17-.05.26-.05Z"/>
-    <path d="m239.19,39.51c0,.17-.03.33-.09.46s-.14.26-.24.36c-.1.11-.22.2-.35.27s-.28.14-.43.19-.31.08-.47.11-.32.03-.47.03c-.33,0-.64-.01-.92-.04s-.55-.08-.82-.14v-.78c.29.08.57.14.85.19s.56.06.84.06c.41,0,.71-.06.9-.17s.29-.27.29-.47c0-.09-.02-.17-.05-.24-.03-.07-.09-.14-.17-.2-.08-.06-.21-.13-.38-.2s-.4-.15-.7-.23c-.22-.07-.43-.14-.61-.22-.19-.08-.35-.18-.49-.29s-.24-.25-.32-.4-.12-.33-.12-.54c0-.14.03-.29.1-.45s.17-.31.32-.45.36-.26.62-.35c.26-.09.59-.14.98-.14.19,0,.41.01.64.03.23.02.48.06.73.11v.76c-.27-.07-.52-.11-.76-.14-.24-.03-.45-.05-.62-.05-.21,0-.39.02-.53.05s-.26.08-.35.13c-.09.06-.15.12-.19.2-.04.08-.06.16-.06.25s.02.17.05.24.1.14.19.21c.09.07.22.13.39.2.17.07.38.14.65.22.29.08.53.17.73.27.2.09.36.2.48.31s.21.24.27.39.08.31.08.49Z"/>
-    <path d="m244.76,40.78c-.19.05-.39.08-.6.11-.21.02-.41.03-.62.03-.62,0-1.07-.14-1.38-.42-.3-.28-.45-.71-.45-1.28v-2.56h-1.37v-.71h1.37v-1.35l.85-.22v1.57h2.2v.71h-2.2v2.49c0,.35.09.61.28.79.19.17.46.26.83.26.16,0,.33-.01.51-.04.19-.03.38-.06.58-.12v.73Z"/>
-  </g>
-  <polygon class="cls-9" points="179.19 31.08 184.59 33.78 179.19 36.48 179.19 31.08"/>
-  <line class="cls-3" x1="114.6" y1="33.78" x2="180.27" y2="33.78"/>
-  <polygon class="cls-9" points="120 45.55 114.6 42.85 120 40.15 120 45.55"/>
-  <line class="cls-3" x1="184.59" y1="42.85" x2="118.92" y2="42.85"/>
-</svg>
\ No newline at end of file
diff --git a/src/nanobind/docs/images/caster-light.svg b/src/nanobind/docs/images/caster-light.svg
deleted file mode 100644
index f8ce092..0000000
--- a/src/nanobind/docs/images/caster-light.svg
+++ /dev/null
@@ -1,108 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<svg id="Layer_1" data-name="Layer 1" xmlns="http://www.w3.org/2000/svg" viewBox="0 0 298.8 62.36">
-  <defs>
-    <style>
-      .cls-1, .cls-2, .cls-3 {
-        fill: none;
-        stroke: #000;
-        stroke-linecap: round;
-        stroke-linejoin: round;
-      }
-
-      .cls-4 {
-        fill: #adffa2;
-      }
-
-      .cls-5 {
-        fill: #dcffdf;
-      }
-
-      .cls-6 {
-        fill: #dcdcff;
-      }
-
-      .cls-7 {
-        fill: #a2a4ff;
-      }
-
-      .cls-2 {
-        stroke-width: .8px;
-      }
-
-      .cls-8 {
-        fill-rule: evenodd;
-      }
-
-      .cls-3 {
-        stroke-width: 1.5px;
-      }
-    </style>
-  </defs>
-  <rect class="cls-6" x="6.35" y="5.67" width="115.87" height="50.74"/>
-  <rect class="cls-1" x="6.35" y="5.67" width="115.87" height="50.74"/>
-  <rect class="cls-5" x="176.58" y="5.67" width="115.87" height="50.74"/>
-  <rect class="cls-1" x="176.58" y="5.67" width="115.87" height="50.74"/>
-  <rect class="cls-7" x="16.68" y="28.05" width="95.21" height="18.58"/>
-  <rect class="cls-2" x="16.68" y="28.05" width="95.21" height="18.58"/>
-  <rect class="cls-4" x="186.91" y="28.05" width="95.21" height="18.58"/>
-  <rect class="cls-2" x="186.91" y="28.05" width="95.21" height="18.58"/>
-  <g>
-    <path d="m60.48,18.29c-.34.46-.77.83-1.31,1.11-.54.28-1.18.43-1.93.43-.65,0-1.25-.11-1.79-.33-.55-.22-1.02-.53-1.42-.92-.4-.4-.71-.87-.93-1.42-.22-.55-.34-1.15-.34-1.81s.11-1.27.34-1.82.54-1.02.95-1.4c.4-.39.88-.69,1.43-.91.55-.22,1.15-.32,1.8-.32.29,0,.58.03.88.08s.58.14.85.25.52.25.74.41c.22.16.42.35.58.57l-.94.72c-.21-.29-.5-.53-.88-.71-.38-.19-.79-.28-1.23-.28-.5,0-.94.09-1.34.27-.4.18-.73.43-1.01.74-.28.31-.5.67-.65,1.09s-.23.85-.23,1.31.07.93.22,1.34c.15.42.36.78.64,1.09.28.31.61.55,1.01.73.4.18.84.26,1.33.26s.92-.1,1.31-.29.72-.47.97-.84l.95.65Z"/>
-    <path d="m65.15,15.49h2.66v.98h-2.66v2.66h-.98v-2.66h-2.66v-.98h2.66v-2.66h.98v2.66Z"/>
-    <path d="m73.14,15.49h2.66v.98h-2.66v2.66h-.98v-2.66h-2.66v-.98h2.66v-2.66h.98v2.66Z"/>
-  </g>
-  <g>
-    <path d="m133.69,23.65c-.12-.18-.3-.34-.54-.46-.24-.12-.5-.19-.77-.19-.3,0-.56.06-.79.17-.23.11-.42.26-.58.45-.16.19-.28.41-.37.65s-.13.51-.13.78.04.53.13.78c.08.25.21.47.37.65.16.19.36.34.59.45.23.11.5.17.79.17s.55-.06.79-.17.43-.26.58-.46l.76.68c-.24.28-.54.5-.9.65-.36.16-.77.23-1.22.23s-.85-.07-1.22-.22c-.37-.14-.69-.35-.97-.61s-.49-.57-.64-.94c-.16-.37-.23-.78-.23-1.24s.08-.86.23-1.22c.15-.37.36-.68.64-.95.27-.26.59-.47.97-.61.37-.14.77-.22,1.21-.22.4,0,.8.08,1.19.24.4.16.71.39.94.7l-.82.66Z"/>
-    <path d="m141.4,25.04c0,.44-.08.84-.23,1.21-.16.37-.37.69-.65.95-.28.27-.6.48-.98.62-.38.15-.78.22-1.21.22s-.84-.07-1.21-.22c-.38-.15-.7-.36-.97-.62-.27-.27-.49-.59-.64-.95-.16-.37-.23-.77-.23-1.21s.08-.84.23-1.21c.16-.36.37-.68.64-.94s.6-.47.97-.62c.38-.15.78-.22,1.21-.22s.84.07,1.21.22c.38.15.7.35.98.62s.49.58.65.94c.16.36.23.77.23,1.21Zm-1.18,0c0-.27-.04-.53-.13-.78-.08-.25-.21-.46-.37-.65s-.36-.34-.6-.45c-.24-.11-.51-.17-.81-.17s-.58.06-.81.17c-.24.11-.44.26-.6.45-.16.19-.28.4-.37.65-.08.25-.13.51-.13.78s.04.53.13.78c.08.25.21.47.37.66.16.19.36.34.6.46.24.11.51.17.81.17s.58-.06.81-.17c.24-.11.44-.26.6-.46s.28-.41.37-.66c.08-.25.13-.51.13-.78Z"/>
-    <path d="m143.98,22.21c.02.14.03.31.04.49s.01.33.01.45h.04c.07-.15.17-.29.29-.43s.27-.25.43-.35c.16-.1.34-.18.53-.23.19-.06.39-.08.6-.08.37,0,.68.06.95.19s.48.29.66.5c.18.21.31.45.39.73s.13.58.13.9v3.53h-1.13v-3.16c0-.23-.02-.45-.05-.66-.04-.21-.1-.39-.2-.55s-.23-.29-.4-.38-.38-.14-.65-.14c-.45,0-.81.17-1.1.51s-.43.79-.43,1.36v3.02h-1.13v-4.46c0-.15,0-.35-.01-.59s-.02-.45-.04-.64h1.07Z"/>
-    <path d="m152.62,27.9h-1.22l-2.32-5.69h1.25l1.67,4.48h.02l1.68-4.48h1.2l-2.28,5.69Z"/>
-    <path d="m161.3,25.01v.19c0,.06,0,.13-.01.19h-4.52c0,.24.06.46.16.67.1.21.23.39.4.55.17.15.36.28.58.36.22.09.45.13.7.13.38,0,.72-.08,1-.25.28-.17.5-.37.66-.61l.79.64c-.3.4-.66.7-1.07.89-.41.19-.87.29-1.37.29-.43,0-.83-.07-1.2-.22-.37-.14-.68-.35-.95-.61-.26-.26-.47-.57-.62-.94-.15-.37-.23-.78-.23-1.22s.07-.85.22-1.22.35-.69.62-.95c.26-.26.58-.47.94-.62.36-.15.75-.22,1.17-.22s.8.07,1.14.2c.34.14.63.33.87.59.24.26.42.57.55.93.13.36.19.77.19,1.23Zm-1.15-.46c0-.22-.05-.43-.11-.63-.07-.2-.17-.37-.3-.51-.13-.14-.3-.26-.49-.34-.2-.08-.43-.13-.69-.13-.24,0-.47.04-.68.13s-.4.2-.55.34c-.16.14-.28.31-.38.51-.1.2-.16.41-.17.63h3.38Z"/>
-    <path d="m162.85,22.84c0-.24-.02-.45-.04-.64h1.07c.02.14.03.31.04.5,0,.19.01.34.01.46h.04c.16-.34.39-.61.7-.81s.65-.31,1.04-.31c.18,0,.32.02.44.05l-.05,1.04c-.16-.04-.33-.06-.52-.06-.27,0-.51.05-.71.15-.2.1-.37.23-.5.4-.13.17-.23.36-.29.58s-.1.45-.1.69v2.99h-1.13v-4.46c0-.15,0-.35-.01-.59Z"/>
-    <path d="m169.86,23.13h-1.51v2.96c0,.34.06.59.19.74s.33.22.61.22c.1,0,.22-.01.34-.03.12-.02.23-.05.32-.1l.04.92c-.14.05-.29.08-.45.11s-.33.04-.51.04c-.54,0-.95-.15-1.23-.44-.28-.3-.43-.74-.43-1.33v-3.08h-1.09v-.92h1.09v-1.63h1.12v1.63h1.51v.92Z"/>
-  </g>
-  <g>
-    <path d="m133.69,53.21c-.12-.18-.3-.34-.54-.46-.24-.12-.5-.19-.77-.19-.3,0-.56.06-.79.17-.23.11-.42.26-.58.45-.16.19-.28.41-.37.65s-.13.51-.13.78.04.53.13.78c.08.25.21.47.37.65.16.19.36.34.59.45.23.11.5.17.79.17s.55-.06.79-.17.43-.26.58-.46l.76.68c-.24.28-.54.5-.9.65-.36.16-.77.23-1.22.23s-.85-.07-1.22-.22c-.37-.14-.69-.35-.97-.61s-.49-.57-.64-.94c-.16-.37-.23-.78-.23-1.24s.08-.86.23-1.22c.15-.37.36-.68.64-.95.27-.26.59-.47.97-.61.37-.14.77-.22,1.21-.22.4,0,.8.08,1.19.24.4.16.71.39.94.7l-.82.66Z"/>
-    <path d="m141.4,54.6c0,.44-.08.84-.23,1.21-.16.37-.37.69-.65.95-.28.27-.6.48-.98.62-.38.15-.78.22-1.21.22s-.84-.07-1.21-.22c-.38-.15-.7-.36-.97-.62-.27-.27-.49-.59-.64-.95-.16-.37-.23-.77-.23-1.21s.08-.84.23-1.21c.16-.36.37-.68.64-.94s.6-.47.97-.62c.38-.15.78-.22,1.21-.22s.84.07,1.21.22c.38.15.7.35.98.62s.49.58.65.94c.16.36.23.77.23,1.21Zm-1.18,0c0-.27-.04-.53-.13-.78-.08-.25-.21-.46-.37-.65s-.36-.34-.6-.45c-.24-.11-.51-.17-.81-.17s-.58.06-.81.17c-.24.11-.44.26-.6.45-.16.19-.28.4-.37.65-.08.25-.13.51-.13.78s.04.53.13.78c.08.25.21.47.37.66.16.19.36.34.6.46.24.11.51.17.81.17s.58-.06.81-.17c.24-.11.44-.26.6-.46s.28-.41.37-.66c.08-.25.13-.51.13-.78Z"/>
-    <path d="m143.98,51.77c.02.14.03.31.04.49s.01.33.01.45h.04c.07-.15.17-.29.29-.43s.27-.25.43-.35c.16-.1.34-.18.53-.23.19-.06.39-.08.6-.08.37,0,.68.06.95.19s.48.29.66.5c.18.21.31.45.39.73s.13.58.13.9v3.53h-1.13v-3.16c0-.23-.02-.45-.05-.66-.04-.21-.1-.39-.2-.55s-.23-.29-.4-.38-.38-.14-.65-.14c-.45,0-.81.17-1.1.51s-.43.79-.43,1.36v3.02h-1.13v-4.46c0-.15,0-.35-.01-.59s-.02-.45-.04-.64h1.07Z"/>
-    <path d="m152.62,57.46h-1.22l-2.32-5.69h1.25l1.67,4.48h.02l1.68-4.48h1.2l-2.28,5.69Z"/>
-    <path d="m161.3,54.57v.19c0,.06,0,.13-.01.19h-4.52c0,.24.06.46.16.67.1.21.23.39.4.55.17.15.36.28.58.36.22.09.45.13.7.13.38,0,.72-.08,1-.25.28-.17.5-.37.66-.61l.79.64c-.3.4-.66.7-1.07.89-.41.19-.87.29-1.37.29-.43,0-.83-.07-1.2-.22-.37-.14-.68-.35-.95-.61-.26-.26-.47-.57-.62-.94-.15-.37-.23-.78-.23-1.22s.07-.85.22-1.22.35-.69.62-.95c.26-.26.58-.47.94-.62.36-.15.75-.22,1.17-.22s.8.07,1.14.2c.34.14.63.33.87.59.24.26.42.57.55.93.13.36.19.77.19,1.23Zm-1.15-.46c0-.22-.05-.43-.11-.63-.07-.2-.17-.37-.3-.51-.13-.14-.3-.26-.49-.34-.2-.08-.43-.13-.69-.13-.24,0-.47.04-.68.13s-.4.2-.55.34c-.16.14-.28.31-.38.51-.1.2-.16.41-.17.63h3.38Z"/>
-    <path d="m162.85,52.41c0-.24-.02-.45-.04-.64h1.07c.02.14.03.31.04.5,0,.19.01.34.01.46h.04c.16-.34.39-.61.7-.81s.65-.31,1.04-.31c.18,0,.32.02.44.05l-.05,1.04c-.16-.04-.33-.06-.52-.06-.27,0-.51.05-.71.15-.2.1-.37.23-.5.4-.13.17-.23.36-.29.58s-.1.45-.1.69v2.99h-1.13v-4.46c0-.15,0-.35-.01-.59Z"/>
-    <path d="m169.86,52.7h-1.51v2.96c0,.34.06.59.19.74s.33.22.61.22c.1,0,.22-.01.34-.03.12-.02.23-.05.32-.1l.04.92c-.14.05-.29.08-.45.11s-.33.04-.51.04c-.54,0-.95-.15-1.23-.44-.28-.3-.43-.74-.43-1.33v-3.08h-1.09v-.92h1.09v-1.63h1.12v1.63h1.51v.92Z"/>
-  </g>
-  <g>
-    <path d="m216.7,11.12h2.59c.46,0,.87.05,1.25.14.38.09.7.23.96.43.26.19.47.44.61.73s.22.65.22,1.07-.08.79-.23,1.09c-.16.3-.37.55-.65.74-.28.19-.6.33-.98.43s-.79.14-1.23.14h-1.34v3.73h-1.19v-8.5Zm1.19,3.76h1.26c.29,0,.55-.03.8-.08.24-.05.45-.13.63-.24.18-.11.31-.25.41-.43.1-.18.14-.39.14-.65s-.05-.47-.15-.64c-.1-.17-.24-.31-.41-.42-.17-.11-.38-.18-.62-.23-.24-.04-.5-.07-.78-.07h-1.28v2.75Z"/>
-    <path d="m225.44,18.39h.02l1.57-4.46h1.2l-2.76,7.03c-.1.24-.2.45-.31.64-.11.19-.24.35-.4.48s-.33.23-.53.31c-.2.07-.45.11-.73.11-.12,0-.24,0-.37-.02-.12-.01-.25-.03-.38-.07l.11-1c.19.06.38.1.56.1.3,0,.52-.08.66-.25.14-.16.28-.4.4-.7l.36-.95-2.44-5.69h1.26l1.76,4.46Z"/>
-    <path d="m232.12,14.85h-1.51v2.96c0,.34.06.59.19.74s.33.22.61.22c.1,0,.22-.01.34-.03.12-.02.23-.05.32-.1l.04.92c-.14.05-.29.08-.45.11s-.33.04-.51.04c-.54,0-.95-.15-1.23-.44-.28-.3-.43-.74-.43-1.33v-3.08h-1.09v-.92h1.09v-1.63h1.12v1.63h1.51v.92Z"/>
-    <path d="m234.46,14.79c.14-.28.37-.52.7-.72.33-.2.7-.3,1.1-.3.37,0,.68.06.95.19s.48.29.66.5c.18.21.31.45.39.73s.13.58.13.9v3.53h-1.13v-3.15c0-.23-.02-.45-.05-.66-.04-.21-.1-.39-.2-.55-.1-.16-.23-.29-.39-.39-.16-.1-.38-.14-.64-.14-.45,0-.82.17-1.1.51s-.43.8-.43,1.37v3.02h-1.13v-9.07h1.13v4.25h.02Z"/>
-    <path d="m246.05,16.76c0,.44-.08.84-.23,1.21-.16.37-.37.69-.65.95-.28.27-.6.48-.98.62-.38.15-.78.22-1.21.22s-.84-.07-1.21-.22c-.38-.15-.7-.36-.97-.62-.27-.27-.49-.59-.64-.95-.16-.37-.23-.77-.23-1.21s.08-.84.23-1.21c.16-.36.37-.68.64-.94s.6-.47.97-.62c.38-.15.78-.22,1.21-.22s.84.07,1.21.22c.38.15.7.35.98.62s.49.58.65.94c.16.36.23.77.23,1.21Zm-1.18,0c0-.27-.04-.53-.13-.78-.08-.25-.21-.46-.37-.65s-.36-.34-.6-.45c-.24-.11-.51-.17-.81-.17s-.58.06-.81.17c-.24.11-.44.26-.6.45-.16.19-.28.4-.37.65-.08.25-.13.51-.13.78s.04.53.13.78c.08.25.21.47.37.66.16.19.36.34.6.46.24.11.51.17.81.17s.58-.06.81-.17c.24-.11.44-.26.6-.46s.28-.41.37-.66c.08-.25.13-.51.13-.78Z"/>
-    <path d="m248.63,13.93c.02.14.03.31.04.49s.01.33.01.45h.04c.07-.15.17-.29.29-.43s.27-.25.43-.35c.16-.1.34-.18.53-.23.19-.06.39-.08.6-.08.37,0,.68.06.95.19s.48.29.66.5c.18.21.31.45.39.73s.13.58.13.9v3.53h-1.13v-3.16c0-.23-.02-.45-.05-.66-.04-.21-.1-.39-.2-.55s-.23-.29-.4-.38-.38-.14-.65-.14c-.45,0-.81.17-1.1.51s-.43.79-.43,1.36v3.02h-1.13v-4.46c0-.15,0-.35-.01-.59s-.02-.45-.04-.64h1.07Z"/>
-  </g>
-  <g>
-    <path d="m24.97,39.51c0,.17-.03.33-.09.46s-.14.26-.24.36c-.1.11-.22.2-.35.27s-.28.14-.43.19-.31.08-.47.11-.32.03-.47.03c-.33,0-.64-.01-.92-.04s-.55-.08-.82-.14v-.78c.29.08.57.14.85.19s.56.06.84.06c.41,0,.71-.06.9-.17s.29-.27.29-.47c0-.09-.02-.17-.05-.24-.03-.07-.09-.14-.17-.2-.08-.06-.21-.13-.38-.2s-.4-.15-.7-.23c-.22-.07-.43-.14-.61-.22-.19-.08-.35-.18-.49-.29s-.24-.25-.32-.4-.12-.33-.12-.54c0-.14.03-.29.1-.45s.17-.31.32-.45.36-.26.62-.35c.26-.09.59-.14.98-.14.19,0,.41.01.64.03.23.02.48.06.73.11v.76c-.27-.07-.52-.11-.76-.14-.24-.03-.45-.05-.62-.05-.21,0-.39.02-.53.05s-.26.08-.35.13c-.09.06-.15.12-.19.2-.04.08-.06.16-.06.25s.02.17.05.24.1.14.19.21c.09.07.22.13.39.2.17.07.38.14.65.22.29.08.53.17.73.27.2.09.36.2.48.31s.21.24.27.39.08.31.08.49Z"/>
-    <path d="m30.54,40.78c-.19.05-.39.08-.6.11-.21.02-.41.03-.62.03-.62,0-1.07-.14-1.38-.42-.3-.28-.45-.71-.45-1.28v-2.56h-1.37v-.71h1.37v-1.35l.85-.22v1.57h2.2v.71h-2.2v2.49c0,.35.09.61.28.79.19.17.46.26.83.26.16,0,.33-.01.51-.04.19-.03.38-.06.58-.12v.73Z"/>
-    <path d="m31.84,38.5c0-.42.06-.79.17-1.11.11-.32.28-.6.49-.82.21-.22.46-.39.76-.51.29-.12.62-.17.98-.17.16,0,.31,0,.46.03s.3.05.45.09v-2.06h.85v6.9h-.76l-.03-.93c-.24.34-.49.6-.77.77s-.58.25-.9.25c-.28,0-.53-.06-.74-.18s-.39-.28-.53-.5c-.14-.21-.25-.47-.32-.77s-.11-.63-.11-1Zm.87-.05c0,.59.09,1.03.26,1.33.17.29.42.44.74.44.21,0,.44-.1.68-.29s.49-.48.75-.85v-2.28c-.14-.07-.29-.11-.46-.15-.17-.03-.34-.05-.5-.05-.46,0-.82.15-1.08.45s-.39.77-.39,1.41Z"/>
-    <path d="m39.55,35.86c.1,0,.2.02.29.06.09.04.17.1.24.16s.12.15.16.24.06.19.06.29-.02.2-.06.29c-.04.09-.1.17-.16.24s-.15.12-.24.16-.19.06-.29.06-.2-.02-.29-.06-.17-.09-.24-.16-.12-.15-.16-.24c-.04-.09-.06-.19-.06-.29s.02-.2.06-.29.09-.17.16-.24.15-.12.24-.16c.09-.04.19-.06.29-.06Zm0,3.58c.1,0,.2.02.29.06.09.04.17.09.24.16s.12.15.16.24.06.19.06.29-.02.2-.06.29c-.04.09-.1.17-.16.24s-.15.12-.24.16-.19.06-.29.06-.2-.02-.29-.06-.17-.09-.24-.16-.12-.15-.16-.24c-.04-.09-.06-.19-.06-.29s.02-.2.06-.29.09-.17.16-.24.15-.12.24-.16c.09-.04.19-.06.29-.06Z"/>
-    <path d="m45.05,35.86c.1,0,.2.02.29.06.09.04.17.1.24.16s.12.15.16.24.06.19.06.29-.02.2-.06.29c-.04.09-.1.17-.16.24s-.15.12-.24.16-.19.06-.29.06-.2-.02-.29-.06-.17-.09-.24-.16-.12-.15-.16-.24c-.04-.09-.06-.19-.06-.29s.02-.2.06-.29.09-.17.16-.24.15-.12.24-.16c.09-.04.19-.06.29-.06Zm0,3.58c.1,0,.2.02.29.06.09.04.17.09.24.16s.12.15.16.24.06.19.06.29-.02.2-.06.29c-.04.09-.1.17-.16.24s-.15.12-.24.16-.19.06-.29.06-.2-.02-.29-.06-.17-.09-.24-.16-.12-.15-.16-.24c-.04-.09-.06-.19-.06-.29s.02-.2.06-.29.09-.17.16-.24.15-.12.24-.16c.09-.04.19-.06.29-.06Z"/>
-    <path d="m48.12,35.95h.97l1.2,3.24.26.79.27-.81,1.19-3.22h.93l-1.92,4.9h-.98l-1.92-4.9Z"/>
-    <path d="m58.22,38.14c0,.12,0,.22,0,.3s0,.16-.01.23h-3.44c0,.5.14.89.42,1.15.28.27.68.4,1.21.4.14,0,.29,0,.43-.02.14-.01.28-.03.42-.05s.26-.04.38-.07c.12-.02.24-.05.34-.08v.7c-.23.07-.49.12-.78.16-.29.04-.59.06-.91.06-.42,0-.78-.06-1.08-.17s-.55-.28-.74-.5c-.19-.22-.34-.48-.43-.8-.09-.31-.14-.67-.14-1.07,0-.34.05-.67.15-.98.1-.31.24-.58.43-.81.19-.23.42-.42.7-.55s.59-.21.94-.21.64.05.91.16.49.26.67.46c.18.2.32.44.41.72.09.28.14.6.14.94Zm-.88-.12c0-.22-.01-.42-.06-.6-.05-.18-.13-.34-.24-.47s-.25-.23-.41-.3c-.16-.07-.35-.11-.57-.11-.19,0-.35.04-.51.11s-.28.17-.4.3-.2.29-.27.47-.11.38-.13.6h2.58Z"/>
-    <path d="m63.38,40.67c-.22.08-.45.15-.68.19-.23.04-.47.06-.72.06-.77,0-1.37-.21-1.79-.63s-.63-1.03-.63-1.84c0-.39.06-.74.18-1.05s.29-.59.51-.81.48-.4.78-.52c.3-.12.64-.18,1-.18.25,0,.49.02.71.05s.43.09.63.18v.81c-.21-.11-.43-.19-.65-.24-.22-.05-.45-.08-.68-.08-.22,0-.42.04-.62.12-.19.08-.36.2-.51.36s-.26.35-.35.57-.13.48-.13.76c0,.59.14,1.04.43,1.33.29.29.69.44,1.2.44.23,0,.46-.03.67-.08s.43-.13.63-.23v.79Z"/>
-    <path d="m69.02,40.78c-.19.05-.39.08-.6.11-.21.02-.41.03-.62.03-.62,0-1.07-.14-1.38-.42-.3-.28-.45-.71-.45-1.28v-2.56h-1.37v-.71h1.37v-1.35l.85-.22v1.57h2.2v.71h-2.2v2.49c0,.35.09.61.28.79.19.17.46.26.83.26.16,0,.33-.01.51-.04.19-.03.38-.06.58-.12v.73Z"/>
-    <path d="m74.84,38.36c0,.38-.05.73-.16,1.05-.11.32-.26.59-.46.82-.2.23-.45.4-.74.53-.29.12-.62.19-.99.19s-.67-.05-.94-.16c-.28-.11-.51-.27-.71-.48s-.34-.47-.44-.79-.15-.67-.15-1.08c0-.38.05-.73.16-1.04.11-.31.26-.58.46-.81.2-.23.45-.4.74-.53.29-.12.62-.19.99-.19s.67.05.94.16c.28.11.51.27.71.48.19.21.34.47.44.78s.15.67.15,1.07Zm-.87.04c0-.3-.03-.57-.1-.79-.07-.23-.16-.42-.29-.57-.12-.15-.27-.27-.45-.34-.18-.08-.38-.12-.59-.12-.25,0-.47.05-.65.15-.18.1-.33.23-.44.4s-.2.36-.25.58c-.05.22-.08.45-.08.69,0,.3.03.57.1.8s.16.42.29.57c.12.15.27.26.45.34.18.08.37.11.6.11.25,0,.47-.05.65-.15.18-.1.33-.23.44-.4s.2-.36.25-.58c.05-.22.08-.45.08-.7Z"/>
-    <path d="m76.27,35.95h.78l.02.9c.29-.35.58-.6.86-.76s.57-.23.85-.23c.51,0,.89.16,1.15.49s.38.82.36,1.46h-.86c0-.43-.05-.74-.19-.93-.14-.19-.33-.29-.59-.29-.11,0-.23.02-.34.06-.12.04-.23.11-.36.2-.12.09-.25.21-.39.34s-.28.31-.44.51v3.15h-.86v-4.9Z"/>
-    <path d="m85.27,40.39l-.53.54-3.28-2.74,3.28-2.74.53.54-2.66,2.19,2.66,2.21Z"/>
-    <path d="m88.74,36.65h-1.45v-.7h2.31v4.19h1.46v.71h-3.93v-.71h1.61v-3.49Zm.3-2.76c.09,0,.18.02.26.05.08.03.15.08.21.14s.11.13.14.21c.03.08.05.17.05.26s-.02.18-.05.26-.08.15-.14.21-.13.11-.21.14c-.08.04-.17.05-.26.05s-.18-.02-.26-.05c-.08-.03-.15-.08-.21-.14s-.11-.13-.14-.21-.05-.17-.05-.26.02-.18.05-.26c.03-.08.08-.15.14-.21s.13-.11.21-.14c.08-.04.17-.05.26-.05Z"/>
-    <path d="m92.56,35.95h.76l.03.79c.14-.17.28-.31.42-.42.13-.11.26-.2.39-.27s.26-.12.39-.14c.13-.03.27-.04.42-.04.5,0,.89.15,1.15.45.26.3.39.75.39,1.34v3.2h-.85v-3.13c0-.38-.07-.67-.21-.85-.14-.18-.36-.28-.64-.28-.1,0-.21.02-.31.05-.1.03-.2.08-.31.16-.11.08-.22.18-.35.31s-.27.29-.42.49v3.25h-.85v-4.9Z"/>
-    <path d="m102.01,40.78c-.19.05-.39.08-.6.11-.21.02-.41.03-.62.03-.62,0-1.07-.14-1.38-.42-.3-.28-.45-.71-.45-1.28v-2.56h-1.37v-.71h1.37v-1.35l.85-.22v1.57h2.2v.71h-2.2v2.49c0,.35.09.61.28.79.19.17.46.26.83.26.16,0,.33-.01.51-.04.19-.03.38-.06.58-.12v.73Z"/>
-    <path d="m103.8,35.99l.53-.54,3.28,2.74-3.28,2.74-.53-.54,2.66-2.19-2.66-2.21Z"/>
-  </g>
-  <g>
-    <path d="m225.98,34.65h-1.45v-.7h2.31v6.19h1.46v.71h-3.93v-.71h1.61v-5.49Z"/>
-    <path d="m231.48,36.65h-1.45v-.7h2.31v4.19h1.46v.71h-3.93v-.71h1.61v-3.49Zm.3-2.76c.09,0,.18.02.26.05.08.03.15.08.21.14s.11.13.14.21c.03.08.05.17.05.26s-.02.18-.05.26-.08.15-.14.21-.13.11-.21.14c-.08.04-.17.05-.26.05s-.18-.02-.26-.05c-.08-.03-.15-.08-.21-.14s-.11-.13-.14-.21-.05-.17-.05-.26.02-.18.05-.26c.03-.08.08-.15.14-.21s.13-.11.21-.14c.08-.04.17-.05.26-.05Z"/>
-    <path d="m239.19,39.51c0,.17-.03.33-.09.46s-.14.26-.24.36c-.1.11-.22.2-.35.27s-.28.14-.43.19-.31.08-.47.11-.32.03-.47.03c-.33,0-.64-.01-.92-.04s-.55-.08-.82-.14v-.78c.29.08.57.14.85.19s.56.06.84.06c.41,0,.71-.06.9-.17s.29-.27.29-.47c0-.09-.02-.17-.05-.24-.03-.07-.09-.14-.17-.2-.08-.06-.21-.13-.38-.2s-.4-.15-.7-.23c-.22-.07-.43-.14-.61-.22-.19-.08-.35-.18-.49-.29s-.24-.25-.32-.4-.12-.33-.12-.54c0-.14.03-.29.1-.45s.17-.31.32-.45.36-.26.62-.35c.26-.09.59-.14.98-.14.19,0,.41.01.64.03.23.02.48.06.73.11v.76c-.27-.07-.52-.11-.76-.14-.24-.03-.45-.05-.62-.05-.21,0-.39.02-.53.05s-.26.08-.35.13c-.09.06-.15.12-.19.2-.04.08-.06.16-.06.25s.02.17.05.24.1.14.19.21c.09.07.22.13.39.2.17.07.38.14.65.22.29.08.53.17.73.27.2.09.36.2.48.31s.21.24.27.39.08.31.08.49Z"/>
-    <path d="m244.76,40.78c-.19.05-.39.08-.6.11-.21.02-.41.03-.62.03-.62,0-1.07-.14-1.38-.42-.3-.28-.45-.71-.45-1.28v-2.56h-1.37v-.71h1.37v-1.35l.85-.22v1.57h2.2v.71h-2.2v2.49c0,.35.09.61.28.79.19.17.46.26.83.26.16,0,.33-.01.51-.04.19-.03.38-.06.58-.12v.73Z"/>
-  </g>
-  <polygon class="cls-8" points="179.18 31.08 184.58 33.78 179.18 36.48 179.18 31.08"/>
-  <line class="cls-3" x1="114.6" y1="33.78" x2="180.26" y2="33.78"/>
-  <polygon class="cls-8" points="120 45.55 114.6 42.85 120 40.15 120 45.55"/>
-  <line class="cls-3" x1="184.58" y1="42.85" x2="118.92" y2="42.85"/>
-</svg>
\ No newline at end of file
diff --git a/src/nanobind/docs/images/logo.jpg b/src/nanobind/docs/images/logo.jpg
deleted file mode 100644
index b7763e9..0000000
Binary files a/src/nanobind/docs/images/logo.jpg and /dev/null differ
diff --git a/src/nanobind/docs/images/perf.svg b/src/nanobind/docs/images/perf.svg
deleted file mode 100644
index ec68479..0000000
--- a/src/nanobind/docs/images/perf.svg
+++ /dev/null
@@ -1,1979 +0,0 @@
-<?xml version="1.0" encoding="utf-8" standalone="no"?>
-<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN"
-  "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd">
-<svg xmlns:xlink="http://www.w3.org/1999/xlink" width="990.47125pt" height="248.47625pt" viewBox="0 0 990.47125 248.47625" xmlns="http://www.w3.org/2000/svg" version="1.1">
- <metadata>
-  <rdf:RDF xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:cc="http://creativecommons.org/ns#" xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#">
-   <cc:Work>
-    <dc:type rdf:resource="http://purl.org/dc/dcmitype/StillImage"/>
-    <dc:date>2023-04-24T16:58:39.940540</dc:date>
-    <dc:format>image/svg+xml</dc:format>
-    <dc:creator>
-     <cc:Agent>
-      <dc:title>Matplotlib v3.5.1, https://matplotlib.org/</dc:title>
-     </cc:Agent>
-    </dc:creator>
-   </cc:Work>
-  </rdf:RDF>
- </metadata>
- <defs>
-  <style type="text/css">*{stroke-linejoin: round; stroke-linecap: butt}</style>
- </defs>
- <g id="figure_1">
-  <g id="patch_1">
-   <path d="M 0 248.47625 
-L 990.47125 248.47625 
-L 990.47125 0 
-L 0 0 
-z
-" style="fill: #ffffff"/>
-  </g>
-  <g id="axes_1">
-   <g id="patch_2">
-    <path d="M 36.58125 231.798125 
-L 990.47125 231.798125 
-L 990.47125 15.118125 
-L 36.58125 15.118125 
-z
-" style="fill: #ffffff"/>
-   </g>
-   <g id="patch_3">
-    <path d="M 41.822404 231.798125 
-L 76.763429 231.798125 
-L 76.763429 -2.615543 
-L 41.822404 -2.615543 
-z
-" clip-path="url(#pc453d5dc25)" style="fill: #ff7f0e; stroke: #000000; stroke-linejoin: miter"/>
-   </g>
-   <g id="patch_4">
-    <path d="M 286.409583 231.798125 
-L 321.350609 231.798125 
-L 321.350609 137.680168 
-L 286.409583 137.680168 
-z
-" clip-path="url(#pc453d5dc25)" style="fill: #ff7f0e; stroke: #000000; stroke-linejoin: miter"/>
-   </g>
-   <g id="patch_5">
-    <path d="M 530.996763 231.798125 
-L 565.937788 231.798125 
-L 565.937788 74.204929 
-L 530.996763 74.204929 
-z
-" clip-path="url(#pc453d5dc25)" style="fill: #ff7f0e; stroke: #000000; stroke-linejoin: miter"/>
-   </g>
-   <g id="patch_6">
-    <path d="M 775.583942 231.798125 
-L 810.524968 231.798125 
-L 810.524968 138.214445 
-L 775.583942 138.214445 
-z
-" clip-path="url(#pc453d5dc25)" style="fill: #ff7f0e; stroke: #000000; stroke-linejoin: miter"/>
-   </g>
-   <g id="patch_7">
-    <path d="M 76.763429 231.798125 
-L 111.704455 231.798125 
-L 111.704455 -654.781253 
-L 76.763429 -654.781253 
-z
-" clip-path="url(#pc453d5dc25)" style="fill: #d62728; stroke: #000000; stroke-linejoin: miter"/>
-   </g>
-   <g id="patch_8">
-    <path d="M 321.350609 231.798125 
-L 356.291635 231.798125 
-L 356.291635 106.323259 
-L 321.350609 106.323259 
-z
-" clip-path="url(#pc453d5dc25)" style="fill: #d62728; stroke: #000000; stroke-linejoin: miter"/>
-   </g>
-   <g id="patch_9">
-    <path d="M 565.937788 231.798125 
-L 600.878814 231.798125 
-L 600.878814 -508.702876 
-L 565.937788 -508.702876 
-z
-" clip-path="url(#pc453d5dc25)" style="fill: #d62728; stroke: #000000; stroke-linejoin: miter"/>
-   </g>
-   <g id="patch_10">
-    <path d="M 810.524968 231.798125 
-L 845.465994 231.798125 
-L 845.465994 18.846916 
-L 810.524968 18.846916 
-z
-" clip-path="url(#pc453d5dc25)" style="fill: #d62728; stroke: #000000; stroke-linejoin: miter"/>
-   </g>
-   <g id="patch_11">
-    <path d="M 111.704455 231.798125 
-L 146.645481 231.798125 
-L 146.645481 164.451888 
-L 111.704455 164.451888 
-z
-" clip-path="url(#pc453d5dc25)" style="fill: #bcbd22; stroke: #000000; stroke-linejoin: miter"/>
-   </g>
-   <g id="patch_12">
-    <path d="M 356.291635 231.798125 
-L 391.23266 231.798125 
-L 391.23266 164.232783 
-L 356.291635 164.232783 
-z
-" clip-path="url(#pc453d5dc25)" style="fill: #bcbd22; stroke: #000000; stroke-linejoin: miter"/>
-   </g>
-   <g id="patch_13">
-    <path d="M 600.878814 231.798125 
-L 635.81984 231.798125 
-L 635.81984 188.326201 
-L 600.878814 188.326201 
-z
-" clip-path="url(#pc453d5dc25)" style="fill: #bcbd22; stroke: #000000; stroke-linejoin: miter"/>
-   </g>
-   <g id="patch_14">
-    <path d="M 845.465994 231.798125 
-L 880.407019 231.798125 
-L 880.407019 188.218761 
-L 845.465994 188.218761 
-z
-" clip-path="url(#pc453d5dc25)" style="fill: #bcbd22; stroke: #000000; stroke-linejoin: miter"/>
-   </g>
-   <g id="patch_15">
-    <path d="M 146.645481 231.798125 
-L 181.586506 231.798125 
-L 181.586506 160.985406 
-L 146.645481 160.985406 
-z
-" clip-path="url(#pc453d5dc25)" style="fill: #9467bd; stroke: #000000; stroke-linejoin: miter"/>
-   </g>
-   <g id="patch_16">
-    <path d="M 391.23266 231.798125 
-L 426.173686 231.798125 
-L 426.173686 184.295454 
-L 391.23266 184.295454 
-z
-" clip-path="url(#pc453d5dc25)" style="fill: #9467bd; stroke: #000000; stroke-linejoin: miter"/>
-   </g>
-   <g id="patch_17">
-    <path d="M 635.81984 231.798125 
-L 670.760865 231.798125 
-L 670.760865 209.032958 
-L 635.81984 209.032958 
-z
-" clip-path="url(#pc453d5dc25)" style="fill: #9467bd; stroke: #000000; stroke-linejoin: miter"/>
-   </g>
-   <g id="patch_18">
-    <path d="M 880.407019 231.798125 
-L 915.348045 231.798125 
-L 915.348045 217.151271 
-L 880.407019 217.151271 
-z
-" clip-path="url(#pc453d5dc25)" style="fill: #9467bd; stroke: #000000; stroke-linejoin: miter"/>
-   </g>
-   <g id="patch_19">
-    <path d="M 181.586506 231.798125 
-L 216.527532 231.798125 
-L 216.527532 167.170572 
-L 181.586506 167.170572 
-z
-" clip-path="url(#pc453d5dc25)" style="fill: #1f77b4; stroke: #000000; stroke-linejoin: miter"/>
-   </g>
-   <g id="patch_20">
-    <path d="M 426.173686 231.798125 
-L 461.114712 231.798125 
-L 461.114712 189.611107 
-L 426.173686 189.611107 
-z
-" clip-path="url(#pc453d5dc25)" style="fill: #1f77b4; stroke: #000000; stroke-linejoin: miter"/>
-   </g>
-   <g id="patch_21">
-    <path d="M 670.760865 231.798125 
-L 705.701891 231.798125 
-L 705.701891 198.815695 
-L 670.760865 198.815695 
-z
-" clip-path="url(#pc453d5dc25)" style="fill: #1f77b4; stroke: #000000; stroke-linejoin: miter"/>
-   </g>
-   <g id="patch_22">
-    <path d="M 915.348045 231.798125 
-L 950.289071 231.798125 
-L 950.289071 210.657522 
-L 915.348045 210.657522 
-z
-" clip-path="url(#pc453d5dc25)" style="fill: #1f77b4; stroke: #000000; stroke-linejoin: miter"/>
-   </g>
-   <g id="patch_23">
-    <path d="M 216.527532 231.798125 
-L 251.468558 231.798125 
-L 251.468558 167.719165 
-L 216.527532 167.719165 
-z
-" clip-path="url(#pc453d5dc25)" style="fill: url(#h19bdc7308c); stroke: #ffffff; stroke-linejoin: miter"/>
-   </g>
-   <g id="patch_24">
-    <path d="M 461.114712 231.798125 
-L 496.055737 231.798125 
-L 496.055737 167.641662 
-L 461.114712 167.641662 
-z
-" clip-path="url(#pc453d5dc25)" style="fill: url(#h19bdc7308c); stroke: #ffffff; stroke-linejoin: miter"/>
-   </g>
-   <g id="patch_25">
-    <path d="M 705.701891 231.798125 
-L 740.642917 231.798125 
-L 740.642917 174.917804 
-L 705.701891 174.917804 
-z
-" clip-path="url(#pc453d5dc25)" style="fill: url(#h19bdc7308c); stroke: #ffffff; stroke-linejoin: miter"/>
-   </g>
-   <g id="patch_26">
-    <path d="M 950.289071 231.798125 
-L 985.230096 231.798125 
-L 985.230096 174.898464 
-L 950.289071 174.898464 
-z
-" clip-path="url(#pc453d5dc25)" style="fill: url(#h19bdc7308c); stroke: #ffffff; stroke-linejoin: miter"/>
-   </g>
-   <g id="patch_27">
-    <path d="M 12.122532 301.416167 
-L 256.709712 301.416167 
-L 256.709712 -1647.889008 
-L 12.122532 -1647.889008 
-z
-" clip-path="url(#pc453d5dc25)" style="fill: #ffffff; opacity: 0.8"/>
-   </g>
-   <g id="patch_28">
-    <path d="M 513.52625 301.416167 
-L 758.113429 301.416167 
-L 758.113429 -1439.034882 
-L 513.52625 -1439.034882 
-z
-" clip-path="url(#pc453d5dc25)" style="fill: #ffffff; opacity: 0.8"/>
-   </g>
-   <g id="matplotlib.axis_1">
-    <g id="xtick_1">
-     <g id="line2d_1">
-      <defs>
-       <path id="mcd6576acd0" d="M 0 0 
-L 0 3.5 
-" style="stroke: #000000; stroke-width: 0.8"/>
-      </defs>
-      <g>
-       <use xlink:href="#mcd6576acd0" x="146.645481" y="231.798125" style="stroke: #000000; stroke-width: 0.8"/>
-      </g>
-     </g>
-     <g id="text_1">
-      <!-- func [debug] -->
-      <g transform="translate(114.540012 246.396563)scale(0.1 -0.1)">
-       <defs>
-        <path id="DejaVuSans-66" d="M 2375 4863 
-L 2375 4384 
-L 1825 4384 
-Q 1516 4384 1395 4259 
-Q 1275 4134 1275 3809 
-L 1275 3500 
-L 2222 3500 
-L 2222 3053 
-L 1275 3053 
-L 1275 0 
-L 697 0 
-L 697 3053 
-L 147 3053 
-L 147 3500 
-L 697 3500 
-L 697 3744 
-Q 697 4328 969 4595 
-Q 1241 4863 1831 4863 
-L 2375 4863 
-z
-" transform="scale(0.015625)"/>
-        <path id="DejaVuSans-75" d="M 544 1381 
-L 544 3500 
-L 1119 3500 
-L 1119 1403 
-Q 1119 906 1312 657 
-Q 1506 409 1894 409 
-Q 2359 409 2629 706 
-Q 2900 1003 2900 1516 
-L 2900 3500 
-L 3475 3500 
-L 3475 0 
-L 2900 0 
-L 2900 538 
-Q 2691 219 2414 64 
-Q 2138 -91 1772 -91 
-Q 1169 -91 856 284 
-Q 544 659 544 1381 
-z
-M 1991 3584 
-L 1991 3584 
-z
-" transform="scale(0.015625)"/>
-        <path id="DejaVuSans-6e" d="M 3513 2113 
-L 3513 0 
-L 2938 0 
-L 2938 2094 
-Q 2938 2591 2744 2837 
-Q 2550 3084 2163 3084 
-Q 1697 3084 1428 2787 
-Q 1159 2491 1159 1978 
-L 1159 0 
-L 581 0 
-L 581 3500 
-L 1159 3500 
-L 1159 2956 
-Q 1366 3272 1645 3428 
-Q 1925 3584 2291 3584 
-Q 2894 3584 3203 3211 
-Q 3513 2838 3513 2113 
-z
-" transform="scale(0.015625)"/>
-        <path id="DejaVuSans-63" d="M 3122 3366 
-L 3122 2828 
-Q 2878 2963 2633 3030 
-Q 2388 3097 2138 3097 
-Q 1578 3097 1268 2742 
-Q 959 2388 959 1747 
-Q 959 1106 1268 751 
-Q 1578 397 2138 397 
-Q 2388 397 2633 464 
-Q 2878 531 3122 666 
-L 3122 134 
-Q 2881 22 2623 -34 
-Q 2366 -91 2075 -91 
-Q 1284 -91 818 406 
-Q 353 903 353 1747 
-Q 353 2603 823 3093 
-Q 1294 3584 2113 3584 
-Q 2378 3584 2631 3529 
-Q 2884 3475 3122 3366 
-z
-" transform="scale(0.015625)"/>
-        <path id="DejaVuSans-20" transform="scale(0.015625)"/>
-        <path id="DejaVuSans-5b" d="M 550 4863 
-L 1875 4863 
-L 1875 4416 
-L 1125 4416 
-L 1125 -397 
-L 1875 -397 
-L 1875 -844 
-L 550 -844 
-L 550 4863 
-z
-" transform="scale(0.015625)"/>
-        <path id="DejaVuSans-64" d="M 2906 2969 
-L 2906 4863 
-L 3481 4863 
-L 3481 0 
-L 2906 0 
-L 2906 525 
-Q 2725 213 2448 61 
-Q 2172 -91 1784 -91 
-Q 1150 -91 751 415 
-Q 353 922 353 1747 
-Q 353 2572 751 3078 
-Q 1150 3584 1784 3584 
-Q 2172 3584 2448 3432 
-Q 2725 3281 2906 2969 
-z
-M 947 1747 
-Q 947 1113 1208 752 
-Q 1469 391 1925 391 
-Q 2381 391 2643 752 
-Q 2906 1113 2906 1747 
-Q 2906 2381 2643 2742 
-Q 2381 3103 1925 3103 
-Q 1469 3103 1208 2742 
-Q 947 2381 947 1747 
-z
-" transform="scale(0.015625)"/>
-        <path id="DejaVuSans-65" d="M 3597 1894 
-L 3597 1613 
-L 953 1613 
-Q 991 1019 1311 708 
-Q 1631 397 2203 397 
-Q 2534 397 2845 478 
-Q 3156 559 3463 722 
-L 3463 178 
-Q 3153 47 2828 -22 
-Q 2503 -91 2169 -91 
-Q 1331 -91 842 396 
-Q 353 884 353 1716 
-Q 353 2575 817 3079 
-Q 1281 3584 2069 3584 
-Q 2775 3584 3186 3129 
-Q 3597 2675 3597 1894 
-z
-M 3022 2063 
-Q 3016 2534 2758 2815 
-Q 2500 3097 2075 3097 
-Q 1594 3097 1305 2825 
-Q 1016 2553 972 2059 
-L 3022 2063 
-z
-" transform="scale(0.015625)"/>
-        <path id="DejaVuSans-62" d="M 3116 1747 
-Q 3116 2381 2855 2742 
-Q 2594 3103 2138 3103 
-Q 1681 3103 1420 2742 
-Q 1159 2381 1159 1747 
-Q 1159 1113 1420 752 
-Q 1681 391 2138 391 
-Q 2594 391 2855 752 
-Q 3116 1113 3116 1747 
-z
-M 1159 2969 
-Q 1341 3281 1617 3432 
-Q 1894 3584 2278 3584 
-Q 2916 3584 3314 3078 
-Q 3713 2572 3713 1747 
-Q 3713 922 3314 415 
-Q 2916 -91 2278 -91 
-Q 1894 -91 1617 61 
-Q 1341 213 1159 525 
-L 1159 0 
-L 581 0 
-L 581 4863 
-L 1159 4863 
-L 1159 2969 
-z
-" transform="scale(0.015625)"/>
-        <path id="DejaVuSans-67" d="M 2906 1791 
-Q 2906 2416 2648 2759 
-Q 2391 3103 1925 3103 
-Q 1463 3103 1205 2759 
-Q 947 2416 947 1791 
-Q 947 1169 1205 825 
-Q 1463 481 1925 481 
-Q 2391 481 2648 825 
-Q 2906 1169 2906 1791 
-z
-M 3481 434 
-Q 3481 -459 3084 -895 
-Q 2688 -1331 1869 -1331 
-Q 1566 -1331 1297 -1286 
-Q 1028 -1241 775 -1147 
-L 775 -588 
-Q 1028 -725 1275 -790 
-Q 1522 -856 1778 -856 
-Q 2344 -856 2625 -561 
-Q 2906 -266 2906 331 
-L 2906 616 
-Q 2728 306 2450 153 
-Q 2172 0 1784 0 
-Q 1141 0 747 490 
-Q 353 981 353 1791 
-Q 353 2603 747 3093 
-Q 1141 3584 1784 3584 
-Q 2172 3584 2450 3431 
-Q 2728 3278 2906 2969 
-L 2906 3500 
-L 3481 3500 
-L 3481 434 
-z
-" transform="scale(0.015625)"/>
-        <path id="DejaVuSans-5d" d="M 1947 4863 
-L 1947 -844 
-L 622 -844 
-L 622 -397 
-L 1369 -397 
-L 1369 4416 
-L 622 4416 
-L 622 4863 
-L 1947 4863 
-z
-" transform="scale(0.015625)"/>
-       </defs>
-       <use xlink:href="#DejaVuSans-66"/>
-       <use xlink:href="#DejaVuSans-75" x="35.205078"/>
-       <use xlink:href="#DejaVuSans-6e" x="98.583984"/>
-       <use xlink:href="#DejaVuSans-63" x="161.962891"/>
-       <use xlink:href="#DejaVuSans-20" x="216.943359"/>
-       <use xlink:href="#DejaVuSans-5b" x="248.730469"/>
-       <use xlink:href="#DejaVuSans-64" x="287.744141"/>
-       <use xlink:href="#DejaVuSans-65" x="351.220703"/>
-       <use xlink:href="#DejaVuSans-62" x="412.744141"/>
-       <use xlink:href="#DejaVuSans-75" x="476.220703"/>
-       <use xlink:href="#DejaVuSans-67" x="539.599609"/>
-       <use xlink:href="#DejaVuSans-5d" x="603.076172"/>
-      </g>
-     </g>
-    </g>
-    <g id="xtick_2">
-     <g id="line2d_2">
-      <g>
-       <use xlink:href="#mcd6576acd0" x="391.23266" y="231.798125" style="stroke: #000000; stroke-width: 0.8"/>
-      </g>
-     </g>
-     <g id="text_2">
-      <!-- func [opt] -->
-      <g transform="translate(366.70141 246.396563)scale(0.1 -0.1)">
-       <defs>
-        <path id="DejaVuSans-6f" d="M 1959 3097 
-Q 1497 3097 1228 2736 
-Q 959 2375 959 1747 
-Q 959 1119 1226 758 
-Q 1494 397 1959 397 
-Q 2419 397 2687 759 
-Q 2956 1122 2956 1747 
-Q 2956 2369 2687 2733 
-Q 2419 3097 1959 3097 
-z
-M 1959 3584 
-Q 2709 3584 3137 3096 
-Q 3566 2609 3566 1747 
-Q 3566 888 3137 398 
-Q 2709 -91 1959 -91 
-Q 1206 -91 779 398 
-Q 353 888 353 1747 
-Q 353 2609 779 3096 
-Q 1206 3584 1959 3584 
-z
-" transform="scale(0.015625)"/>
-        <path id="DejaVuSans-70" d="M 1159 525 
-L 1159 -1331 
-L 581 -1331 
-L 581 3500 
-L 1159 3500 
-L 1159 2969 
-Q 1341 3281 1617 3432 
-Q 1894 3584 2278 3584 
-Q 2916 3584 3314 3078 
-Q 3713 2572 3713 1747 
-Q 3713 922 3314 415 
-Q 2916 -91 2278 -91 
-Q 1894 -91 1617 61 
-Q 1341 213 1159 525 
-z
-M 3116 1747 
-Q 3116 2381 2855 2742 
-Q 2594 3103 2138 3103 
-Q 1681 3103 1420 2742 
-Q 1159 2381 1159 1747 
-Q 1159 1113 1420 752 
-Q 1681 391 2138 391 
-Q 2594 391 2855 752 
-Q 3116 1113 3116 1747 
-z
-" transform="scale(0.015625)"/>
-        <path id="DejaVuSans-74" d="M 1172 4494 
-L 1172 3500 
-L 2356 3500 
-L 2356 3053 
-L 1172 3053 
-L 1172 1153 
-Q 1172 725 1289 603 
-Q 1406 481 1766 481 
-L 2356 481 
-L 2356 0 
-L 1766 0 
-Q 1100 0 847 248 
-Q 594 497 594 1153 
-L 594 3053 
-L 172 3053 
-L 172 3500 
-L 594 3500 
-L 594 4494 
-L 1172 4494 
-z
-" transform="scale(0.015625)"/>
-       </defs>
-       <use xlink:href="#DejaVuSans-66"/>
-       <use xlink:href="#DejaVuSans-75" x="35.205078"/>
-       <use xlink:href="#DejaVuSans-6e" x="98.583984"/>
-       <use xlink:href="#DejaVuSans-63" x="161.962891"/>
-       <use xlink:href="#DejaVuSans-20" x="216.943359"/>
-       <use xlink:href="#DejaVuSans-5b" x="248.730469"/>
-       <use xlink:href="#DejaVuSans-6f" x="287.744141"/>
-       <use xlink:href="#DejaVuSans-70" x="348.925781"/>
-       <use xlink:href="#DejaVuSans-74" x="412.402344"/>
-       <use xlink:href="#DejaVuSans-5d" x="451.611328"/>
-      </g>
-     </g>
-    </g>
-    <g id="xtick_3">
-     <g id="line2d_3">
-      <g>
-       <use xlink:href="#mcd6576acd0" x="635.81984" y="231.798125" style="stroke: #000000; stroke-width: 0.8"/>
-      </g>
-     </g>
-     <g id="text_3">
-      <!-- class [debug] -->
-      <g transform="translate(602.149527 246.396563)scale(0.1 -0.1)">
-       <defs>
-        <path id="DejaVuSans-6c" d="M 603 4863 
-L 1178 4863 
-L 1178 0 
-L 603 0 
-L 603 4863 
-z
-" transform="scale(0.015625)"/>
-        <path id="DejaVuSans-61" d="M 2194 1759 
-Q 1497 1759 1228 1600 
-Q 959 1441 959 1056 
-Q 959 750 1161 570 
-Q 1363 391 1709 391 
-Q 2188 391 2477 730 
-Q 2766 1069 2766 1631 
-L 2766 1759 
-L 2194 1759 
-z
-M 3341 1997 
-L 3341 0 
-L 2766 0 
-L 2766 531 
-Q 2569 213 2275 61 
-Q 1981 -91 1556 -91 
-Q 1019 -91 701 211 
-Q 384 513 384 1019 
-Q 384 1609 779 1909 
-Q 1175 2209 1959 2209 
-L 2766 2209 
-L 2766 2266 
-Q 2766 2663 2505 2880 
-Q 2244 3097 1772 3097 
-Q 1472 3097 1187 3025 
-Q 903 2953 641 2809 
-L 641 3341 
-Q 956 3463 1253 3523 
-Q 1550 3584 1831 3584 
-Q 2591 3584 2966 3190 
-Q 3341 2797 3341 1997 
-z
-" transform="scale(0.015625)"/>
-        <path id="DejaVuSans-73" d="M 2834 3397 
-L 2834 2853 
-Q 2591 2978 2328 3040 
-Q 2066 3103 1784 3103 
-Q 1356 3103 1142 2972 
-Q 928 2841 928 2578 
-Q 928 2378 1081 2264 
-Q 1234 2150 1697 2047 
-L 1894 2003 
-Q 2506 1872 2764 1633 
-Q 3022 1394 3022 966 
-Q 3022 478 2636 193 
-Q 2250 -91 1575 -91 
-Q 1294 -91 989 -36 
-Q 684 19 347 128 
-L 347 722 
-Q 666 556 975 473 
-Q 1284 391 1588 391 
-Q 1994 391 2212 530 
-Q 2431 669 2431 922 
-Q 2431 1156 2273 1281 
-Q 2116 1406 1581 1522 
-L 1381 1569 
-Q 847 1681 609 1914 
-Q 372 2147 372 2553 
-Q 372 3047 722 3315 
-Q 1072 3584 1716 3584 
-Q 2034 3584 2315 3537 
-Q 2597 3491 2834 3397 
-z
-" transform="scale(0.015625)"/>
-       </defs>
-       <use xlink:href="#DejaVuSans-63"/>
-       <use xlink:href="#DejaVuSans-6c" x="54.980469"/>
-       <use xlink:href="#DejaVuSans-61" x="82.763672"/>
-       <use xlink:href="#DejaVuSans-73" x="144.042969"/>
-       <use xlink:href="#DejaVuSans-73" x="196.142578"/>
-       <use xlink:href="#DejaVuSans-20" x="248.242188"/>
-       <use xlink:href="#DejaVuSans-5b" x="280.029297"/>
-       <use xlink:href="#DejaVuSans-64" x="319.042969"/>
-       <use xlink:href="#DejaVuSans-65" x="382.519531"/>
-       <use xlink:href="#DejaVuSans-62" x="444.042969"/>
-       <use xlink:href="#DejaVuSans-75" x="507.519531"/>
-       <use xlink:href="#DejaVuSans-67" x="570.898438"/>
-       <use xlink:href="#DejaVuSans-5d" x="634.375"/>
-      </g>
-     </g>
-    </g>
-    <g id="xtick_4">
-     <g id="line2d_4">
-      <g>
-       <use xlink:href="#mcd6576acd0" x="880.407019" y="231.798125" style="stroke: #000000; stroke-width: 0.8"/>
-      </g>
-     </g>
-     <g id="text_4">
-      <!-- class [opt] -->
-      <g transform="translate(854.310925 246.396563)scale(0.1 -0.1)">
-       <use xlink:href="#DejaVuSans-63"/>
-       <use xlink:href="#DejaVuSans-6c" x="54.980469"/>
-       <use xlink:href="#DejaVuSans-61" x="82.763672"/>
-       <use xlink:href="#DejaVuSans-73" x="144.042969"/>
-       <use xlink:href="#DejaVuSans-73" x="196.142578"/>
-       <use xlink:href="#DejaVuSans-20" x="248.242188"/>
-       <use xlink:href="#DejaVuSans-5b" x="280.029297"/>
-       <use xlink:href="#DejaVuSans-6f" x="319.042969"/>
-       <use xlink:href="#DejaVuSans-70" x="380.224609"/>
-       <use xlink:href="#DejaVuSans-74" x="443.701172"/>
-       <use xlink:href="#DejaVuSans-5d" x="482.910156"/>
-      </g>
-     </g>
-    </g>
-   </g>
-   <g id="matplotlib.axis_2">
-    <g id="ytick_1">
-     <g id="line2d_5">
-      <defs>
-       <path id="mfb4d7a7f43" d="M 0 0 
-L -3.5 0 
-" style="stroke: #000000; stroke-width: 0.8"/>
-      </defs>
-      <g>
-       <use xlink:href="#mfb4d7a7f43" x="36.58125" y="231.798125" style="stroke: #000000; stroke-width: 0.8"/>
-      </g>
-     </g>
-     <g id="text_5">
-      <!-- 0.0 -->
-      <g transform="translate(13.678125 235.597344)scale(0.1 -0.1)">
-       <defs>
-        <path id="DejaVuSans-30" d="M 2034 4250 
-Q 1547 4250 1301 3770 
-Q 1056 3291 1056 2328 
-Q 1056 1369 1301 889 
-Q 1547 409 2034 409 
-Q 2525 409 2770 889 
-Q 3016 1369 3016 2328 
-Q 3016 3291 2770 3770 
-Q 2525 4250 2034 4250 
-z
-M 2034 4750 
-Q 2819 4750 3233 4129 
-Q 3647 3509 3647 2328 
-Q 3647 1150 3233 529 
-Q 2819 -91 2034 -91 
-Q 1250 -91 836 529 
-Q 422 1150 422 2328 
-Q 422 3509 836 4129 
-Q 1250 4750 2034 4750 
-z
-" transform="scale(0.015625)"/>
-        <path id="DejaVuSans-2e" d="M 684 794 
-L 1344 794 
-L 1344 0 
-L 684 0 
-L 684 794 
-z
-" transform="scale(0.015625)"/>
-       </defs>
-       <use xlink:href="#DejaVuSans-30"/>
-       <use xlink:href="#DejaVuSans-2e" x="63.623047"/>
-       <use xlink:href="#DejaVuSans-30" x="95.410156"/>
-      </g>
-     </g>
-    </g>
-    <g id="ytick_2">
-     <g id="line2d_6">
-      <g>
-       <use xlink:href="#mfb4d7a7f43" x="36.58125" y="196.989104" style="stroke: #000000; stroke-width: 0.8"/>
-      </g>
-     </g>
-     <g id="text_6">
-      <!-- 0.5 -->
-      <g transform="translate(13.678125 200.788323)scale(0.1 -0.1)">
-       <defs>
-        <path id="DejaVuSans-35" d="M 691 4666 
-L 3169 4666 
-L 3169 4134 
-L 1269 4134 
-L 1269 2991 
-Q 1406 3038 1543 3061 
-Q 1681 3084 1819 3084 
-Q 2600 3084 3056 2656 
-Q 3513 2228 3513 1497 
-Q 3513 744 3044 326 
-Q 2575 -91 1722 -91 
-Q 1428 -91 1123 -41 
-Q 819 9 494 109 
-L 494 744 
-Q 775 591 1075 516 
-Q 1375 441 1709 441 
-Q 2250 441 2565 725 
-Q 2881 1009 2881 1497 
-Q 2881 1984 2565 2268 
-Q 2250 2553 1709 2553 
-Q 1456 2553 1204 2497 
-Q 953 2441 691 2322 
-L 691 4666 
-z
-" transform="scale(0.015625)"/>
-       </defs>
-       <use xlink:href="#DejaVuSans-30"/>
-       <use xlink:href="#DejaVuSans-2e" x="63.623047"/>
-       <use xlink:href="#DejaVuSans-35" x="95.410156"/>
-      </g>
-     </g>
-    </g>
-    <g id="ytick_3">
-     <g id="line2d_7">
-      <g>
-       <use xlink:href="#mfb4d7a7f43" x="36.58125" y="162.180083" style="stroke: #000000; stroke-width: 0.8"/>
-      </g>
-     </g>
-     <g id="text_7">
-      <!-- 1.0 -->
-      <g transform="translate(13.678125 165.979302)scale(0.1 -0.1)">
-       <defs>
-        <path id="DejaVuSans-31" d="M 794 531 
-L 1825 531 
-L 1825 4091 
-L 703 3866 
-L 703 4441 
-L 1819 4666 
-L 2450 4666 
-L 2450 531 
-L 3481 531 
-L 3481 0 
-L 794 0 
-L 794 531 
-z
-" transform="scale(0.015625)"/>
-       </defs>
-       <use xlink:href="#DejaVuSans-31"/>
-       <use xlink:href="#DejaVuSans-2e" x="63.623047"/>
-       <use xlink:href="#DejaVuSans-30" x="95.410156"/>
-      </g>
-     </g>
-    </g>
-    <g id="ytick_4">
-     <g id="line2d_8">
-      <g>
-       <use xlink:href="#mfb4d7a7f43" x="36.58125" y="127.371062" style="stroke: #000000; stroke-width: 0.8"/>
-      </g>
-     </g>
-     <g id="text_8">
-      <!-- 1.5 -->
-      <g transform="translate(13.678125 131.170281)scale(0.1 -0.1)">
-       <use xlink:href="#DejaVuSans-31"/>
-       <use xlink:href="#DejaVuSans-2e" x="63.623047"/>
-       <use xlink:href="#DejaVuSans-35" x="95.410156"/>
-      </g>
-     </g>
-    </g>
-    <g id="ytick_5">
-     <g id="line2d_9">
-      <g>
-       <use xlink:href="#mfb4d7a7f43" x="36.58125" y="92.562041" style="stroke: #000000; stroke-width: 0.8"/>
-      </g>
-     </g>
-     <g id="text_9">
-      <!-- 2.0 -->
-      <g transform="translate(13.678125 96.36126)scale(0.1 -0.1)">
-       <defs>
-        <path id="DejaVuSans-32" d="M 1228 531 
-L 3431 531 
-L 3431 0 
-L 469 0 
-L 469 531 
-Q 828 903 1448 1529 
-Q 2069 2156 2228 2338 
-Q 2531 2678 2651 2914 
-Q 2772 3150 2772 3378 
-Q 2772 3750 2511 3984 
-Q 2250 4219 1831 4219 
-Q 1534 4219 1204 4116 
-Q 875 4013 500 3803 
-L 500 4441 
-Q 881 4594 1212 4672 
-Q 1544 4750 1819 4750 
-Q 2544 4750 2975 4387 
-Q 3406 4025 3406 3419 
-Q 3406 3131 3298 2873 
-Q 3191 2616 2906 2266 
-Q 2828 2175 2409 1742 
-Q 1991 1309 1228 531 
-z
-" transform="scale(0.015625)"/>
-       </defs>
-       <use xlink:href="#DejaVuSans-32"/>
-       <use xlink:href="#DejaVuSans-2e" x="63.623047"/>
-       <use xlink:href="#DejaVuSans-30" x="95.410156"/>
-      </g>
-     </g>
-    </g>
-    <g id="ytick_6">
-     <g id="line2d_10">
-      <g>
-       <use xlink:href="#mfb4d7a7f43" x="36.58125" y="57.75302" style="stroke: #000000; stroke-width: 0.8"/>
-      </g>
-     </g>
-     <g id="text_10">
-      <!-- 2.5 -->
-      <g transform="translate(13.678125 61.552239)scale(0.1 -0.1)">
-       <use xlink:href="#DejaVuSans-32"/>
-       <use xlink:href="#DejaVuSans-2e" x="63.623047"/>
-       <use xlink:href="#DejaVuSans-35" x="95.410156"/>
-      </g>
-     </g>
-    </g>
-    <g id="ytick_7">
-     <g id="line2d_11">
-      <g>
-       <use xlink:href="#mfb4d7a7f43" x="36.58125" y="22.943999" style="stroke: #000000; stroke-width: 0.8"/>
-      </g>
-     </g>
-     <g id="text_11">
-      <!-- 3.0 -->
-      <g transform="translate(13.678125 26.743218)scale(0.1 -0.1)">
-       <defs>
-        <path id="DejaVuSans-33" d="M 2597 2516 
-Q 3050 2419 3304 2112 
-Q 3559 1806 3559 1356 
-Q 3559 666 3084 287 
-Q 2609 -91 1734 -91 
-Q 1441 -91 1130 -33 
-Q 819 25 488 141 
-L 488 750 
-Q 750 597 1062 519 
-Q 1375 441 1716 441 
-Q 2309 441 2620 675 
-Q 2931 909 2931 1356 
-Q 2931 1769 2642 2001 
-Q 2353 2234 1838 2234 
-L 1294 2234 
-L 1294 2753 
-L 1863 2753 
-Q 2328 2753 2575 2939 
-Q 2822 3125 2822 3475 
-Q 2822 3834 2567 4026 
-Q 2313 4219 1838 4219 
-Q 1578 4219 1281 4162 
-Q 984 4106 628 3988 
-L 628 4550 
-Q 988 4650 1302 4700 
-Q 1616 4750 1894 4750 
-Q 2613 4750 3031 4423 
-Q 3450 4097 3450 3541 
-Q 3450 3153 3228 2886 
-Q 3006 2619 2597 2516 
-z
-" transform="scale(0.015625)"/>
-       </defs>
-       <use xlink:href="#DejaVuSans-33"/>
-       <use xlink:href="#DejaVuSans-2e" x="63.623047"/>
-       <use xlink:href="#DejaVuSans-30" x="95.410156"/>
-      </g>
-     </g>
-    </g>
-    <g id="text_12">
-     <!-- Time (seconds) -->
-     <g transform="translate(7.598438 161.619844)rotate(-90)scale(0.1 -0.1)">
-      <defs>
-       <path id="DejaVuSans-54" d="M -19 4666 
-L 3928 4666 
-L 3928 4134 
-L 2272 4134 
-L 2272 0 
-L 1638 0 
-L 1638 4134 
-L -19 4134 
-L -19 4666 
-z
-" transform="scale(0.015625)"/>
-       <path id="DejaVuSans-69" d="M 603 3500 
-L 1178 3500 
-L 1178 0 
-L 603 0 
-L 603 3500 
-z
-M 603 4863 
-L 1178 4863 
-L 1178 4134 
-L 603 4134 
-L 603 4863 
-z
-" transform="scale(0.015625)"/>
-       <path id="DejaVuSans-6d" d="M 3328 2828 
-Q 3544 3216 3844 3400 
-Q 4144 3584 4550 3584 
-Q 5097 3584 5394 3201 
-Q 5691 2819 5691 2113 
-L 5691 0 
-L 5113 0 
-L 5113 2094 
-Q 5113 2597 4934 2840 
-Q 4756 3084 4391 3084 
-Q 3944 3084 3684 2787 
-Q 3425 2491 3425 1978 
-L 3425 0 
-L 2847 0 
-L 2847 2094 
-Q 2847 2600 2669 2842 
-Q 2491 3084 2119 3084 
-Q 1678 3084 1418 2786 
-Q 1159 2488 1159 1978 
-L 1159 0 
-L 581 0 
-L 581 3500 
-L 1159 3500 
-L 1159 2956 
-Q 1356 3278 1631 3431 
-Q 1906 3584 2284 3584 
-Q 2666 3584 2933 3390 
-Q 3200 3197 3328 2828 
-z
-" transform="scale(0.015625)"/>
-       <path id="DejaVuSans-28" d="M 1984 4856 
-Q 1566 4138 1362 3434 
-Q 1159 2731 1159 2009 
-Q 1159 1288 1364 580 
-Q 1569 -128 1984 -844 
-L 1484 -844 
-Q 1016 -109 783 600 
-Q 550 1309 550 2009 
-Q 550 2706 781 3412 
-Q 1013 4119 1484 4856 
-L 1984 4856 
-z
-" transform="scale(0.015625)"/>
-       <path id="DejaVuSans-29" d="M 513 4856 
-L 1013 4856 
-Q 1481 4119 1714 3412 
-Q 1947 2706 1947 2009 
-Q 1947 1309 1714 600 
-Q 1481 -109 1013 -844 
-L 513 -844 
-Q 928 -128 1133 580 
-Q 1338 1288 1338 2009 
-Q 1338 2731 1133 3434 
-Q 928 4138 513 4856 
-z
-" transform="scale(0.015625)"/>
-      </defs>
-      <use xlink:href="#DejaVuSans-54"/>
-      <use xlink:href="#DejaVuSans-69" x="57.958984"/>
-      <use xlink:href="#DejaVuSans-6d" x="85.742188"/>
-      <use xlink:href="#DejaVuSans-65" x="183.154297"/>
-      <use xlink:href="#DejaVuSans-20" x="244.677734"/>
-      <use xlink:href="#DejaVuSans-28" x="276.464844"/>
-      <use xlink:href="#DejaVuSans-73" x="315.478516"/>
-      <use xlink:href="#DejaVuSans-65" x="367.578125"/>
-      <use xlink:href="#DejaVuSans-63" x="429.101562"/>
-      <use xlink:href="#DejaVuSans-6f" x="484.082031"/>
-      <use xlink:href="#DejaVuSans-6e" x="545.263672"/>
-      <use xlink:href="#DejaVuSans-64" x="608.642578"/>
-      <use xlink:href="#DejaVuSans-73" x="672.119141"/>
-      <use xlink:href="#DejaVuSans-29" x="724.21875"/>
-     </g>
-    </g>
-   </g>
-   <g id="patch_29">
-    <path d="M 36.58125 231.798125 
-L 36.58125 15.118125 
-" style="fill: none; stroke: #000000; stroke-width: 0.8; stroke-linejoin: miter; stroke-linecap: square"/>
-   </g>
-   <g id="patch_30">
-    <path d="M 990.47125 231.798125 
-L 990.47125 15.118125 
-" style="fill: none; stroke: #000000; stroke-width: 0.8; stroke-linejoin: miter; stroke-linecap: square"/>
-   </g>
-   <g id="patch_31">
-    <path d="M 36.58125 231.798125 
-L 990.47125 231.798125 
-" style="fill: none; stroke: #000000; stroke-width: 0.8; stroke-linejoin: miter; stroke-linecap: square"/>
-   </g>
-   <g id="patch_32">
-    <path d="M 36.58125 15.118125 
-L 990.47125 15.118125 
-" style="fill: none; stroke: #000000; stroke-width: 0.8; stroke-linejoin: miter; stroke-linecap: square"/>
-   </g>
-   <g id="text_13">
-    <!-- 3.37 -->
-    <g transform="translate(48.160104 42.176625)scale(0.1 -0.1)">
-     <defs>
-      <path id="DejaVuSans-37" d="M 525 4666 
-L 3525 4666 
-L 3525 4397 
-L 1831 0 
-L 1172 0 
-L 2766 4134 
-L 525 4134 
-L 525 4666 
-z
-" transform="scale(0.015625)"/>
-     </defs>
-     <use xlink:href="#DejaVuSans-33"/>
-     <use xlink:href="#DejaVuSans-2e" x="63.623047"/>
-     <use xlink:href="#DejaVuSans-33" x="95.410156"/>
-     <use xlink:href="#DejaVuSans-37" x="159.033203"/>
-    </g>
-    <!-- (x3.6) -->
-    <g transform="translate(44.480417 53.374438)scale(0.1 -0.1)">
-     <defs>
-      <path id="DejaVuSans-78" d="M 3513 3500 
-L 2247 1797 
-L 3578 0 
-L 2900 0 
-L 1881 1375 
-L 863 0 
-L 184 0 
-L 1544 1831 
-L 300 3500 
-L 978 3500 
-L 1906 2253 
-L 2834 3500 
-L 3513 3500 
-z
-" transform="scale(0.015625)"/>
-      <path id="DejaVuSans-36" d="M 2113 2584 
-Q 1688 2584 1439 2293 
-Q 1191 2003 1191 1497 
-Q 1191 994 1439 701 
-Q 1688 409 2113 409 
-Q 2538 409 2786 701 
-Q 3034 994 3034 1497 
-Q 3034 2003 2786 2293 
-Q 2538 2584 2113 2584 
-z
-M 3366 4563 
-L 3366 3988 
-Q 3128 4100 2886 4159 
-Q 2644 4219 2406 4219 
-Q 1781 4219 1451 3797 
-Q 1122 3375 1075 2522 
-Q 1259 2794 1537 2939 
-Q 1816 3084 2150 3084 
-Q 2853 3084 3261 2657 
-Q 3669 2231 3669 1497 
-Q 3669 778 3244 343 
-Q 2819 -91 2113 -91 
-Q 1303 -91 875 529 
-Q 447 1150 447 2328 
-Q 447 3434 972 4092 
-Q 1497 4750 2381 4750 
-Q 2619 4750 2861 4703 
-Q 3103 4656 3366 4563 
-z
-" transform="scale(0.015625)"/>
-     </defs>
-     <use xlink:href="#DejaVuSans-28"/>
-     <use xlink:href="#DejaVuSans-78" x="39.013672"/>
-     <use xlink:href="#DejaVuSans-33" x="98.193359"/>
-     <use xlink:href="#DejaVuSans-2e" x="161.816406"/>
-     <use xlink:href="#DejaVuSans-36" x="193.603516"/>
-     <use xlink:href="#DejaVuSans-29" x="257.226562"/>
-    </g>
-   </g>
-   <g id="text_14">
-    <!-- 1.35 -->
-    <g transform="translate(292.747284 121.402668)scale(0.1 -0.1)">
-     <use xlink:href="#DejaVuSans-31"/>
-     <use xlink:href="#DejaVuSans-2e" x="63.623047"/>
-     <use xlink:href="#DejaVuSans-33" x="95.410156"/>
-     <use xlink:href="#DejaVuSans-35" x="159.033203"/>
-    </g>
-    <!-- (x2.2) -->
-    <g transform="translate(289.067596 132.600481)scale(0.1 -0.1)">
-     <use xlink:href="#DejaVuSans-28"/>
-     <use xlink:href="#DejaVuSans-78" x="39.013672"/>
-     <use xlink:href="#DejaVuSans-32" x="98.193359"/>
-     <use xlink:href="#DejaVuSans-2e" x="161.816406"/>
-     <use xlink:href="#DejaVuSans-32" x="193.603516"/>
-     <use xlink:href="#DejaVuSans-29" x="257.226562"/>
-    </g>
-   </g>
-   <g id="text_15">
-    <!-- 2.26 -->
-    <g transform="translate(537.334463 57.927429)scale(0.1 -0.1)">
-     <use xlink:href="#DejaVuSans-32"/>
-     <use xlink:href="#DejaVuSans-2e" x="63.623047"/>
-     <use xlink:href="#DejaVuSans-32" x="95.410156"/>
-     <use xlink:href="#DejaVuSans-36" x="159.033203"/>
-    </g>
-    <!-- (x4.8) -->
-    <g transform="translate(533.654776 69.125241)scale(0.1 -0.1)">
-     <defs>
-      <path id="DejaVuSans-34" d="M 2419 4116 
-L 825 1625 
-L 2419 1625 
-L 2419 4116 
-z
-M 2253 4666 
-L 3047 4666 
-L 3047 1625 
-L 3713 1625 
-L 3713 1100 
-L 3047 1100 
-L 3047 0 
-L 2419 0 
-L 2419 1100 
-L 313 1100 
-L 313 1709 
-L 2253 4666 
-z
-" transform="scale(0.015625)"/>
-      <path id="DejaVuSans-38" d="M 2034 2216 
-Q 1584 2216 1326 1975 
-Q 1069 1734 1069 1313 
-Q 1069 891 1326 650 
-Q 1584 409 2034 409 
-Q 2484 409 2743 651 
-Q 3003 894 3003 1313 
-Q 3003 1734 2745 1975 
-Q 2488 2216 2034 2216 
-z
-M 1403 2484 
-Q 997 2584 770 2862 
-Q 544 3141 544 3541 
-Q 544 4100 942 4425 
-Q 1341 4750 2034 4750 
-Q 2731 4750 3128 4425 
-Q 3525 4100 3525 3541 
-Q 3525 3141 3298 2862 
-Q 3072 2584 2669 2484 
-Q 3125 2378 3379 2068 
-Q 3634 1759 3634 1313 
-Q 3634 634 3220 271 
-Q 2806 -91 2034 -91 
-Q 1263 -91 848 271 
-Q 434 634 434 1313 
-Q 434 1759 690 2068 
-Q 947 2378 1403 2484 
-z
-M 1172 3481 
-Q 1172 3119 1398 2916 
-Q 1625 2713 2034 2713 
-Q 2441 2713 2670 2916 
-Q 2900 3119 2900 3481 
-Q 2900 3844 2670 4047 
-Q 2441 4250 2034 4250 
-Q 1625 4250 1398 4047 
-Q 1172 3844 1172 3481 
-z
-" transform="scale(0.015625)"/>
-     </defs>
-     <use xlink:href="#DejaVuSans-28"/>
-     <use xlink:href="#DejaVuSans-78" x="39.013672"/>
-     <use xlink:href="#DejaVuSans-34" x="98.193359"/>
-     <use xlink:href="#DejaVuSans-2e" x="161.816406"/>
-     <use xlink:href="#DejaVuSans-38" x="193.603516"/>
-     <use xlink:href="#DejaVuSans-29" x="257.226562"/>
-    </g>
-   </g>
-   <g id="text_16">
-    <!-- 1.34 -->
-    <g transform="translate(781.921643 121.936945)scale(0.1 -0.1)">
-     <use xlink:href="#DejaVuSans-31"/>
-     <use xlink:href="#DejaVuSans-2e" x="63.623047"/>
-     <use xlink:href="#DejaVuSans-33" x="95.410156"/>
-     <use xlink:href="#DejaVuSans-34" x="159.033203"/>
-    </g>
-    <!-- (x4.4) -->
-    <g transform="translate(778.241955 133.134758)scale(0.1 -0.1)">
-     <use xlink:href="#DejaVuSans-28"/>
-     <use xlink:href="#DejaVuSans-78" x="39.013672"/>
-     <use xlink:href="#DejaVuSans-34" x="98.193359"/>
-     <use xlink:href="#DejaVuSans-2e" x="161.816406"/>
-     <use xlink:href="#DejaVuSans-34" x="193.603516"/>
-     <use xlink:href="#DejaVuSans-29" x="257.226562"/>
-    </g>
-   </g>
-   <g id="text_17">
-    <!-- 12.73 -->
-    <g transform="translate(79.91988 42.176625)scale(0.1 -0.1)">
-     <use xlink:href="#DejaVuSans-31"/>
-     <use xlink:href="#DejaVuSans-32" x="63.623047"/>
-     <use xlink:href="#DejaVuSans-2e" x="127.246094"/>
-     <use xlink:href="#DejaVuSans-37" x="159.033203"/>
-     <use xlink:href="#DejaVuSans-33" x="222.65625"/>
-    </g>
-    <!-- (x13.7) -->
-    <g transform="translate(76.240192 53.374438)scale(0.1 -0.1)">
-     <use xlink:href="#DejaVuSans-28"/>
-     <use xlink:href="#DejaVuSans-78" x="39.013672"/>
-     <use xlink:href="#DejaVuSans-31" x="98.193359"/>
-     <use xlink:href="#DejaVuSans-33" x="161.816406"/>
-     <use xlink:href="#DejaVuSans-2e" x="225.439453"/>
-     <use xlink:href="#DejaVuSans-37" x="257.226562"/>
-     <use xlink:href="#DejaVuSans-29" x="320.849609"/>
-    </g>
-   </g>
-   <g id="text_18">
-    <!-- 1.80 -->
-    <g transform="translate(327.688309 90.045759)scale(0.1 -0.1)">
-     <use xlink:href="#DejaVuSans-31"/>
-     <use xlink:href="#DejaVuSans-2e" x="63.623047"/>
-     <use xlink:href="#DejaVuSans-38" x="95.410156"/>
-     <use xlink:href="#DejaVuSans-30" x="159.033203"/>
-    </g>
-    <!-- (x3.0) -->
-    <g transform="translate(324.008622 101.243572)scale(0.1 -0.1)">
-     <use xlink:href="#DejaVuSans-28"/>
-     <use xlink:href="#DejaVuSans-78" x="39.013672"/>
-     <use xlink:href="#DejaVuSans-33" x="98.193359"/>
-     <use xlink:href="#DejaVuSans-2e" x="161.816406"/>
-     <use xlink:href="#DejaVuSans-30" x="193.603516"/>
-     <use xlink:href="#DejaVuSans-29" x="257.226562"/>
-    </g>
-   </g>
-   <g id="text_19">
-    <!-- 10.64 -->
-    <g transform="translate(569.094239 42.176625)scale(0.1 -0.1)">
-     <use xlink:href="#DejaVuSans-31"/>
-     <use xlink:href="#DejaVuSans-30" x="63.623047"/>
-     <use xlink:href="#DejaVuSans-2e" x="127.246094"/>
-     <use xlink:href="#DejaVuSans-36" x="159.033203"/>
-     <use xlink:href="#DejaVuSans-34" x="222.65625"/>
-    </g>
-    <!-- (x22.5) -->
-    <g transform="translate(565.414551 53.374438)scale(0.1 -0.1)">
-     <use xlink:href="#DejaVuSans-28"/>
-     <use xlink:href="#DejaVuSans-78" x="39.013672"/>
-     <use xlink:href="#DejaVuSans-32" x="98.193359"/>
-     <use xlink:href="#DejaVuSans-32" x="161.816406"/>
-     <use xlink:href="#DejaVuSans-2e" x="225.439453"/>
-     <use xlink:href="#DejaVuSans-35" x="257.226562"/>
-     <use xlink:href="#DejaVuSans-29" x="320.849609"/>
-    </g>
-   </g>
-   <g id="text_20">
-    <!-- 3.06 -->
-    <g style="fill: #ffffff" transform="translate(816.862668 42.176625)scale(0.1 -0.1)">
-     <use xlink:href="#DejaVuSans-33"/>
-     <use xlink:href="#DejaVuSans-2e" x="63.623047"/>
-     <use xlink:href="#DejaVuSans-30" x="95.410156"/>
-     <use xlink:href="#DejaVuSans-36" x="159.033203"/>
-    </g>
-    <!-- (x10.1) -->
-    <g style="fill: #ffffff" transform="translate(810.001731 53.374438)scale(0.1 -0.1)">
-     <use xlink:href="#DejaVuSans-28"/>
-     <use xlink:href="#DejaVuSans-78" x="39.013672"/>
-     <use xlink:href="#DejaVuSans-31" x="98.193359"/>
-     <use xlink:href="#DejaVuSans-30" x="161.816406"/>
-     <use xlink:href="#DejaVuSans-2e" x="225.439453"/>
-     <use xlink:href="#DejaVuSans-31" x="257.226562"/>
-     <use xlink:href="#DejaVuSans-29" x="320.849609"/>
-    </g>
-   </g>
-   <g id="text_21">
-    <!-- 0.97 -->
-    <g transform="translate(118.042155 148.174388)scale(0.1 -0.1)">
-     <defs>
-      <path id="DejaVuSans-39" d="M 703 97 
-L 703 672 
-Q 941 559 1184 500 
-Q 1428 441 1663 441 
-Q 2288 441 2617 861 
-Q 2947 1281 2994 2138 
-Q 2813 1869 2534 1725 
-Q 2256 1581 1919 1581 
-Q 1219 1581 811 2004 
-Q 403 2428 403 3163 
-Q 403 3881 828 4315 
-Q 1253 4750 1959 4750 
-Q 2769 4750 3195 4129 
-Q 3622 3509 3622 2328 
-Q 3622 1225 3098 567 
-Q 2575 -91 1691 -91 
-Q 1453 -91 1209 -44 
-Q 966 3 703 97 
-z
-M 1959 2075 
-Q 2384 2075 2632 2365 
-Q 2881 2656 2881 3163 
-Q 2881 3666 2632 3958 
-Q 2384 4250 1959 4250 
-Q 1534 4250 1286 3958 
-Q 1038 3666 1038 3163 
-Q 1038 2656 1286 2365 
-Q 1534 2075 1959 2075 
-z
-" transform="scale(0.015625)"/>
-     </defs>
-     <use xlink:href="#DejaVuSans-30"/>
-     <use xlink:href="#DejaVuSans-2e" x="63.623047"/>
-     <use xlink:href="#DejaVuSans-39" x="95.410156"/>
-     <use xlink:href="#DejaVuSans-37" x="159.033203"/>
-    </g>
-    <!-- (x1.0) -->
-    <g transform="translate(114.362468 159.3722)scale(0.1 -0.1)">
-     <use xlink:href="#DejaVuSans-28"/>
-     <use xlink:href="#DejaVuSans-78" x="39.013672"/>
-     <use xlink:href="#DejaVuSans-31" x="98.193359"/>
-     <use xlink:href="#DejaVuSans-2e" x="161.816406"/>
-     <use xlink:href="#DejaVuSans-30" x="193.603516"/>
-     <use xlink:href="#DejaVuSans-29" x="257.226562"/>
-    </g>
-   </g>
-   <g id="text_22">
-    <!-- 0.97 -->
-    <g transform="translate(362.629335 147.955283)scale(0.1 -0.1)">
-     <use xlink:href="#DejaVuSans-30"/>
-     <use xlink:href="#DejaVuSans-2e" x="63.623047"/>
-     <use xlink:href="#DejaVuSans-39" x="95.410156"/>
-     <use xlink:href="#DejaVuSans-37" x="159.033203"/>
-    </g>
-    <!-- (x1.6) -->
-    <g transform="translate(358.949647 159.153096)scale(0.1 -0.1)">
-     <use xlink:href="#DejaVuSans-28"/>
-     <use xlink:href="#DejaVuSans-78" x="39.013672"/>
-     <use xlink:href="#DejaVuSans-31" x="98.193359"/>
-     <use xlink:href="#DejaVuSans-2e" x="161.816406"/>
-     <use xlink:href="#DejaVuSans-36" x="193.603516"/>
-     <use xlink:href="#DejaVuSans-29" x="257.226562"/>
-    </g>
-   </g>
-   <g id="text_23">
-    <!-- 0.62 -->
-    <g transform="translate(607.216514 172.048701)scale(0.1 -0.1)">
-     <use xlink:href="#DejaVuSans-30"/>
-     <use xlink:href="#DejaVuSans-2e" x="63.623047"/>
-     <use xlink:href="#DejaVuSans-36" x="95.410156"/>
-     <use xlink:href="#DejaVuSans-32" x="159.033203"/>
-    </g>
-    <!-- (x1.3) -->
-    <g transform="translate(603.536827 183.246513)scale(0.1 -0.1)">
-     <use xlink:href="#DejaVuSans-28"/>
-     <use xlink:href="#DejaVuSans-78" x="39.013672"/>
-     <use xlink:href="#DejaVuSans-31" x="98.193359"/>
-     <use xlink:href="#DejaVuSans-2e" x="161.816406"/>
-     <use xlink:href="#DejaVuSans-33" x="193.603516"/>
-     <use xlink:href="#DejaVuSans-29" x="257.226562"/>
-    </g>
-   </g>
-   <g id="text_24">
-    <!-- 0.63 -->
-    <g transform="translate(851.803694 171.941261)scale(0.1 -0.1)">
-     <use xlink:href="#DejaVuSans-30"/>
-     <use xlink:href="#DejaVuSans-2e" x="63.623047"/>
-     <use xlink:href="#DejaVuSans-36" x="95.410156"/>
-     <use xlink:href="#DejaVuSans-33" x="159.033203"/>
-    </g>
-    <!-- (x2.1) -->
-    <g transform="translate(848.124006 183.139074)scale(0.1 -0.1)">
-     <use xlink:href="#DejaVuSans-28"/>
-     <use xlink:href="#DejaVuSans-78" x="39.013672"/>
-     <use xlink:href="#DejaVuSans-32" x="98.193359"/>
-     <use xlink:href="#DejaVuSans-2e" x="161.816406"/>
-     <use xlink:href="#DejaVuSans-31" x="193.603516"/>
-     <use xlink:href="#DejaVuSans-29" x="257.226562"/>
-    </g>
-   </g>
-   <g id="text_25">
-    <!-- 1.02 -->
-    <g transform="translate(152.983181 144.707906)scale(0.1 -0.1)">
-     <use xlink:href="#DejaVuSans-31"/>
-     <use xlink:href="#DejaVuSans-2e" x="63.623047"/>
-     <use xlink:href="#DejaVuSans-30" x="95.410156"/>
-     <use xlink:href="#DejaVuSans-32" x="159.033203"/>
-    </g>
-    <!-- (x1.1) -->
-    <g transform="translate(149.303494 155.905718)scale(0.1 -0.1)">
-     <use xlink:href="#DejaVuSans-28"/>
-     <use xlink:href="#DejaVuSans-78" x="39.013672"/>
-     <use xlink:href="#DejaVuSans-31" x="98.193359"/>
-     <use xlink:href="#DejaVuSans-2e" x="161.816406"/>
-     <use xlink:href="#DejaVuSans-31" x="193.603516"/>
-     <use xlink:href="#DejaVuSans-29" x="257.226562"/>
-    </g>
-   </g>
-   <g id="text_26">
-    <!-- 0.68 -->
-    <g transform="translate(397.570361 168.017954)scale(0.1 -0.1)">
-     <use xlink:href="#DejaVuSans-30"/>
-     <use xlink:href="#DejaVuSans-2e" x="63.623047"/>
-     <use xlink:href="#DejaVuSans-36" x="95.410156"/>
-     <use xlink:href="#DejaVuSans-38" x="159.033203"/>
-    </g>
-    <!-- (x1.1) -->
-    <g transform="translate(393.890673 179.215766)scale(0.1 -0.1)">
-     <use xlink:href="#DejaVuSans-28"/>
-     <use xlink:href="#DejaVuSans-78" x="39.013672"/>
-     <use xlink:href="#DejaVuSans-31" x="98.193359"/>
-     <use xlink:href="#DejaVuSans-2e" x="161.816406"/>
-     <use xlink:href="#DejaVuSans-31" x="193.603516"/>
-     <use xlink:href="#DejaVuSans-29" x="257.226562"/>
-    </g>
-   </g>
-   <g id="text_27">
-    <!-- 0.33 -->
-    <g transform="translate(642.15754 192.755458)scale(0.1 -0.1)">
-     <use xlink:href="#DejaVuSans-30"/>
-     <use xlink:href="#DejaVuSans-2e" x="63.623047"/>
-     <use xlink:href="#DejaVuSans-33" x="95.410156"/>
-     <use xlink:href="#DejaVuSans-33" x="159.033203"/>
-    </g>
-    <!-- (x0.7) -->
-    <g transform="translate(638.477853 203.953271)scale(0.1 -0.1)">
-     <use xlink:href="#DejaVuSans-28"/>
-     <use xlink:href="#DejaVuSans-78" x="39.013672"/>
-     <use xlink:href="#DejaVuSans-30" x="98.193359"/>
-     <use xlink:href="#DejaVuSans-2e" x="161.816406"/>
-     <use xlink:href="#DejaVuSans-37" x="193.603516"/>
-     <use xlink:href="#DejaVuSans-29" x="257.226562"/>
-    </g>
-   </g>
-   <g id="text_28">
-    <!-- 0.21 -->
-    <g transform="translate(886.74472 200.873771)scale(0.1 -0.1)">
-     <use xlink:href="#DejaVuSans-30"/>
-     <use xlink:href="#DejaVuSans-2e" x="63.623047"/>
-     <use xlink:href="#DejaVuSans-32" x="95.410156"/>
-     <use xlink:href="#DejaVuSans-31" x="159.033203"/>
-    </g>
-    <!-- (x0.7) -->
-    <g transform="translate(883.065032 212.071583)scale(0.1 -0.1)">
-     <use xlink:href="#DejaVuSans-28"/>
-     <use xlink:href="#DejaVuSans-78" x="39.013672"/>
-     <use xlink:href="#DejaVuSans-30" x="98.193359"/>
-     <use xlink:href="#DejaVuSans-2e" x="161.816406"/>
-     <use xlink:href="#DejaVuSans-37" x="193.603516"/>
-     <use xlink:href="#DejaVuSans-29" x="257.226562"/>
-    </g>
-   </g>
-   <g id="text_29">
-    <!-- 0.93 -->
-    <g transform="translate(187.924207 165.090885)scale(0.1 -0.1)">
-     <use xlink:href="#DejaVuSans-30"/>
-     <use xlink:href="#DejaVuSans-2e" x="63.623047"/>
-     <use xlink:href="#DejaVuSans-39" x="95.410156"/>
-     <use xlink:href="#DejaVuSans-33" x="159.033203"/>
-    </g>
-   </g>
-   <g id="text_30">
-    <!-- 0.61 -->
-    <g transform="translate(432.511386 187.53142)scale(0.1 -0.1)">
-     <use xlink:href="#DejaVuSans-30"/>
-     <use xlink:href="#DejaVuSans-2e" x="63.623047"/>
-     <use xlink:href="#DejaVuSans-36" x="95.410156"/>
-     <use xlink:href="#DejaVuSans-31" x="159.033203"/>
-    </g>
-   </g>
-   <g id="text_31">
-    <!-- 0.47 -->
-    <g transform="translate(677.098566 196.736008)scale(0.1 -0.1)">
-     <use xlink:href="#DejaVuSans-30"/>
-     <use xlink:href="#DejaVuSans-2e" x="63.623047"/>
-     <use xlink:href="#DejaVuSans-34" x="95.410156"/>
-     <use xlink:href="#DejaVuSans-37" x="159.033203"/>
-    </g>
-   </g>
-   <g id="text_32">
-    <!-- 0.30 -->
-    <g transform="translate(921.685745 208.577835)scale(0.1 -0.1)">
-     <use xlink:href="#DejaVuSans-30"/>
-     <use xlink:href="#DejaVuSans-2e" x="63.623047"/>
-     <use xlink:href="#DejaVuSans-33" x="95.410156"/>
-     <use xlink:href="#DejaVuSans-30" x="159.033203"/>
-    </g>
-   </g>
-   <g id="text_33">
-    <!-- 0.92 -->
-    <g transform="translate(222.865232 151.441665)scale(0.1 -0.1)">
-     <use xlink:href="#DejaVuSans-30"/>
-     <use xlink:href="#DejaVuSans-2e" x="63.623047"/>
-     <use xlink:href="#DejaVuSans-39" x="95.410156"/>
-     <use xlink:href="#DejaVuSans-32" x="159.033203"/>
-    </g>
-    <!-- (x1.0) -->
-    <g transform="translate(219.185545 162.639477)scale(0.1 -0.1)">
-     <use xlink:href="#DejaVuSans-28"/>
-     <use xlink:href="#DejaVuSans-78" x="39.013672"/>
-     <use xlink:href="#DejaVuSans-31" x="98.193359"/>
-     <use xlink:href="#DejaVuSans-2e" x="161.816406"/>
-     <use xlink:href="#DejaVuSans-30" x="193.603516"/>
-     <use xlink:href="#DejaVuSans-29" x="257.226562"/>
-    </g>
-   </g>
-   <g id="text_34">
-    <!-- 0.92 -->
-    <g transform="translate(467.452412 151.364162)scale(0.1 -0.1)">
-     <use xlink:href="#DejaVuSans-30"/>
-     <use xlink:href="#DejaVuSans-2e" x="63.623047"/>
-     <use xlink:href="#DejaVuSans-39" x="95.410156"/>
-     <use xlink:href="#DejaVuSans-32" x="159.033203"/>
-    </g>
-    <!-- (x1.5) -->
-    <g transform="translate(463.772724 162.561974)scale(0.1 -0.1)">
-     <use xlink:href="#DejaVuSans-28"/>
-     <use xlink:href="#DejaVuSans-78" x="39.013672"/>
-     <use xlink:href="#DejaVuSans-31" x="98.193359"/>
-     <use xlink:href="#DejaVuSans-2e" x="161.816406"/>
-     <use xlink:href="#DejaVuSans-35" x="193.603516"/>
-     <use xlink:href="#DejaVuSans-29" x="257.226562"/>
-    </g>
-   </g>
-   <g id="text_35">
-    <!-- 0.82 -->
-    <g transform="translate(712.039591 158.640304)scale(0.1 -0.1)">
-     <use xlink:href="#DejaVuSans-30"/>
-     <use xlink:href="#DejaVuSans-2e" x="63.623047"/>
-     <use xlink:href="#DejaVuSans-38" x="95.410156"/>
-     <use xlink:href="#DejaVuSans-32" x="159.033203"/>
-    </g>
-    <!-- (x1.7) -->
-    <g transform="translate(708.359904 169.838116)scale(0.1 -0.1)">
-     <use xlink:href="#DejaVuSans-28"/>
-     <use xlink:href="#DejaVuSans-78" x="39.013672"/>
-     <use xlink:href="#DejaVuSans-31" x="98.193359"/>
-     <use xlink:href="#DejaVuSans-2e" x="161.816406"/>
-     <use xlink:href="#DejaVuSans-37" x="193.603516"/>
-     <use xlink:href="#DejaVuSans-29" x="257.226562"/>
-    </g>
-   </g>
-   <g id="text_36">
-    <!-- 0.82 -->
-    <g transform="translate(956.626771 158.620964)scale(0.1 -0.1)">
-     <use xlink:href="#DejaVuSans-30"/>
-     <use xlink:href="#DejaVuSans-2e" x="63.623047"/>
-     <use xlink:href="#DejaVuSans-38" x="95.410156"/>
-     <use xlink:href="#DejaVuSans-32" x="159.033203"/>
-    </g>
-    <!-- (x2.7) -->
-    <g transform="translate(952.947083 169.818777)scale(0.1 -0.1)">
-     <use xlink:href="#DejaVuSans-28"/>
-     <use xlink:href="#DejaVuSans-78" x="39.013672"/>
-     <use xlink:href="#DejaVuSans-32" x="98.193359"/>
-     <use xlink:href="#DejaVuSans-2e" x="161.816406"/>
-     <use xlink:href="#DejaVuSans-37" x="193.603516"/>
-     <use xlink:href="#DejaVuSans-29" x="257.226562"/>
-    </g>
-   </g>
-   <g id="text_37">
-    <!-- Runtime performance -->
-    <g transform="translate(448.132812 9.118125)scale(0.12 -0.12)">
-     <defs>
-      <path id="DejaVuSans-52" d="M 2841 2188 
-Q 3044 2119 3236 1894 
-Q 3428 1669 3622 1275 
-L 4263 0 
-L 3584 0 
-L 2988 1197 
-Q 2756 1666 2539 1819 
-Q 2322 1972 1947 1972 
-L 1259 1972 
-L 1259 0 
-L 628 0 
-L 628 4666 
-L 2053 4666 
-Q 2853 4666 3247 4331 
-Q 3641 3997 3641 3322 
-Q 3641 2881 3436 2590 
-Q 3231 2300 2841 2188 
-z
-M 1259 4147 
-L 1259 2491 
-L 2053 2491 
-Q 2509 2491 2742 2702 
-Q 2975 2913 2975 3322 
-Q 2975 3731 2742 3939 
-Q 2509 4147 2053 4147 
-L 1259 4147 
-z
-" transform="scale(0.015625)"/>
-      <path id="DejaVuSans-72" d="M 2631 2963 
-Q 2534 3019 2420 3045 
-Q 2306 3072 2169 3072 
-Q 1681 3072 1420 2755 
-Q 1159 2438 1159 1844 
-L 1159 0 
-L 581 0 
-L 581 3500 
-L 1159 3500 
-L 1159 2956 
-Q 1341 3275 1631 3429 
-Q 1922 3584 2338 3584 
-Q 2397 3584 2469 3576 
-Q 2541 3569 2628 3553 
-L 2631 2963 
-z
-" transform="scale(0.015625)"/>
-     </defs>
-     <use xlink:href="#DejaVuSans-52"/>
-     <use xlink:href="#DejaVuSans-75" x="64.982422"/>
-     <use xlink:href="#DejaVuSans-6e" x="128.361328"/>
-     <use xlink:href="#DejaVuSans-74" x="191.740234"/>
-     <use xlink:href="#DejaVuSans-69" x="230.949219"/>
-     <use xlink:href="#DejaVuSans-6d" x="258.732422"/>
-     <use xlink:href="#DejaVuSans-65" x="356.144531"/>
-     <use xlink:href="#DejaVuSans-20" x="417.667969"/>
-     <use xlink:href="#DejaVuSans-70" x="449.455078"/>
-     <use xlink:href="#DejaVuSans-65" x="512.931641"/>
-     <use xlink:href="#DejaVuSans-72" x="574.455078"/>
-     <use xlink:href="#DejaVuSans-66" x="615.568359"/>
-     <use xlink:href="#DejaVuSans-6f" x="650.773438"/>
-     <use xlink:href="#DejaVuSans-72" x="711.955078"/>
-     <use xlink:href="#DejaVuSans-6d" x="751.318359"/>
-     <use xlink:href="#DejaVuSans-61" x="848.730469"/>
-     <use xlink:href="#DejaVuSans-6e" x="910.009766"/>
-     <use xlink:href="#DejaVuSans-63" x="973.388672"/>
-     <use xlink:href="#DejaVuSans-65" x="1028.369141"/>
-    </g>
-   </g>
-   <g id="legend_1">
-    <g id="patch_33">
-     <path d="M 885.4025 111.186875 
-L 983.47125 111.186875 
-Q 985.47125 111.186875 985.47125 109.186875 
-L 985.47125 22.118125 
-Q 985.47125 20.118125 983.47125 20.118125 
-L 885.4025 20.118125 
-Q 883.4025 20.118125 883.4025 22.118125 
-L 883.4025 109.186875 
-Q 883.4025 111.186875 885.4025 111.186875 
-z
-" style="fill: #ffffff; opacity: 0.8; stroke: #cccccc; stroke-linejoin: miter"/>
-    </g>
-    <g id="patch_34">
-     <path d="M 887.4025 31.716563 
-L 907.4025 31.716563 
-L 907.4025 24.716563 
-L 887.4025 24.716563 
-z
-" style="fill: #ff7f0e; stroke: #000000; stroke-linejoin: miter"/>
-    </g>
-    <g id="text_38">
-     <!-- Boost.Python -->
-     <g transform="translate(915.4025 31.716563)scale(0.1 -0.1)">
-      <defs>
-       <path id="DejaVuSans-42" d="M 1259 2228 
-L 1259 519 
-L 2272 519 
-Q 2781 519 3026 730 
-Q 3272 941 3272 1375 
-Q 3272 1813 3026 2020 
-Q 2781 2228 2272 2228 
-L 1259 2228 
-z
-M 1259 4147 
-L 1259 2741 
-L 2194 2741 
-Q 2656 2741 2882 2914 
-Q 3109 3088 3109 3444 
-Q 3109 3797 2882 3972 
-Q 2656 4147 2194 4147 
-L 1259 4147 
-z
-M 628 4666 
-L 2241 4666 
-Q 2963 4666 3353 4366 
-Q 3744 4066 3744 3513 
-Q 3744 3084 3544 2831 
-Q 3344 2578 2956 2516 
-Q 3422 2416 3680 2098 
-Q 3938 1781 3938 1306 
-Q 3938 681 3513 340 
-Q 3088 0 2303 0 
-L 628 0 
-L 628 4666 
-z
-" transform="scale(0.015625)"/>
-       <path id="DejaVuSans-50" d="M 1259 4147 
-L 1259 2394 
-L 2053 2394 
-Q 2494 2394 2734 2622 
-Q 2975 2850 2975 3272 
-Q 2975 3691 2734 3919 
-Q 2494 4147 2053 4147 
-L 1259 4147 
-z
-M 628 4666 
-L 2053 4666 
-Q 2838 4666 3239 4311 
-Q 3641 3956 3641 3272 
-Q 3641 2581 3239 2228 
-Q 2838 1875 2053 1875 
-L 1259 1875 
-L 1259 0 
-L 628 0 
-L 628 4666 
-z
-" transform="scale(0.015625)"/>
-       <path id="DejaVuSans-79" d="M 2059 -325 
-Q 1816 -950 1584 -1140 
-Q 1353 -1331 966 -1331 
-L 506 -1331 
-L 506 -850 
-L 844 -850 
-Q 1081 -850 1212 -737 
-Q 1344 -625 1503 -206 
-L 1606 56 
-L 191 3500 
-L 800 3500 
-L 1894 763 
-L 2988 3500 
-L 3597 3500 
-L 2059 -325 
-z
-" transform="scale(0.015625)"/>
-       <path id="DejaVuSans-68" d="M 3513 2113 
-L 3513 0 
-L 2938 0 
-L 2938 2094 
-Q 2938 2591 2744 2837 
-Q 2550 3084 2163 3084 
-Q 1697 3084 1428 2787 
-Q 1159 2491 1159 1978 
-L 1159 0 
-L 581 0 
-L 581 4863 
-L 1159 4863 
-L 1159 2956 
-Q 1366 3272 1645 3428 
-Q 1925 3584 2291 3584 
-Q 2894 3584 3203 3211 
-Q 3513 2838 3513 2113 
-z
-" transform="scale(0.015625)"/>
-      </defs>
-      <use xlink:href="#DejaVuSans-42"/>
-      <use xlink:href="#DejaVuSans-6f" x="68.603516"/>
-      <use xlink:href="#DejaVuSans-6f" x="129.785156"/>
-      <use xlink:href="#DejaVuSans-73" x="190.966797"/>
-      <use xlink:href="#DejaVuSans-74" x="243.066406"/>
-      <use xlink:href="#DejaVuSans-2e" x="282.275391"/>
-      <use xlink:href="#DejaVuSans-50" x="314.0625"/>
-      <use xlink:href="#DejaVuSans-79" x="374.365234"/>
-      <use xlink:href="#DejaVuSans-74" x="433.544922"/>
-      <use xlink:href="#DejaVuSans-68" x="472.753906"/>
-      <use xlink:href="#DejaVuSans-6f" x="536.132812"/>
-      <use xlink:href="#DejaVuSans-6e" x="597.314453"/>
-     </g>
-    </g>
-    <g id="patch_35">
-     <path d="M 887.4025 46.394688 
-L 907.4025 46.394688 
-L 907.4025 39.394688 
-L 887.4025 39.394688 
-z
-" style="fill: #d62728; stroke: #000000; stroke-linejoin: miter"/>
-    </g>
-    <g id="text_39">
-     <!-- pybind11 -->
-     <g transform="translate(915.4025 46.394688)scale(0.1 -0.1)">
-      <use xlink:href="#DejaVuSans-70"/>
-      <use xlink:href="#DejaVuSans-79" x="63.476562"/>
-      <use xlink:href="#DejaVuSans-62" x="122.65625"/>
-      <use xlink:href="#DejaVuSans-69" x="186.132812"/>
-      <use xlink:href="#DejaVuSans-6e" x="213.916016"/>
-      <use xlink:href="#DejaVuSans-64" x="277.294922"/>
-      <use xlink:href="#DejaVuSans-31" x="340.771484"/>
-      <use xlink:href="#DejaVuSans-31" x="404.394531"/>
-     </g>
-    </g>
-    <g id="patch_36">
-     <path d="M 887.4025 61.072813 
-L 907.4025 61.072813 
-L 907.4025 54.072813 
-L 887.4025 54.072813 
-z
-" style="fill: #bcbd22; stroke: #000000; stroke-linejoin: miter"/>
-    </g>
-    <g id="text_40">
-     <!-- cppyy -->
-     <g transform="translate(915.4025 61.072813)scale(0.1 -0.1)">
-      <use xlink:href="#DejaVuSans-63"/>
-      <use xlink:href="#DejaVuSans-70" x="54.980469"/>
-      <use xlink:href="#DejaVuSans-70" x="118.457031"/>
-      <use xlink:href="#DejaVuSans-79" x="181.933594"/>
-      <use xlink:href="#DejaVuSans-79" x="241.113281"/>
-     </g>
-    </g>
-    <g id="patch_37">
-     <path d="M 887.4025 75.750938 
-L 907.4025 75.750938 
-L 907.4025 68.750938 
-L 887.4025 68.750938 
-z
-" style="fill: #9467bd; stroke: #000000; stroke-linejoin: miter"/>
-    </g>
-    <g id="text_41">
-     <!-- Cython -->
-     <g transform="translate(915.4025 75.750938)scale(0.1 -0.1)">
-      <defs>
-       <path id="DejaVuSans-43" d="M 4122 4306 
-L 4122 3641 
-Q 3803 3938 3442 4084 
-Q 3081 4231 2675 4231 
-Q 1875 4231 1450 3742 
-Q 1025 3253 1025 2328 
-Q 1025 1406 1450 917 
-Q 1875 428 2675 428 
-Q 3081 428 3442 575 
-Q 3803 722 4122 1019 
-L 4122 359 
-Q 3791 134 3420 21 
-Q 3050 -91 2638 -91 
-Q 1578 -91 968 557 
-Q 359 1206 359 2328 
-Q 359 3453 968 4101 
-Q 1578 4750 2638 4750 
-Q 3056 4750 3426 4639 
-Q 3797 4528 4122 4306 
-z
-" transform="scale(0.015625)"/>
-      </defs>
-      <use xlink:href="#DejaVuSans-43"/>
-      <use xlink:href="#DejaVuSans-79" x="69.824219"/>
-      <use xlink:href="#DejaVuSans-74" x="129.003906"/>
-      <use xlink:href="#DejaVuSans-68" x="168.212891"/>
-      <use xlink:href="#DejaVuSans-6f" x="231.591797"/>
-      <use xlink:href="#DejaVuSans-6e" x="292.773438"/>
-     </g>
-    </g>
-    <g id="patch_38">
-     <path d="M 887.4025 90.429063 
-L 907.4025 90.429063 
-L 907.4025 83.429063 
-L 887.4025 83.429063 
-z
-" style="fill: #1f77b4; stroke: #000000; stroke-linejoin: miter"/>
-    </g>
-    <g id="text_42">
-     <!-- nanobind -->
-     <g transform="translate(915.4025 90.429063)scale(0.1 -0.1)">
-      <use xlink:href="#DejaVuSans-6e"/>
-      <use xlink:href="#DejaVuSans-61" x="63.378906"/>
-      <use xlink:href="#DejaVuSans-6e" x="124.658203"/>
-      <use xlink:href="#DejaVuSans-6f" x="188.037109"/>
-      <use xlink:href="#DejaVuSans-62" x="249.21875"/>
-      <use xlink:href="#DejaVuSans-69" x="312.695312"/>
-      <use xlink:href="#DejaVuSans-6e" x="340.478516"/>
-      <use xlink:href="#DejaVuSans-64" x="403.857422"/>
-     </g>
-    </g>
-    <g id="patch_39">
-     <path d="M 887.4025 105.107188 
-L 907.4025 105.107188 
-L 907.4025 98.107188 
-L 887.4025 98.107188 
-z
-" style="fill: url(#h19bdc7308c); stroke: #ffffff; stroke-linejoin: miter"/>
-    </g>
-    <g id="text_43">
-     <!-- Python -->
-     <g transform="translate(915.4025 105.107188)scale(0.1 -0.1)">
-      <use xlink:href="#DejaVuSans-50"/>
-      <use xlink:href="#DejaVuSans-79" x="60.302734"/>
-      <use xlink:href="#DejaVuSans-74" x="119.482422"/>
-      <use xlink:href="#DejaVuSans-68" x="158.691406"/>
-      <use xlink:href="#DejaVuSans-6f" x="222.070312"/>
-      <use xlink:href="#DejaVuSans-6e" x="283.251953"/>
-     </g>
-    </g>
-   </g>
-  </g>
- </g>
- <defs>
-  <clipPath id="pc453d5dc25">
-   <rect x="36.58125" y="15.118125" width="953.89" height="216.68"/>
-  </clipPath>
- </defs>
- <defs>
-  <pattern id="h19bdc7308c" patternUnits="userSpaceOnUse" x="0" y="0" width="72" height="72">
-   <rect x="0" y="0" width="73" height="73" fill="#7f7f7f"/>
-   <path d="M -36 36 
-L 36 -36 
-M -24 48 
-L 48 -24 
-M -12 60 
-L 60 -12 
-M 0 72 
-L 72 0 
-M 12 84 
-L 84 12 
-M 24 96 
-L 96 24 
-M 36 108 
-L 108 36 
-" style="fill: #ffffff; stroke: #ffffff; stroke-width: 5.0; stroke-linecap: butt; stroke-linejoin: miter"/>
-  </pattern>
- </defs>
-</svg>
diff --git a/src/nanobind/docs/images/sizes.svg b/src/nanobind/docs/images/sizes.svg
deleted file mode 100644
index 4ad568b..0000000
--- a/src/nanobind/docs/images/sizes.svg
+++ /dev/null
@@ -1,1909 +0,0 @@
-<?xml version="1.0" encoding="utf-8" standalone="no"?>
-<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN"
-  "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd">
-<svg xmlns:xlink="http://www.w3.org/1999/xlink" width="868.97125pt" height="216.07625pt" viewBox="0 0 868.97125 216.07625" xmlns="http://www.w3.org/2000/svg" version="1.1">
- <metadata>
-  <rdf:RDF xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:cc="http://creativecommons.org/ns#" xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#">
-   <cc:Work>
-    <dc:type rdf:resource="http://purl.org/dc/dcmitype/StillImage"/>
-    <dc:date>2023-04-24T16:53:14.348990</dc:date>
-    <dc:format>image/svg+xml</dc:format>
-    <dc:creator>
-     <cc:Agent>
-      <dc:title>Matplotlib v3.5.1, https://matplotlib.org/</dc:title>
-     </cc:Agent>
-    </dc:creator>
-   </cc:Work>
-  </rdf:RDF>
- </metadata>
- <defs>
-  <style type="text/css">*{stroke-linejoin: round; stroke-linecap: butt}</style>
- </defs>
- <g id="figure_1">
-  <g id="patch_1">
-   <path d="M 0 216.07625 
-L 868.97125 216.07625 
-L 868.97125 0 
-L 0 0 
-z
-" style="fill: #ffffff"/>
-  </g>
-  <g id="axes_1">
-   <g id="patch_2">
-    <path d="M 36.58125 199.398125 
-L 868.97125 199.398125 
-L 868.97125 15.118125 
-L 36.58125 15.118125 
-z
-" style="fill: #ffffff"/>
-   </g>
-   <g id="patch_3">
-    <path d="M 43.695694 199.398125 
-L 79.267917 199.398125 
-L 79.267917 -778.449295 
-L 43.695694 -778.449295 
-z
-" clip-path="url(#p3e07c8c336)" style="fill: #ff7f0e; stroke: #000000; stroke-linejoin: miter"/>
-   </g>
-   <g id="patch_4">
-    <path d="M 257.129028 199.398125 
-L 292.70125 199.398125 
-L 292.70125 -2.215995 
-L 257.129028 -2.215995 
-z
-" clip-path="url(#p3e07c8c336)" style="fill: #ff7f0e; stroke: #000000; stroke-linejoin: miter"/>
-   </g>
-   <g id="patch_5">
-    <path d="M 470.562361 199.398125 
-L 506.134583 199.398125 
-L 506.134583 -1468.294183 
-L 470.562361 -1468.294183 
-z
-" clip-path="url(#p3e07c8c336)" style="fill: #ff7f0e; stroke: #000000; stroke-linejoin: miter"/>
-   </g>
-   <g id="patch_6">
-    <path d="M 683.995694 199.398125 
-L 719.567917 199.398125 
-L 719.567917 82.955295 
-L 683.995694 82.955295 
-z
-" clip-path="url(#p3e07c8c336)" style="fill: #ff7f0e; stroke: #000000; stroke-linejoin: miter"/>
-   </g>
-   <g id="patch_7">
-    <path d="M 79.267917 199.398125 
-L 114.840139 199.398125 
-L 114.840139 -989.720045 
-L 79.267917 -989.720045 
-z
-" clip-path="url(#p3e07c8c336)" style="fill: #d62728; stroke: #000000; stroke-linejoin: miter"/>
-   </g>
-   <g id="patch_8">
-    <path d="M 292.70125 199.398125 
-L 328.273472 199.398125 
-L 328.273472 131.700895 
-L 292.70125 131.700895 
-z
-" clip-path="url(#p3e07c8c336)" style="fill: #d62728; stroke: #000000; stroke-linejoin: miter"/>
-   </g>
-   <g id="patch_9">
-    <path d="M 506.134583 199.398125 
-L 541.706806 199.398125 
-L 541.706806 -1053.734854 
-L 506.134583 -1053.734854 
-z
-" clip-path="url(#p3e07c8c336)" style="fill: #d62728; stroke: #000000; stroke-linejoin: miter"/>
-   </g>
-   <g id="patch_10">
-    <path d="M 719.567917 199.398125 
-L 755.140139 199.398125 
-L 755.140139 158.80711 
-L 719.567917 158.80711 
-z
-" clip-path="url(#p3e07c8c336)" style="fill: #d62728; stroke: #000000; stroke-linejoin: miter"/>
-   </g>
-   <g id="patch_11">
-    <path d="M 114.840139 199.398125 
-L 150.412361 199.398125 
-L 150.412361 -990.362944 
-L 114.840139 -990.362944 
-z
-" clip-path="url(#p3e07c8c336)" style="fill: #8c564b; stroke: #000000; stroke-linejoin: miter"/>
-   </g>
-   <g id="patch_12">
-    <path d="M 328.273472 199.398125 
-L 363.845694 199.398125 
-L 363.845694 131.700895 
-L 328.273472 131.700895 
-z
-" clip-path="url(#p3e07c8c336)" style="fill: #8c564b; stroke: #000000; stroke-linejoin: miter"/>
-   </g>
-   <g id="patch_13">
-    <path d="M 541.706806 199.398125 
-L 577.279028 199.398125 
-L 577.279028 -1283.960157 
-L 541.706806 -1283.960157 
-z
-" clip-path="url(#p3e07c8c336)" style="fill: #8c564b; stroke: #000000; stroke-linejoin: miter"/>
-   </g>
-   <g id="patch_14">
-    <path d="M 755.140139 199.398125 
-L 790.712361 199.398125 
-L 790.712361 138.978069 
-L 755.140139 138.978069 
-z
-" clip-path="url(#p3e07c8c336)" style="fill: #8c564b; stroke: #000000; stroke-linejoin: miter"/>
-   </g>
-   <g id="patch_15">
-    <path d="M 150.412361 199.398125 
-L 185.984583 199.398125 
-L 185.984583 -17.324844 
-L 150.412361 -17.324844 
-z
-" clip-path="url(#p3e07c8c336)" style="fill: #9467bd; stroke: #000000; stroke-linejoin: miter"/>
-   </g>
-   <g id="patch_16">
-    <path d="M 363.845694 199.398125 
-L 399.417917 199.398125 
-L 399.417917 138.141936 
-L 363.845694 138.141936 
-z
-" clip-path="url(#p3e07c8c336)" style="fill: #9467bd; stroke: #000000; stroke-linejoin: miter"/>
-   </g>
-   <g id="patch_17">
-    <path d="M 577.279028 199.398125 
-L 612.85125 199.398125 
-L 612.85125 -354.232241 
-L 577.279028 -354.232241 
-z
-" clip-path="url(#p3e07c8c336)" style="fill: #9467bd; stroke: #000000; stroke-linejoin: miter"/>
-   </g>
-   <g id="patch_18">
-    <path d="M 790.712361 199.398125 
-L 826.284583 199.398125 
-L 826.284583 43.986138 
-L 790.712361 43.986138 
-z
-" clip-path="url(#p3e07c8c336)" style="fill: #9467bd; stroke: #000000; stroke-linejoin: miter"/>
-   </g>
-   <g id="patch_19">
-    <path d="M 185.984583 199.398125 
-L 221.556806 199.398125 
-L 221.556806 -325.250296 
-L 185.984583 -325.250296 
-z
-" clip-path="url(#p3e07c8c336)" style="fill: #1f77b4; stroke: #000000; stroke-linejoin: miter"/>
-   </g>
-   <g id="patch_20">
-    <path d="M 399.417917 199.398125 
-L 434.990139 199.398125 
-L 434.990139 180.969946 
-L 399.417917 180.969946 
-z
-" clip-path="url(#p3e07c8c336)" style="fill: #1f77b4; stroke: #000000; stroke-linejoin: miter"/>
-   </g>
-   <g id="patch_21">
-    <path d="M 612.85125 199.398125 
-L 648.423472 199.398125 
-L 648.423472 -219.294019 
-L 612.85125 -219.294019 
-z
-" clip-path="url(#p3e07c8c336)" style="fill: #1f77b4; stroke: #000000; stroke-linejoin: miter"/>
-   </g>
-   <g id="patch_22">
-    <path d="M 826.284583 199.398125 
-L 861.856806 199.398125 
-L 861.856806 186.949269 
-L 826.284583 186.949269 
-z
-" clip-path="url(#p3e07c8c336)" style="fill: #1f77b4; stroke: #000000; stroke-linejoin: miter"/>
-   </g>
-   <g id="patch_23">
-    <path d="M 15.237917 247.276543 
-L 228.67125 247.276543 
-L 228.67125 -1093.319148 
-L 15.237917 -1093.319148 
-z
-" clip-path="url(#p3e07c8c336)" style="fill: #ffffff; opacity: 0.8"/>
-   </g>
-   <g id="patch_24">
-    <path d="M 452.77625 247.276543 
-L 666.209583 247.276543 
-L 666.209583 -949.683896 
-L 452.77625 -949.683896 
-z
-" clip-path="url(#p3e07c8c336)" style="fill: #ffffff; opacity: 0.8"/>
-   </g>
-   <g id="matplotlib.axis_1">
-    <g id="xtick_1">
-     <g id="line2d_1">
-      <defs>
-       <path id="mb6a28bdaec" d="M 0 0 
-L 0 3.5 
-" style="stroke: #000000; stroke-width: 0.8"/>
-      </defs>
-      <g>
-       <use xlink:href="#mb6a28bdaec" x="132.62625" y="199.398125" style="stroke: #000000; stroke-width: 0.8"/>
-      </g>
-     </g>
-     <g id="text_1">
-      <!-- func [debug] -->
-      <g transform="translate(100.520781 213.996563)scale(0.1 -0.1)">
-       <defs>
-        <path id="DejaVuSans-66" d="M 2375 4863 
-L 2375 4384 
-L 1825 4384 
-Q 1516 4384 1395 4259 
-Q 1275 4134 1275 3809 
-L 1275 3500 
-L 2222 3500 
-L 2222 3053 
-L 1275 3053 
-L 1275 0 
-L 697 0 
-L 697 3053 
-L 147 3053 
-L 147 3500 
-L 697 3500 
-L 697 3744 
-Q 697 4328 969 4595 
-Q 1241 4863 1831 4863 
-L 2375 4863 
-z
-" transform="scale(0.015625)"/>
-        <path id="DejaVuSans-75" d="M 544 1381 
-L 544 3500 
-L 1119 3500 
-L 1119 1403 
-Q 1119 906 1312 657 
-Q 1506 409 1894 409 
-Q 2359 409 2629 706 
-Q 2900 1003 2900 1516 
-L 2900 3500 
-L 3475 3500 
-L 3475 0 
-L 2900 0 
-L 2900 538 
-Q 2691 219 2414 64 
-Q 2138 -91 1772 -91 
-Q 1169 -91 856 284 
-Q 544 659 544 1381 
-z
-M 1991 3584 
-L 1991 3584 
-z
-" transform="scale(0.015625)"/>
-        <path id="DejaVuSans-6e" d="M 3513 2113 
-L 3513 0 
-L 2938 0 
-L 2938 2094 
-Q 2938 2591 2744 2837 
-Q 2550 3084 2163 3084 
-Q 1697 3084 1428 2787 
-Q 1159 2491 1159 1978 
-L 1159 0 
-L 581 0 
-L 581 3500 
-L 1159 3500 
-L 1159 2956 
-Q 1366 3272 1645 3428 
-Q 1925 3584 2291 3584 
-Q 2894 3584 3203 3211 
-Q 3513 2838 3513 2113 
-z
-" transform="scale(0.015625)"/>
-        <path id="DejaVuSans-63" d="M 3122 3366 
-L 3122 2828 
-Q 2878 2963 2633 3030 
-Q 2388 3097 2138 3097 
-Q 1578 3097 1268 2742 
-Q 959 2388 959 1747 
-Q 959 1106 1268 751 
-Q 1578 397 2138 397 
-Q 2388 397 2633 464 
-Q 2878 531 3122 666 
-L 3122 134 
-Q 2881 22 2623 -34 
-Q 2366 -91 2075 -91 
-Q 1284 -91 818 406 
-Q 353 903 353 1747 
-Q 353 2603 823 3093 
-Q 1294 3584 2113 3584 
-Q 2378 3584 2631 3529 
-Q 2884 3475 3122 3366 
-z
-" transform="scale(0.015625)"/>
-        <path id="DejaVuSans-20" transform="scale(0.015625)"/>
-        <path id="DejaVuSans-5b" d="M 550 4863 
-L 1875 4863 
-L 1875 4416 
-L 1125 4416 
-L 1125 -397 
-L 1875 -397 
-L 1875 -844 
-L 550 -844 
-L 550 4863 
-z
-" transform="scale(0.015625)"/>
-        <path id="DejaVuSans-64" d="M 2906 2969 
-L 2906 4863 
-L 3481 4863 
-L 3481 0 
-L 2906 0 
-L 2906 525 
-Q 2725 213 2448 61 
-Q 2172 -91 1784 -91 
-Q 1150 -91 751 415 
-Q 353 922 353 1747 
-Q 353 2572 751 3078 
-Q 1150 3584 1784 3584 
-Q 2172 3584 2448 3432 
-Q 2725 3281 2906 2969 
-z
-M 947 1747 
-Q 947 1113 1208 752 
-Q 1469 391 1925 391 
-Q 2381 391 2643 752 
-Q 2906 1113 2906 1747 
-Q 2906 2381 2643 2742 
-Q 2381 3103 1925 3103 
-Q 1469 3103 1208 2742 
-Q 947 2381 947 1747 
-z
-" transform="scale(0.015625)"/>
-        <path id="DejaVuSans-65" d="M 3597 1894 
-L 3597 1613 
-L 953 1613 
-Q 991 1019 1311 708 
-Q 1631 397 2203 397 
-Q 2534 397 2845 478 
-Q 3156 559 3463 722 
-L 3463 178 
-Q 3153 47 2828 -22 
-Q 2503 -91 2169 -91 
-Q 1331 -91 842 396 
-Q 353 884 353 1716 
-Q 353 2575 817 3079 
-Q 1281 3584 2069 3584 
-Q 2775 3584 3186 3129 
-Q 3597 2675 3597 1894 
-z
-M 3022 2063 
-Q 3016 2534 2758 2815 
-Q 2500 3097 2075 3097 
-Q 1594 3097 1305 2825 
-Q 1016 2553 972 2059 
-L 3022 2063 
-z
-" transform="scale(0.015625)"/>
-        <path id="DejaVuSans-62" d="M 3116 1747 
-Q 3116 2381 2855 2742 
-Q 2594 3103 2138 3103 
-Q 1681 3103 1420 2742 
-Q 1159 2381 1159 1747 
-Q 1159 1113 1420 752 
-Q 1681 391 2138 391 
-Q 2594 391 2855 752 
-Q 3116 1113 3116 1747 
-z
-M 1159 2969 
-Q 1341 3281 1617 3432 
-Q 1894 3584 2278 3584 
-Q 2916 3584 3314 3078 
-Q 3713 2572 3713 1747 
-Q 3713 922 3314 415 
-Q 2916 -91 2278 -91 
-Q 1894 -91 1617 61 
-Q 1341 213 1159 525 
-L 1159 0 
-L 581 0 
-L 581 4863 
-L 1159 4863 
-L 1159 2969 
-z
-" transform="scale(0.015625)"/>
-        <path id="DejaVuSans-67" d="M 2906 1791 
-Q 2906 2416 2648 2759 
-Q 2391 3103 1925 3103 
-Q 1463 3103 1205 2759 
-Q 947 2416 947 1791 
-Q 947 1169 1205 825 
-Q 1463 481 1925 481 
-Q 2391 481 2648 825 
-Q 2906 1169 2906 1791 
-z
-M 3481 434 
-Q 3481 -459 3084 -895 
-Q 2688 -1331 1869 -1331 
-Q 1566 -1331 1297 -1286 
-Q 1028 -1241 775 -1147 
-L 775 -588 
-Q 1028 -725 1275 -790 
-Q 1522 -856 1778 -856 
-Q 2344 -856 2625 -561 
-Q 2906 -266 2906 331 
-L 2906 616 
-Q 2728 306 2450 153 
-Q 2172 0 1784 0 
-Q 1141 0 747 490 
-Q 353 981 353 1791 
-Q 353 2603 747 3093 
-Q 1141 3584 1784 3584 
-Q 2172 3584 2450 3431 
-Q 2728 3278 2906 2969 
-L 2906 3500 
-L 3481 3500 
-L 3481 434 
-z
-" transform="scale(0.015625)"/>
-        <path id="DejaVuSans-5d" d="M 1947 4863 
-L 1947 -844 
-L 622 -844 
-L 622 -397 
-L 1369 -397 
-L 1369 4416 
-L 622 4416 
-L 622 4863 
-L 1947 4863 
-z
-" transform="scale(0.015625)"/>
-       </defs>
-       <use xlink:href="#DejaVuSans-66"/>
-       <use xlink:href="#DejaVuSans-75" x="35.205078"/>
-       <use xlink:href="#DejaVuSans-6e" x="98.583984"/>
-       <use xlink:href="#DejaVuSans-63" x="161.962891"/>
-       <use xlink:href="#DejaVuSans-20" x="216.943359"/>
-       <use xlink:href="#DejaVuSans-5b" x="248.730469"/>
-       <use xlink:href="#DejaVuSans-64" x="287.744141"/>
-       <use xlink:href="#DejaVuSans-65" x="351.220703"/>
-       <use xlink:href="#DejaVuSans-62" x="412.744141"/>
-       <use xlink:href="#DejaVuSans-75" x="476.220703"/>
-       <use xlink:href="#DejaVuSans-67" x="539.599609"/>
-       <use xlink:href="#DejaVuSans-5d" x="603.076172"/>
-      </g>
-     </g>
-    </g>
-    <g id="xtick_2">
-     <g id="line2d_2">
-      <g>
-       <use xlink:href="#mb6a28bdaec" x="346.059583" y="199.398125" style="stroke: #000000; stroke-width: 0.8"/>
-      </g>
-     </g>
-     <g id="text_2">
-      <!-- func [opt] -->
-      <g transform="translate(321.528333 213.996563)scale(0.1 -0.1)">
-       <defs>
-        <path id="DejaVuSans-6f" d="M 1959 3097 
-Q 1497 3097 1228 2736 
-Q 959 2375 959 1747 
-Q 959 1119 1226 758 
-Q 1494 397 1959 397 
-Q 2419 397 2687 759 
-Q 2956 1122 2956 1747 
-Q 2956 2369 2687 2733 
-Q 2419 3097 1959 3097 
-z
-M 1959 3584 
-Q 2709 3584 3137 3096 
-Q 3566 2609 3566 1747 
-Q 3566 888 3137 398 
-Q 2709 -91 1959 -91 
-Q 1206 -91 779 398 
-Q 353 888 353 1747 
-Q 353 2609 779 3096 
-Q 1206 3584 1959 3584 
-z
-" transform="scale(0.015625)"/>
-        <path id="DejaVuSans-70" d="M 1159 525 
-L 1159 -1331 
-L 581 -1331 
-L 581 3500 
-L 1159 3500 
-L 1159 2969 
-Q 1341 3281 1617 3432 
-Q 1894 3584 2278 3584 
-Q 2916 3584 3314 3078 
-Q 3713 2572 3713 1747 
-Q 3713 922 3314 415 
-Q 2916 -91 2278 -91 
-Q 1894 -91 1617 61 
-Q 1341 213 1159 525 
-z
-M 3116 1747 
-Q 3116 2381 2855 2742 
-Q 2594 3103 2138 3103 
-Q 1681 3103 1420 2742 
-Q 1159 2381 1159 1747 
-Q 1159 1113 1420 752 
-Q 1681 391 2138 391 
-Q 2594 391 2855 752 
-Q 3116 1113 3116 1747 
-z
-" transform="scale(0.015625)"/>
-        <path id="DejaVuSans-74" d="M 1172 4494 
-L 1172 3500 
-L 2356 3500 
-L 2356 3053 
-L 1172 3053 
-L 1172 1153 
-Q 1172 725 1289 603 
-Q 1406 481 1766 481 
-L 2356 481 
-L 2356 0 
-L 1766 0 
-Q 1100 0 847 248 
-Q 594 497 594 1153 
-L 594 3053 
-L 172 3053 
-L 172 3500 
-L 594 3500 
-L 594 4494 
-L 1172 4494 
-z
-" transform="scale(0.015625)"/>
-       </defs>
-       <use xlink:href="#DejaVuSans-66"/>
-       <use xlink:href="#DejaVuSans-75" x="35.205078"/>
-       <use xlink:href="#DejaVuSans-6e" x="98.583984"/>
-       <use xlink:href="#DejaVuSans-63" x="161.962891"/>
-       <use xlink:href="#DejaVuSans-20" x="216.943359"/>
-       <use xlink:href="#DejaVuSans-5b" x="248.730469"/>
-       <use xlink:href="#DejaVuSans-6f" x="287.744141"/>
-       <use xlink:href="#DejaVuSans-70" x="348.925781"/>
-       <use xlink:href="#DejaVuSans-74" x="412.402344"/>
-       <use xlink:href="#DejaVuSans-5d" x="451.611328"/>
-      </g>
-     </g>
-    </g>
-    <g id="xtick_3">
-     <g id="line2d_3">
-      <g>
-       <use xlink:href="#mb6a28bdaec" x="559.492917" y="199.398125" style="stroke: #000000; stroke-width: 0.8"/>
-      </g>
-     </g>
-     <g id="text_3">
-      <!-- class [debug] -->
-      <g transform="translate(525.822604 213.996563)scale(0.1 -0.1)">
-       <defs>
-        <path id="DejaVuSans-6c" d="M 603 4863 
-L 1178 4863 
-L 1178 0 
-L 603 0 
-L 603 4863 
-z
-" transform="scale(0.015625)"/>
-        <path id="DejaVuSans-61" d="M 2194 1759 
-Q 1497 1759 1228 1600 
-Q 959 1441 959 1056 
-Q 959 750 1161 570 
-Q 1363 391 1709 391 
-Q 2188 391 2477 730 
-Q 2766 1069 2766 1631 
-L 2766 1759 
-L 2194 1759 
-z
-M 3341 1997 
-L 3341 0 
-L 2766 0 
-L 2766 531 
-Q 2569 213 2275 61 
-Q 1981 -91 1556 -91 
-Q 1019 -91 701 211 
-Q 384 513 384 1019 
-Q 384 1609 779 1909 
-Q 1175 2209 1959 2209 
-L 2766 2209 
-L 2766 2266 
-Q 2766 2663 2505 2880 
-Q 2244 3097 1772 3097 
-Q 1472 3097 1187 3025 
-Q 903 2953 641 2809 
-L 641 3341 
-Q 956 3463 1253 3523 
-Q 1550 3584 1831 3584 
-Q 2591 3584 2966 3190 
-Q 3341 2797 3341 1997 
-z
-" transform="scale(0.015625)"/>
-        <path id="DejaVuSans-73" d="M 2834 3397 
-L 2834 2853 
-Q 2591 2978 2328 3040 
-Q 2066 3103 1784 3103 
-Q 1356 3103 1142 2972 
-Q 928 2841 928 2578 
-Q 928 2378 1081 2264 
-Q 1234 2150 1697 2047 
-L 1894 2003 
-Q 2506 1872 2764 1633 
-Q 3022 1394 3022 966 
-Q 3022 478 2636 193 
-Q 2250 -91 1575 -91 
-Q 1294 -91 989 -36 
-Q 684 19 347 128 
-L 347 722 
-Q 666 556 975 473 
-Q 1284 391 1588 391 
-Q 1994 391 2212 530 
-Q 2431 669 2431 922 
-Q 2431 1156 2273 1281 
-Q 2116 1406 1581 1522 
-L 1381 1569 
-Q 847 1681 609 1914 
-Q 372 2147 372 2553 
-Q 372 3047 722 3315 
-Q 1072 3584 1716 3584 
-Q 2034 3584 2315 3537 
-Q 2597 3491 2834 3397 
-z
-" transform="scale(0.015625)"/>
-       </defs>
-       <use xlink:href="#DejaVuSans-63"/>
-       <use xlink:href="#DejaVuSans-6c" x="54.980469"/>
-       <use xlink:href="#DejaVuSans-61" x="82.763672"/>
-       <use xlink:href="#DejaVuSans-73" x="144.042969"/>
-       <use xlink:href="#DejaVuSans-73" x="196.142578"/>
-       <use xlink:href="#DejaVuSans-20" x="248.242188"/>
-       <use xlink:href="#DejaVuSans-5b" x="280.029297"/>
-       <use xlink:href="#DejaVuSans-64" x="319.042969"/>
-       <use xlink:href="#DejaVuSans-65" x="382.519531"/>
-       <use xlink:href="#DejaVuSans-62" x="444.042969"/>
-       <use xlink:href="#DejaVuSans-75" x="507.519531"/>
-       <use xlink:href="#DejaVuSans-67" x="570.898438"/>
-       <use xlink:href="#DejaVuSans-5d" x="634.375"/>
-      </g>
-     </g>
-    </g>
-    <g id="xtick_4">
-     <g id="line2d_4">
-      <g>
-       <use xlink:href="#mb6a28bdaec" x="772.92625" y="199.398125" style="stroke: #000000; stroke-width: 0.8"/>
-      </g>
-     </g>
-     <g id="text_4">
-      <!-- class [opt] -->
-      <g transform="translate(746.830156 213.996563)scale(0.1 -0.1)">
-       <use xlink:href="#DejaVuSans-63"/>
-       <use xlink:href="#DejaVuSans-6c" x="54.980469"/>
-       <use xlink:href="#DejaVuSans-61" x="82.763672"/>
-       <use xlink:href="#DejaVuSans-73" x="144.042969"/>
-       <use xlink:href="#DejaVuSans-73" x="196.142578"/>
-       <use xlink:href="#DejaVuSans-20" x="248.242188"/>
-       <use xlink:href="#DejaVuSans-5b" x="280.029297"/>
-       <use xlink:href="#DejaVuSans-6f" x="319.042969"/>
-       <use xlink:href="#DejaVuSans-70" x="380.224609"/>
-       <use xlink:href="#DejaVuSans-74" x="443.701172"/>
-       <use xlink:href="#DejaVuSans-5d" x="482.910156"/>
-      </g>
-     </g>
-    </g>
-   </g>
-   <g id="matplotlib.axis_2">
-    <g id="ytick_1">
-     <g id="line2d_5">
-      <defs>
-       <path id="mb71978bee2" d="M 0 0 
-L -3.5 0 
-" style="stroke: #000000; stroke-width: 0.8"/>
-      </defs>
-      <g>
-       <use xlink:href="#mb71978bee2" x="36.58125" y="199.398125" style="stroke: #000000; stroke-width: 0.8"/>
-      </g>
-     </g>
-     <g id="text_5">
-      <!-- 0.0 -->
-      <g transform="translate(13.678125 203.197344)scale(0.1 -0.1)">
-       <defs>
-        <path id="DejaVuSans-30" d="M 2034 4250 
-Q 1547 4250 1301 3770 
-Q 1056 3291 1056 2328 
-Q 1056 1369 1301 889 
-Q 1547 409 2034 409 
-Q 2525 409 2770 889 
-Q 3016 1369 3016 2328 
-Q 3016 3291 2770 3770 
-Q 2525 4250 2034 4250 
-z
-M 2034 4750 
-Q 2819 4750 3233 4129 
-Q 3647 3509 3647 2328 
-Q 3647 1150 3233 529 
-Q 2819 -91 2034 -91 
-Q 1250 -91 836 529 
-Q 422 1150 422 2328 
-Q 422 3509 836 4129 
-Q 1250 4750 2034 4750 
-z
-" transform="scale(0.015625)"/>
-        <path id="DejaVuSans-2e" d="M 684 794 
-L 1344 794 
-L 1344 0 
-L 684 0 
-L 684 794 
-z
-" transform="scale(0.015625)"/>
-       </defs>
-       <use xlink:href="#DejaVuSans-30"/>
-       <use xlink:href="#DejaVuSans-2e" x="63.623047"/>
-       <use xlink:href="#DejaVuSans-30" x="95.410156"/>
-      </g>
-     </g>
-    </g>
-    <g id="ytick_2">
-     <g id="line2d_6">
-      <g>
-       <use xlink:href="#mb71978bee2" x="36.58125" y="175.458916" style="stroke: #000000; stroke-width: 0.8"/>
-      </g>
-     </g>
-     <g id="text_6">
-      <!-- 0.5 -->
-      <g transform="translate(13.678125 179.258135)scale(0.1 -0.1)">
-       <defs>
-        <path id="DejaVuSans-35" d="M 691 4666 
-L 3169 4666 
-L 3169 4134 
-L 1269 4134 
-L 1269 2991 
-Q 1406 3038 1543 3061 
-Q 1681 3084 1819 3084 
-Q 2600 3084 3056 2656 
-Q 3513 2228 3513 1497 
-Q 3513 744 3044 326 
-Q 2575 -91 1722 -91 
-Q 1428 -91 1123 -41 
-Q 819 9 494 109 
-L 494 744 
-Q 775 591 1075 516 
-Q 1375 441 1709 441 
-Q 2250 441 2565 725 
-Q 2881 1009 2881 1497 
-Q 2881 1984 2565 2268 
-Q 2250 2553 1709 2553 
-Q 1456 2553 1204 2497 
-Q 953 2441 691 2322 
-L 691 4666 
-z
-" transform="scale(0.015625)"/>
-       </defs>
-       <use xlink:href="#DejaVuSans-30"/>
-       <use xlink:href="#DejaVuSans-2e" x="63.623047"/>
-       <use xlink:href="#DejaVuSans-35" x="95.410156"/>
-      </g>
-     </g>
-    </g>
-    <g id="ytick_3">
-     <g id="line2d_7">
-      <g>
-       <use xlink:href="#mb71978bee2" x="36.58125" y="151.519707" style="stroke: #000000; stroke-width: 0.8"/>
-      </g>
-     </g>
-     <g id="text_7">
-      <!-- 1.0 -->
-      <g transform="translate(13.678125 155.318926)scale(0.1 -0.1)">
-       <defs>
-        <path id="DejaVuSans-31" d="M 794 531 
-L 1825 531 
-L 1825 4091 
-L 703 3866 
-L 703 4441 
-L 1819 4666 
-L 2450 4666 
-L 2450 531 
-L 3481 531 
-L 3481 0 
-L 794 0 
-L 794 531 
-z
-" transform="scale(0.015625)"/>
-       </defs>
-       <use xlink:href="#DejaVuSans-31"/>
-       <use xlink:href="#DejaVuSans-2e" x="63.623047"/>
-       <use xlink:href="#DejaVuSans-30" x="95.410156"/>
-      </g>
-     </g>
-    </g>
-    <g id="ytick_4">
-     <g id="line2d_8">
-      <g>
-       <use xlink:href="#mb71978bee2" x="36.58125" y="127.580499" style="stroke: #000000; stroke-width: 0.8"/>
-      </g>
-     </g>
-     <g id="text_8">
-      <!-- 1.5 -->
-      <g transform="translate(13.678125 131.379717)scale(0.1 -0.1)">
-       <use xlink:href="#DejaVuSans-31"/>
-       <use xlink:href="#DejaVuSans-2e" x="63.623047"/>
-       <use xlink:href="#DejaVuSans-35" x="95.410156"/>
-      </g>
-     </g>
-    </g>
-    <g id="ytick_5">
-     <g id="line2d_9">
-      <g>
-       <use xlink:href="#mb71978bee2" x="36.58125" y="103.64129" style="stroke: #000000; stroke-width: 0.8"/>
-      </g>
-     </g>
-     <g id="text_9">
-      <!-- 2.0 -->
-      <g transform="translate(13.678125 107.440509)scale(0.1 -0.1)">
-       <defs>
-        <path id="DejaVuSans-32" d="M 1228 531 
-L 3431 531 
-L 3431 0 
-L 469 0 
-L 469 531 
-Q 828 903 1448 1529 
-Q 2069 2156 2228 2338 
-Q 2531 2678 2651 2914 
-Q 2772 3150 2772 3378 
-Q 2772 3750 2511 3984 
-Q 2250 4219 1831 4219 
-Q 1534 4219 1204 4116 
-Q 875 4013 500 3803 
-L 500 4441 
-Q 881 4594 1212 4672 
-Q 1544 4750 1819 4750 
-Q 2544 4750 2975 4387 
-Q 3406 4025 3406 3419 
-Q 3406 3131 3298 2873 
-Q 3191 2616 2906 2266 
-Q 2828 2175 2409 1742 
-Q 1991 1309 1228 531 
-z
-" transform="scale(0.015625)"/>
-       </defs>
-       <use xlink:href="#DejaVuSans-32"/>
-       <use xlink:href="#DejaVuSans-2e" x="63.623047"/>
-       <use xlink:href="#DejaVuSans-30" x="95.410156"/>
-      </g>
-     </g>
-    </g>
-    <g id="ytick_6">
-     <g id="line2d_10">
-      <g>
-       <use xlink:href="#mb71978bee2" x="36.58125" y="79.702081" style="stroke: #000000; stroke-width: 0.8"/>
-      </g>
-     </g>
-     <g id="text_10">
-      <!-- 2.5 -->
-      <g transform="translate(13.678125 83.5013)scale(0.1 -0.1)">
-       <use xlink:href="#DejaVuSans-32"/>
-       <use xlink:href="#DejaVuSans-2e" x="63.623047"/>
-       <use xlink:href="#DejaVuSans-35" x="95.410156"/>
-      </g>
-     </g>
-    </g>
-    <g id="ytick_7">
-     <g id="line2d_11">
-      <g>
-       <use xlink:href="#mb71978bee2" x="36.58125" y="55.762872" style="stroke: #000000; stroke-width: 0.8"/>
-      </g>
-     </g>
-     <g id="text_11">
-      <!-- 3.0 -->
-      <g transform="translate(13.678125 59.562091)scale(0.1 -0.1)">
-       <defs>
-        <path id="DejaVuSans-33" d="M 2597 2516 
-Q 3050 2419 3304 2112 
-Q 3559 1806 3559 1356 
-Q 3559 666 3084 287 
-Q 2609 -91 1734 -91 
-Q 1441 -91 1130 -33 
-Q 819 25 488 141 
-L 488 750 
-Q 750 597 1062 519 
-Q 1375 441 1716 441 
-Q 2309 441 2620 675 
-Q 2931 909 2931 1356 
-Q 2931 1769 2642 2001 
-Q 2353 2234 1838 2234 
-L 1294 2234 
-L 1294 2753 
-L 1863 2753 
-Q 2328 2753 2575 2939 
-Q 2822 3125 2822 3475 
-Q 2822 3834 2567 4026 
-Q 2313 4219 1838 4219 
-Q 1578 4219 1281 4162 
-Q 984 4106 628 3988 
-L 628 4550 
-Q 988 4650 1302 4700 
-Q 1616 4750 1894 4750 
-Q 2613 4750 3031 4423 
-Q 3450 4097 3450 3541 
-Q 3450 3153 3228 2886 
-Q 3006 2619 2597 2516 
-z
-" transform="scale(0.015625)"/>
-       </defs>
-       <use xlink:href="#DejaVuSans-33"/>
-       <use xlink:href="#DejaVuSans-2e" x="63.623047"/>
-       <use xlink:href="#DejaVuSans-30" x="95.410156"/>
-      </g>
-     </g>
-    </g>
-    <g id="ytick_8">
-     <g id="line2d_12">
-      <g>
-       <use xlink:href="#mb71978bee2" x="36.58125" y="31.823664" style="stroke: #000000; stroke-width: 0.8"/>
-      </g>
-     </g>
-     <g id="text_12">
-      <!-- 3.5 -->
-      <g transform="translate(13.678125 35.622882)scale(0.1 -0.1)">
-       <use xlink:href="#DejaVuSans-33"/>
-       <use xlink:href="#DejaVuSans-2e" x="63.623047"/>
-       <use xlink:href="#DejaVuSans-35" x="95.410156"/>
-      </g>
-     </g>
-    </g>
-    <g id="text_13">
-     <!-- Size (MiB) -->
-     <g transform="translate(7.598438 132.146406)rotate(-90)scale(0.1 -0.1)">
-      <defs>
-       <path id="DejaVuSans-53" d="M 3425 4513 
-L 3425 3897 
-Q 3066 4069 2747 4153 
-Q 2428 4238 2131 4238 
-Q 1616 4238 1336 4038 
-Q 1056 3838 1056 3469 
-Q 1056 3159 1242 3001 
-Q 1428 2844 1947 2747 
-L 2328 2669 
-Q 3034 2534 3370 2195 
-Q 3706 1856 3706 1288 
-Q 3706 609 3251 259 
-Q 2797 -91 1919 -91 
-Q 1588 -91 1214 -16 
-Q 841 59 441 206 
-L 441 856 
-Q 825 641 1194 531 
-Q 1563 422 1919 422 
-Q 2459 422 2753 634 
-Q 3047 847 3047 1241 
-Q 3047 1584 2836 1778 
-Q 2625 1972 2144 2069 
-L 1759 2144 
-Q 1053 2284 737 2584 
-Q 422 2884 422 3419 
-Q 422 4038 858 4394 
-Q 1294 4750 2059 4750 
-Q 2388 4750 2728 4690 
-Q 3069 4631 3425 4513 
-z
-" transform="scale(0.015625)"/>
-       <path id="DejaVuSans-69" d="M 603 3500 
-L 1178 3500 
-L 1178 0 
-L 603 0 
-L 603 3500 
-z
-M 603 4863 
-L 1178 4863 
-L 1178 4134 
-L 603 4134 
-L 603 4863 
-z
-" transform="scale(0.015625)"/>
-       <path id="DejaVuSans-7a" d="M 353 3500 
-L 3084 3500 
-L 3084 2975 
-L 922 459 
-L 3084 459 
-L 3084 0 
-L 275 0 
-L 275 525 
-L 2438 3041 
-L 353 3041 
-L 353 3500 
-z
-" transform="scale(0.015625)"/>
-       <path id="DejaVuSans-28" d="M 1984 4856 
-Q 1566 4138 1362 3434 
-Q 1159 2731 1159 2009 
-Q 1159 1288 1364 580 
-Q 1569 -128 1984 -844 
-L 1484 -844 
-Q 1016 -109 783 600 
-Q 550 1309 550 2009 
-Q 550 2706 781 3412 
-Q 1013 4119 1484 4856 
-L 1984 4856 
-z
-" transform="scale(0.015625)"/>
-       <path id="DejaVuSans-4d" d="M 628 4666 
-L 1569 4666 
-L 2759 1491 
-L 3956 4666 
-L 4897 4666 
-L 4897 0 
-L 4281 0 
-L 4281 4097 
-L 3078 897 
-L 2444 897 
-L 1241 4097 
-L 1241 0 
-L 628 0 
-L 628 4666 
-z
-" transform="scale(0.015625)"/>
-       <path id="DejaVuSans-42" d="M 1259 2228 
-L 1259 519 
-L 2272 519 
-Q 2781 519 3026 730 
-Q 3272 941 3272 1375 
-Q 3272 1813 3026 2020 
-Q 2781 2228 2272 2228 
-L 1259 2228 
-z
-M 1259 4147 
-L 1259 2741 
-L 2194 2741 
-Q 2656 2741 2882 2914 
-Q 3109 3088 3109 3444 
-Q 3109 3797 2882 3972 
-Q 2656 4147 2194 4147 
-L 1259 4147 
-z
-M 628 4666 
-L 2241 4666 
-Q 2963 4666 3353 4366 
-Q 3744 4066 3744 3513 
-Q 3744 3084 3544 2831 
-Q 3344 2578 2956 2516 
-Q 3422 2416 3680 2098 
-Q 3938 1781 3938 1306 
-Q 3938 681 3513 340 
-Q 3088 0 2303 0 
-L 628 0 
-L 628 4666 
-z
-" transform="scale(0.015625)"/>
-       <path id="DejaVuSans-29" d="M 513 4856 
-L 1013 4856 
-Q 1481 4119 1714 3412 
-Q 1947 2706 1947 2009 
-Q 1947 1309 1714 600 
-Q 1481 -109 1013 -844 
-L 513 -844 
-Q 928 -128 1133 580 
-Q 1338 1288 1338 2009 
-Q 1338 2731 1133 3434 
-Q 928 4138 513 4856 
-z
-" transform="scale(0.015625)"/>
-      </defs>
-      <use xlink:href="#DejaVuSans-53"/>
-      <use xlink:href="#DejaVuSans-69" x="63.476562"/>
-      <use xlink:href="#DejaVuSans-7a" x="91.259766"/>
-      <use xlink:href="#DejaVuSans-65" x="143.75"/>
-      <use xlink:href="#DejaVuSans-20" x="205.273438"/>
-      <use xlink:href="#DejaVuSans-28" x="237.060547"/>
-      <use xlink:href="#DejaVuSans-4d" x="276.074219"/>
-      <use xlink:href="#DejaVuSans-69" x="362.353516"/>
-      <use xlink:href="#DejaVuSans-42" x="390.136719"/>
-      <use xlink:href="#DejaVuSans-29" x="458.740234"/>
-     </g>
-    </g>
-   </g>
-   <g id="patch_25">
-    <path d="M 36.58125 199.398125 
-L 36.58125 15.118125 
-" style="fill: none; stroke: #000000; stroke-width: 0.8; stroke-linejoin: miter; stroke-linecap: square"/>
-   </g>
-   <g id="patch_26">
-    <path d="M 868.97125 199.398125 
-L 868.97125 15.118125 
-" style="fill: none; stroke: #000000; stroke-width: 0.8; stroke-linejoin: miter; stroke-linecap: square"/>
-   </g>
-   <g id="patch_27">
-    <path d="M 36.58125 199.398125 
-L 868.97125 199.398125 
-" style="fill: none; stroke: #000000; stroke-width: 0.8; stroke-linejoin: miter; stroke-linecap: square"/>
-   </g>
-   <g id="patch_28">
-    <path d="M 36.58125 15.118125 
-L 868.97125 15.118125 
-" style="fill: none; stroke: #000000; stroke-width: 0.8; stroke-linejoin: miter; stroke-linecap: square"/>
-   </g>
-   <g id="text_14">
-    <!-- 20.42 -->
-    <g transform="translate(47.167743 35.696625)scale(0.1 -0.1)">
-     <defs>
-      <path id="DejaVuSans-34" d="M 2419 4116 
-L 825 1625 
-L 2419 1625 
-L 2419 4116 
-z
-M 2253 4666 
-L 3047 4666 
-L 3047 1625 
-L 3713 1625 
-L 3713 1100 
-L 3047 1100 
-L 3047 0 
-L 2419 0 
-L 2419 1100 
-L 313 1100 
-L 313 1709 
-L 2253 4666 
-z
-" transform="scale(0.015625)"/>
-     </defs>
-     <use xlink:href="#DejaVuSans-32"/>
-     <use xlink:href="#DejaVuSans-30" x="63.623047"/>
-     <use xlink:href="#DejaVuSans-2e" x="127.246094"/>
-     <use xlink:href="#DejaVuSans-34" x="159.033203"/>
-     <use xlink:href="#DejaVuSans-32" x="222.65625"/>
-    </g>
-    <!-- (x1.9) -->
-    <g transform="translate(46.669306 46.894438)scale(0.1 -0.1)">
-     <defs>
-      <path id="DejaVuSans-78" d="M 3513 3500 
-L 2247 1797 
-L 3578 0 
-L 2900 0 
-L 1881 1375 
-L 863 0 
-L 184 0 
-L 1544 1831 
-L 300 3500 
-L 978 3500 
-L 1906 2253 
-L 2834 3500 
-L 3513 3500 
-z
-" transform="scale(0.015625)"/>
-      <path id="DejaVuSans-39" d="M 703 97 
-L 703 672 
-Q 941 559 1184 500 
-Q 1428 441 1663 441 
-Q 2288 441 2617 861 
-Q 2947 1281 2994 2138 
-Q 2813 1869 2534 1725 
-Q 2256 1581 1919 1581 
-Q 1219 1581 811 2004 
-Q 403 2428 403 3163 
-Q 403 3881 828 4315 
-Q 1253 4750 1959 4750 
-Q 2769 4750 3195 4129 
-Q 3622 3509 3622 2328 
-Q 3622 1225 3098 567 
-Q 2575 -91 1691 -91 
-Q 1453 -91 1209 -44 
-Q 966 3 703 97 
-z
-M 1959 2075 
-Q 2384 2075 2632 2365 
-Q 2881 2656 2881 3163 
-Q 2881 3666 2632 3958 
-Q 2384 4250 1959 4250 
-Q 1534 4250 1286 3958 
-Q 1038 3666 1038 3163 
-Q 1038 2656 1286 2365 
-Q 1534 2075 1959 2075 
-z
-" transform="scale(0.015625)"/>
-     </defs>
-     <use xlink:href="#DejaVuSans-28"/>
-     <use xlink:href="#DejaVuSans-78" x="39.013672"/>
-     <use xlink:href="#DejaVuSans-31" x="98.193359"/>
-     <use xlink:href="#DejaVuSans-2e" x="161.816406"/>
-     <use xlink:href="#DejaVuSans-39" x="193.603516"/>
-     <use xlink:href="#DejaVuSans-29" x="257.226562"/>
-    </g>
-   </g>
-   <g id="text_15">
-    <!-- 4.21 -->
-    <g style="fill: #ffffff" transform="translate(263.782326 35.696625)scale(0.1 -0.1)">
-     <use xlink:href="#DejaVuSans-34"/>
-     <use xlink:href="#DejaVuSans-2e" x="63.623047"/>
-     <use xlink:href="#DejaVuSans-32" x="95.410156"/>
-     <use xlink:href="#DejaVuSans-31" x="159.033203"/>
-    </g>
-    <!-- (x10.9) -->
-    <g style="fill: #ffffff" transform="translate(256.921389 46.894438)scale(0.1 -0.1)">
-     <use xlink:href="#DejaVuSans-28"/>
-     <use xlink:href="#DejaVuSans-78" x="39.013672"/>
-     <use xlink:href="#DejaVuSans-31" x="98.193359"/>
-     <use xlink:href="#DejaVuSans-30" x="161.816406"/>
-     <use xlink:href="#DejaVuSans-2e" x="225.439453"/>
-     <use xlink:href="#DejaVuSans-39" x="257.226562"/>
-     <use xlink:href="#DejaVuSans-29" x="320.849609"/>
-    </g>
-   </g>
-   <g id="text_16">
-    <!-- 34.83 -->
-    <g transform="translate(474.03441 35.696625)scale(0.1 -0.1)">
-     <defs>
-      <path id="DejaVuSans-38" d="M 2034 2216 
-Q 1584 2216 1326 1975 
-Q 1069 1734 1069 1313 
-Q 1069 891 1326 650 
-Q 1584 409 2034 409 
-Q 2484 409 2743 651 
-Q 3003 894 3003 1313 
-Q 3003 1734 2745 1975 
-Q 2488 2216 2034 2216 
-z
-M 1403 2484 
-Q 997 2584 770 2862 
-Q 544 3141 544 3541 
-Q 544 4100 942 4425 
-Q 1341 4750 2034 4750 
-Q 2731 4750 3128 4425 
-Q 3525 4100 3525 3541 
-Q 3525 3141 3298 2862 
-Q 3072 2584 2669 2484 
-Q 3125 2378 3379 2068 
-Q 3634 1759 3634 1313 
-Q 3634 634 3220 271 
-Q 2806 -91 2034 -91 
-Q 1263 -91 848 271 
-Q 434 634 434 1313 
-Q 434 1759 690 2068 
-Q 947 2378 1403 2484 
-z
-M 1172 3481 
-Q 1172 3119 1398 2916 
-Q 1625 2713 2034 2713 
-Q 2441 2713 2670 2916 
-Q 2900 3119 2900 3481 
-Q 2900 3844 2670 4047 
-Q 2441 4250 2034 4250 
-Q 1625 4250 1398 4047 
-Q 1172 3844 1172 3481 
-z
-" transform="scale(0.015625)"/>
-     </defs>
-     <use xlink:href="#DejaVuSans-33"/>
-     <use xlink:href="#DejaVuSans-34" x="63.623047"/>
-     <use xlink:href="#DejaVuSans-2e" x="127.246094"/>
-     <use xlink:href="#DejaVuSans-38" x="159.033203"/>
-     <use xlink:href="#DejaVuSans-33" x="222.65625"/>
-    </g>
-    <!-- (x4.0) -->
-    <g transform="translate(473.535972 46.894438)scale(0.1 -0.1)">
-     <use xlink:href="#DejaVuSans-28"/>
-     <use xlink:href="#DejaVuSans-78" x="39.013672"/>
-     <use xlink:href="#DejaVuSans-34" x="98.193359"/>
-     <use xlink:href="#DejaVuSans-2e" x="161.816406"/>
-     <use xlink:href="#DejaVuSans-30" x="193.603516"/>
-     <use xlink:href="#DejaVuSans-29" x="257.226562"/>
-    </g>
-   </g>
-   <g id="text_17">
-    <!-- 2.43 -->
-    <g transform="translate(690.648993 66.677795)scale(0.1 -0.1)">
-     <use xlink:href="#DejaVuSans-32"/>
-     <use xlink:href="#DejaVuSans-2e" x="63.623047"/>
-     <use xlink:href="#DejaVuSans-34" x="95.410156"/>
-     <use xlink:href="#DejaVuSans-33" x="159.033203"/>
-    </g>
-    <!-- (x9.4) -->
-    <g transform="translate(686.969306 77.875607)scale(0.1 -0.1)">
-     <use xlink:href="#DejaVuSans-28"/>
-     <use xlink:href="#DejaVuSans-78" x="39.013672"/>
-     <use xlink:href="#DejaVuSans-39" x="98.193359"/>
-     <use xlink:href="#DejaVuSans-2e" x="161.816406"/>
-     <use xlink:href="#DejaVuSans-34" x="193.603516"/>
-     <use xlink:href="#DejaVuSans-29" x="257.226562"/>
-    </g>
-   </g>
-   <g id="text_18">
-    <!-- 24.84 -->
-    <g transform="translate(82.739965 35.696625)scale(0.1 -0.1)">
-     <use xlink:href="#DejaVuSans-32"/>
-     <use xlink:href="#DejaVuSans-34" x="63.623047"/>
-     <use xlink:href="#DejaVuSans-2e" x="127.246094"/>
-     <use xlink:href="#DejaVuSans-38" x="159.033203"/>
-     <use xlink:href="#DejaVuSans-34" x="222.65625"/>
-    </g>
-    <!-- (x2.3) -->
-    <g transform="translate(82.241528 46.894438)scale(0.1 -0.1)">
-     <use xlink:href="#DejaVuSans-28"/>
-     <use xlink:href="#DejaVuSans-78" x="39.013672"/>
-     <use xlink:href="#DejaVuSans-32" x="98.193359"/>
-     <use xlink:href="#DejaVuSans-2e" x="161.816406"/>
-     <use xlink:href="#DejaVuSans-33" x="193.603516"/>
-     <use xlink:href="#DejaVuSans-29" x="257.226562"/>
-    </g>
-   </g>
-   <g id="text_19">
-    <!-- 1.41 -->
-    <g transform="translate(299.354549 115.423395)scale(0.1 -0.1)">
-     <use xlink:href="#DejaVuSans-31"/>
-     <use xlink:href="#DejaVuSans-2e" x="63.623047"/>
-     <use xlink:href="#DejaVuSans-34" x="95.410156"/>
-     <use xlink:href="#DejaVuSans-31" x="159.033203"/>
-    </g>
-    <!-- (x3.7) -->
-    <g transform="translate(295.674861 126.621207)scale(0.1 -0.1)">
-     <defs>
-      <path id="DejaVuSans-37" d="M 525 4666 
-L 3525 4666 
-L 3525 4397 
-L 1831 0 
-L 1172 0 
-L 2766 4134 
-L 525 4134 
-L 525 4666 
-z
-" transform="scale(0.015625)"/>
-     </defs>
-     <use xlink:href="#DejaVuSans-28"/>
-     <use xlink:href="#DejaVuSans-78" x="39.013672"/>
-     <use xlink:href="#DejaVuSans-33" x="98.193359"/>
-     <use xlink:href="#DejaVuSans-2e" x="161.816406"/>
-     <use xlink:href="#DejaVuSans-37" x="193.603516"/>
-     <use xlink:href="#DejaVuSans-29" x="257.226562"/>
-    </g>
-   </g>
-   <g id="text_20">
-    <!-- 26.17 -->
-    <g transform="translate(509.606632 35.696625)scale(0.1 -0.1)">
-     <defs>
-      <path id="DejaVuSans-36" d="M 2113 2584 
-Q 1688 2584 1439 2293 
-Q 1191 2003 1191 1497 
-Q 1191 994 1439 701 
-Q 1688 409 2113 409 
-Q 2538 409 2786 701 
-Q 3034 994 3034 1497 
-Q 3034 2003 2786 2293 
-Q 2538 2584 2113 2584 
-z
-M 3366 4563 
-L 3366 3988 
-Q 3128 4100 2886 4159 
-Q 2644 4219 2406 4219 
-Q 1781 4219 1451 3797 
-Q 1122 3375 1075 2522 
-Q 1259 2794 1537 2939 
-Q 1816 3084 2150 3084 
-Q 2853 3084 3261 2657 
-Q 3669 2231 3669 1497 
-Q 3669 778 3244 343 
-Q 2819 -91 2113 -91 
-Q 1303 -91 875 529 
-Q 447 1150 447 2328 
-Q 447 3434 972 4092 
-Q 1497 4750 2381 4750 
-Q 2619 4750 2861 4703 
-Q 3103 4656 3366 4563 
-z
-" transform="scale(0.015625)"/>
-     </defs>
-     <use xlink:href="#DejaVuSans-32"/>
-     <use xlink:href="#DejaVuSans-36" x="63.623047"/>
-     <use xlink:href="#DejaVuSans-2e" x="127.246094"/>
-     <use xlink:href="#DejaVuSans-31" x="159.033203"/>
-     <use xlink:href="#DejaVuSans-37" x="222.65625"/>
-    </g>
-    <!-- (x3.0) -->
-    <g transform="translate(509.108194 46.894438)scale(0.1 -0.1)">
-     <use xlink:href="#DejaVuSans-28"/>
-     <use xlink:href="#DejaVuSans-78" x="39.013672"/>
-     <use xlink:href="#DejaVuSans-33" x="98.193359"/>
-     <use xlink:href="#DejaVuSans-2e" x="161.816406"/>
-     <use xlink:href="#DejaVuSans-30" x="193.603516"/>
-     <use xlink:href="#DejaVuSans-29" x="257.226562"/>
-    </g>
-   </g>
-   <g id="text_21">
-    <!-- 0.85 -->
-    <g transform="translate(726.221215 142.52961)scale(0.1 -0.1)">
-     <use xlink:href="#DejaVuSans-30"/>
-     <use xlink:href="#DejaVuSans-2e" x="63.623047"/>
-     <use xlink:href="#DejaVuSans-38" x="95.410156"/>
-     <use xlink:href="#DejaVuSans-35" x="159.033203"/>
-    </g>
-    <!-- (x3.3) -->
-    <g transform="translate(722.541528 153.727423)scale(0.1 -0.1)">
-     <use xlink:href="#DejaVuSans-28"/>
-     <use xlink:href="#DejaVuSans-78" x="39.013672"/>
-     <use xlink:href="#DejaVuSans-33" x="98.193359"/>
-     <use xlink:href="#DejaVuSans-2e" x="161.816406"/>
-     <use xlink:href="#DejaVuSans-33" x="193.603516"/>
-     <use xlink:href="#DejaVuSans-29" x="257.226562"/>
-    </g>
-   </g>
-   <g id="text_22">
-    <!-- 24.85 -->
-    <g transform="translate(118.312188 35.696625)scale(0.1 -0.1)">
-     <use xlink:href="#DejaVuSans-32"/>
-     <use xlink:href="#DejaVuSans-34" x="63.623047"/>
-     <use xlink:href="#DejaVuSans-2e" x="127.246094"/>
-     <use xlink:href="#DejaVuSans-38" x="159.033203"/>
-     <use xlink:href="#DejaVuSans-35" x="222.65625"/>
-    </g>
-    <!-- (x2.3) -->
-    <g transform="translate(117.81375 46.894438)scale(0.1 -0.1)">
-     <use xlink:href="#DejaVuSans-28"/>
-     <use xlink:href="#DejaVuSans-78" x="39.013672"/>
-     <use xlink:href="#DejaVuSans-32" x="98.193359"/>
-     <use xlink:href="#DejaVuSans-2e" x="161.816406"/>
-     <use xlink:href="#DejaVuSans-33" x="193.603516"/>
-     <use xlink:href="#DejaVuSans-29" x="257.226562"/>
-    </g>
-   </g>
-   <g id="text_23">
-    <!-- 1.41 -->
-    <g transform="translate(334.926771 115.423395)scale(0.1 -0.1)">
-     <use xlink:href="#DejaVuSans-31"/>
-     <use xlink:href="#DejaVuSans-2e" x="63.623047"/>
-     <use xlink:href="#DejaVuSans-34" x="95.410156"/>
-     <use xlink:href="#DejaVuSans-31" x="159.033203"/>
-    </g>
-    <!-- (x3.7) -->
-    <g transform="translate(331.247083 126.621207)scale(0.1 -0.1)">
-     <use xlink:href="#DejaVuSans-28"/>
-     <use xlink:href="#DejaVuSans-78" x="39.013672"/>
-     <use xlink:href="#DejaVuSans-33" x="98.193359"/>
-     <use xlink:href="#DejaVuSans-2e" x="161.816406"/>
-     <use xlink:href="#DejaVuSans-37" x="193.603516"/>
-     <use xlink:href="#DejaVuSans-29" x="257.226562"/>
-    </g>
-   </g>
-   <g id="text_24">
-    <!-- 30.98 -->
-    <g transform="translate(545.178854 35.696625)scale(0.1 -0.1)">
-     <use xlink:href="#DejaVuSans-33"/>
-     <use xlink:href="#DejaVuSans-30" x="63.623047"/>
-     <use xlink:href="#DejaVuSans-2e" x="127.246094"/>
-     <use xlink:href="#DejaVuSans-39" x="159.033203"/>
-     <use xlink:href="#DejaVuSans-38" x="222.65625"/>
-    </g>
-    <!-- (x3.5) -->
-    <g transform="translate(544.680417 46.894438)scale(0.1 -0.1)">
-     <use xlink:href="#DejaVuSans-28"/>
-     <use xlink:href="#DejaVuSans-78" x="39.013672"/>
-     <use xlink:href="#DejaVuSans-33" x="98.193359"/>
-     <use xlink:href="#DejaVuSans-2e" x="161.816406"/>
-     <use xlink:href="#DejaVuSans-35" x="193.603516"/>
-     <use xlink:href="#DejaVuSans-29" x="257.226562"/>
-    </g>
-   </g>
-   <g id="text_25">
-    <!-- 1.26 -->
-    <g transform="translate(761.793437 122.700569)scale(0.1 -0.1)">
-     <use xlink:href="#DejaVuSans-31"/>
-     <use xlink:href="#DejaVuSans-2e" x="63.623047"/>
-     <use xlink:href="#DejaVuSans-32" x="95.410156"/>
-     <use xlink:href="#DejaVuSans-36" x="159.033203"/>
-    </g>
-    <!-- (x4.9) -->
-    <g transform="translate(758.11375 133.898382)scale(0.1 -0.1)">
-     <use xlink:href="#DejaVuSans-28"/>
-     <use xlink:href="#DejaVuSans-78" x="39.013672"/>
-     <use xlink:href="#DejaVuSans-34" x="98.193359"/>
-     <use xlink:href="#DejaVuSans-2e" x="161.816406"/>
-     <use xlink:href="#DejaVuSans-39" x="193.603516"/>
-     <use xlink:href="#DejaVuSans-29" x="257.226562"/>
-    </g>
-   </g>
-   <g id="text_26">
-    <!-- 4.53 -->
-    <g transform="translate(157.06566 35.696625)scale(0.1 -0.1)">
-     <use xlink:href="#DejaVuSans-34"/>
-     <use xlink:href="#DejaVuSans-2e" x="63.623047"/>
-     <use xlink:href="#DejaVuSans-35" x="95.410156"/>
-     <use xlink:href="#DejaVuSans-33" x="159.033203"/>
-    </g>
-    <!-- (x0.4) -->
-    <g transform="translate(153.385972 46.894438)scale(0.1 -0.1)">
-     <use xlink:href="#DejaVuSans-28"/>
-     <use xlink:href="#DejaVuSans-78" x="39.013672"/>
-     <use xlink:href="#DejaVuSans-30" x="98.193359"/>
-     <use xlink:href="#DejaVuSans-2e" x="161.816406"/>
-     <use xlink:href="#DejaVuSans-34" x="193.603516"/>
-     <use xlink:href="#DejaVuSans-29" x="257.226562"/>
-    </g>
-   </g>
-   <g id="text_27">
-    <!-- 1.28 -->
-    <g transform="translate(370.498993 121.864436)scale(0.1 -0.1)">
-     <use xlink:href="#DejaVuSans-31"/>
-     <use xlink:href="#DejaVuSans-2e" x="63.623047"/>
-     <use xlink:href="#DejaVuSans-32" x="95.410156"/>
-     <use xlink:href="#DejaVuSans-38" x="159.033203"/>
-    </g>
-    <!-- (x3.3) -->
-    <g transform="translate(366.819306 133.062248)scale(0.1 -0.1)">
-     <use xlink:href="#DejaVuSans-28"/>
-     <use xlink:href="#DejaVuSans-78" x="39.013672"/>
-     <use xlink:href="#DejaVuSans-33" x="98.193359"/>
-     <use xlink:href="#DejaVuSans-2e" x="161.816406"/>
-     <use xlink:href="#DejaVuSans-33" x="193.603516"/>
-     <use xlink:href="#DejaVuSans-29" x="257.226562"/>
-    </g>
-   </g>
-   <g id="text_28">
-    <!-- 11.56 -->
-    <g transform="translate(580.751076 35.696625)scale(0.1 -0.1)">
-     <use xlink:href="#DejaVuSans-31"/>
-     <use xlink:href="#DejaVuSans-31" x="63.623047"/>
-     <use xlink:href="#DejaVuSans-2e" x="127.246094"/>
-     <use xlink:href="#DejaVuSans-35" x="159.033203"/>
-     <use xlink:href="#DejaVuSans-36" x="222.65625"/>
-    </g>
-    <!-- (x1.3) -->
-    <g transform="translate(580.252639 46.894438)scale(0.1 -0.1)">
-     <use xlink:href="#DejaVuSans-28"/>
-     <use xlink:href="#DejaVuSans-78" x="39.013672"/>
-     <use xlink:href="#DejaVuSans-31" x="98.193359"/>
-     <use xlink:href="#DejaVuSans-2e" x="161.816406"/>
-     <use xlink:href="#DejaVuSans-33" x="193.603516"/>
-     <use xlink:href="#DejaVuSans-29" x="257.226562"/>
-    </g>
-   </g>
-   <g id="text_29">
-    <!-- 3.25 -->
-    <g transform="translate(797.36566 27.708638)scale(0.1 -0.1)">
-     <use xlink:href="#DejaVuSans-33"/>
-     <use xlink:href="#DejaVuSans-2e" x="63.623047"/>
-     <use xlink:href="#DejaVuSans-32" x="95.410156"/>
-     <use xlink:href="#DejaVuSans-35" x="159.033203"/>
-    </g>
-    <!-- (x12.5) -->
-    <g transform="translate(790.504722 38.90645)scale(0.1 -0.1)">
-     <use xlink:href="#DejaVuSans-28"/>
-     <use xlink:href="#DejaVuSans-78" x="39.013672"/>
-     <use xlink:href="#DejaVuSans-31" x="98.193359"/>
-     <use xlink:href="#DejaVuSans-32" x="161.816406"/>
-     <use xlink:href="#DejaVuSans-2e" x="225.439453"/>
-     <use xlink:href="#DejaVuSans-35" x="257.226562"/>
-     <use xlink:href="#DejaVuSans-29" x="320.849609"/>
-    </g>
-   </g>
-   <g id="text_30">
-    <!-- 10.96 -->
-    <g transform="translate(189.456632 49.894438)scale(0.1 -0.1)">
-     <use xlink:href="#DejaVuSans-31"/>
-     <use xlink:href="#DejaVuSans-30" x="63.623047"/>
-     <use xlink:href="#DejaVuSans-2e" x="127.246094"/>
-     <use xlink:href="#DejaVuSans-39" x="159.033203"/>
-     <use xlink:href="#DejaVuSans-36" x="222.65625"/>
-    </g>
-   </g>
-   <g id="text_31">
-    <!-- 0.38 -->
-    <g transform="translate(406.071215 178.890258)scale(0.1 -0.1)">
-     <use xlink:href="#DejaVuSans-30"/>
-     <use xlink:href="#DejaVuSans-2e" x="63.623047"/>
-     <use xlink:href="#DejaVuSans-33" x="95.410156"/>
-     <use xlink:href="#DejaVuSans-38" x="159.033203"/>
-    </g>
-   </g>
-   <g id="text_32">
-    <!-- 8.74 -->
-    <g transform="translate(619.504549 49.894438)scale(0.1 -0.1)">
-     <use xlink:href="#DejaVuSans-38"/>
-     <use xlink:href="#DejaVuSans-2e" x="63.623047"/>
-     <use xlink:href="#DejaVuSans-37" x="95.410156"/>
-     <use xlink:href="#DejaVuSans-34" x="159.033203"/>
-    </g>
-   </g>
-   <g id="text_33">
-    <!-- 0.26 -->
-    <g transform="translate(832.937882 184.869581)scale(0.1 -0.1)">
-     <use xlink:href="#DejaVuSans-30"/>
-     <use xlink:href="#DejaVuSans-2e" x="63.623047"/>
-     <use xlink:href="#DejaVuSans-32" x="95.410156"/>
-     <use xlink:href="#DejaVuSans-36" x="159.033203"/>
-    </g>
-   </g>
-   <g id="text_34">
-    <!-- Binary size -->
-    <g transform="translate(419.955313 9.118125)scale(0.12 -0.12)">
-     <defs>
-      <path id="DejaVuSans-72" d="M 2631 2963 
-Q 2534 3019 2420 3045 
-Q 2306 3072 2169 3072 
-Q 1681 3072 1420 2755 
-Q 1159 2438 1159 1844 
-L 1159 0 
-L 581 0 
-L 581 3500 
-L 1159 3500 
-L 1159 2956 
-Q 1341 3275 1631 3429 
-Q 1922 3584 2338 3584 
-Q 2397 3584 2469 3576 
-Q 2541 3569 2628 3553 
-L 2631 2963 
-z
-" transform="scale(0.015625)"/>
-      <path id="DejaVuSans-79" d="M 2059 -325 
-Q 1816 -950 1584 -1140 
-Q 1353 -1331 966 -1331 
-L 506 -1331 
-L 506 -850 
-L 844 -850 
-Q 1081 -850 1212 -737 
-Q 1344 -625 1503 -206 
-L 1606 56 
-L 191 3500 
-L 800 3500 
-L 1894 763 
-L 2988 3500 
-L 3597 3500 
-L 2059 -325 
-z
-" transform="scale(0.015625)"/>
-     </defs>
-     <use xlink:href="#DejaVuSans-42"/>
-     <use xlink:href="#DejaVuSans-69" x="68.603516"/>
-     <use xlink:href="#DejaVuSans-6e" x="96.386719"/>
-     <use xlink:href="#DejaVuSans-61" x="159.765625"/>
-     <use xlink:href="#DejaVuSans-72" x="221.044922"/>
-     <use xlink:href="#DejaVuSans-79" x="262.158203"/>
-     <use xlink:href="#DejaVuSans-20" x="321.337891"/>
-     <use xlink:href="#DejaVuSans-73" x="353.125"/>
-     <use xlink:href="#DejaVuSans-69" x="405.224609"/>
-     <use xlink:href="#DejaVuSans-7a" x="433.007812"/>
-     <use xlink:href="#DejaVuSans-65" x="485.498047"/>
-    </g>
-   </g>
-   <g id="legend_1">
-    <g id="patch_29">
-     <path d="M 43.58125 194.398125 
-L 203.078125 194.398125 
-Q 205.078125 194.398125 205.078125 192.398125 
-L 205.078125 119.729375 
-Q 205.078125 117.729375 203.078125 117.729375 
-L 43.58125 117.729375 
-Q 41.58125 117.729375 41.58125 119.729375 
-L 41.58125 192.398125 
-Q 41.58125 194.398125 43.58125 194.398125 
-z
-" style="fill: #ffffff; opacity: 0.8; stroke: #cccccc; stroke-linejoin: miter"/>
-    </g>
-    <g id="patch_30">
-     <path d="M 45.58125 129.327813 
-L 65.58125 129.327813 
-L 65.58125 122.327813 
-L 45.58125 122.327813 
-z
-" style="fill: #ff7f0e; stroke: #000000; stroke-linejoin: miter"/>
-    </g>
-    <g id="text_35">
-     <!-- Boost.Python -->
-     <g transform="translate(73.58125 129.327813)scale(0.1 -0.1)">
-      <defs>
-       <path id="DejaVuSans-50" d="M 1259 4147 
-L 1259 2394 
-L 2053 2394 
-Q 2494 2394 2734 2622 
-Q 2975 2850 2975 3272 
-Q 2975 3691 2734 3919 
-Q 2494 4147 2053 4147 
-L 1259 4147 
-z
-M 628 4666 
-L 2053 4666 
-Q 2838 4666 3239 4311 
-Q 3641 3956 3641 3272 
-Q 3641 2581 3239 2228 
-Q 2838 1875 2053 1875 
-L 1259 1875 
-L 1259 0 
-L 628 0 
-L 628 4666 
-z
-" transform="scale(0.015625)"/>
-       <path id="DejaVuSans-68" d="M 3513 2113 
-L 3513 0 
-L 2938 0 
-L 2938 2094 
-Q 2938 2591 2744 2837 
-Q 2550 3084 2163 3084 
-Q 1697 3084 1428 2787 
-Q 1159 2491 1159 1978 
-L 1159 0 
-L 581 0 
-L 581 4863 
-L 1159 4863 
-L 1159 2956 
-Q 1366 3272 1645 3428 
-Q 1925 3584 2291 3584 
-Q 2894 3584 3203 3211 
-Q 3513 2838 3513 2113 
-z
-" transform="scale(0.015625)"/>
-      </defs>
-      <use xlink:href="#DejaVuSans-42"/>
-      <use xlink:href="#DejaVuSans-6f" x="68.603516"/>
-      <use xlink:href="#DejaVuSans-6f" x="129.785156"/>
-      <use xlink:href="#DejaVuSans-73" x="190.966797"/>
-      <use xlink:href="#DejaVuSans-74" x="243.066406"/>
-      <use xlink:href="#DejaVuSans-2e" x="282.275391"/>
-      <use xlink:href="#DejaVuSans-50" x="314.0625"/>
-      <use xlink:href="#DejaVuSans-79" x="374.365234"/>
-      <use xlink:href="#DejaVuSans-74" x="433.544922"/>
-      <use xlink:href="#DejaVuSans-68" x="472.753906"/>
-      <use xlink:href="#DejaVuSans-6f" x="536.132812"/>
-      <use xlink:href="#DejaVuSans-6e" x="597.314453"/>
-     </g>
-    </g>
-    <g id="patch_31">
-     <path d="M 45.58125 144.005938 
-L 65.58125 144.005938 
-L 65.58125 137.005938 
-L 45.58125 137.005938 
-z
-" style="fill: #d62728; stroke: #000000; stroke-linejoin: miter"/>
-    </g>
-    <g id="text_36">
-     <!-- pybind11 -->
-     <g transform="translate(73.58125 144.005938)scale(0.1 -0.1)">
-      <use xlink:href="#DejaVuSans-70"/>
-      <use xlink:href="#DejaVuSans-79" x="63.476562"/>
-      <use xlink:href="#DejaVuSans-62" x="122.65625"/>
-      <use xlink:href="#DejaVuSans-69" x="186.132812"/>
-      <use xlink:href="#DejaVuSans-6e" x="213.916016"/>
-      <use xlink:href="#DejaVuSans-64" x="277.294922"/>
-      <use xlink:href="#DejaVuSans-31" x="340.771484"/>
-      <use xlink:href="#DejaVuSans-31" x="404.394531"/>
-     </g>
-    </g>
-    <g id="patch_32">
-     <path d="M 45.58125 158.684063 
-L 65.58125 158.684063 
-L 65.58125 151.684063 
-L 45.58125 151.684063 
-z
-" style="fill: #8c564b; stroke: #000000; stroke-linejoin: miter"/>
-    </g>
-    <g id="text_37">
-     <!-- pybind11 + smart_holder -->
-     <g transform="translate(73.58125 158.684063)scale(0.1 -0.1)">
-      <defs>
-       <path id="DejaVuSans-2b" d="M 2944 4013 
-L 2944 2272 
-L 4684 2272 
-L 4684 1741 
-L 2944 1741 
-L 2944 0 
-L 2419 0 
-L 2419 1741 
-L 678 1741 
-L 678 2272 
-L 2419 2272 
-L 2419 4013 
-L 2944 4013 
-z
-" transform="scale(0.015625)"/>
-       <path id="DejaVuSans-6d" d="M 3328 2828 
-Q 3544 3216 3844 3400 
-Q 4144 3584 4550 3584 
-Q 5097 3584 5394 3201 
-Q 5691 2819 5691 2113 
-L 5691 0 
-L 5113 0 
-L 5113 2094 
-Q 5113 2597 4934 2840 
-Q 4756 3084 4391 3084 
-Q 3944 3084 3684 2787 
-Q 3425 2491 3425 1978 
-L 3425 0 
-L 2847 0 
-L 2847 2094 
-Q 2847 2600 2669 2842 
-Q 2491 3084 2119 3084 
-Q 1678 3084 1418 2786 
-Q 1159 2488 1159 1978 
-L 1159 0 
-L 581 0 
-L 581 3500 
-L 1159 3500 
-L 1159 2956 
-Q 1356 3278 1631 3431 
-Q 1906 3584 2284 3584 
-Q 2666 3584 2933 3390 
-Q 3200 3197 3328 2828 
-z
-" transform="scale(0.015625)"/>
-       <path id="DejaVuSans-5f" d="M 3263 -1063 
-L 3263 -1509 
-L -63 -1509 
-L -63 -1063 
-L 3263 -1063 
-z
-" transform="scale(0.015625)"/>
-      </defs>
-      <use xlink:href="#DejaVuSans-70"/>
-      <use xlink:href="#DejaVuSans-79" x="63.476562"/>
-      <use xlink:href="#DejaVuSans-62" x="122.65625"/>
-      <use xlink:href="#DejaVuSans-69" x="186.132812"/>
-      <use xlink:href="#DejaVuSans-6e" x="213.916016"/>
-      <use xlink:href="#DejaVuSans-64" x="277.294922"/>
-      <use xlink:href="#DejaVuSans-31" x="340.771484"/>
-      <use xlink:href="#DejaVuSans-31" x="404.394531"/>
-      <use xlink:href="#DejaVuSans-20" x="468.017578"/>
-      <use xlink:href="#DejaVuSans-2b" x="499.804688"/>
-      <use xlink:href="#DejaVuSans-20" x="583.59375"/>
-      <use xlink:href="#DejaVuSans-73" x="615.380859"/>
-      <use xlink:href="#DejaVuSans-6d" x="667.480469"/>
-      <use xlink:href="#DejaVuSans-61" x="764.892578"/>
-      <use xlink:href="#DejaVuSans-72" x="826.171875"/>
-      <use xlink:href="#DejaVuSans-74" x="867.285156"/>
-      <use xlink:href="#DejaVuSans-5f" x="906.494141"/>
-      <use xlink:href="#DejaVuSans-68" x="956.494141"/>
-      <use xlink:href="#DejaVuSans-6f" x="1019.873047"/>
-      <use xlink:href="#DejaVuSans-6c" x="1081.054688"/>
-      <use xlink:href="#DejaVuSans-64" x="1108.837891"/>
-      <use xlink:href="#DejaVuSans-65" x="1172.314453"/>
-      <use xlink:href="#DejaVuSans-72" x="1233.837891"/>
-     </g>
-    </g>
-    <g id="patch_33">
-     <path d="M 45.58125 173.640313 
-L 65.58125 173.640313 
-L 65.58125 166.640313 
-L 45.58125 166.640313 
-z
-" style="fill: #9467bd; stroke: #000000; stroke-linejoin: miter"/>
-    </g>
-    <g id="text_38">
-     <!-- Cython -->
-     <g transform="translate(73.58125 173.640313)scale(0.1 -0.1)">
-      <defs>
-       <path id="DejaVuSans-43" d="M 4122 4306 
-L 4122 3641 
-Q 3803 3938 3442 4084 
-Q 3081 4231 2675 4231 
-Q 1875 4231 1450 3742 
-Q 1025 3253 1025 2328 
-Q 1025 1406 1450 917 
-Q 1875 428 2675 428 
-Q 3081 428 3442 575 
-Q 3803 722 4122 1019 
-L 4122 359 
-Q 3791 134 3420 21 
-Q 3050 -91 2638 -91 
-Q 1578 -91 968 557 
-Q 359 1206 359 2328 
-Q 359 3453 968 4101 
-Q 1578 4750 2638 4750 
-Q 3056 4750 3426 4639 
-Q 3797 4528 4122 4306 
-z
-" transform="scale(0.015625)"/>
-      </defs>
-      <use xlink:href="#DejaVuSans-43"/>
-      <use xlink:href="#DejaVuSans-79" x="69.824219"/>
-      <use xlink:href="#DejaVuSans-74" x="129.003906"/>
-      <use xlink:href="#DejaVuSans-68" x="168.212891"/>
-      <use xlink:href="#DejaVuSans-6f" x="231.591797"/>
-      <use xlink:href="#DejaVuSans-6e" x="292.773438"/>
-     </g>
-    </g>
-    <g id="patch_34">
-     <path d="M 45.58125 188.318438 
-L 65.58125 188.318438 
-L 65.58125 181.318438 
-L 45.58125 181.318438 
-z
-" style="fill: #1f77b4; stroke: #000000; stroke-linejoin: miter"/>
-    </g>
-    <g id="text_39">
-     <!-- nanobind -->
-     <g transform="translate(73.58125 188.318438)scale(0.1 -0.1)">
-      <use xlink:href="#DejaVuSans-6e"/>
-      <use xlink:href="#DejaVuSans-61" x="63.378906"/>
-      <use xlink:href="#DejaVuSans-6e" x="124.658203"/>
-      <use xlink:href="#DejaVuSans-6f" x="188.037109"/>
-      <use xlink:href="#DejaVuSans-62" x="249.21875"/>
-      <use xlink:href="#DejaVuSans-69" x="312.695312"/>
-      <use xlink:href="#DejaVuSans-6e" x="340.478516"/>
-      <use xlink:href="#DejaVuSans-64" x="403.857422"/>
-     </g>
-    </g>
-   </g>
-  </g>
- </g>
- <defs>
-  <clipPath id="p3e07c8c336">
-   <rect x="36.58125" y="15.118125" width="832.39" height="184.28"/>
-  </clipPath>
- </defs>
-</svg>
diff --git a/src/nanobind/docs/images/times.svg b/src/nanobind/docs/images/times.svg
deleted file mode 100644
index 686dfe5..0000000
--- a/src/nanobind/docs/images/times.svg
+++ /dev/null
@@ -1,1859 +0,0 @@
-<?xml version="1.0" encoding="utf-8" standalone="no"?>
-<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN"
-  "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd">
-<svg xmlns:xlink="http://www.w3.org/1999/xlink" width="868.943125pt" height="216.07625pt" viewBox="0 0 868.943125 216.07625" xmlns="http://www.w3.org/2000/svg" version="1.1">
- <metadata>
-  <rdf:RDF xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:cc="http://creativecommons.org/ns#" xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#">
-   <cc:Work>
-    <dc:type rdf:resource="http://purl.org/dc/dcmitype/StillImage"/>
-    <dc:date>2023-04-24T16:53:10.667274</dc:date>
-    <dc:format>image/svg+xml</dc:format>
-    <dc:creator>
-     <cc:Agent>
-      <dc:title>Matplotlib v3.5.1, https://matplotlib.org/</dc:title>
-     </cc:Agent>
-    </dc:creator>
-   </cc:Work>
-  </rdf:RDF>
- </metadata>
- <defs>
-  <style type="text/css">*{stroke-linejoin: round; stroke-linecap: butt}</style>
- </defs>
- <g id="figure_1">
-  <g id="patch_1">
-   <path d="M 0 216.07625 
-L 868.943125 216.07625 
-L 868.943125 0 
-L 0 0 
-z
-" style="fill: #ffffff"/>
-  </g>
-  <g id="axes_1">
-   <g id="patch_2">
-    <path d="M 33.403125 199.398125 
-L 868.943125 199.398125 
-L 868.943125 15.118125 
-L 33.403125 15.118125 
-z
-" style="fill: #ffffff"/>
-   </g>
-   <g id="patch_3">
-    <path d="M 40.544493 199.398125 
-L 76.25133 199.398125 
-L 76.25133 155.279789 
-L 40.544493 155.279789 
-z
-" clip-path="url(#p042a290d9a)" style="fill: #ff7f0e; stroke: #000000; stroke-linejoin: miter"/>
-   </g>
-   <g id="patch_4">
-    <path d="M 254.785518 199.398125 
-L 290.492356 199.398125 
-L 290.492356 117.186373 
-L 254.785518 117.186373 
-z
-" clip-path="url(#p042a290d9a)" style="fill: #ff7f0e; stroke: #000000; stroke-linejoin: miter"/>
-   </g>
-   <g id="patch_5">
-    <path d="M 469.026544 199.398125 
-L 504.733381 199.398125 
-L 504.733381 133.214577 
-L 469.026544 133.214577 
-z
-" clip-path="url(#p042a290d9a)" style="fill: #ff7f0e; stroke: #000000; stroke-linejoin: miter"/>
-   </g>
-   <g id="patch_6">
-    <path d="M 683.267569 199.398125 
-L 718.974407 199.398125 
-L 718.974407 81.335046 
-L 683.267569 81.335046 
-z
-" clip-path="url(#p042a290d9a)" style="fill: #ff7f0e; stroke: #000000; stroke-linejoin: miter"/>
-   </g>
-   <g id="patch_7">
-    <path d="M 76.25133 199.398125 
-L 111.958168 199.398125 
-L 111.958168 125.52643 
-L 76.25133 125.52643 
-z
-" clip-path="url(#p042a290d9a)" style="fill: #d62728; stroke: #000000; stroke-linejoin: miter"/>
-   </g>
-   <g id="patch_8">
-    <path d="M 290.492356 199.398125 
-L 326.199193 199.398125 
-L 326.199193 105.018086 
-L 290.492356 105.018086 
-z
-" clip-path="url(#p042a290d9a)" style="fill: #d62728; stroke: #000000; stroke-linejoin: miter"/>
-   </g>
-   <g id="patch_9">
-    <path d="M 504.733381 199.398125 
-L 540.440219 199.398125 
-L 540.440219 126.025857 
-L 504.733381 126.025857 
-z
-" clip-path="url(#p042a290d9a)" style="fill: #d62728; stroke: #000000; stroke-linejoin: miter"/>
-   </g>
-   <g id="patch_10">
-    <path d="M 718.974407 199.398125 
-L 754.681245 199.398125 
-L 754.681245 94.254184 
-L 718.974407 94.254184 
-z
-" clip-path="url(#p042a290d9a)" style="fill: #d62728; stroke: #000000; stroke-linejoin: miter"/>
-   </g>
-   <g id="patch_11">
-    <path d="M 111.958168 199.398125 
-L 147.665005 199.398125 
-L 147.665005 124.982827 
-L 111.958168 124.982827 
-z
-" clip-path="url(#p042a290d9a)" style="fill: #8c564b; stroke: #000000; stroke-linejoin: miter"/>
-   </g>
-   <g id="patch_12">
-    <path d="M 326.199193 199.398125 
-L 361.906031 199.398125 
-L 361.906031 104.148757 
-L 326.199193 104.148757 
-z
-" clip-path="url(#p042a290d9a)" style="fill: #8c564b; stroke: #000000; stroke-linejoin: miter"/>
-   </g>
-   <g id="patch_13">
-    <path d="M 540.440219 199.398125 
-L 576.147057 199.398125 
-L 576.147057 121.069674 
-L 540.440219 121.069674 
-z
-" clip-path="url(#p042a290d9a)" style="fill: #8c564b; stroke: #000000; stroke-linejoin: miter"/>
-   </g>
-   <g id="patch_14">
-    <path d="M 754.681245 199.398125 
-L 790.388082 199.398125 
-L 790.388082 62.173895 
-L 754.681245 62.173895 
-z
-" clip-path="url(#p042a290d9a)" style="fill: #8c564b; stroke: #000000; stroke-linejoin: miter"/>
-   </g>
-   <g id="patch_15">
-    <path d="M 147.665005 199.398125 
-L 183.371843 199.398125 
-L 183.371843 174.433835 
-L 147.665005 174.433835 
-z
-" clip-path="url(#p042a290d9a)" style="fill: #9467bd; stroke: #000000; stroke-linejoin: miter"/>
-   </g>
-   <g id="patch_16">
-    <path d="M 361.906031 199.398125 
-L 397.612869 199.398125 
-L 397.612869 142.808627 
-L 361.906031 142.808627 
-z
-" clip-path="url(#p042a290d9a)" style="fill: #9467bd; stroke: #000000; stroke-linejoin: miter"/>
-   </g>
-   <g id="patch_17">
-    <path d="M 576.147057 199.398125 
-L 611.853894 199.398125 
-L 611.853894 141.189894 
-L 576.147057 141.189894 
-z
-" clip-path="url(#p042a290d9a)" style="fill: #9467bd; stroke: #000000; stroke-linejoin: miter"/>
-   </g>
-   <g id="patch_18">
-    <path d="M 790.388082 199.398125 
-L 826.09492 199.398125 
-L 826.09492 46.974635 
-L 790.388082 46.974635 
-z
-" clip-path="url(#p042a290d9a)" style="fill: #9467bd; stroke: #000000; stroke-linejoin: miter"/>
-   </g>
-   <g id="patch_19">
-    <path d="M 183.371843 199.398125 
-L 219.078681 199.398125 
-L 219.078681 167.428371 
-L 183.371843 167.428371 
-z
-" clip-path="url(#p042a290d9a)" style="fill: #1f77b4; stroke: #000000; stroke-linejoin: miter"/>
-   </g>
-   <g id="patch_20">
-    <path d="M 397.612869 199.398125 
-L 433.319706 199.398125 
-L 433.319706 164.398183 
-L 397.612869 164.398183 
-z
-" clip-path="url(#p042a290d9a)" style="fill: #1f77b4; stroke: #000000; stroke-linejoin: miter"/>
-   </g>
-   <g id="patch_21">
-    <path d="M 611.853894 199.398125 
-L 647.560732 199.398125 
-L 647.560732 169.390973 
-L 611.853894 169.390973 
-z
-" clip-path="url(#p042a290d9a)" style="fill: #1f77b4; stroke: #000000; stroke-linejoin: miter"/>
-   </g>
-   <g id="patch_22">
-    <path d="M 826.09492 199.398125 
-L 861.801757 199.398125 
-L 861.801757 164.957286 
-L 826.09492 164.957286 
-z
-" clip-path="url(#p042a290d9a)" style="fill: #1f77b4; stroke: #000000; stroke-linejoin: miter"/>
-   </g>
-   <g id="patch_23">
-    <path d="M 11.979022 204.242382 
-L 226.220048 204.242382 
-L 226.220048 68.60318 
-L 11.979022 68.60318 
-z
-" clip-path="url(#p042a290d9a)" style="fill: #ffffff; opacity: 0.8"/>
-   </g>
-   <g id="patch_24">
-    <path d="M 451.173125 204.242382 
-L 665.414151 204.242382 
-L 665.414151 83.135952 
-L 451.173125 83.135952 
-z
-" clip-path="url(#p042a290d9a)" style="fill: #ffffff; opacity: 0.8"/>
-   </g>
-   <g id="matplotlib.axis_1">
-    <g id="xtick_1">
-     <g id="line2d_1">
-      <defs>
-       <path id="me11ec72ead" d="M 0 0 
-L 0 3.5 
-" style="stroke: #000000; stroke-width: 0.8"/>
-      </defs>
-      <g>
-       <use xlink:href="#me11ec72ead" x="129.811587" y="199.398125" style="stroke: #000000; stroke-width: 0.8"/>
-      </g>
-     </g>
-     <g id="text_1">
-      <!-- func [debug] -->
-      <g transform="translate(97.706118 213.996563)scale(0.1 -0.1)">
-       <defs>
-        <path id="DejaVuSans-66" d="M 2375 4863 
-L 2375 4384 
-L 1825 4384 
-Q 1516 4384 1395 4259 
-Q 1275 4134 1275 3809 
-L 1275 3500 
-L 2222 3500 
-L 2222 3053 
-L 1275 3053 
-L 1275 0 
-L 697 0 
-L 697 3053 
-L 147 3053 
-L 147 3500 
-L 697 3500 
-L 697 3744 
-Q 697 4328 969 4595 
-Q 1241 4863 1831 4863 
-L 2375 4863 
-z
-" transform="scale(0.015625)"/>
-        <path id="DejaVuSans-75" d="M 544 1381 
-L 544 3500 
-L 1119 3500 
-L 1119 1403 
-Q 1119 906 1312 657 
-Q 1506 409 1894 409 
-Q 2359 409 2629 706 
-Q 2900 1003 2900 1516 
-L 2900 3500 
-L 3475 3500 
-L 3475 0 
-L 2900 0 
-L 2900 538 
-Q 2691 219 2414 64 
-Q 2138 -91 1772 -91 
-Q 1169 -91 856 284 
-Q 544 659 544 1381 
-z
-M 1991 3584 
-L 1991 3584 
-z
-" transform="scale(0.015625)"/>
-        <path id="DejaVuSans-6e" d="M 3513 2113 
-L 3513 0 
-L 2938 0 
-L 2938 2094 
-Q 2938 2591 2744 2837 
-Q 2550 3084 2163 3084 
-Q 1697 3084 1428 2787 
-Q 1159 2491 1159 1978 
-L 1159 0 
-L 581 0 
-L 581 3500 
-L 1159 3500 
-L 1159 2956 
-Q 1366 3272 1645 3428 
-Q 1925 3584 2291 3584 
-Q 2894 3584 3203 3211 
-Q 3513 2838 3513 2113 
-z
-" transform="scale(0.015625)"/>
-        <path id="DejaVuSans-63" d="M 3122 3366 
-L 3122 2828 
-Q 2878 2963 2633 3030 
-Q 2388 3097 2138 3097 
-Q 1578 3097 1268 2742 
-Q 959 2388 959 1747 
-Q 959 1106 1268 751 
-Q 1578 397 2138 397 
-Q 2388 397 2633 464 
-Q 2878 531 3122 666 
-L 3122 134 
-Q 2881 22 2623 -34 
-Q 2366 -91 2075 -91 
-Q 1284 -91 818 406 
-Q 353 903 353 1747 
-Q 353 2603 823 3093 
-Q 1294 3584 2113 3584 
-Q 2378 3584 2631 3529 
-Q 2884 3475 3122 3366 
-z
-" transform="scale(0.015625)"/>
-        <path id="DejaVuSans-20" transform="scale(0.015625)"/>
-        <path id="DejaVuSans-5b" d="M 550 4863 
-L 1875 4863 
-L 1875 4416 
-L 1125 4416 
-L 1125 -397 
-L 1875 -397 
-L 1875 -844 
-L 550 -844 
-L 550 4863 
-z
-" transform="scale(0.015625)"/>
-        <path id="DejaVuSans-64" d="M 2906 2969 
-L 2906 4863 
-L 3481 4863 
-L 3481 0 
-L 2906 0 
-L 2906 525 
-Q 2725 213 2448 61 
-Q 2172 -91 1784 -91 
-Q 1150 -91 751 415 
-Q 353 922 353 1747 
-Q 353 2572 751 3078 
-Q 1150 3584 1784 3584 
-Q 2172 3584 2448 3432 
-Q 2725 3281 2906 2969 
-z
-M 947 1747 
-Q 947 1113 1208 752 
-Q 1469 391 1925 391 
-Q 2381 391 2643 752 
-Q 2906 1113 2906 1747 
-Q 2906 2381 2643 2742 
-Q 2381 3103 1925 3103 
-Q 1469 3103 1208 2742 
-Q 947 2381 947 1747 
-z
-" transform="scale(0.015625)"/>
-        <path id="DejaVuSans-65" d="M 3597 1894 
-L 3597 1613 
-L 953 1613 
-Q 991 1019 1311 708 
-Q 1631 397 2203 397 
-Q 2534 397 2845 478 
-Q 3156 559 3463 722 
-L 3463 178 
-Q 3153 47 2828 -22 
-Q 2503 -91 2169 -91 
-Q 1331 -91 842 396 
-Q 353 884 353 1716 
-Q 353 2575 817 3079 
-Q 1281 3584 2069 3584 
-Q 2775 3584 3186 3129 
-Q 3597 2675 3597 1894 
-z
-M 3022 2063 
-Q 3016 2534 2758 2815 
-Q 2500 3097 2075 3097 
-Q 1594 3097 1305 2825 
-Q 1016 2553 972 2059 
-L 3022 2063 
-z
-" transform="scale(0.015625)"/>
-        <path id="DejaVuSans-62" d="M 3116 1747 
-Q 3116 2381 2855 2742 
-Q 2594 3103 2138 3103 
-Q 1681 3103 1420 2742 
-Q 1159 2381 1159 1747 
-Q 1159 1113 1420 752 
-Q 1681 391 2138 391 
-Q 2594 391 2855 752 
-Q 3116 1113 3116 1747 
-z
-M 1159 2969 
-Q 1341 3281 1617 3432 
-Q 1894 3584 2278 3584 
-Q 2916 3584 3314 3078 
-Q 3713 2572 3713 1747 
-Q 3713 922 3314 415 
-Q 2916 -91 2278 -91 
-Q 1894 -91 1617 61 
-Q 1341 213 1159 525 
-L 1159 0 
-L 581 0 
-L 581 4863 
-L 1159 4863 
-L 1159 2969 
-z
-" transform="scale(0.015625)"/>
-        <path id="DejaVuSans-67" d="M 2906 1791 
-Q 2906 2416 2648 2759 
-Q 2391 3103 1925 3103 
-Q 1463 3103 1205 2759 
-Q 947 2416 947 1791 
-Q 947 1169 1205 825 
-Q 1463 481 1925 481 
-Q 2391 481 2648 825 
-Q 2906 1169 2906 1791 
-z
-M 3481 434 
-Q 3481 -459 3084 -895 
-Q 2688 -1331 1869 -1331 
-Q 1566 -1331 1297 -1286 
-Q 1028 -1241 775 -1147 
-L 775 -588 
-Q 1028 -725 1275 -790 
-Q 1522 -856 1778 -856 
-Q 2344 -856 2625 -561 
-Q 2906 -266 2906 331 
-L 2906 616 
-Q 2728 306 2450 153 
-Q 2172 0 1784 0 
-Q 1141 0 747 490 
-Q 353 981 353 1791 
-Q 353 2603 747 3093 
-Q 1141 3584 1784 3584 
-Q 2172 3584 2450 3431 
-Q 2728 3278 2906 2969 
-L 2906 3500 
-L 3481 3500 
-L 3481 434 
-z
-" transform="scale(0.015625)"/>
-        <path id="DejaVuSans-5d" d="M 1947 4863 
-L 1947 -844 
-L 622 -844 
-L 622 -397 
-L 1369 -397 
-L 1369 4416 
-L 622 4416 
-L 622 4863 
-L 1947 4863 
-z
-" transform="scale(0.015625)"/>
-       </defs>
-       <use xlink:href="#DejaVuSans-66"/>
-       <use xlink:href="#DejaVuSans-75" x="35.205078"/>
-       <use xlink:href="#DejaVuSans-6e" x="98.583984"/>
-       <use xlink:href="#DejaVuSans-63" x="161.962891"/>
-       <use xlink:href="#DejaVuSans-20" x="216.943359"/>
-       <use xlink:href="#DejaVuSans-5b" x="248.730469"/>
-       <use xlink:href="#DejaVuSans-64" x="287.744141"/>
-       <use xlink:href="#DejaVuSans-65" x="351.220703"/>
-       <use xlink:href="#DejaVuSans-62" x="412.744141"/>
-       <use xlink:href="#DejaVuSans-75" x="476.220703"/>
-       <use xlink:href="#DejaVuSans-67" x="539.599609"/>
-       <use xlink:href="#DejaVuSans-5d" x="603.076172"/>
-      </g>
-     </g>
-    </g>
-    <g id="xtick_2">
-     <g id="line2d_2">
-      <g>
-       <use xlink:href="#me11ec72ead" x="344.052612" y="199.398125" style="stroke: #000000; stroke-width: 0.8"/>
-      </g>
-     </g>
-     <g id="text_2">
-      <!-- func [opt] -->
-      <g transform="translate(319.521362 213.996563)scale(0.1 -0.1)">
-       <defs>
-        <path id="DejaVuSans-6f" d="M 1959 3097 
-Q 1497 3097 1228 2736 
-Q 959 2375 959 1747 
-Q 959 1119 1226 758 
-Q 1494 397 1959 397 
-Q 2419 397 2687 759 
-Q 2956 1122 2956 1747 
-Q 2956 2369 2687 2733 
-Q 2419 3097 1959 3097 
-z
-M 1959 3584 
-Q 2709 3584 3137 3096 
-Q 3566 2609 3566 1747 
-Q 3566 888 3137 398 
-Q 2709 -91 1959 -91 
-Q 1206 -91 779 398 
-Q 353 888 353 1747 
-Q 353 2609 779 3096 
-Q 1206 3584 1959 3584 
-z
-" transform="scale(0.015625)"/>
-        <path id="DejaVuSans-70" d="M 1159 525 
-L 1159 -1331 
-L 581 -1331 
-L 581 3500 
-L 1159 3500 
-L 1159 2969 
-Q 1341 3281 1617 3432 
-Q 1894 3584 2278 3584 
-Q 2916 3584 3314 3078 
-Q 3713 2572 3713 1747 
-Q 3713 922 3314 415 
-Q 2916 -91 2278 -91 
-Q 1894 -91 1617 61 
-Q 1341 213 1159 525 
-z
-M 3116 1747 
-Q 3116 2381 2855 2742 
-Q 2594 3103 2138 3103 
-Q 1681 3103 1420 2742 
-Q 1159 2381 1159 1747 
-Q 1159 1113 1420 752 
-Q 1681 391 2138 391 
-Q 2594 391 2855 752 
-Q 3116 1113 3116 1747 
-z
-" transform="scale(0.015625)"/>
-        <path id="DejaVuSans-74" d="M 1172 4494 
-L 1172 3500 
-L 2356 3500 
-L 2356 3053 
-L 1172 3053 
-L 1172 1153 
-Q 1172 725 1289 603 
-Q 1406 481 1766 481 
-L 2356 481 
-L 2356 0 
-L 1766 0 
-Q 1100 0 847 248 
-Q 594 497 594 1153 
-L 594 3053 
-L 172 3053 
-L 172 3500 
-L 594 3500 
-L 594 4494 
-L 1172 4494 
-z
-" transform="scale(0.015625)"/>
-       </defs>
-       <use xlink:href="#DejaVuSans-66"/>
-       <use xlink:href="#DejaVuSans-75" x="35.205078"/>
-       <use xlink:href="#DejaVuSans-6e" x="98.583984"/>
-       <use xlink:href="#DejaVuSans-63" x="161.962891"/>
-       <use xlink:href="#DejaVuSans-20" x="216.943359"/>
-       <use xlink:href="#DejaVuSans-5b" x="248.730469"/>
-       <use xlink:href="#DejaVuSans-6f" x="287.744141"/>
-       <use xlink:href="#DejaVuSans-70" x="348.925781"/>
-       <use xlink:href="#DejaVuSans-74" x="412.402344"/>
-       <use xlink:href="#DejaVuSans-5d" x="451.611328"/>
-      </g>
-     </g>
-    </g>
-    <g id="xtick_3">
-     <g id="line2d_3">
-      <g>
-       <use xlink:href="#me11ec72ead" x="558.293638" y="199.398125" style="stroke: #000000; stroke-width: 0.8"/>
-      </g>
-     </g>
-     <g id="text_3">
-      <!-- class [debug] -->
-      <g transform="translate(524.623325 213.996563)scale(0.1 -0.1)">
-       <defs>
-        <path id="DejaVuSans-6c" d="M 603 4863 
-L 1178 4863 
-L 1178 0 
-L 603 0 
-L 603 4863 
-z
-" transform="scale(0.015625)"/>
-        <path id="DejaVuSans-61" d="M 2194 1759 
-Q 1497 1759 1228 1600 
-Q 959 1441 959 1056 
-Q 959 750 1161 570 
-Q 1363 391 1709 391 
-Q 2188 391 2477 730 
-Q 2766 1069 2766 1631 
-L 2766 1759 
-L 2194 1759 
-z
-M 3341 1997 
-L 3341 0 
-L 2766 0 
-L 2766 531 
-Q 2569 213 2275 61 
-Q 1981 -91 1556 -91 
-Q 1019 -91 701 211 
-Q 384 513 384 1019 
-Q 384 1609 779 1909 
-Q 1175 2209 1959 2209 
-L 2766 2209 
-L 2766 2266 
-Q 2766 2663 2505 2880 
-Q 2244 3097 1772 3097 
-Q 1472 3097 1187 3025 
-Q 903 2953 641 2809 
-L 641 3341 
-Q 956 3463 1253 3523 
-Q 1550 3584 1831 3584 
-Q 2591 3584 2966 3190 
-Q 3341 2797 3341 1997 
-z
-" transform="scale(0.015625)"/>
-        <path id="DejaVuSans-73" d="M 2834 3397 
-L 2834 2853 
-Q 2591 2978 2328 3040 
-Q 2066 3103 1784 3103 
-Q 1356 3103 1142 2972 
-Q 928 2841 928 2578 
-Q 928 2378 1081 2264 
-Q 1234 2150 1697 2047 
-L 1894 2003 
-Q 2506 1872 2764 1633 
-Q 3022 1394 3022 966 
-Q 3022 478 2636 193 
-Q 2250 -91 1575 -91 
-Q 1294 -91 989 -36 
-Q 684 19 347 128 
-L 347 722 
-Q 666 556 975 473 
-Q 1284 391 1588 391 
-Q 1994 391 2212 530 
-Q 2431 669 2431 922 
-Q 2431 1156 2273 1281 
-Q 2116 1406 1581 1522 
-L 1381 1569 
-Q 847 1681 609 1914 
-Q 372 2147 372 2553 
-Q 372 3047 722 3315 
-Q 1072 3584 1716 3584 
-Q 2034 3584 2315 3537 
-Q 2597 3491 2834 3397 
-z
-" transform="scale(0.015625)"/>
-       </defs>
-       <use xlink:href="#DejaVuSans-63"/>
-       <use xlink:href="#DejaVuSans-6c" x="54.980469"/>
-       <use xlink:href="#DejaVuSans-61" x="82.763672"/>
-       <use xlink:href="#DejaVuSans-73" x="144.042969"/>
-       <use xlink:href="#DejaVuSans-73" x="196.142578"/>
-       <use xlink:href="#DejaVuSans-20" x="248.242188"/>
-       <use xlink:href="#DejaVuSans-5b" x="280.029297"/>
-       <use xlink:href="#DejaVuSans-64" x="319.042969"/>
-       <use xlink:href="#DejaVuSans-65" x="382.519531"/>
-       <use xlink:href="#DejaVuSans-62" x="444.042969"/>
-       <use xlink:href="#DejaVuSans-75" x="507.519531"/>
-       <use xlink:href="#DejaVuSans-67" x="570.898438"/>
-       <use xlink:href="#DejaVuSans-5d" x="634.375"/>
-      </g>
-     </g>
-    </g>
-    <g id="xtick_4">
-     <g id="line2d_4">
-      <g>
-       <use xlink:href="#me11ec72ead" x="772.534663" y="199.398125" style="stroke: #000000; stroke-width: 0.8"/>
-      </g>
-     </g>
-     <g id="text_4">
-      <!-- class [opt] -->
-      <g transform="translate(746.43857 213.996563)scale(0.1 -0.1)">
-       <use xlink:href="#DejaVuSans-63"/>
-       <use xlink:href="#DejaVuSans-6c" x="54.980469"/>
-       <use xlink:href="#DejaVuSans-61" x="82.763672"/>
-       <use xlink:href="#DejaVuSans-73" x="144.042969"/>
-       <use xlink:href="#DejaVuSans-73" x="196.142578"/>
-       <use xlink:href="#DejaVuSans-20" x="248.242188"/>
-       <use xlink:href="#DejaVuSans-5b" x="280.029297"/>
-       <use xlink:href="#DejaVuSans-6f" x="319.042969"/>
-       <use xlink:href="#DejaVuSans-70" x="380.224609"/>
-       <use xlink:href="#DejaVuSans-74" x="443.701172"/>
-       <use xlink:href="#DejaVuSans-5d" x="482.910156"/>
-      </g>
-     </g>
-    </g>
-   </g>
-   <g id="matplotlib.axis_2">
-    <g id="ytick_1">
-     <g id="line2d_5">
-      <defs>
-       <path id="m2ee62bde15" d="M 0 0 
-L -3.5 0 
-" style="stroke: #000000; stroke-width: 0.8"/>
-      </defs>
-      <g>
-       <use xlink:href="#m2ee62bde15" x="33.403125" y="199.398125" style="stroke: #000000; stroke-width: 0.8"/>
-      </g>
-     </g>
-     <g id="text_5">
-      <!-- 0 -->
-      <g transform="translate(20.040625 203.197344)scale(0.1 -0.1)">
-       <defs>
-        <path id="DejaVuSans-30" d="M 2034 4250 
-Q 1547 4250 1301 3770 
-Q 1056 3291 1056 2328 
-Q 1056 1369 1301 889 
-Q 1547 409 2034 409 
-Q 2525 409 2770 889 
-Q 3016 1369 3016 2328 
-Q 3016 3291 2770 3770 
-Q 2525 4250 2034 4250 
-z
-M 2034 4750 
-Q 2819 4750 3233 4129 
-Q 3647 3509 3647 2328 
-Q 3647 1150 3233 529 
-Q 2819 -91 2034 -91 
-Q 1250 -91 836 529 
-Q 422 1150 422 2328 
-Q 422 3509 836 4129 
-Q 1250 4750 2034 4750 
-z
-" transform="scale(0.015625)"/>
-       </defs>
-       <use xlink:href="#DejaVuSans-30"/>
-      </g>
-     </g>
-    </g>
-    <g id="ytick_2">
-     <g id="line2d_6">
-      <g>
-       <use xlink:href="#m2ee62bde15" x="33.403125" y="175.176839" style="stroke: #000000; stroke-width: 0.8"/>
-      </g>
-     </g>
-     <g id="text_6">
-      <!-- 5 -->
-      <g transform="translate(20.040625 178.976058)scale(0.1 -0.1)">
-       <defs>
-        <path id="DejaVuSans-35" d="M 691 4666 
-L 3169 4666 
-L 3169 4134 
-L 1269 4134 
-L 1269 2991 
-Q 1406 3038 1543 3061 
-Q 1681 3084 1819 3084 
-Q 2600 3084 3056 2656 
-Q 3513 2228 3513 1497 
-Q 3513 744 3044 326 
-Q 2575 -91 1722 -91 
-Q 1428 -91 1123 -41 
-Q 819 9 494 109 
-L 494 744 
-Q 775 591 1075 516 
-Q 1375 441 1709 441 
-Q 2250 441 2565 725 
-Q 2881 1009 2881 1497 
-Q 2881 1984 2565 2268 
-Q 2250 2553 1709 2553 
-Q 1456 2553 1204 2497 
-Q 953 2441 691 2322 
-L 691 4666 
-z
-" transform="scale(0.015625)"/>
-       </defs>
-       <use xlink:href="#DejaVuSans-35"/>
-      </g>
-     </g>
-    </g>
-    <g id="ytick_3">
-     <g id="line2d_7">
-      <g>
-       <use xlink:href="#m2ee62bde15" x="33.403125" y="150.955553" style="stroke: #000000; stroke-width: 0.8"/>
-      </g>
-     </g>
-     <g id="text_7">
-      <!-- 10 -->
-      <g transform="translate(13.678125 154.754772)scale(0.1 -0.1)">
-       <defs>
-        <path id="DejaVuSans-31" d="M 794 531 
-L 1825 531 
-L 1825 4091 
-L 703 3866 
-L 703 4441 
-L 1819 4666 
-L 2450 4666 
-L 2450 531 
-L 3481 531 
-L 3481 0 
-L 794 0 
-L 794 531 
-z
-" transform="scale(0.015625)"/>
-       </defs>
-       <use xlink:href="#DejaVuSans-31"/>
-       <use xlink:href="#DejaVuSans-30" x="63.623047"/>
-      </g>
-     </g>
-    </g>
-    <g id="ytick_4">
-     <g id="line2d_8">
-      <g>
-       <use xlink:href="#m2ee62bde15" x="33.403125" y="126.734267" style="stroke: #000000; stroke-width: 0.8"/>
-      </g>
-     </g>
-     <g id="text_8">
-      <!-- 15 -->
-      <g transform="translate(13.678125 130.533486)scale(0.1 -0.1)">
-       <use xlink:href="#DejaVuSans-31"/>
-       <use xlink:href="#DejaVuSans-35" x="63.623047"/>
-      </g>
-     </g>
-    </g>
-    <g id="ytick_5">
-     <g id="line2d_9">
-      <g>
-       <use xlink:href="#m2ee62bde15" x="33.403125" y="102.512981" style="stroke: #000000; stroke-width: 0.8"/>
-      </g>
-     </g>
-     <g id="text_9">
-      <!-- 20 -->
-      <g transform="translate(13.678125 106.3122)scale(0.1 -0.1)">
-       <defs>
-        <path id="DejaVuSans-32" d="M 1228 531 
-L 3431 531 
-L 3431 0 
-L 469 0 
-L 469 531 
-Q 828 903 1448 1529 
-Q 2069 2156 2228 2338 
-Q 2531 2678 2651 2914 
-Q 2772 3150 2772 3378 
-Q 2772 3750 2511 3984 
-Q 2250 4219 1831 4219 
-Q 1534 4219 1204 4116 
-Q 875 4013 500 3803 
-L 500 4441 
-Q 881 4594 1212 4672 
-Q 1544 4750 1819 4750 
-Q 2544 4750 2975 4387 
-Q 3406 4025 3406 3419 
-Q 3406 3131 3298 2873 
-Q 3191 2616 2906 2266 
-Q 2828 2175 2409 1742 
-Q 1991 1309 1228 531 
-z
-" transform="scale(0.015625)"/>
-       </defs>
-       <use xlink:href="#DejaVuSans-32"/>
-       <use xlink:href="#DejaVuSans-30" x="63.623047"/>
-      </g>
-     </g>
-    </g>
-    <g id="ytick_6">
-     <g id="line2d_10">
-      <g>
-       <use xlink:href="#m2ee62bde15" x="33.403125" y="78.291695" style="stroke: #000000; stroke-width: 0.8"/>
-      </g>
-     </g>
-     <g id="text_10">
-      <!-- 25 -->
-      <g transform="translate(13.678125 82.090913)scale(0.1 -0.1)">
-       <use xlink:href="#DejaVuSans-32"/>
-       <use xlink:href="#DejaVuSans-35" x="63.623047"/>
-      </g>
-     </g>
-    </g>
-    <g id="ytick_7">
-     <g id="line2d_11">
-      <g>
-       <use xlink:href="#m2ee62bde15" x="33.403125" y="54.070409" style="stroke: #000000; stroke-width: 0.8"/>
-      </g>
-     </g>
-     <g id="text_11">
-      <!-- 30 -->
-      <g transform="translate(13.678125 57.869627)scale(0.1 -0.1)">
-       <defs>
-        <path id="DejaVuSans-33" d="M 2597 2516 
-Q 3050 2419 3304 2112 
-Q 3559 1806 3559 1356 
-Q 3559 666 3084 287 
-Q 2609 -91 1734 -91 
-Q 1441 -91 1130 -33 
-Q 819 25 488 141 
-L 488 750 
-Q 750 597 1062 519 
-Q 1375 441 1716 441 
-Q 2309 441 2620 675 
-Q 2931 909 2931 1356 
-Q 2931 1769 2642 2001 
-Q 2353 2234 1838 2234 
-L 1294 2234 
-L 1294 2753 
-L 1863 2753 
-Q 2328 2753 2575 2939 
-Q 2822 3125 2822 3475 
-Q 2822 3834 2567 4026 
-Q 2313 4219 1838 4219 
-Q 1578 4219 1281 4162 
-Q 984 4106 628 3988 
-L 628 4550 
-Q 988 4650 1302 4700 
-Q 1616 4750 1894 4750 
-Q 2613 4750 3031 4423 
-Q 3450 4097 3450 3541 
-Q 3450 3153 3228 2886 
-Q 3006 2619 2597 2516 
-z
-" transform="scale(0.015625)"/>
-       </defs>
-       <use xlink:href="#DejaVuSans-33"/>
-       <use xlink:href="#DejaVuSans-30" x="63.623047"/>
-      </g>
-     </g>
-    </g>
-    <g id="ytick_8">
-     <g id="line2d_12">
-      <g>
-       <use xlink:href="#m2ee62bde15" x="33.403125" y="29.849123" style="stroke: #000000; stroke-width: 0.8"/>
-      </g>
-     </g>
-     <g id="text_12">
-      <!-- 35 -->
-      <g transform="translate(13.678125 33.648341)scale(0.1 -0.1)">
-       <use xlink:href="#DejaVuSans-33"/>
-       <use xlink:href="#DejaVuSans-35" x="63.623047"/>
-      </g>
-     </g>
-    </g>
-    <g id="text_13">
-     <!-- Time (seconds) -->
-     <g transform="translate(7.598437 145.419844)rotate(-90)scale(0.1 -0.1)">
-      <defs>
-       <path id="DejaVuSans-54" d="M -19 4666 
-L 3928 4666 
-L 3928 4134 
-L 2272 4134 
-L 2272 0 
-L 1638 0 
-L 1638 4134 
-L -19 4134 
-L -19 4666 
-z
-" transform="scale(0.015625)"/>
-       <path id="DejaVuSans-69" d="M 603 3500 
-L 1178 3500 
-L 1178 0 
-L 603 0 
-L 603 3500 
-z
-M 603 4863 
-L 1178 4863 
-L 1178 4134 
-L 603 4134 
-L 603 4863 
-z
-" transform="scale(0.015625)"/>
-       <path id="DejaVuSans-6d" d="M 3328 2828 
-Q 3544 3216 3844 3400 
-Q 4144 3584 4550 3584 
-Q 5097 3584 5394 3201 
-Q 5691 2819 5691 2113 
-L 5691 0 
-L 5113 0 
-L 5113 2094 
-Q 5113 2597 4934 2840 
-Q 4756 3084 4391 3084 
-Q 3944 3084 3684 2787 
-Q 3425 2491 3425 1978 
-L 3425 0 
-L 2847 0 
-L 2847 2094 
-Q 2847 2600 2669 2842 
-Q 2491 3084 2119 3084 
-Q 1678 3084 1418 2786 
-Q 1159 2488 1159 1978 
-L 1159 0 
-L 581 0 
-L 581 3500 
-L 1159 3500 
-L 1159 2956 
-Q 1356 3278 1631 3431 
-Q 1906 3584 2284 3584 
-Q 2666 3584 2933 3390 
-Q 3200 3197 3328 2828 
-z
-" transform="scale(0.015625)"/>
-       <path id="DejaVuSans-28" d="M 1984 4856 
-Q 1566 4138 1362 3434 
-Q 1159 2731 1159 2009 
-Q 1159 1288 1364 580 
-Q 1569 -128 1984 -844 
-L 1484 -844 
-Q 1016 -109 783 600 
-Q 550 1309 550 2009 
-Q 550 2706 781 3412 
-Q 1013 4119 1484 4856 
-L 1984 4856 
-z
-" transform="scale(0.015625)"/>
-       <path id="DejaVuSans-29" d="M 513 4856 
-L 1013 4856 
-Q 1481 4119 1714 3412 
-Q 1947 2706 1947 2009 
-Q 1947 1309 1714 600 
-Q 1481 -109 1013 -844 
-L 513 -844 
-Q 928 -128 1133 580 
-Q 1338 1288 1338 2009 
-Q 1338 2731 1133 3434 
-Q 928 4138 513 4856 
-z
-" transform="scale(0.015625)"/>
-      </defs>
-      <use xlink:href="#DejaVuSans-54"/>
-      <use xlink:href="#DejaVuSans-69" x="57.958984"/>
-      <use xlink:href="#DejaVuSans-6d" x="85.742188"/>
-      <use xlink:href="#DejaVuSans-65" x="183.154297"/>
-      <use xlink:href="#DejaVuSans-20" x="244.677734"/>
-      <use xlink:href="#DejaVuSans-28" x="276.464844"/>
-      <use xlink:href="#DejaVuSans-73" x="315.478516"/>
-      <use xlink:href="#DejaVuSans-65" x="367.578125"/>
-      <use xlink:href="#DejaVuSans-63" x="429.101562"/>
-      <use xlink:href="#DejaVuSans-6f" x="484.082031"/>
-      <use xlink:href="#DejaVuSans-6e" x="545.263672"/>
-      <use xlink:href="#DejaVuSans-64" x="608.642578"/>
-      <use xlink:href="#DejaVuSans-73" x="672.119141"/>
-      <use xlink:href="#DejaVuSans-29" x="724.21875"/>
-     </g>
-    </g>
-   </g>
-   <g id="patch_25">
-    <path d="M 33.403125 199.398125 
-L 33.403125 15.118125 
-" style="fill: none; stroke: #000000; stroke-width: 0.8; stroke-linejoin: miter; stroke-linecap: square"/>
-   </g>
-   <g id="patch_26">
-    <path d="M 868.943125 199.398125 
-L 868.943125 15.118125 
-" style="fill: none; stroke: #000000; stroke-width: 0.8; stroke-linejoin: miter; stroke-linecap: square"/>
-   </g>
-   <g id="patch_27">
-    <path d="M 33.403125 199.398125 
-L 868.943125 199.398125 
-" style="fill: none; stroke: #000000; stroke-width: 0.8; stroke-linejoin: miter; stroke-linecap: square"/>
-   </g>
-   <g id="patch_28">
-    <path d="M 33.403125 15.118125 
-L 868.943125 15.118125 
-" style="fill: none; stroke: #000000; stroke-width: 0.8; stroke-linejoin: miter; stroke-linecap: square"/>
-   </g>
-   <g id="text_14">
-    <!-- 9.11 -->
-    <g transform="translate(47.265099 139.002289)scale(0.1 -0.1)">
-     <defs>
-      <path id="DejaVuSans-39" d="M 703 97 
-L 703 672 
-Q 941 559 1184 500 
-Q 1428 441 1663 441 
-Q 2288 441 2617 861 
-Q 2947 1281 2994 2138 
-Q 2813 1869 2534 1725 
-Q 2256 1581 1919 1581 
-Q 1219 1581 811 2004 
-Q 403 2428 403 3163 
-Q 403 3881 828 4315 
-Q 1253 4750 1959 4750 
-Q 2769 4750 3195 4129 
-Q 3622 3509 3622 2328 
-Q 3622 1225 3098 567 
-Q 2575 -91 1691 -91 
-Q 1453 -91 1209 -44 
-Q 966 3 703 97 
-z
-M 1959 2075 
-Q 2384 2075 2632 2365 
-Q 2881 2656 2881 3163 
-Q 2881 3666 2632 3958 
-Q 2384 4250 1959 4250 
-Q 1534 4250 1286 3958 
-Q 1038 3666 1038 3163 
-Q 1038 2656 1286 2365 
-Q 1534 2075 1959 2075 
-z
-" transform="scale(0.015625)"/>
-      <path id="DejaVuSans-2e" d="M 684 794 
-L 1344 794 
-L 1344 0 
-L 684 0 
-L 684 794 
-z
-" transform="scale(0.015625)"/>
-     </defs>
-     <use xlink:href="#DejaVuSans-39"/>
-     <use xlink:href="#DejaVuSans-2e" x="63.623047"/>
-     <use xlink:href="#DejaVuSans-31" x="95.410156"/>
-     <use xlink:href="#DejaVuSans-31" x="159.033203"/>
-    </g>
-    <!-- (x1.4) -->
-    <g transform="translate(43.585411 150.200101)scale(0.1 -0.1)">
-     <defs>
-      <path id="DejaVuSans-78" d="M 3513 3500 
-L 2247 1797 
-L 3578 0 
-L 2900 0 
-L 1881 1375 
-L 863 0 
-L 184 0 
-L 1544 1831 
-L 300 3500 
-L 978 3500 
-L 1906 2253 
-L 2834 3500 
-L 3513 3500 
-z
-" transform="scale(0.015625)"/>
-      <path id="DejaVuSans-34" d="M 2419 4116 
-L 825 1625 
-L 2419 1625 
-L 2419 4116 
-z
-M 2253 4666 
-L 3047 4666 
-L 3047 1625 
-L 3713 1625 
-L 3713 1100 
-L 3047 1100 
-L 3047 0 
-L 2419 0 
-L 2419 1100 
-L 313 1100 
-L 313 1709 
-L 2253 4666 
-z
-" transform="scale(0.015625)"/>
-     </defs>
-     <use xlink:href="#DejaVuSans-28"/>
-     <use xlink:href="#DejaVuSans-78" x="39.013672"/>
-     <use xlink:href="#DejaVuSans-31" x="98.193359"/>
-     <use xlink:href="#DejaVuSans-2e" x="161.816406"/>
-     <use xlink:href="#DejaVuSans-34" x="193.603516"/>
-     <use xlink:href="#DejaVuSans-29" x="257.226562"/>
-    </g>
-   </g>
-   <g id="text_15">
-    <!-- 16.97 -->
-    <g transform="translate(258.324874 100.908873)scale(0.1 -0.1)">
-     <defs>
-      <path id="DejaVuSans-36" d="M 2113 2584 
-Q 1688 2584 1439 2293 
-Q 1191 2003 1191 1497 
-Q 1191 994 1439 701 
-Q 1688 409 2113 409 
-Q 2538 409 2786 701 
-Q 3034 994 3034 1497 
-Q 3034 2003 2786 2293 
-Q 2538 2584 2113 2584 
-z
-M 3366 4563 
-L 3366 3988 
-Q 3128 4100 2886 4159 
-Q 2644 4219 2406 4219 
-Q 1781 4219 1451 3797 
-Q 1122 3375 1075 2522 
-Q 1259 2794 1537 2939 
-Q 1816 3084 2150 3084 
-Q 2853 3084 3261 2657 
-Q 3669 2231 3669 1497 
-Q 3669 778 3244 343 
-Q 2819 -91 2113 -91 
-Q 1303 -91 875 529 
-Q 447 1150 447 2328 
-Q 447 3434 972 4092 
-Q 1497 4750 2381 4750 
-Q 2619 4750 2861 4703 
-Q 3103 4656 3366 4563 
-z
-" transform="scale(0.015625)"/>
-      <path id="DejaVuSans-37" d="M 525 4666 
-L 3525 4666 
-L 3525 4397 
-L 1831 0 
-L 1172 0 
-L 2766 4134 
-L 525 4134 
-L 525 4666 
-z
-" transform="scale(0.015625)"/>
-     </defs>
-     <use xlink:href="#DejaVuSans-31"/>
-     <use xlink:href="#DejaVuSans-36" x="63.623047"/>
-     <use xlink:href="#DejaVuSans-2e" x="127.246094"/>
-     <use xlink:href="#DejaVuSans-39" x="159.033203"/>
-     <use xlink:href="#DejaVuSans-37" x="222.65625"/>
-    </g>
-    <!-- (x2.3) -->
-    <g transform="translate(257.826437 112.106686)scale(0.1 -0.1)">
-     <use xlink:href="#DejaVuSans-28"/>
-     <use xlink:href="#DejaVuSans-78" x="39.013672"/>
-     <use xlink:href="#DejaVuSans-32" x="98.193359"/>
-     <use xlink:href="#DejaVuSans-2e" x="161.816406"/>
-     <use xlink:href="#DejaVuSans-33" x="193.603516"/>
-     <use xlink:href="#DejaVuSans-29" x="257.226562"/>
-    </g>
-   </g>
-   <g id="text_16">
-    <!-- 13.66 -->
-    <g transform="translate(472.5659 116.937077)scale(0.1 -0.1)">
-     <use xlink:href="#DejaVuSans-31"/>
-     <use xlink:href="#DejaVuSans-33" x="63.623047"/>
-     <use xlink:href="#DejaVuSans-2e" x="127.246094"/>
-     <use xlink:href="#DejaVuSans-36" x="159.033203"/>
-     <use xlink:href="#DejaVuSans-36" x="222.65625"/>
-    </g>
-    <!-- (x2.2) -->
-    <g transform="translate(472.067463 128.13489)scale(0.1 -0.1)">
-     <use xlink:href="#DejaVuSans-28"/>
-     <use xlink:href="#DejaVuSans-78" x="39.013672"/>
-     <use xlink:href="#DejaVuSans-32" x="98.193359"/>
-     <use xlink:href="#DejaVuSans-2e" x="161.816406"/>
-     <use xlink:href="#DejaVuSans-32" x="193.603516"/>
-     <use xlink:href="#DejaVuSans-29" x="257.226562"/>
-    </g>
-   </g>
-   <g id="text_17">
-    <!-- 24.37 -->
-    <g transform="translate(686.806926 65.057546)scale(0.1 -0.1)">
-     <use xlink:href="#DejaVuSans-32"/>
-     <use xlink:href="#DejaVuSans-34" x="63.623047"/>
-     <use xlink:href="#DejaVuSans-2e" x="127.246094"/>
-     <use xlink:href="#DejaVuSans-33" x="159.033203"/>
-     <use xlink:href="#DejaVuSans-37" x="222.65625"/>
-    </g>
-    <!-- (x3.4) -->
-    <g transform="translate(686.308488 76.255359)scale(0.1 -0.1)">
-     <use xlink:href="#DejaVuSans-28"/>
-     <use xlink:href="#DejaVuSans-78" x="39.013672"/>
-     <use xlink:href="#DejaVuSans-33" x="98.193359"/>
-     <use xlink:href="#DejaVuSans-2e" x="161.816406"/>
-     <use xlink:href="#DejaVuSans-34" x="193.603516"/>
-     <use xlink:href="#DejaVuSans-29" x="257.226562"/>
-    </g>
-   </g>
-   <g id="text_18">
-    <!-- 15.25 -->
-    <g transform="translate(79.790686 109.24893)scale(0.1 -0.1)">
-     <use xlink:href="#DejaVuSans-31"/>
-     <use xlink:href="#DejaVuSans-35" x="63.623047"/>
-     <use xlink:href="#DejaVuSans-2e" x="127.246094"/>
-     <use xlink:href="#DejaVuSans-32" x="159.033203"/>
-     <use xlink:href="#DejaVuSans-35" x="222.65625"/>
-    </g>
-    <!-- (x2.3) -->
-    <g transform="translate(79.292249 120.446742)scale(0.1 -0.1)">
-     <use xlink:href="#DejaVuSans-28"/>
-     <use xlink:href="#DejaVuSans-78" x="39.013672"/>
-     <use xlink:href="#DejaVuSans-32" x="98.193359"/>
-     <use xlink:href="#DejaVuSans-2e" x="161.816406"/>
-     <use xlink:href="#DejaVuSans-33" x="193.603516"/>
-     <use xlink:href="#DejaVuSans-29" x="257.226562"/>
-    </g>
-   </g>
-   <g id="text_19">
-    <!-- 19.48 -->
-    <g transform="translate(294.031712 88.740586)scale(0.1 -0.1)">
-     <defs>
-      <path id="DejaVuSans-38" d="M 2034 2216 
-Q 1584 2216 1326 1975 
-Q 1069 1734 1069 1313 
-Q 1069 891 1326 650 
-Q 1584 409 2034 409 
-Q 2484 409 2743 651 
-Q 3003 894 3003 1313 
-Q 3003 1734 2745 1975 
-Q 2488 2216 2034 2216 
-z
-M 1403 2484 
-Q 997 2584 770 2862 
-Q 544 3141 544 3541 
-Q 544 4100 942 4425 
-Q 1341 4750 2034 4750 
-Q 2731 4750 3128 4425 
-Q 3525 4100 3525 3541 
-Q 3525 3141 3298 2862 
-Q 3072 2584 2669 2484 
-Q 3125 2378 3379 2068 
-Q 3634 1759 3634 1313 
-Q 3634 634 3220 271 
-Q 2806 -91 2034 -91 
-Q 1263 -91 848 271 
-Q 434 634 434 1313 
-Q 434 1759 690 2068 
-Q 947 2378 1403 2484 
-z
-M 1172 3481 
-Q 1172 3119 1398 2916 
-Q 1625 2713 2034 2713 
-Q 2441 2713 2670 2916 
-Q 2900 3119 2900 3481 
-Q 2900 3844 2670 4047 
-Q 2441 4250 2034 4250 
-Q 1625 4250 1398 4047 
-Q 1172 3844 1172 3481 
-z
-" transform="scale(0.015625)"/>
-     </defs>
-     <use xlink:href="#DejaVuSans-31"/>
-     <use xlink:href="#DejaVuSans-39" x="63.623047"/>
-     <use xlink:href="#DejaVuSans-2e" x="127.246094"/>
-     <use xlink:href="#DejaVuSans-34" x="159.033203"/>
-     <use xlink:href="#DejaVuSans-38" x="222.65625"/>
-    </g>
-    <!-- (x2.7) -->
-    <g transform="translate(293.533275 99.938398)scale(0.1 -0.1)">
-     <use xlink:href="#DejaVuSans-28"/>
-     <use xlink:href="#DejaVuSans-78" x="39.013672"/>
-     <use xlink:href="#DejaVuSans-32" x="98.193359"/>
-     <use xlink:href="#DejaVuSans-2e" x="161.816406"/>
-     <use xlink:href="#DejaVuSans-37" x="193.603516"/>
-     <use xlink:href="#DejaVuSans-29" x="257.226562"/>
-    </g>
-   </g>
-   <g id="text_20">
-    <!-- 15.15 -->
-    <g transform="translate(508.272738 109.748357)scale(0.1 -0.1)">
-     <use xlink:href="#DejaVuSans-31"/>
-     <use xlink:href="#DejaVuSans-35" x="63.623047"/>
-     <use xlink:href="#DejaVuSans-2e" x="127.246094"/>
-     <use xlink:href="#DejaVuSans-31" x="159.033203"/>
-     <use xlink:href="#DejaVuSans-35" x="222.65625"/>
-    </g>
-    <!-- (x2.4) -->
-    <g transform="translate(507.7743 120.946169)scale(0.1 -0.1)">
-     <use xlink:href="#DejaVuSans-28"/>
-     <use xlink:href="#DejaVuSans-78" x="39.013672"/>
-     <use xlink:href="#DejaVuSans-32" x="98.193359"/>
-     <use xlink:href="#DejaVuSans-2e" x="161.816406"/>
-     <use xlink:href="#DejaVuSans-34" x="193.603516"/>
-     <use xlink:href="#DejaVuSans-29" x="257.226562"/>
-    </g>
-   </g>
-   <g id="text_21">
-    <!-- 21.70 -->
-    <g transform="translate(722.513763 77.976684)scale(0.1 -0.1)">
-     <use xlink:href="#DejaVuSans-32"/>
-     <use xlink:href="#DejaVuSans-31" x="63.623047"/>
-     <use xlink:href="#DejaVuSans-2e" x="127.246094"/>
-     <use xlink:href="#DejaVuSans-37" x="159.033203"/>
-     <use xlink:href="#DejaVuSans-30" x="222.65625"/>
-    </g>
-    <!-- (x3.1) -->
-    <g transform="translate(722.015326 89.174497)scale(0.1 -0.1)">
-     <use xlink:href="#DejaVuSans-28"/>
-     <use xlink:href="#DejaVuSans-78" x="39.013672"/>
-     <use xlink:href="#DejaVuSans-33" x="98.193359"/>
-     <use xlink:href="#DejaVuSans-2e" x="161.816406"/>
-     <use xlink:href="#DejaVuSans-31" x="193.603516"/>
-     <use xlink:href="#DejaVuSans-29" x="257.226562"/>
-    </g>
-   </g>
-   <g id="text_22">
-    <!-- 15.36 -->
-    <g transform="translate(115.497524 108.705327)scale(0.1 -0.1)">
-     <use xlink:href="#DejaVuSans-31"/>
-     <use xlink:href="#DejaVuSans-35" x="63.623047"/>
-     <use xlink:href="#DejaVuSans-2e" x="127.246094"/>
-     <use xlink:href="#DejaVuSans-33" x="159.033203"/>
-     <use xlink:href="#DejaVuSans-36" x="222.65625"/>
-    </g>
-    <!-- (x2.3) -->
-    <g transform="translate(114.999087 119.90314)scale(0.1 -0.1)">
-     <use xlink:href="#DejaVuSans-28"/>
-     <use xlink:href="#DejaVuSans-78" x="39.013672"/>
-     <use xlink:href="#DejaVuSans-32" x="98.193359"/>
-     <use xlink:href="#DejaVuSans-2e" x="161.816406"/>
-     <use xlink:href="#DejaVuSans-33" x="193.603516"/>
-     <use xlink:href="#DejaVuSans-29" x="257.226562"/>
-    </g>
-   </g>
-   <g id="text_23">
-    <!-- 19.66 -->
-    <g transform="translate(329.73855 87.871257)scale(0.1 -0.1)">
-     <use xlink:href="#DejaVuSans-31"/>
-     <use xlink:href="#DejaVuSans-39" x="63.623047"/>
-     <use xlink:href="#DejaVuSans-2e" x="127.246094"/>
-     <use xlink:href="#DejaVuSans-36" x="159.033203"/>
-     <use xlink:href="#DejaVuSans-36" x="222.65625"/>
-    </g>
-    <!-- (x2.7) -->
-    <g transform="translate(329.240112 99.069069)scale(0.1 -0.1)">
-     <use xlink:href="#DejaVuSans-28"/>
-     <use xlink:href="#DejaVuSans-78" x="39.013672"/>
-     <use xlink:href="#DejaVuSans-32" x="98.193359"/>
-     <use xlink:href="#DejaVuSans-2e" x="161.816406"/>
-     <use xlink:href="#DejaVuSans-37" x="193.603516"/>
-     <use xlink:href="#DejaVuSans-29" x="257.226562"/>
-    </g>
-   </g>
-   <g id="text_24">
-    <!-- 16.17 -->
-    <g transform="translate(543.979575 104.792174)scale(0.1 -0.1)">
-     <use xlink:href="#DejaVuSans-31"/>
-     <use xlink:href="#DejaVuSans-36" x="63.623047"/>
-     <use xlink:href="#DejaVuSans-2e" x="127.246094"/>
-     <use xlink:href="#DejaVuSans-31" x="159.033203"/>
-     <use xlink:href="#DejaVuSans-37" x="222.65625"/>
-    </g>
-    <!-- (x2.6) -->
-    <g transform="translate(543.481138 115.989987)scale(0.1 -0.1)">
-     <use xlink:href="#DejaVuSans-28"/>
-     <use xlink:href="#DejaVuSans-78" x="39.013672"/>
-     <use xlink:href="#DejaVuSans-32" x="98.193359"/>
-     <use xlink:href="#DejaVuSans-2e" x="161.816406"/>
-     <use xlink:href="#DejaVuSans-36" x="193.603516"/>
-     <use xlink:href="#DejaVuSans-29" x="257.226562"/>
-    </g>
-   </g>
-   <g id="text_25">
-    <!-- 28.33 -->
-    <g transform="translate(758.220601 45.896395)scale(0.1 -0.1)">
-     <use xlink:href="#DejaVuSans-32"/>
-     <use xlink:href="#DejaVuSans-38" x="63.623047"/>
-     <use xlink:href="#DejaVuSans-2e" x="127.246094"/>
-     <use xlink:href="#DejaVuSans-33" x="159.033203"/>
-     <use xlink:href="#DejaVuSans-33" x="222.65625"/>
-    </g>
-    <!-- (x4.0) -->
-    <g transform="translate(757.722163 57.094207)scale(0.1 -0.1)">
-     <use xlink:href="#DejaVuSans-28"/>
-     <use xlink:href="#DejaVuSans-78" x="39.013672"/>
-     <use xlink:href="#DejaVuSans-34" x="98.193359"/>
-     <use xlink:href="#DejaVuSans-2e" x="161.816406"/>
-     <use xlink:href="#DejaVuSans-30" x="193.603516"/>
-     <use xlink:href="#DejaVuSans-29" x="257.226562"/>
-    </g>
-   </g>
-   <g id="text_26">
-    <!-- 5.15 -->
-    <g transform="translate(154.385612 158.156335)scale(0.1 -0.1)">
-     <use xlink:href="#DejaVuSans-35"/>
-     <use xlink:href="#DejaVuSans-2e" x="63.623047"/>
-     <use xlink:href="#DejaVuSans-31" x="95.410156"/>
-     <use xlink:href="#DejaVuSans-35" x="159.033203"/>
-    </g>
-    <!-- (x0.8) -->
-    <g transform="translate(150.705924 169.354147)scale(0.1 -0.1)">
-     <use xlink:href="#DejaVuSans-28"/>
-     <use xlink:href="#DejaVuSans-78" x="39.013672"/>
-     <use xlink:href="#DejaVuSans-30" x="98.193359"/>
-     <use xlink:href="#DejaVuSans-2e" x="161.816406"/>
-     <use xlink:href="#DejaVuSans-38" x="193.603516"/>
-     <use xlink:href="#DejaVuSans-29" x="257.226562"/>
-    </g>
-   </g>
-   <g id="text_27">
-    <!-- 11.68 -->
-    <g transform="translate(365.445387 126.531127)scale(0.1 -0.1)">
-     <use xlink:href="#DejaVuSans-31"/>
-     <use xlink:href="#DejaVuSans-31" x="63.623047"/>
-     <use xlink:href="#DejaVuSans-2e" x="127.246094"/>
-     <use xlink:href="#DejaVuSans-36" x="159.033203"/>
-     <use xlink:href="#DejaVuSans-38" x="222.65625"/>
-    </g>
-    <!-- (x1.6) -->
-    <g transform="translate(364.94695 137.728939)scale(0.1 -0.1)">
-     <use xlink:href="#DejaVuSans-28"/>
-     <use xlink:href="#DejaVuSans-78" x="39.013672"/>
-     <use xlink:href="#DejaVuSans-31" x="98.193359"/>
-     <use xlink:href="#DejaVuSans-2e" x="161.816406"/>
-     <use xlink:href="#DejaVuSans-36" x="193.603516"/>
-     <use xlink:href="#DejaVuSans-29" x="257.226562"/>
-    </g>
-   </g>
-   <g id="text_28">
-    <!-- 12.02 -->
-    <g transform="translate(579.686413 124.912394)scale(0.1 -0.1)">
-     <use xlink:href="#DejaVuSans-31"/>
-     <use xlink:href="#DejaVuSans-32" x="63.623047"/>
-     <use xlink:href="#DejaVuSans-2e" x="127.246094"/>
-     <use xlink:href="#DejaVuSans-30" x="159.033203"/>
-     <use xlink:href="#DejaVuSans-32" x="222.65625"/>
-    </g>
-    <!-- (x1.9) -->
-    <g transform="translate(579.187975 136.110206)scale(0.1 -0.1)">
-     <use xlink:href="#DejaVuSans-28"/>
-     <use xlink:href="#DejaVuSans-78" x="39.013672"/>
-     <use xlink:href="#DejaVuSans-31" x="98.193359"/>
-     <use xlink:href="#DejaVuSans-2e" x="161.816406"/>
-     <use xlink:href="#DejaVuSans-39" x="193.603516"/>
-     <use xlink:href="#DejaVuSans-29" x="257.226562"/>
-    </g>
-   </g>
-   <g id="text_29">
-    <!-- 31.46 -->
-    <g transform="translate(793.927439 30.697135)scale(0.1 -0.1)">
-     <use xlink:href="#DejaVuSans-33"/>
-     <use xlink:href="#DejaVuSans-31" x="63.623047"/>
-     <use xlink:href="#DejaVuSans-2e" x="127.246094"/>
-     <use xlink:href="#DejaVuSans-34" x="159.033203"/>
-     <use xlink:href="#DejaVuSans-36" x="222.65625"/>
-    </g>
-    <!-- (x4.4) -->
-    <g transform="translate(793.429001 41.894947)scale(0.1 -0.1)">
-     <use xlink:href="#DejaVuSans-28"/>
-     <use xlink:href="#DejaVuSans-78" x="39.013672"/>
-     <use xlink:href="#DejaVuSans-34" x="98.193359"/>
-     <use xlink:href="#DejaVuSans-2e" x="161.816406"/>
-     <use xlink:href="#DejaVuSans-34" x="193.603516"/>
-     <use xlink:href="#DejaVuSans-29" x="257.226562"/>
-    </g>
-   </g>
-   <g id="text_30">
-    <!-- 6.60 -->
-    <g transform="translate(190.092449 165.348683)scale(0.1 -0.1)">
-     <use xlink:href="#DejaVuSans-36"/>
-     <use xlink:href="#DejaVuSans-2e" x="63.623047"/>
-     <use xlink:href="#DejaVuSans-36" x="95.410156"/>
-     <use xlink:href="#DejaVuSans-30" x="159.033203"/>
-    </g>
-   </g>
-   <g id="text_31">
-    <!-- 7.23 -->
-    <g transform="translate(404.333475 162.318495)scale(0.1 -0.1)">
-     <use xlink:href="#DejaVuSans-37"/>
-     <use xlink:href="#DejaVuSans-2e" x="63.623047"/>
-     <use xlink:href="#DejaVuSans-32" x="95.410156"/>
-     <use xlink:href="#DejaVuSans-33" x="159.033203"/>
-    </g>
-   </g>
-   <g id="text_32">
-    <!-- 6.19 -->
-    <g transform="translate(618.574501 167.311285)scale(0.1 -0.1)">
-     <use xlink:href="#DejaVuSans-36"/>
-     <use xlink:href="#DejaVuSans-2e" x="63.623047"/>
-     <use xlink:href="#DejaVuSans-31" x="95.410156"/>
-     <use xlink:href="#DejaVuSans-39" x="159.033203"/>
-    </g>
-   </g>
-   <g id="text_33">
-    <!-- 7.11 -->
-    <g transform="translate(832.815526 162.877599)scale(0.1 -0.1)">
-     <use xlink:href="#DejaVuSans-37"/>
-     <use xlink:href="#DejaVuSans-2e" x="63.623047"/>
-     <use xlink:href="#DejaVuSans-31" x="95.410156"/>
-     <use xlink:href="#DejaVuSans-31" x="159.033203"/>
-    </g>
-   </g>
-   <g id="text_34">
-    <!-- Compilation time -->
-    <g transform="translate(399.693125 9.118125)scale(0.12 -0.12)">
-     <defs>
-      <path id="DejaVuSans-43" d="M 4122 4306 
-L 4122 3641 
-Q 3803 3938 3442 4084 
-Q 3081 4231 2675 4231 
-Q 1875 4231 1450 3742 
-Q 1025 3253 1025 2328 
-Q 1025 1406 1450 917 
-Q 1875 428 2675 428 
-Q 3081 428 3442 575 
-Q 3803 722 4122 1019 
-L 4122 359 
-Q 3791 134 3420 21 
-Q 3050 -91 2638 -91 
-Q 1578 -91 968 557 
-Q 359 1206 359 2328 
-Q 359 3453 968 4101 
-Q 1578 4750 2638 4750 
-Q 3056 4750 3426 4639 
-Q 3797 4528 4122 4306 
-z
-" transform="scale(0.015625)"/>
-     </defs>
-     <use xlink:href="#DejaVuSans-43"/>
-     <use xlink:href="#DejaVuSans-6f" x="69.824219"/>
-     <use xlink:href="#DejaVuSans-6d" x="131.005859"/>
-     <use xlink:href="#DejaVuSans-70" x="228.417969"/>
-     <use xlink:href="#DejaVuSans-69" x="291.894531"/>
-     <use xlink:href="#DejaVuSans-6c" x="319.677734"/>
-     <use xlink:href="#DejaVuSans-61" x="347.460938"/>
-     <use xlink:href="#DejaVuSans-74" x="408.740234"/>
-     <use xlink:href="#DejaVuSans-69" x="447.949219"/>
-     <use xlink:href="#DejaVuSans-6f" x="475.732422"/>
-     <use xlink:href="#DejaVuSans-6e" x="536.914062"/>
-     <use xlink:href="#DejaVuSans-20" x="600.292969"/>
-     <use xlink:href="#DejaVuSans-74" x="632.080078"/>
-     <use xlink:href="#DejaVuSans-69" x="671.289062"/>
-     <use xlink:href="#DejaVuSans-6d" x="699.072266"/>
-     <use xlink:href="#DejaVuSans-65" x="796.484375"/>
-    </g>
-   </g>
-   <g id="legend_1">
-    <g id="patch_29">
-     <path d="M 40.403125 96.786875 
-L 199.9 96.786875 
-Q 201.9 96.786875 201.9 94.786875 
-L 201.9 22.118125 
-Q 201.9 20.118125 199.9 20.118125 
-L 40.403125 20.118125 
-Q 38.403125 20.118125 38.403125 22.118125 
-L 38.403125 94.786875 
-Q 38.403125 96.786875 40.403125 96.786875 
-z
-" style="fill: #ffffff; opacity: 0.8; stroke: #cccccc; stroke-linejoin: miter"/>
-    </g>
-    <g id="patch_30">
-     <path d="M 42.403125 31.716562 
-L 62.403125 31.716562 
-L 62.403125 24.716562 
-L 42.403125 24.716562 
-z
-" style="fill: #ff7f0e; stroke: #000000; stroke-linejoin: miter"/>
-    </g>
-    <g id="text_35">
-     <!-- Boost.Python -->
-     <g transform="translate(70.403125 31.716562)scale(0.1 -0.1)">
-      <defs>
-       <path id="DejaVuSans-42" d="M 1259 2228 
-L 1259 519 
-L 2272 519 
-Q 2781 519 3026 730 
-Q 3272 941 3272 1375 
-Q 3272 1813 3026 2020 
-Q 2781 2228 2272 2228 
-L 1259 2228 
-z
-M 1259 4147 
-L 1259 2741 
-L 2194 2741 
-Q 2656 2741 2882 2914 
-Q 3109 3088 3109 3444 
-Q 3109 3797 2882 3972 
-Q 2656 4147 2194 4147 
-L 1259 4147 
-z
-M 628 4666 
-L 2241 4666 
-Q 2963 4666 3353 4366 
-Q 3744 4066 3744 3513 
-Q 3744 3084 3544 2831 
-Q 3344 2578 2956 2516 
-Q 3422 2416 3680 2098 
-Q 3938 1781 3938 1306 
-Q 3938 681 3513 340 
-Q 3088 0 2303 0 
-L 628 0 
-L 628 4666 
-z
-" transform="scale(0.015625)"/>
-       <path id="DejaVuSans-50" d="M 1259 4147 
-L 1259 2394 
-L 2053 2394 
-Q 2494 2394 2734 2622 
-Q 2975 2850 2975 3272 
-Q 2975 3691 2734 3919 
-Q 2494 4147 2053 4147 
-L 1259 4147 
-z
-M 628 4666 
-L 2053 4666 
-Q 2838 4666 3239 4311 
-Q 3641 3956 3641 3272 
-Q 3641 2581 3239 2228 
-Q 2838 1875 2053 1875 
-L 1259 1875 
-L 1259 0 
-L 628 0 
-L 628 4666 
-z
-" transform="scale(0.015625)"/>
-       <path id="DejaVuSans-79" d="M 2059 -325 
-Q 1816 -950 1584 -1140 
-Q 1353 -1331 966 -1331 
-L 506 -1331 
-L 506 -850 
-L 844 -850 
-Q 1081 -850 1212 -737 
-Q 1344 -625 1503 -206 
-L 1606 56 
-L 191 3500 
-L 800 3500 
-L 1894 763 
-L 2988 3500 
-L 3597 3500 
-L 2059 -325 
-z
-" transform="scale(0.015625)"/>
-       <path id="DejaVuSans-68" d="M 3513 2113 
-L 3513 0 
-L 2938 0 
-L 2938 2094 
-Q 2938 2591 2744 2837 
-Q 2550 3084 2163 3084 
-Q 1697 3084 1428 2787 
-Q 1159 2491 1159 1978 
-L 1159 0 
-L 581 0 
-L 581 4863 
-L 1159 4863 
-L 1159 2956 
-Q 1366 3272 1645 3428 
-Q 1925 3584 2291 3584 
-Q 2894 3584 3203 3211 
-Q 3513 2838 3513 2113 
-z
-" transform="scale(0.015625)"/>
-      </defs>
-      <use xlink:href="#DejaVuSans-42"/>
-      <use xlink:href="#DejaVuSans-6f" x="68.603516"/>
-      <use xlink:href="#DejaVuSans-6f" x="129.785156"/>
-      <use xlink:href="#DejaVuSans-73" x="190.966797"/>
-      <use xlink:href="#DejaVuSans-74" x="243.066406"/>
-      <use xlink:href="#DejaVuSans-2e" x="282.275391"/>
-      <use xlink:href="#DejaVuSans-50" x="314.0625"/>
-      <use xlink:href="#DejaVuSans-79" x="374.365234"/>
-      <use xlink:href="#DejaVuSans-74" x="433.544922"/>
-      <use xlink:href="#DejaVuSans-68" x="472.753906"/>
-      <use xlink:href="#DejaVuSans-6f" x="536.132812"/>
-      <use xlink:href="#DejaVuSans-6e" x="597.314453"/>
-     </g>
-    </g>
-    <g id="patch_31">
-     <path d="M 42.403125 46.394687 
-L 62.403125 46.394687 
-L 62.403125 39.394687 
-L 42.403125 39.394687 
-z
-" style="fill: #d62728; stroke: #000000; stroke-linejoin: miter"/>
-    </g>
-    <g id="text_36">
-     <!-- pybind11 -->
-     <g transform="translate(70.403125 46.394687)scale(0.1 -0.1)">
-      <use xlink:href="#DejaVuSans-70"/>
-      <use xlink:href="#DejaVuSans-79" x="63.476562"/>
-      <use xlink:href="#DejaVuSans-62" x="122.65625"/>
-      <use xlink:href="#DejaVuSans-69" x="186.132812"/>
-      <use xlink:href="#DejaVuSans-6e" x="213.916016"/>
-      <use xlink:href="#DejaVuSans-64" x="277.294922"/>
-      <use xlink:href="#DejaVuSans-31" x="340.771484"/>
-      <use xlink:href="#DejaVuSans-31" x="404.394531"/>
-     </g>
-    </g>
-    <g id="patch_32">
-     <path d="M 42.403125 61.072812 
-L 62.403125 61.072812 
-L 62.403125 54.072812 
-L 42.403125 54.072812 
-z
-" style="fill: #8c564b; stroke: #000000; stroke-linejoin: miter"/>
-    </g>
-    <g id="text_37">
-     <!-- pybind11 + smart_holder -->
-     <g transform="translate(70.403125 61.072812)scale(0.1 -0.1)">
-      <defs>
-       <path id="DejaVuSans-2b" d="M 2944 4013 
-L 2944 2272 
-L 4684 2272 
-L 4684 1741 
-L 2944 1741 
-L 2944 0 
-L 2419 0 
-L 2419 1741 
-L 678 1741 
-L 678 2272 
-L 2419 2272 
-L 2419 4013 
-L 2944 4013 
-z
-" transform="scale(0.015625)"/>
-       <path id="DejaVuSans-72" d="M 2631 2963 
-Q 2534 3019 2420 3045 
-Q 2306 3072 2169 3072 
-Q 1681 3072 1420 2755 
-Q 1159 2438 1159 1844 
-L 1159 0 
-L 581 0 
-L 581 3500 
-L 1159 3500 
-L 1159 2956 
-Q 1341 3275 1631 3429 
-Q 1922 3584 2338 3584 
-Q 2397 3584 2469 3576 
-Q 2541 3569 2628 3553 
-L 2631 2963 
-z
-" transform="scale(0.015625)"/>
-       <path id="DejaVuSans-5f" d="M 3263 -1063 
-L 3263 -1509 
-L -63 -1509 
-L -63 -1063 
-L 3263 -1063 
-z
-" transform="scale(0.015625)"/>
-      </defs>
-      <use xlink:href="#DejaVuSans-70"/>
-      <use xlink:href="#DejaVuSans-79" x="63.476562"/>
-      <use xlink:href="#DejaVuSans-62" x="122.65625"/>
-      <use xlink:href="#DejaVuSans-69" x="186.132812"/>
-      <use xlink:href="#DejaVuSans-6e" x="213.916016"/>
-      <use xlink:href="#DejaVuSans-64" x="277.294922"/>
-      <use xlink:href="#DejaVuSans-31" x="340.771484"/>
-      <use xlink:href="#DejaVuSans-31" x="404.394531"/>
-      <use xlink:href="#DejaVuSans-20" x="468.017578"/>
-      <use xlink:href="#DejaVuSans-2b" x="499.804688"/>
-      <use xlink:href="#DejaVuSans-20" x="583.59375"/>
-      <use xlink:href="#DejaVuSans-73" x="615.380859"/>
-      <use xlink:href="#DejaVuSans-6d" x="667.480469"/>
-      <use xlink:href="#DejaVuSans-61" x="764.892578"/>
-      <use xlink:href="#DejaVuSans-72" x="826.171875"/>
-      <use xlink:href="#DejaVuSans-74" x="867.285156"/>
-      <use xlink:href="#DejaVuSans-5f" x="906.494141"/>
-      <use xlink:href="#DejaVuSans-68" x="956.494141"/>
-      <use xlink:href="#DejaVuSans-6f" x="1019.873047"/>
-      <use xlink:href="#DejaVuSans-6c" x="1081.054688"/>
-      <use xlink:href="#DejaVuSans-64" x="1108.837891"/>
-      <use xlink:href="#DejaVuSans-65" x="1172.314453"/>
-      <use xlink:href="#DejaVuSans-72" x="1233.837891"/>
-     </g>
-    </g>
-    <g id="patch_33">
-     <path d="M 42.403125 76.029062 
-L 62.403125 76.029062 
-L 62.403125 69.029062 
-L 42.403125 69.029062 
-z
-" style="fill: #9467bd; stroke: #000000; stroke-linejoin: miter"/>
-    </g>
-    <g id="text_38">
-     <!-- Cython -->
-     <g transform="translate(70.403125 76.029062)scale(0.1 -0.1)">
-      <use xlink:href="#DejaVuSans-43"/>
-      <use xlink:href="#DejaVuSans-79" x="69.824219"/>
-      <use xlink:href="#DejaVuSans-74" x="129.003906"/>
-      <use xlink:href="#DejaVuSans-68" x="168.212891"/>
-      <use xlink:href="#DejaVuSans-6f" x="231.591797"/>
-      <use xlink:href="#DejaVuSans-6e" x="292.773438"/>
-     </g>
-    </g>
-    <g id="patch_34">
-     <path d="M 42.403125 90.707187 
-L 62.403125 90.707187 
-L 62.403125 83.707187 
-L 42.403125 83.707187 
-z
-" style="fill: #1f77b4; stroke: #000000; stroke-linejoin: miter"/>
-    </g>
-    <g id="text_39">
-     <!-- nanobind -->
-     <g transform="translate(70.403125 90.707187)scale(0.1 -0.1)">
-      <use xlink:href="#DejaVuSans-6e"/>
-      <use xlink:href="#DejaVuSans-61" x="63.378906"/>
-      <use xlink:href="#DejaVuSans-6e" x="124.658203"/>
-      <use xlink:href="#DejaVuSans-6f" x="188.037109"/>
-      <use xlink:href="#DejaVuSans-62" x="249.21875"/>
-      <use xlink:href="#DejaVuSans-69" x="312.695312"/>
-      <use xlink:href="#DejaVuSans-6e" x="340.478516"/>
-      <use xlink:href="#DejaVuSans-64" x="403.857422"/>
-     </g>
-    </g>
-   </g>
-  </g>
- </g>
- <defs>
-  <clipPath id="p042a290d9a">
-   <rect x="33.403125" y="15.118125" width="835.54" height="184.28"/>
-  </clipPath>
- </defs>
-</svg>
diff --git a/src/nanobind/docs/images/wrapper-dark.svg b/src/nanobind/docs/images/wrapper-dark.svg
deleted file mode 100644
index 4ca0ee0..0000000
--- a/src/nanobind/docs/images/wrapper-dark.svg
+++ /dev/null
@@ -1,102 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<svg id="Layer_1" data-name="Layer 1" xmlns="http://www.w3.org/2000/svg" viewBox="0 0 298.8 62.36">
-  <defs>
-    <style>
-      .cls-1 {
-        stroke: #fff;
-      }
-
-      .cls-1, .cls-2, .cls-3 {
-        fill: none;
-        stroke-linecap: round;
-        stroke-linejoin: round;
-      }
-
-      .cls-4 {
-        fill: #fff;
-      }
-
-      .cls-5 {
-        fill: #adffa2;
-      }
-
-      .cls-6 {
-        fill: #dcffdf;
-      }
-
-      .cls-7 {
-        fill: #dcdcff;
-      }
-
-      .cls-8 {
-        fill: #919191;
-        fill-rule: evenodd;
-      }
-
-      .cls-2 {
-        stroke: #000;
-        stroke-width: .8px;
-      }
-
-      .cls-3 {
-        stroke: #919191;
-        stroke-width: 1.5px;
-      }
-    </style>
-  </defs>
-  <rect class="cls-7" x="6.35" y="5.85" width="115.87" height="50.74"/>
-  <rect class="cls-1" x="6.35" y="5.85" width="115.87" height="50.74"/>
-  <rect class="cls-6" x="176.58" y="5.85" width="115.87" height="50.74"/>
-  <rect class="cls-1" x="176.58" y="5.85" width="115.87" height="50.74"/>
-  <rect class="cls-5" x="16.68" y="28.23" width="95.21" height="18.58"/>
-  <rect class="cls-2" x="16.68" y="28.23" width="95.21" height="18.58"/>
-  <rect class="cls-5" x="186.94" y="28.23" width="95.21" height="18.58"/>
-  <rect class="cls-2" x="186.94" y="28.23" width="95.21" height="18.58"/>
-  <g>
-    <path d="m60.48,18.47c-.34.46-.77.83-1.31,1.11-.54.28-1.18.43-1.93.43-.65,0-1.25-.11-1.79-.33-.55-.22-1.02-.53-1.42-.92-.4-.4-.71-.87-.93-1.42-.22-.55-.34-1.15-.34-1.81s.11-1.27.34-1.82.54-1.02.95-1.4c.4-.39.88-.69,1.43-.91.55-.22,1.15-.32,1.8-.32.29,0,.58.03.88.08s.58.14.85.25.52.25.74.41c.22.16.42.35.58.57l-.94.72c-.21-.29-.5-.53-.88-.71-.38-.19-.79-.28-1.23-.28-.5,0-.94.09-1.34.27-.4.18-.73.43-1.01.74-.28.31-.5.67-.65,1.09s-.23.85-.23,1.31.07.93.22,1.34c.15.42.36.78.64,1.09.28.31.61.55,1.01.73.4.18.84.26,1.33.26s.92-.1,1.31-.29.72-.47.97-.84l.95.65Z"/>
-    <path d="m65.15,15.66h2.66v.98h-2.66v2.66h-.98v-2.66h-2.66v-.98h2.66v-2.66h.98v2.66Z"/>
-    <path d="m73.14,15.66h2.66v.98h-2.66v2.66h-.98v-2.66h-2.66v-.98h2.66v-2.66h.98v2.66Z"/>
-  </g>
-  <g>
-    <path class="cls-4" d="m133.6,26.74c-.02-.14-.03-.31-.04-.49,0-.18-.01-.33-.01-.45h-.02c-.14.3-.39.56-.73.77-.34.21-.72.32-1.13.32-.37,0-.69-.06-.95-.18-.27-.12-.49-.29-.66-.5-.17-.21-.3-.46-.38-.74s-.13-.58-.13-.9v-3.53h1.13v3.14c0,.23.02.45.05.67s.1.4.2.56c.1.16.23.29.4.38.17.1.38.14.65.14.46,0,.82-.17,1.1-.51.28-.34.42-.79.42-1.36v-3.02h1.13v4.46c0,.15,0,.35.01.59,0,.24.02.45.04.64h-1.07Z"/>
-    <path class="cls-4" d="m137.59,21.05c.02.14.03.31.04.49s.01.33.01.45h.04c.07-.15.17-.29.29-.43s.27-.25.43-.35c.16-.1.34-.18.53-.23.19-.06.39-.08.6-.08.37,0,.68.06.95.19s.48.29.66.5c.18.21.31.45.39.73s.13.58.13.9v3.53h-1.13v-3.16c0-.23-.02-.45-.05-.66-.04-.21-.1-.39-.2-.55s-.23-.29-.4-.38-.38-.14-.65-.14c-.45,0-.81.17-1.1.51s-.43.79-.43,1.36v3.02h-1.13v-4.46c0-.15,0-.35-.01-.59s-.02-.45-.04-.64h1.07Z"/>
-    <path class="cls-4" d="m143.98,21.05l1.28,4.34h.02l1.36-4.34h1.19l1.38,4.34h.02l1.28-4.34h1.19l-1.88,5.69h-1.18l-1.4-4.27h-.02l-1.39,4.27h-1.18l-1.9-5.69h1.22Z"/>
-    <path class="cls-4" d="m152.82,21.69c0-.24-.02-.45-.04-.64h1.07c.02.14.03.31.04.5,0,.19.01.34.01.46h.04c.16-.34.39-.61.7-.81s.65-.31,1.04-.31c.18,0,.32.02.44.05l-.05,1.04c-.16-.04-.33-.06-.52-.06-.27,0-.51.05-.71.15-.2.1-.37.23-.5.4-.13.17-.23.36-.29.58s-.1.45-.1.69v2.99h-1.13v-4.46c0-.15,0-.35-.01-.59Z"/>
-    <path class="cls-4" d="m160.56,23.05c0-.42-.13-.74-.38-.94s-.6-.31-1.02-.31c-.32,0-.62.06-.91.19-.28.12-.52.28-.71.47l-.6-.72c.28-.26.62-.47,1.03-.62.4-.15.84-.23,1.3-.23.41,0,.76.06,1.06.17.3.12.55.27.74.47.19.2.34.44.43.71.1.27.14.56.14.88v2.48c0,.19,0,.39.02.61.01.21.03.39.07.52h-1.02c-.06-.27-.1-.54-.1-.82h-.04c-.21.3-.47.54-.79.71s-.69.25-1.12.25c-.22,0-.46-.03-.7-.09-.24-.06-.47-.16-.67-.29-.2-.14-.37-.32-.5-.54-.13-.22-.2-.5-.2-.83,0-.43.12-.77.35-1.03s.54-.44.91-.58.8-.22,1.27-.26.95-.06,1.43-.06v-.16Zm-.28.97c-.28,0-.57.01-.87.04-.3.02-.57.07-.82.14-.24.07-.45.18-.61.32s-.24.34-.24.58c0,.17.03.31.1.42.07.11.16.2.27.28.11.07.24.12.37.15.14.03.28.04.42.04.53,0,.93-.16,1.22-.47.28-.32.43-.71.43-1.19v-.3h-.28Z"/>
-    <path class="cls-4" d="m164.65,29.62h-1.13v-8.57h1.1v.89h.04c.18-.3.45-.55.81-.75s.77-.29,1.24-.29c.42,0,.81.08,1.15.23.35.15.65.36.9.64.25.27.44.59.58.95.14.36.2.75.2,1.17s-.07.81-.2,1.18-.33.69-.57.96c-.25.27-.55.49-.9.64-.35.16-.75.23-1.19.23-.41,0-.79-.09-1.15-.26-.36-.18-.64-.42-.85-.74h-.04v3.73Zm3.74-5.74c0-.26-.04-.52-.12-.77-.08-.25-.2-.47-.36-.66-.16-.19-.36-.34-.59-.46-.24-.11-.51-.17-.82-.17-.29,0-.55.06-.79.17-.24.11-.44.26-.61.46-.17.19-.3.41-.39.66-.09.25-.14.51-.14.78s.05.53.14.78c.09.25.22.47.39.65.17.19.37.34.61.45.24.11.5.17.79.17.31,0,.59-.06.82-.17s.43-.27.59-.46c.16-.19.28-.41.36-.66.08-.25.12-.5.12-.77Z"/>
-  </g>
-  <g>
-    <path class="cls-4" d="m136.99,51.59l1.28,4.34h.02l1.36-4.34h1.19l1.38,4.34h.02l1.28-4.34h1.19l-1.88,5.69h-1.18l-1.4-4.27h-.02l-1.39,4.27h-1.18l-1.9-5.69h1.22Z"/>
-    <path class="cls-4" d="m145.84,52.23c0-.24-.02-.45-.04-.64h1.07c.02.14.03.31.04.5,0,.19.01.34.01.46h.04c.16-.34.39-.61.7-.81s.65-.31,1.04-.31c.18,0,.32.02.44.05l-.05,1.04c-.16-.04-.33-.06-.52-.06-.27,0-.51.05-.71.15-.2.1-.37.23-.5.4-.13.17-.23.36-.29.58s-.1.45-.1.69v2.99h-1.13v-4.46c0-.15,0-.35-.01-.59Z"/>
-    <path class="cls-4" d="m153.58,53.6c0-.42-.13-.74-.38-.94s-.6-.31-1.02-.31c-.32,0-.62.06-.91.19-.28.12-.52.28-.71.47l-.6-.72c.28-.26.62-.47,1.03-.62.4-.15.84-.23,1.3-.23.41,0,.76.06,1.06.17.3.12.55.27.74.47.19.2.34.44.43.71.1.27.14.56.14.88v2.48c0,.19,0,.39.02.61.01.21.03.39.07.52h-1.02c-.06-.27-.1-.54-.1-.82h-.04c-.21.3-.47.54-.79.71s-.69.25-1.12.25c-.22,0-.46-.03-.7-.09-.24-.06-.47-.16-.67-.29-.2-.14-.37-.32-.5-.54-.13-.22-.2-.5-.2-.83,0-.43.12-.77.35-1.03s.54-.44.91-.58.8-.22,1.27-.26.95-.06,1.43-.06v-.16Zm-.28.97c-.28,0-.57.01-.87.04-.3.02-.57.07-.82.14-.24.07-.45.18-.61.32s-.24.34-.24.58c0,.17.03.31.1.42.07.11.16.2.27.28.11.07.24.12.37.15.14.03.28.04.42.04.53,0,.93-.16,1.22-.47.28-.32.43-.71.43-1.19v-.3h-.28Z"/>
-    <path class="cls-4" d="m157.67,60.16h-1.13v-8.57h1.1v.89h.04c.18-.3.45-.55.81-.75s.77-.29,1.24-.29c.42,0,.81.08,1.15.23.35.15.65.36.9.64.25.27.44.59.58.95.14.36.2.75.2,1.17s-.07.81-.2,1.18-.33.69-.57.96c-.25.27-.55.49-.9.64-.35.16-.75.23-1.19.23-.41,0-.79-.09-1.15-.26-.36-.18-.64-.42-.85-.74h-.04v3.73Zm3.74-5.74c0-.26-.04-.52-.12-.77-.08-.25-.2-.47-.36-.66-.16-.19-.36-.34-.59-.46-.24-.11-.51-.17-.82-.17-.29,0-.55.06-.79.17-.24.11-.44.26-.61.46-.17.19-.3.41-.39.66-.09.25-.14.51-.14.78s.05.53.14.78c.09.25.22.47.39.65.17.19.37.34.61.45.24.11.5.17.79.17.31,0,.59-.06.82-.17s.43-.27.59-.46c.16-.19.28-.41.36-.66.08-.25.12-.5.12-.77Z"/>
-  </g>
-  <g>
-    <path d="m216.7,11.3h2.59c.46,0,.87.05,1.25.14.38.09.7.23.96.43.26.19.47.44.61.73s.22.65.22,1.07-.08.79-.23,1.09c-.16.3-.37.55-.65.74-.28.19-.6.33-.98.43s-.79.14-1.23.14h-1.34v3.73h-1.19v-8.5Zm1.19,3.76h1.26c.29,0,.55-.03.8-.08.24-.05.45-.13.63-.24.18-.11.31-.25.41-.43.1-.18.14-.39.14-.65s-.05-.47-.15-.64c-.1-.17-.24-.31-.41-.42-.17-.11-.38-.18-.62-.23-.24-.04-.5-.07-.78-.07h-1.28v2.75Z"/>
-    <path d="m225.45,18.57h.02l1.57-4.46h1.2l-2.76,7.03c-.1.24-.2.45-.31.64-.11.19-.24.35-.4.48s-.33.23-.53.31c-.2.07-.45.11-.73.11-.12,0-.24,0-.37-.02-.12-.01-.25-.03-.38-.07l.11-1c.19.06.38.1.56.1.3,0,.52-.08.66-.25.14-.16.28-.4.4-.7l.36-.95-2.44-5.69h1.26l1.76,4.46Z"/>
-    <path d="m232.12,15.03h-1.51v2.96c0,.34.06.59.19.74s.33.22.61.22c.1,0,.22-.01.34-.03.12-.02.23-.05.32-.1l.04.92c-.14.05-.29.08-.45.11s-.33.04-.51.04c-.54,0-.95-.15-1.23-.44-.28-.3-.43-.74-.43-1.33v-3.08h-1.09v-.92h1.09v-1.63h1.12v1.63h1.51v.92Z"/>
-    <path d="m234.46,14.97c.14-.28.37-.52.7-.72.33-.2.7-.3,1.1-.3.37,0,.68.06.95.19s.48.29.66.5c.18.21.31.45.39.73s.13.58.13.9v3.53h-1.13v-3.15c0-.23-.02-.45-.05-.66-.04-.21-.1-.39-.2-.55-.1-.16-.23-.29-.39-.39-.16-.1-.38-.14-.64-.14-.45,0-.82.17-1.1.51s-.43.8-.43,1.37v3.02h-1.13v-9.07h1.13v4.25h.02Z"/>
-    <path d="m246.05,16.94c0,.44-.08.84-.23,1.21-.16.37-.37.69-.65.95-.28.27-.6.48-.98.62-.38.15-.78.22-1.21.22s-.84-.07-1.21-.22c-.38-.15-.7-.36-.97-.62-.27-.27-.49-.59-.64-.95-.16-.37-.23-.77-.23-1.21s.08-.84.23-1.21c.16-.36.37-.68.64-.94s.6-.47.97-.62c.38-.15.78-.22,1.21-.22s.84.07,1.21.22c.38.15.7.35.98.62s.49.58.65.94c.16.36.23.77.23,1.21Zm-1.18,0c0-.27-.04-.53-.13-.78-.08-.25-.21-.46-.37-.65s-.36-.34-.6-.45c-.24-.11-.51-.17-.81-.17s-.58.06-.81.17c-.24.11-.44.26-.6.45-.16.19-.28.4-.37.65-.08.25-.13.51-.13.78s.04.53.13.78c.08.25.21.47.37.66.16.19.36.34.6.46.24.11.51.17.81.17s.58-.06.81-.17c.24-.11.44-.26.6-.46s.28-.41.37-.66c.08-.25.13-.51.13-.78Z"/>
-    <path d="m248.63,14.1c.02.14.03.31.04.49s.01.33.01.45h.04c.07-.15.17-.29.29-.43s.27-.25.43-.35c.16-.1.34-.18.53-.23.19-.06.39-.08.6-.08.37,0,.68.06.95.19s.48.29.66.5c.18.21.31.45.39.73s.13.58.13.9v3.53h-1.13v-3.16c0-.23-.02-.45-.05-.66-.04-.21-.1-.39-.2-.55s-.23-.29-.4-.38-.38-.14-.65-.14c-.45,0-.81.17-1.1.51s-.43.79-.43,1.36v3.02h-1.13v-4.46c0-.15,0-.35-.01-.59s-.02-.45-.04-.64h1.07Z"/>
-  </g>
-  <g>
-    <path d="m43.08,36.13h.76l.03.79c.14-.17.28-.31.42-.42.13-.11.26-.2.39-.27s.26-.12.39-.14c.13-.03.27-.04.42-.04.5,0,.89.15,1.15.45.26.3.39.75.39,1.34v3.2h-.85v-3.13c0-.38-.07-.67-.21-.85-.14-.18-.36-.28-.64-.28-.1,0-.21.02-.31.05-.1.03-.2.08-.31.16-.11.08-.22.18-.35.31s-.27.29-.42.49v3.25h-.85v-4.9Z"/>
-    <path d="m52.77,38.49c0,.41-.06.77-.17,1.09-.11.32-.27.59-.48.81-.21.22-.46.39-.75.51-.3.12-.63.18-1,.18-.29,0-.59-.03-.89-.08s-.6-.14-.9-.26v-6.61h.85v1.9l-.04.91c.24-.33.51-.56.78-.7.28-.14.58-.2.9-.2.28,0,.53.06.74.18s.39.28.53.5c.14.21.25.47.32.77.07.3.11.64.11,1.01Zm-.87.04c0-.26-.02-.49-.06-.71s-.1-.4-.18-.55-.19-.27-.31-.36c-.13-.09-.28-.13-.45-.13-.11,0-.22.02-.33.05-.11.04-.23.09-.34.17-.12.08-.24.19-.38.32-.13.13-.27.3-.42.49v2.38c.17.07.34.12.51.15.17.04.34.06.49.06.2,0,.38-.03.56-.09s.33-.17.47-.31c.14-.14.24-.34.32-.58.08-.24.12-.54.12-.89Z"/>
-    <path d="m56.05,36.04c.1,0,.2.02.29.06.09.04.17.1.24.16s.12.15.16.24.06.19.06.29-.02.2-.06.29c-.04.09-.1.17-.16.24s-.15.12-.24.16-.19.06-.29.06-.2-.02-.29-.06-.17-.09-.24-.16-.12-.15-.16-.24c-.04-.09-.06-.19-.06-.29s.02-.2.06-.29.09-.17.16-.24.15-.12.24-.16c.09-.04.19-.06.29-.06Zm0,3.58c.1,0,.2.02.29.06.09.04.17.09.24.16s.12.15.16.24.06.19.06.29-.02.2-.06.29c-.04.09-.1.17-.16.24s-.15.12-.24.16-.19.06-.29.06-.2-.02-.29-.06-.17-.09-.24-.16-.12-.15-.16-.24c-.04-.09-.06-.19-.06-.29s.02-.2.06-.29.09-.17.16-.24.15-.12.24-.16c.09-.04.19-.06.29-.06Z"/>
-    <path d="m61.54,36.04c.1,0,.2.02.29.06.09.04.17.1.24.16s.12.15.16.24.06.19.06.29-.02.2-.06.29c-.04.09-.1.17-.16.24s-.15.12-.24.16-.19.06-.29.06-.2-.02-.29-.06-.17-.09-.24-.16-.12-.15-.16-.24c-.04-.09-.06-.19-.06-.29s.02-.2.06-.29.09-.17.16-.24.15-.12.24-.16c.09-.04.19-.06.29-.06Zm0,3.58c.1,0,.2.02.29.06.09.04.17.09.24.16s.12.15.16.24.06.19.06.29-.02.2-.06.29c-.04.09-.1.17-.16.24s-.15.12-.24.16-.19.06-.29.06-.2-.02-.29-.06-.17-.09-.24-.16-.12-.15-.16-.24c-.04-.09-.06-.19-.06-.29s.02-.2.06-.29.09-.17.16-.24.15-.12.24-.16c.09-.04.19-.06.29-.06Z"/>
-    <path d="m66.74,34.83h-1.45v-.7h2.31v6.19h1.46v.71h-3.93v-.71h1.61v-5.49Z"/>
-    <path d="m72.24,36.83h-1.45v-.7h2.31v4.19h1.46v.71h-3.93v-.71h1.61v-3.49Zm.3-2.76c.09,0,.18.02.26.05.08.03.15.08.21.14s.11.13.14.21c.03.08.05.17.05.26s-.02.18-.05.26-.08.15-.14.21-.13.11-.21.14c-.08.04-.17.05-.26.05s-.18-.02-.26-.05c-.08-.03-.15-.08-.21-.14s-.11-.13-.14-.21-.05-.17-.05-.26.02-.18.05-.26c.03-.08.08-.15.14-.21s.13-.11.21-.14c.08-.04.17-.05.26-.05Z"/>
-    <path d="m79.95,39.69c0,.17-.03.33-.09.46s-.14.26-.24.36c-.1.11-.22.2-.35.27s-.28.14-.43.19-.31.08-.47.11-.32.03-.47.03c-.33,0-.64-.01-.92-.04s-.55-.08-.82-.14v-.78c.29.08.57.14.85.19s.56.06.84.06c.41,0,.71-.06.9-.17s.29-.27.29-.47c0-.09-.02-.17-.05-.24-.03-.07-.09-.14-.17-.2-.08-.06-.21-.13-.38-.2s-.4-.15-.7-.23c-.22-.07-.43-.14-.61-.22-.19-.08-.35-.18-.49-.29s-.24-.25-.32-.4-.12-.33-.12-.54c0-.14.03-.29.1-.45s.17-.31.32-.45.36-.26.62-.35c.26-.09.59-.14.98-.14.19,0,.41.01.64.03.23.02.48.06.73.11v.76c-.27-.07-.52-.11-.76-.14-.24-.03-.45-.05-.62-.05-.21,0-.39.02-.53.05s-.26.08-.35.13c-.09.06-.15.12-.19.2-.04.08-.06.16-.06.25s.02.17.05.24.1.14.19.21c.09.07.22.13.39.2.17.07.38.14.65.22.29.08.53.17.73.27.2.09.36.2.48.31s.21.24.27.39.08.31.08.49Z"/>
-    <path d="m85.52,40.96c-.19.05-.39.08-.6.11-.21.02-.41.03-.62.03-.62,0-1.07-.14-1.38-.42-.3-.28-.45-.71-.45-1.28v-2.56h-1.37v-.71h1.37v-1.35l.85-.22v1.57h2.2v.71h-2.2v2.49c0,.35.09.61.28.79.19.17.46.26.83.26.16,0,.33-.01.51-.04.19-.03.38-.06.58-.12v.73Z"/>
-  </g>
-  <g>
-    <path d="m226.01,34.83h-1.45v-.7h2.31v6.19h1.46v.71h-3.93v-.71h1.61v-5.49Z"/>
-    <path d="m231.51,36.83h-1.45v-.7h2.31v4.19h1.46v.71h-3.93v-.71h1.61v-3.49Zm.3-2.76c.09,0,.18.02.26.05.08.03.15.08.21.14s.11.13.14.21c.03.08.05.17.05.26s-.02.18-.05.26-.08.15-.14.21-.13.11-.21.14c-.08.04-.17.05-.26.05s-.18-.02-.26-.05c-.08-.03-.15-.08-.21-.14s-.11-.13-.14-.21-.05-.17-.05-.26.02-.18.05-.26c.03-.08.08-.15.14-.21s.13-.11.21-.14c.08-.04.17-.05.26-.05Z"/>
-    <path d="m239.22,39.69c0,.17-.03.33-.09.46s-.14.26-.24.36c-.1.11-.22.2-.35.27s-.28.14-.43.19-.31.08-.47.11-.32.03-.47.03c-.33,0-.64-.01-.92-.04s-.55-.08-.82-.14v-.78c.29.08.57.14.85.19s.56.06.84.06c.41,0,.71-.06.9-.17s.29-.27.29-.47c0-.09-.02-.17-.05-.24-.03-.07-.09-.14-.17-.2-.08-.06-.21-.13-.38-.2s-.4-.15-.7-.23c-.22-.07-.43-.14-.61-.22-.19-.08-.35-.18-.49-.29s-.24-.25-.32-.4-.12-.33-.12-.54c0-.14.03-.29.1-.45s.17-.31.32-.45.36-.26.62-.35c.26-.09.59-.14.98-.14.19,0,.41.01.64.03.23.02.48.06.73.11v.76c-.27-.07-.52-.11-.76-.14-.24-.03-.45-.05-.62-.05-.21,0-.39.02-.53.05s-.26.08-.35.13c-.09.06-.15.12-.19.2-.04.08-.06.16-.06.25s.02.17.05.24.1.14.19.21c.09.07.22.13.39.2.17.07.38.14.65.22.29.08.53.17.73.27.2.09.36.2.48.31s.21.24.27.39.08.31.08.49Z"/>
-    <path d="m244.78,40.96c-.19.05-.39.08-.6.11-.21.02-.41.03-.62.03-.62,0-1.07-.14-1.38-.42-.3-.28-.45-.71-.45-1.28v-2.56h-1.37v-.71h1.37v-1.35l.85-.22v1.57h2.2v.71h-2.2v2.49c0,.35.09.61.28.79.19.17.46.26.83.26.16,0,.33-.01.51-.04.19-.03.38-.06.58-.12v.73Z"/>
-  </g>
-  <polygon class="cls-8" points="179.19 31.26 184.59 33.96 179.19 36.66 179.19 31.26"/>
-  <line class="cls-3" x1="114.6" y1="33.96" x2="180.27" y2="33.96"/>
-  <polygon class="cls-8" points="120 45.73 114.6 43.03 120 40.33 120 45.73"/>
-  <line class="cls-3" x1="184.59" y1="43.03" x2="118.92" y2="43.03"/>
-</svg>
\ No newline at end of file
diff --git a/src/nanobind/docs/images/wrapper-light.svg b/src/nanobind/docs/images/wrapper-light.svg
deleted file mode 100644
index 62f73c9..0000000
--- a/src/nanobind/docs/images/wrapper-light.svg
+++ /dev/null
@@ -1,92 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<svg id="Layer_1" data-name="Layer 1" xmlns="http://www.w3.org/2000/svg" viewBox="0 0 298.8 62.36">
-  <defs>
-    <style>
-      .cls-1, .cls-2, .cls-3 {
-        fill: none;
-        stroke: #000;
-        stroke-linecap: round;
-        stroke-linejoin: round;
-      }
-
-      .cls-4 {
-        fill: #adffa2;
-      }
-
-      .cls-5 {
-        fill: #dcffdf;
-      }
-
-      .cls-6 {
-        fill: #dcdcff;
-      }
-
-      .cls-2 {
-        stroke-width: .8px;
-      }
-
-      .cls-7 {
-        fill-rule: evenodd;
-      }
-
-      .cls-3 {
-        stroke-width: 1.5px;
-      }
-    </style>
-  </defs>
-  <rect class="cls-6" x="6.35" y="5.85" width="115.87" height="50.74"/>
-  <rect class="cls-1" x="6.35" y="5.85" width="115.87" height="50.74"/>
-  <rect class="cls-5" x="176.58" y="5.85" width="115.87" height="50.74"/>
-  <rect class="cls-1" x="176.58" y="5.85" width="115.87" height="50.74"/>
-  <rect class="cls-4" x="16.68" y="28.23" width="95.21" height="18.58"/>
-  <rect class="cls-2" x="16.68" y="28.23" width="95.21" height="18.58"/>
-  <rect class="cls-4" x="186.94" y="28.23" width="95.21" height="18.58"/>
-  <rect class="cls-2" x="186.94" y="28.23" width="95.21" height="18.58"/>
-  <g>
-    <path d="m60.48,18.47c-.34.46-.77.83-1.31,1.11-.54.28-1.18.43-1.93.43-.65,0-1.25-.11-1.79-.33-.55-.22-1.02-.53-1.42-.92-.4-.4-.71-.87-.93-1.42-.22-.55-.34-1.15-.34-1.81s.11-1.27.34-1.82.54-1.02.95-1.4c.4-.39.88-.69,1.43-.91.55-.22,1.15-.32,1.8-.32.29,0,.58.03.88.08s.58.14.85.25.52.25.74.41c.22.16.42.35.58.57l-.94.72c-.21-.29-.5-.53-.88-.71-.38-.19-.79-.28-1.23-.28-.5,0-.94.09-1.34.27-.4.18-.73.43-1.01.74-.28.31-.5.67-.65,1.09s-.23.85-.23,1.31.07.93.22,1.34c.15.42.36.78.64,1.09.28.31.61.55,1.01.73.4.18.84.26,1.33.26s.92-.1,1.31-.29.72-.47.97-.84l.95.65Z"/>
-    <path d="m65.15,15.67h2.66v.98h-2.66v2.66h-.98v-2.66h-2.66v-.98h2.66v-2.66h.98v2.66Z"/>
-    <path d="m73.14,15.67h2.66v.98h-2.66v2.66h-.98v-2.66h-2.66v-.98h2.66v-2.66h.98v2.66Z"/>
-  </g>
-  <g>
-    <path d="m133.6,26.74c-.02-.14-.03-.31-.04-.49,0-.18-.01-.33-.01-.45h-.02c-.14.3-.39.56-.73.77-.34.21-.72.32-1.13.32-.37,0-.69-.06-.95-.18-.27-.12-.49-.29-.66-.5-.17-.21-.3-.46-.38-.74s-.13-.58-.13-.9v-3.53h1.13v3.14c0,.23.02.45.05.67s.1.4.2.56c.1.16.23.29.4.38.17.1.38.14.65.14.46,0,.82-.17,1.1-.51.28-.34.42-.79.42-1.36v-3.02h1.13v4.46c0,.15,0,.35.01.59,0,.24.02.45.04.64h-1.07Z"/>
-    <path d="m137.59,21.05c.02.14.03.31.04.49s.01.33.01.45h.04c.07-.15.17-.29.29-.43s.27-.25.43-.35c.16-.1.34-.18.53-.23.19-.06.39-.08.6-.08.37,0,.68.06.95.19s.48.29.66.5c.18.21.31.45.39.73s.13.58.13.9v3.53h-1.13v-3.16c0-.23-.02-.45-.05-.66-.04-.21-.1-.39-.2-.55s-.23-.29-.4-.38-.38-.14-.65-.14c-.45,0-.81.17-1.1.51s-.43.79-.43,1.36v3.02h-1.13v-4.46c0-.15,0-.35-.01-.59s-.02-.45-.04-.64h1.07Z"/>
-    <path d="m143.98,21.05l1.28,4.34h.02l1.36-4.34h1.19l1.38,4.34h.02l1.28-4.34h1.19l-1.88,5.69h-1.18l-1.4-4.27h-.02l-1.39,4.27h-1.18l-1.9-5.69h1.22Z"/>
-    <path d="m152.82,21.69c0-.24-.02-.45-.04-.64h1.07c.02.14.03.31.04.5,0,.19.01.34.01.46h.04c.16-.34.39-.61.7-.81s.65-.31,1.04-.31c.18,0,.32.02.44.05l-.05,1.04c-.16-.04-.33-.06-.52-.06-.27,0-.51.05-.71.15-.2.1-.37.23-.5.4-.13.17-.23.36-.29.58s-.1.45-.1.69v2.99h-1.13v-4.46c0-.15,0-.35-.01-.59Z"/>
-    <path d="m160.56,23.05c0-.42-.13-.74-.38-.94s-.6-.31-1.02-.31c-.32,0-.62.06-.91.19-.28.12-.52.28-.71.47l-.6-.72c.28-.26.62-.47,1.03-.62.4-.15.84-.23,1.3-.23.41,0,.76.06,1.06.17.3.12.55.27.74.47.19.2.34.44.43.71.1.27.14.56.14.88v2.48c0,.19,0,.39.02.61.01.21.03.39.07.52h-1.02c-.06-.27-.1-.54-.1-.82h-.04c-.21.3-.47.54-.79.71s-.69.25-1.12.25c-.22,0-.46-.03-.7-.09-.24-.06-.47-.16-.67-.29-.2-.14-.37-.32-.5-.54-.13-.22-.2-.5-.2-.83,0-.43.12-.77.35-1.03s.54-.44.91-.58.8-.22,1.27-.26.95-.06,1.43-.06v-.16Zm-.28.97c-.28,0-.57.01-.87.04-.3.02-.57.07-.82.14-.24.07-.45.18-.61.32s-.24.34-.24.58c0,.17.03.31.1.42.07.11.16.2.27.28.11.07.24.12.37.15.14.03.28.04.42.04.53,0,.93-.16,1.22-.47.28-.32.43-.71.43-1.19v-.3h-.28Z"/>
-    <path d="m164.65,29.62h-1.13v-8.57h1.1v.89h.04c.18-.3.45-.55.81-.75s.77-.29,1.24-.29c.42,0,.81.08,1.15.23.35.15.65.36.9.64.25.27.44.59.58.95.14.36.2.75.2,1.17s-.07.81-.2,1.18-.33.69-.57.96c-.25.27-.55.49-.9.64-.35.16-.75.23-1.19.23-.41,0-.79-.09-1.15-.26-.36-.18-.64-.42-.85-.74h-.04v3.73Zm3.74-5.74c0-.26-.04-.52-.12-.77-.08-.25-.2-.47-.36-.66-.16-.19-.36-.34-.59-.46-.24-.11-.51-.17-.82-.17-.29,0-.55.06-.79.17-.24.11-.44.26-.61.46-.17.19-.3.41-.39.66-.09.25-.14.51-.14.78s.05.53.14.78c.09.25.22.47.39.65.17.19.37.34.61.45.24.11.5.17.79.17.31,0,.59-.06.82-.17s.43-.27.59-.46c.16-.19.28-.41.36-.66.08-.25.12-.5.12-.77Z"/>
-  </g>
-  <g>
-    <path d="m136.99,51.59l1.28,4.34h.02l1.36-4.34h1.19l1.38,4.34h.02l1.28-4.34h1.19l-1.88,5.69h-1.18l-1.4-4.27h-.02l-1.39,4.27h-1.18l-1.9-5.69h1.22Z"/>
-    <path d="m145.84,52.23c0-.24-.02-.45-.04-.64h1.07c.02.14.03.31.04.5,0,.19.01.34.01.46h.04c.16-.34.39-.61.7-.81s.65-.31,1.04-.31c.18,0,.32.02.44.05l-.05,1.04c-.16-.04-.33-.06-.52-.06-.27,0-.51.05-.71.15-.2.1-.37.23-.5.4-.13.17-.23.36-.29.58s-.1.45-.1.69v2.99h-1.13v-4.46c0-.15,0-.35-.01-.59Z"/>
-    <path d="m153.58,53.6c0-.42-.13-.74-.38-.94s-.6-.31-1.02-.31c-.32,0-.62.06-.91.19-.28.12-.52.28-.71.47l-.6-.72c.28-.26.62-.47,1.03-.62.4-.15.84-.23,1.3-.23.41,0,.76.06,1.06.17.3.12.55.27.74.47.19.2.34.44.43.71.1.27.14.56.14.88v2.48c0,.19,0,.39.02.61.01.21.03.39.07.52h-1.02c-.06-.27-.1-.54-.1-.82h-.04c-.21.3-.47.54-.79.71s-.69.25-1.12.25c-.22,0-.46-.03-.7-.09-.24-.06-.47-.16-.67-.29-.2-.14-.37-.32-.5-.54-.13-.22-.2-.5-.2-.83,0-.43.12-.77.35-1.03s.54-.44.91-.58.8-.22,1.27-.26.95-.06,1.43-.06v-.16Zm-.28.97c-.28,0-.57.01-.87.04-.3.02-.57.07-.82.14-.24.07-.45.18-.61.32s-.24.34-.24.58c0,.17.03.31.1.42.07.11.16.2.27.28.11.07.24.12.37.15.14.03.28.04.42.04.53,0,.93-.16,1.22-.47.28-.32.43-.71.43-1.19v-.3h-.28Z"/>
-    <path d="m157.67,60.16h-1.13v-8.57h1.1v.89h.04c.18-.3.45-.55.81-.75s.77-.29,1.24-.29c.42,0,.81.08,1.15.23.35.15.65.36.9.64.25.27.44.59.58.95.14.36.2.75.2,1.17s-.07.81-.2,1.18-.33.69-.57.96c-.25.27-.55.49-.9.64-.35.16-.75.23-1.19.23-.41,0-.79-.09-1.15-.26-.36-.18-.64-.42-.85-.74h-.04v3.73Zm3.74-5.74c0-.26-.04-.52-.12-.77-.08-.25-.2-.47-.36-.66-.16-.19-.36-.34-.59-.46-.24-.11-.51-.17-.82-.17-.29,0-.55.06-.79.17-.24.11-.44.26-.61.46-.17.19-.3.41-.39.66-.09.25-.14.51-.14.78s.05.53.14.78c.09.25.22.47.39.65.17.19.37.34.61.45.24.11.5.17.79.17.31,0,.59-.06.82-.17s.43-.27.59-.46c.16-.19.28-.41.36-.66.08-.25.12-.5.12-.77Z"/>
-  </g>
-  <g>
-    <path d="m216.7,11.3h2.59c.46,0,.87.05,1.25.14.38.09.7.23.96.43.26.19.47.44.61.73s.22.65.22,1.07-.08.79-.23,1.09c-.16.3-.37.55-.65.74-.28.19-.6.33-.98.43s-.79.14-1.23.14h-1.34v3.73h-1.19v-8.5Zm1.19,3.76h1.26c.29,0,.55-.03.8-.08.24-.05.45-.13.63-.24.18-.11.31-.25.41-.43.1-.18.14-.39.14-.65s-.05-.47-.15-.64c-.1-.17-.24-.31-.41-.42-.17-.11-.38-.18-.62-.23-.24-.04-.5-.07-.78-.07h-1.28v2.75Z"/>
-    <path d="m225.44,18.57h.02l1.57-4.46h1.2l-2.76,7.03c-.1.24-.2.45-.31.64-.11.19-.24.35-.4.48s-.33.23-.53.31c-.2.07-.45.11-.73.11-.12,0-.24,0-.37-.02-.12-.01-.25-.03-.38-.07l.11-1c.19.06.38.1.56.1.3,0,.52-.08.66-.25.14-.16.28-.4.4-.7l.36-.95-2.44-5.69h1.26l1.76,4.46Z"/>
-    <path d="m232.12,15.03h-1.51v2.96c0,.34.06.59.19.74s.33.22.61.22c.1,0,.22-.01.34-.03.12-.02.23-.05.32-.1l.04.92c-.14.05-.29.08-.45.11s-.33.04-.51.04c-.54,0-.95-.15-1.23-.44-.28-.3-.43-.74-.43-1.33v-3.08h-1.09v-.92h1.09v-1.63h1.12v1.63h1.51v.92Z"/>
-    <path d="m234.46,14.97c.14-.28.37-.52.7-.72.33-.2.7-.3,1.1-.3.37,0,.68.06.95.19s.48.29.66.5c.18.21.31.45.39.73s.13.58.13.9v3.53h-1.13v-3.15c0-.23-.02-.45-.05-.66-.04-.21-.1-.39-.2-.55-.1-.16-.23-.29-.39-.39-.16-.1-.38-.14-.64-.14-.45,0-.82.17-1.1.51s-.43.8-.43,1.37v3.02h-1.13v-9.07h1.13v4.25h.02Z"/>
-    <path d="m246.05,16.94c0,.44-.08.84-.23,1.21-.16.37-.37.69-.65.95-.28.27-.6.48-.98.62-.38.15-.78.22-1.21.22s-.84-.07-1.21-.22c-.38-.15-.7-.36-.97-.62-.27-.27-.49-.59-.64-.95-.16-.37-.23-.77-.23-1.21s.08-.84.23-1.21c.16-.36.37-.68.64-.94s.6-.47.97-.62c.38-.15.78-.22,1.21-.22s.84.07,1.21.22c.38.15.7.35.98.62s.49.58.65.94c.16.36.23.77.23,1.21Zm-1.18,0c0-.27-.04-.53-.13-.78-.08-.25-.21-.46-.37-.65s-.36-.34-.6-.45c-.24-.11-.51-.17-.81-.17s-.58.06-.81.17c-.24.11-.44.26-.6.45-.16.19-.28.4-.37.65-.08.25-.13.51-.13.78s.04.53.13.78c.08.25.21.47.37.66.16.19.36.34.6.46.24.11.51.17.81.17s.58-.06.81-.17c.24-.11.44-.26.6-.46s.28-.41.37-.66c.08-.25.13-.51.13-.78Z"/>
-    <path d="m248.63,14.1c.02.14.03.31.04.49s.01.33.01.45h.04c.07-.15.17-.29.29-.43s.27-.25.43-.35c.16-.1.34-.18.53-.23.19-.06.39-.08.6-.08.37,0,.68.06.95.19s.48.29.66.5c.18.21.31.45.39.73s.13.58.13.9v3.53h-1.13v-3.16c0-.23-.02-.45-.05-.66-.04-.21-.1-.39-.2-.55s-.23-.29-.4-.38-.38-.14-.65-.14c-.45,0-.81.17-1.1.51s-.43.79-.43,1.36v3.02h-1.13v-4.46c0-.15,0-.35-.01-.59s-.02-.45-.04-.64h1.07Z"/>
-  </g>
-  <g>
-    <path d="m43.08,36.13h.76l.03.79c.14-.17.28-.31.42-.42.13-.11.26-.2.39-.27s.26-.12.39-.14c.13-.03.27-.04.42-.04.5,0,.89.15,1.15.45.26.3.39.75.39,1.34v3.2h-.85v-3.13c0-.38-.07-.67-.21-.85-.14-.18-.36-.28-.64-.28-.1,0-.21.02-.31.05-.1.03-.2.08-.31.16-.11.08-.22.18-.35.31s-.27.29-.42.49v3.25h-.85v-4.9Z"/>
-    <path d="m52.77,38.49c0,.41-.06.77-.17,1.09-.11.32-.27.59-.48.81-.21.22-.46.39-.75.51-.3.12-.63.18-1,.18-.29,0-.59-.03-.89-.08s-.6-.14-.9-.26v-6.61h.85v1.9l-.04.91c.24-.33.51-.56.78-.7.28-.14.58-.2.9-.2.28,0,.53.06.74.18s.39.28.53.5c.14.21.25.47.32.77.07.3.11.64.11,1.01Zm-.87.04c0-.26-.02-.49-.06-.71s-.1-.4-.18-.55-.19-.27-.31-.36c-.13-.09-.28-.13-.45-.13-.11,0-.22.02-.33.05-.11.04-.23.09-.34.17-.12.08-.24.19-.38.32-.13.13-.27.3-.42.49v2.38c.17.07.34.12.51.15.17.04.34.06.49.06.2,0,.38-.03.56-.09s.33-.17.47-.31c.14-.14.24-.34.32-.58.08-.24.12-.54.12-.89Z"/>
-    <path d="m56.04,36.04c.1,0,.2.02.29.06.09.04.17.1.24.16s.12.15.16.24.06.19.06.29-.02.2-.06.29c-.04.09-.1.17-.16.24s-.15.12-.24.16-.19.06-.29.06-.2-.02-.29-.06-.17-.09-.24-.16-.12-.15-.16-.24c-.04-.09-.06-.19-.06-.29s.02-.2.06-.29.09-.17.16-.24.15-.12.24-.16c.09-.04.19-.06.29-.06Zm0,3.58c.1,0,.2.02.29.06.09.04.17.09.24.16s.12.15.16.24.06.19.06.29-.02.2-.06.29c-.04.09-.1.17-.16.24s-.15.12-.24.16-.19.06-.29.06-.2-.02-.29-.06-.17-.09-.24-.16-.12-.15-.16-.24c-.04-.09-.06-.19-.06-.29s.02-.2.06-.29.09-.17.16-.24.15-.12.24-.16c.09-.04.19-.06.29-.06Z"/>
-    <path d="m61.54,36.04c.1,0,.2.02.29.06.09.04.17.1.24.16s.12.15.16.24.06.19.06.29-.02.2-.06.29c-.04.09-.1.17-.16.24s-.15.12-.24.16-.19.06-.29.06-.2-.02-.29-.06-.17-.09-.24-.16-.12-.15-.16-.24c-.04-.09-.06-.19-.06-.29s.02-.2.06-.29.09-.17.16-.24.15-.12.24-.16c.09-.04.19-.06.29-.06Zm0,3.58c.1,0,.2.02.29.06.09.04.17.09.24.16s.12.15.16.24.06.19.06.29-.02.2-.06.29c-.04.09-.1.17-.16.24s-.15.12-.24.16-.19.06-.29.06-.2-.02-.29-.06-.17-.09-.24-.16-.12-.15-.16-.24c-.04-.09-.06-.19-.06-.29s.02-.2.06-.29.09-.17.16-.24.15-.12.24-.16c.09-.04.19-.06.29-.06Z"/>
-    <path d="m66.74,34.83h-1.45v-.7h2.31v6.19h1.46v.71h-3.93v-.71h1.61v-5.49Z"/>
-    <path d="m72.24,36.83h-1.45v-.7h2.31v4.19h1.46v.71h-3.93v-.71h1.61v-3.49Zm.3-2.76c.09,0,.18.02.26.05.08.03.15.08.21.14s.11.13.14.21c.03.08.05.17.05.26s-.02.18-.05.26-.08.15-.14.21-.13.11-.21.14c-.08.04-.17.05-.26.05s-.18-.02-.26-.05c-.08-.03-.15-.08-.21-.14s-.11-.13-.14-.21-.05-.17-.05-.26.02-.18.05-.26c.03-.08.08-.15.14-.21s.13-.11.21-.14c.08-.04.17-.05.26-.05Z"/>
-    <path d="m79.95,39.69c0,.17-.03.33-.09.46s-.14.26-.24.36c-.1.11-.22.2-.35.27s-.28.14-.43.19-.31.08-.47.11-.32.03-.47.03c-.33,0-.64-.01-.92-.04s-.55-.08-.82-.14v-.78c.29.08.57.14.85.19s.56.06.84.06c.41,0,.71-.06.9-.17s.29-.27.29-.47c0-.09-.02-.17-.05-.24-.03-.07-.09-.14-.17-.2-.08-.06-.21-.13-.38-.2s-.4-.15-.7-.23c-.22-.07-.43-.14-.61-.22-.19-.08-.35-.18-.49-.29s-.24-.25-.32-.4-.12-.33-.12-.54c0-.14.03-.29.1-.45s.17-.31.32-.45.36-.26.62-.35c.26-.09.59-.14.98-.14.19,0,.41.01.64.03.23.02.48.06.73.11v.76c-.27-.07-.52-.11-.76-.14-.24-.03-.45-.05-.62-.05-.21,0-.39.02-.53.05s-.26.08-.35.13c-.09.06-.15.12-.19.2-.04.08-.06.16-.06.25s.02.17.05.24.1.14.19.21c.09.07.22.13.39.2.17.07.38.14.65.22.29.08.53.17.73.27.2.09.36.2.48.31s.21.24.27.39.08.31.08.49Z"/>
-    <path d="m85.52,40.96c-.19.05-.39.08-.6.11-.21.02-.41.03-.62.03-.62,0-1.07-.14-1.38-.42-.3-.28-.45-.71-.45-1.28v-2.56h-1.37v-.71h1.37v-1.35l.85-.22v1.57h2.2v.71h-2.2v2.49c0,.35.09.61.28.79.19.17.46.26.83.26.16,0,.33-.01.51-.04.19-.03.38-.06.58-.12v.73Z"/>
-  </g>
-  <g>
-    <path d="m226.01,34.83h-1.45v-.7h2.31v6.19h1.46v.71h-3.93v-.71h1.61v-5.49Z"/>
-    <path d="m231.51,36.83h-1.45v-.7h2.31v4.19h1.46v.71h-3.93v-.71h1.61v-3.49Zm.3-2.76c.09,0,.18.02.26.05.08.03.15.08.21.14s.11.13.14.21c.03.08.05.17.05.26s-.02.18-.05.26-.08.15-.14.21-.13.11-.21.14c-.08.04-.17.05-.26.05s-.18-.02-.26-.05c-.08-.03-.15-.08-.21-.14s-.11-.13-.14-.21-.05-.17-.05-.26.02-.18.05-.26c.03-.08.08-.15.14-.21s.13-.11.21-.14c.08-.04.17-.05.26-.05Z"/>
-    <path d="m239.22,39.69c0,.17-.03.33-.09.46s-.14.26-.24.36c-.1.11-.22.2-.35.27s-.28.14-.43.19-.31.08-.47.11-.32.03-.47.03c-.33,0-.64-.01-.92-.04s-.55-.08-.82-.14v-.78c.29.08.57.14.85.19s.56.06.84.06c.41,0,.71-.06.9-.17s.29-.27.29-.47c0-.09-.02-.17-.05-.24-.03-.07-.09-.14-.17-.2-.08-.06-.21-.13-.38-.2s-.4-.15-.7-.23c-.22-.07-.43-.14-.61-.22-.19-.08-.35-.18-.49-.29s-.24-.25-.32-.4-.12-.33-.12-.54c0-.14.03-.29.1-.45s.17-.31.32-.45.36-.26.62-.35c.26-.09.59-.14.98-.14.19,0,.41.01.64.03.23.02.48.06.73.11v.76c-.27-.07-.52-.11-.76-.14-.24-.03-.45-.05-.62-.05-.21,0-.39.02-.53.05s-.26.08-.35.13c-.09.06-.15.12-.19.2-.04.08-.06.16-.06.25s.02.17.05.24.1.14.19.21c.09.07.22.13.39.2.17.07.38.14.65.22.29.08.53.17.73.27.2.09.36.2.48.31s.21.24.27.39.08.31.08.49Z"/>
-    <path d="m244.78,40.96c-.19.05-.39.08-.6.11-.21.02-.41.03-.62.03-.62,0-1.07-.14-1.38-.42-.3-.28-.45-.71-.45-1.28v-2.56h-1.37v-.71h1.37v-1.35l.85-.22v1.57h2.2v.71h-2.2v2.49c0,.35.09.61.28.79.19.17.46.26.83.26.16,0,.33-.01.51-.04.19-.03.38-.06.58-.12v.73Z"/>
-  </g>
-  <polygon class="cls-7" points="179.18 31.26 184.58 33.96 179.18 36.66 179.18 31.26"/>
-  <line class="cls-3" x1="114.6" y1="33.96" x2="180.26" y2="33.96"/>
-  <polygon class="cls-7" points="120 45.73 114.6 43.03 120 40.33 120 45.73"/>
-  <line class="cls-3" x1="184.58" y1="43.03" x2="118.92" y2="43.03"/>
-</svg>
\ No newline at end of file
diff --git a/src/nanobind/docs/index.rst b/src/nanobind/docs/index.rst
deleted file mode 100644
index 53a7dc4..0000000
--- a/src/nanobind/docs/index.rst
+++ /dev/null
@@ -1,147 +0,0 @@
-Introduction
-============
-
-.. only:: not latex
-
-   .. image:: https://github.com/wjakob/nanobind/raw/master/docs/images/logo.jpg
-     :width: 800
-     :align: center
-     :alt: nanobind logo
-     :class: only-light
-
-   .. image:: https://rgl.s3.eu-central-1.amazonaws.com/media/uploads/wjakob/2023/03/28/nanobind_logo_dark.png
-     :width: 800
-     :align: center
-     :alt: nanobind logo
-     :class: only-dark
-
-.. only:: latex
-
-   .. image:: https://github.com/wjakob/nanobind/raw/master/docs/images/logo.jpg
-     :width: 800
-     :align: center
-     :alt: nanobind logo
-
-*nanobind* is a small binding library that exposes C++ types in Python and vice
-versa. It is reminiscent of `Boost.Python
-<https://www.boost.org/doc/libs/1_64_0/libs/python/doc/html>`_ and `pybind11
-<http://github.com/pybind/pybind11>`_ and uses near-identical syntax. In
-contrast to these existing tools, nanobind is *more efficient*: bindings
-compile in a shorter amount of time, produce smaller binaries, and have better
-runtime performance.
-
-More concretely, :ref:`benchmarks <benchmarks>` show up to **~4× faster**
-compile time, **~5× smaller** binaries, and **~10× lower** runtime overheads
-compared to pybind11. nanobind also outperforms Cython in important metrics
-(**3-12×** binary size reduction, **1.6-4×** compilation time reduction,
-similar runtime performance).
-
-.. only:: not latex
-
-   Documentation formats
-   ---------------------
-
-   You are reading the HTML version of the documentation. An alternative `PDF
-   version <https://nanobind.readthedocs.io/_/downloads/en/latest/pdf/>`__ is
-   also available.
-
-   Dependencies
-   ------------
-
-.. only:: latex
-
-   .. rubric:: Dependencies
-
-nanobinds depends on
-
-- **Python 3.8+** or **PyPy 7.3.10+** (the *3.8* and *3.9* PyPy flavors are
-  supported, though there are :ref:`some limitations <pypy_issues>`).
-- **CMake 3.15+**.
-- **A C++17 compiler**: Clang 8+, GCC 8+, MSVC2019+, and the CUDA NVCC compiler
-  are officially supported. Others (MinGW, Cygwin, Intel, ..) may work as well
-  but will not receive support.
-
-.. only:: not latex
-
-   How to cite this project?
-   -------------------------
-
-.. only:: latex
-
-   .. rubric:: How to cite this project?
-
-Please use the following BibTeX template to cite nanobind in scientific
-discourse:
-
-.. code-block:: bibtex
-
-    @misc{nanobind,
-       author = {Wenzel Jakob},
-       year = {2022},
-       note = {https://github.com/wjakob/nanobind},
-       title = {nanobind: tiny and efficient C++/Python bindings}
-    }
-
-
-The nanobind logo was designed by `AndoTwin Studio
-<https://andotwinstudio.com>`__. High-resolution version are available `here
-<https://rgl.s3.eu-central-1.amazonaws.com/media/uploads/wjakob/2023/03/27/nanobind_logo.jpg>`__
-(light) and `here
-<https://rgl.s3.eu-central-1.amazonaws.com/media/uploads/wjakob/2023/03/28/nanobind_logo_dark_1.png>`__
-(dark).
-
-.. only:: not latex
-
-   Table of contents
-   -----------------
-
-.. toctree::
-   :maxdepth: 1
-
-   changelog
-   why
-   benchmark
-   porting
-   faq
-
-.. toctree::
-   :caption: Basics
-   :maxdepth: 1
-
-   installing
-   building
-   basics
-   bazel
-   meson
-
-.. toctree::
-   :caption: Intermediate
-   :maxdepth: 1
-
-   exchanging
-   ownership
-   functions
-   classes
-   exceptions
-   ndarray_index
-   refleaks
-   packaging
-   typing
-   utilities
-
-.. toctree::
-   :caption: Advanced
-   :maxdepth: 1
-
-   free_threaded
-   ownership_adv
-   lowlevel
-
-.. toctree::
-   :caption: API Reference
-   :maxdepth: 1
-
-   api_core
-   api_extra
-   api_cmake
-   api_bazel
diff --git a/src/nanobind/docs/installing.rst b/src/nanobind/docs/installing.rst
deleted file mode 100644
index 7f5c7dd..0000000
--- a/src/nanobind/docs/installing.rst
+++ /dev/null
@@ -1,48 +0,0 @@
-.. _installing:
-
-Installing the library
-######################
-
-The *nanobind* project is hosted at `wjakob/nanobind on GitHub
-<https://github.com/wjakob/nanobind>`_. To use the library in your own
-projects, it is usually easiest to install it using one of the following three
-methods:
-
-Install via Pip (recommended)
-==============================
-
-Run the following command in your terminal to install a package containing both
-C++ and CMake source code needed to compile extension modules.
-
-.. code-block:: bash
-
-    python -m pip install nanobind
-
-Install via Conda
-=================
-
-The following alternative installs an equivalent package through Conda. It is
-provided for users that develop Conda-based extensions with a build-time
-dependency on *nanobind*, in which case the PyPI package cannot be used.
-
-.. code-block:: bash
-
-    conda install -c conda-forge nanobind
-
-Install as a Git submodule
-==========================
-
-If you prefer not to involve external package managers, and if your project
-uses the Git control system, you may also directly reference *nanobind* as a
-`Git submodule <https://git-scm.com/book/en/v2/Git-Tools-Submodules>`_. In the
-main directory of your repository, run the following commands:
-
-.. code-block:: bash
-
-    git submodule add https://github.com/wjakob/nanobind ext/nanobind
-    git submodule update --init --recursive
-
-This assumes you are placing your dependencies in ``ext/``.
-
-The :ref:`next section <building>` will explain how to set up a basic build
-system that you can use to build your first extension module.
diff --git a/src/nanobind/docs/lowlevel.rst b/src/nanobind/docs/lowlevel.rst
deleted file mode 100644
index fb2c035..0000000
--- a/src/nanobind/docs/lowlevel.rst
+++ /dev/null
@@ -1,323 +0,0 @@
-.. _lowlevel:
-
-.. cpp:namespace:: nanobind
-
-Low-level interface
-===================
-
-nanobind exposes a low-level interface to provide fine-grained control over
-the sequence of steps that instantiates a Python object wrapping a C++
-instance. This is useful when writing generic binding code that manipulates
-nanobind-based objects of various types.
-
-Given a previous :cpp:class:`nb::class_\<...\> <class_>` binding declaration,
-the :cpp:func:`nb::type\<T\>() <type>` template function can be used to look up
-the Python type object associated with a C++ class named ``MyClass``.
-
-.. code-block:: cpp
-
-   nb::handle py_type = nb::type<MyClass>();
-
-In the case of failure, this line will return a ``nullptr`` pointer, which
-can be checked via ``py_type.is_valid()``. We can verify that the type
-lookup succeeded, and that the returned instance indeed represents a
-nanobind-owned type (via :cpp:func:`nb::type_check() <type_check>`, which is
-redundant in this case):
-
-.. code-block:: cpp
-
-   assert(py_type.is_valid() && nb::type_check(py_type));
-
-nanobind knows the size, alignment, and C++ RTTI ``std::type_info`` record of
-all bound types. They can be queried on the fly via :cpp:func:`nb::type_size()
-<type_size>`, :cpp:func:`nb::type_align() <type_size>`, and
-:cpp:func:`nb::type_info() <type_size>` in situations where this is useful.
-
-.. code-block:: cpp
-
-   assert(nb::type_size(py_type) == sizeof(MyClass) &&
-          nb::type_align(py_type) == alignof(MyClass) &&
-          nb::type_info(py_type) == typeid(MyClass));
-
-Given a type object representing a C++ type, we can create an uninitialized
-instance via :cpp:func:`nb::inst_alloc() <inst_alloc>`. This is an ordinary
-Python object that can, however, not (yet) be passed to bound C++ functions
-to prevent undefined behavior. It must first be initialized.
-
-.. code-block:: cpp
-
-   nb::object py_inst = nb::inst_alloc(py_type);
-
-We can confirm via :cpp:func:`nb::inst_check() <inst_check>` that this newly
-created instance is managed by nanobind, that it has the correct type in
-Python. Calling :cpp:func:`nb::inst_ready() <inst_ready>` reveals that the
-*ready* flag of the instance is set to ``false`` (i.e., it is still
-uninitialized).
-
-.. code-block:: cpp
-
-   assert(nb::inst_check(py_inst) &&
-          py_inst.type().is(py_type) &&
-          !nb::inst_ready(py_inst));
-
-For simple *plain old data* (POD) types, the :cpp:func:`nb::inst_zero()
-<inst_zero>` function can be used to *zero-initialize* the object and mark it
-as ready.
-
-.. code-block:: cpp
-
-   nb::inst_zero(py_inst);
-   assert(nb::inst_ready(py_inst));
-
-We can destruct this default instance via :cpp:func:`nb::inst_destruct()
-<inst_destruct>` and convert it back to non-ready status. This memory region
-can then be reinitialized once more.
-
-.. code-block:: cpp
-
-   nb::inst_destruct(py_inst);
-   assert(!nb::inst_ready(py_inst));
-
-What follows is a more interesting example, where we use a lesser-known feature
-of C++ (the "`placement new <https://en.wikipedia.org/wiki/Placement_syntax>`_"
-operator) to construct an instance *in-place* into the memory region allocated
-by nanobind.
-
-.. code-block:: cpp
-
-   // Get a C++ pointer to the uninitialized instance data
-   MyClass *ptr = nb::inst_ptr<MyClass>(py_inst);
-
-   // Perform an in-place construction of the C++ object at address 'ptr'
-   new (ptr) MyClass(/* constructor arguments go here */);
-
-Following this constructor call, we must inform nanobind that the instance
-object is now fully constructed via :cpp:func:`nb::inst_mark_ready()
-<inst_mark_ready>`. When its reference count reaches zero, nanobind will then
-automatically call the in-place destructor (``MyClass::~MyClass``).
-
-.. code-block:: cpp
-
-   nb::inst_mark_ready(py_inst);
-   assert(nb::inst_ready(py_inst));
-
-Let’s destroy this instance once more manually (which will, again, call
-the C++ destructor and mark the Python object as non-ready).
-
-.. code-block:: cpp
-
-   nb::inst_destruct(py_inst);
-
-Another useful feature is that nanobind can copy- or move-construct ``py_inst``
-from another instance of the same type via :cpp:func:`nb::inst_copy()
-<inst_copy>` and :cpp:func:`nb::inst_move() <inst_move>`. These functions call
-the C++ copy or move constructor and transition ``py_inst`` back to ``ready``
-status. This is equivalent to calling an in-place version of these constructors
-followed by a call to :cpp:func:`nb::inst_mark_ready() <inst_mark_ready>` but
-compiles to more compact code (the :cpp:class:`nb::class_\<MyClass\> <class_>`
-declaration had already created bindings for both constructors, and this simply
-calls those bindings).
-
-.. code-block:: cpp
-
-   if (copy_instance)
-       nb::inst_copy(/* dst = */ py_inst, /* src = */ some_other_instance);
-   else
-       nb::inst_move(/* dst = */ py_inst, /* src = */ some_other_instance);
-
-Both functions assume that the destination object is uninitialized. Two
-alternative versions :cpp:func:`nb::inst_replace_copy() <inst_replace_copy>`
-and :cpp:func:`nb::inst_replace_move() <inst_replace_move>` destruct an
-initialized instance and replace it with the contents of another by either
-copying or moving.
-
-.. code-block:: cpp
-
-   if (copy_instance)
-       nb::inst_replace_copy(/* dst = */ py_inst, /* src = */ some_other_instance);
-   else
-       nb::inst_replace_move(/* dst = */ py_inst, /* src = */ some_other_instance);
-
-Note that these functions are all *unsafe* in the sense that they do not
-verify that their input arguments are valid. This is done for
-performance reasons, and such checks (if needed) are therefore the
-responsibility of the caller. Functions labeled ``nb::type_*`` should
-only be called with nanobind type objects, and functions labeled
-``nb::inst_*`` should only be called with nanobind instance objects.
-
-The functions :cpp:func:`nb::type_check() <type_check>` and
-:cpp:func:`nb::inst_check() <inst_check>` are exceptions to this rule:
-they accept any Python object and test whether something is a nanobind type or
-instance object.
-
-Two further functions :cpp:func:`nb::type_name() <type_name>` and
-:cpp:func:`nb::inst_name() <inst_name>` determine the type name associated with
-a type or instance thereof. These also accept non-nanobind types and instances.
-
-Even lower-level interface
---------------------------
-
-Every nanobind object has two important flags that control its behavior:
-
-1. ``ready``: is the object fully constructed? If set to ``false``,
-   nanobind will raise an exception when the object is passed to a bound
-   C++ function.
-
-2. ``destruct``: Should nanobind call the C++ destructor when the
-   instance is garbage collected?
-
-The functions :cpp:func:`nb::inst_zero() <inst_zero>`,
-:cpp:func:`nb::inst_mark_ready() <inst_mark_ready>`, :cpp:func:`nb::inst_move()
-<inst_move>`, and :cpp:func:`nb::inst_copy() <inst_copy>` set both of these
-flags to ``true``, and :cpp:func:`nb::inst_destruct() <inst_destruct>` sets
-both of them to ``false``.
-
-In rare situations, the destructor should *not* be invoked when the instance is
-garbage collected, for example when working with a nanobind instance
-representing a field of a parent instance created using the
-:cpp:enumerator:`nb::rv_policy::reference_internal
-<rv_policy::reference_internal>` return value policy. The library therefore
-exposes two more functions :cpp:func:`nb::inst_state() <inst_state>` and
-:cpp:func:`nb::inst_set_state() <inst_set_state>` that can be used to access
-them individually.
-
-Referencing existing instances
-------------------------------
-
-The above examples used the function :cpp:func:`nb::inst_alloc() <inst_alloc>`
-to allocate a Python object along with space to hold a C++ instance associated
-with the binding ``py_type``.
-
-.. code-block:: cpp
-
-   nb::object py_inst = nb::inst_alloc(py_type);
-
-   // Next, perform a C++ in-place construction into the
-   // address given by nb::inst_ptr<MyClass>(py_inst)
-   ... omitted, see the previous examples ...
-
-What if the C++ instance already exists? nanobind also supports this case via
-the :cpp:func:`nb::inst_reference() <inst_reference>` and
-:cpp:func:`nb::inst_take_ownership() <inst_take_ownership>` functions—in this
-case, the Python object references the existing memory region, which is
-potentially (slightly) less efficient due to the need for an extra indirection.
-
-.. code-block:: cpp
-
-   MyClass *inst = new MyClass();
-
-   // Transfer ownership of 'inst' to Python (which will use a delete
-   // expression to free it when the Python instance is garbage collected)
-   nb::object py_inst = nb::inst_take_ownership(py_type, inst);
-
-   // We can also wrap C++ instances that should not be destructed since
-   // they represent offsets into another data structure. In this case,
-   // the optional 'parent' parameter ensures that 'py_inst' remains alive
-   // while 'py_subinst' exists to prevent undefined behavior.
-   nb::object py_subinst = nb::inst_reference(
-       py_field_type, &inst->field, /* parent = */ py_inst);
-
-.. _supplement:
-
-Supplemental type data
-----------------------
-
-nanobind can stash supplemental data *inside* the type object of bound types.
-This involves the :cpp:class:`nb::supplement\<T\>() <supplement>` class binding
-annotation to reserve space and :cpp:func:`nb::type_supplement\<T\>()
-<type_supplement>` to access the reserved memory region.
-
-An example use of this fairly advanced feature are libraries that register
-large numbers of different types (e.g. flavors of tensors). A single
-generically implemented function can then query the supplemental data block to
-handle each tensor type slightly differently.
-
-Here is what this might look like in an implementation:
-
-.. code-block:: cpp
-
-  struct MyTensorMetadata {
-      bool stored_on_gpu;
-      // ..
-      // should be a POD (plain old data) type
-  };
-
-  // Register a new type MyTensor, and reserve space for sizeof(MyTensorMedadata)
-  nb::class_<MyTensor> cls(m, "MyTensor", nb::supplement<MyTensorMedadata>())
-
-  /// Mutable reference to 'MyTensorMedadata' portion in Python type object
-  MyTensorMedadata &supplement = nb::type_supplement<MyTensorMedadata>(cls);
-  supplement.stored_on_gpu = true;
-
-The :cpp:class:`nb::supplement\<T\>() <supplement>` annotation implicitly also
-passes :cpp:class:`nb::is_final() <is_final>` to ensure that type objects with
-supplemental data cannot be subclassed in Python.
-
-nanobind requires that the specified type ``T`` be trivially default
-constructible. It zero-initializes the supplement when the type is first
-created but does not perform any further custom initialization or destruction.
-You can fill the supplement with different contents following the type
-creation, e.g., using the placement new operator.
-
-The contents of the supplemental data are not directly visible to Python's
-cyclic garbage collector, which creates challenges if you want to reference
-Python objects. The recommended workaround is to store the Python objects
-as attributes of the type object (in its ``__dict__``) and store a borrowed
-``PyObject*`` reference in the supplemental data. If you use an attribute
-name that begins with the symbol ``@``, then nanobind will prevent Python
-code from rebinding or deleting the attribute after it has been set, making
-the borrowed reference reasonably safe.
-
-.. _typeslots:
-
-Customizing type creation
-=========================
-
-nanobind exposes a low-level interface to install custom *type slots*
-(``PyType_Slot`` in the `CPython API
-<https://docs.python.org/3/c-api/type.html#c.PyType_Slot>`_) in newly
-constructed types. This provides an escape hatch to realize features that were
-not foreseen in the design of this library.
-
-To use this feature, specify the :cpp:class:`nb::type_slots() <type_slots>`
-annotation when creating the type.
-
-.. code-block:: cpp
-
-   nb::class_<MyClass>(m, "MyClass", nb::type_slots(slots));
-
-Here, ``slots`` should refer to an array of function pointers that are tagged
-with a corresponding slot identifier. For example, here is an example
-function that overrides the addition operator so that it behaves like a
-multiplication.
-
-.. code-block:: cpp
-
-   PyObject *myclass_tp_add(PyObject *a, PyObject *b) {
-       return PyNumber_Multiply(a, b);
-   }
-
-   PyType_Slot slots[] = {
-       { Py_nb_add, (void *) myclass_tp_add },
-       { 0, nullptr }
-   };
-
-The ``slots`` array specified in the previous
-:cpp:class:`nb::class_\<MyClass\>() <class_>` declaration references the
-function ``myclass_tp_add`` and is followed by a mandatory null terminator.
-Information on type slots can be found in the CPython documentation sections
-covering `type objects <https://docs.python.org/3/c-api/typeobj.html>`_ and
-`type construction <https://docs.python.org/3/c-api/type.html>`_.
-
-This example is contrived because it could have been accomplished using
-builtin features:
-
-.. code-block:: cpp
-
-   nb::class_<MyClass>(m, "MyClass")
-       .def("__add__",
-            [](const MyClass &a, const MyClass &b) { return a * b; },
-            nb::is_operator())
-
-The documentation section on :ref:`reference leaks <refleaks>` discusses
-another important use case of type slots.
diff --git a/src/nanobind/docs/meson.rst b/src/nanobind/docs/meson.rst
deleted file mode 100644
index bd21a03..0000000
--- a/src/nanobind/docs/meson.rst
+++ /dev/null
@@ -1,116 +0,0 @@
-.. _meson:
-
-Building extensions using Meson
-===============================
-
-If you prefer the Meson build system to CMake, you can build extensions using
-the `Meson WrapDB <https://mesonbuild.com/Wrapdb-projects.html>`__ package.
-
-.. note::
-
-    This package is a community contribution maintained by
-    `Will Ayd <https://github.com/WillAyd/>`__, please report issues
-    directly in the
-    `Meson WrapDB <https://github.com/mesonbuild/wrapdb/issues>`__ repository.
-
-.. _meson-setup:
-
-Adding nanobind to your Meson project
--------------------------------------
-
-To use Meson as the build generator in your Python project, you will want to
-install the
-`meson-python <https://meson-python.readthedocs.io/en/latest/index.html>`__
-project as a build dependency. To do so, simply add the following to your
-pyproject.toml file:
-
-.. code-block:: toml
-
-   [project]
-   name = "my_project_name"
-   dynamic = ['version']
-
-   [build-system]
-   requires = ['meson-python']
-
-   build-backend = 'mesonpy'
-
-In your project root, you will also want to create the subprojects folder
-that Meson can install into. Then you will need to install the wrap packages
-for both nanobind and robin-map:
-
-.. code-block:: sh
-
-   mkdir -p subprojects
-   meson wrap install robin-map
-   meson wrap install nanobind
-
-The ``meson.build`` definition in your project root should look like:
-
-.. code-block:: meson
-
-   project(
-     'my_project_name',
-     'cpp',
-     version: '0.0.1',
-     meson_version: '>=1.0.0',
-     default_options: ['cpp_std=c++17', 'b_ndebug=if-release'],
-   )
-
-   py = import('python').find_installation()
-   nanobind_dep = dependency('nanobind')
-   py.extension_module(
-     'my_module_name',
-     sources: ['path_to_module.cpp'],
-     dependencies: [nanobind_dep],
-     install: true,
-   )
-
-With this configuration, you may then call:
-
-.. code-block:: sh
-
-   meson setup --buildtype release builddir
-   meson compile -C builddir
-
-to compile the extension in the ``builddir`` folder.
-
-Alternatively, if you don't care to have a local build folder, you can use
-the Python build frontend of your choosing to install the package as an
-editable install. With pip, this would look like:
-
-.. code-block:: sh
-
-   python -m pip install -e .
-
-.. _meson-stable-abi:
-
-Building against the stable ABI
--------------------------------
-
-As in nanobind's CMake config, you can build bindings targeting Python's
-stable ABI, starting from version 3.12. To do this, specify the target
-version using the ``limited_api`` argument in your configuration. For example,
-to build extensions against the CPython 3.12 stable ABI, use:
-
-.. code-block:: meson
-
-   project(
-     'my_project_name',
-     'cpp',
-     version: '0.0.1',
-     meson_version: '>=1.3.0',
-     default_options: ['cpp_std=c++17', 'b_ndebug=if-release'],
-   )
-
-   py = import('python').find_installation()
-   nanobind_dep = dependency('nanobind')
-   py.extension_module(
-     'my_module_name',
-     sources: ['path_to_module.cpp'],
-     dependencies: [nanobind_dep],
-     install: true,
-     limited_api: '3.12',
-   )
-
-as your ``meson.build`` file.
diff --git a/src/nanobind/docs/microbenchmark.ipynb b/src/nanobind/docs/microbenchmark.ipynb
deleted file mode 100644
index 30a434a..0000000
--- a/src/nanobind/docs/microbenchmark.ipynb
+++ /dev/null
@@ -1,447 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "83b016f7-695a-43b7-8baf-4bd0d435a0c8",
-   "metadata": {
-    "tags": []
-   },
-   "outputs": [],
-   "source": [
-    "import random\n",
-    "import subprocess\n",
-    "import itertools\n",
-    "from collections import defaultdict\n",
-    "import importlib.machinery\n",
-    "import os\n",
-    "import time\n",
-    "import cython\n",
-    "from matplotlib.patches import Rectangle\n",
-    "    \n",
-    "import matplotlib.pyplot as plt\n",
-    "import numpy as np\n",
-    "\n",
-    "import matplotlib as mpl\n",
-    "mpl.rcParams['hatch.linewidth'] = 5.0 \n",
-    "cycle = [x['color'] for x in mpl.rcParams['axes.prop_cycle']]"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "705868b4-c013-4fc2-a4c3-bdaca6c90d05",
-   "metadata": {
-    "tags": []
-   },
-   "outputs": [],
-   "source": [
-    "experiment_labels = []\n",
-    "sizes = defaultdict(lambda: [])\n",
-    "times = defaultdict(lambda: [])\n",
-    "\n",
-    "from sysconfig import get_paths as gp\n",
-    "suffix = importlib.machinery.EXTENSION_SUFFIXES[0]\n",
-    "\n",
-    "# Path to pybind11 git repository\n",
-    "pybind11_path = '/home/wjakob/pybind11/include'\n",
-    "\n",
-    "# Path to pybind11 git repository (smartholder branch)\n",
-    "pybind11_sh_path = '/home/wjakob/pybind11_sh/include'\n",
-    "\n",
-    "# Path to boost (in this case, assumed to be installed by the OS)\n",
-    "boost_path = '/usr/include/boost'\n",
-    "\n",
-    "cmd_base = ['clang++', '-march=native', '-shared', '-rpath', '..', '-std=c++17', '-I', '../include', '-I', gp()['include'],\n",
-    "            '-Wno-deprecated-declarations', '-fPIC', f'-L{boost_path}/stage/lib', '-L..', '-fno-stack-protector',\n",
-    "            '-DPYBIND11_USE_SMART_HOLDER_AS_DEFAULT']\n",
-    "\n",
-    "def gen_file(name, func, libs=('cython', 'boost', 'pybind11', 'pybind11_sh', 'nanobind')):\n",
-    "    for i, lib in enumerate(libs):    \n",
-    "        for opt_mode, opt_flags in {'debug' : ['-O0', '-g3'], 'opt' : ['-Os', '-g0']}.items():\n",
-    "            if lib != 'cython':\n",
-    "                fname = name + '_' + lib + '.cpp'\n",
-    "            else:\n",
-    "                fname = name + '_' + lib + '_' + opt_mode + '.pyx'\n",
-    "            \n",
-    "            with open(fname, 'w') as f:\n",
-    "                if lib == 'boost':\n",
-    "                    f.write(f'#include <boost/python.hpp>\\n')\n",
-    "                    f.write(f'namespace py = boost::python;\\n\\n')\n",
-    "                    f.write(f'BOOST_PYTHON_MODULE({name}_{lib}_{opt_mode}) {{\\n')\n",
-    "                elif lib == 'nanobind':\n",
-    "                    f.write(f'#include <nanobind/nanobind.h>\\n\\n')\n",
-    "                    f.write(f'namespace py = nanobind;\\n\\n')\n",
-    "                    f.write(f'NB_MODULE({name}_{lib}_{opt_mode}, m) {{\\n')\n",
-    "                elif lib.startswith('pybind11'):\n",
-    "                    f.write(f'#include <pybind11/pybind11.h>\\n\\n')\n",
-    "                    f.write(f'namespace py = pybind11;\\n\\n')\n",
-    "                    f.write(f'PYBIND11_MODULE({name}_{lib}_{opt_mode}, m) {{\\n')\n",
-    "                elif lib == 'cython':\n",
-    "                    f.write(f'from libc.stdint cimport uint16_t, int32_t, uint32_t, int64_t, uint64_t\\n')\n",
-    "\n",
-    "                func(f, lib)\n",
-    "                if lib != 'cython':\n",
-    "                    f.write(f'}}\\n')\n",
-    "\n",
-    "            fname_out = name + '_' + lib + '_' + opt_mode  + suffix\n",
-    "            cmd = cmd_base + opt_flags + [name + '_' + lib + '.cpp', '-o', fname_out]\n",
-    "            if lib == 'nanobind':\n",
-    "                cmd += ['-lnanobind']\n",
-    "            elif lib == 'boost':\n",
-    "                cmd += ['-I', boost_path, '-lboost_python310']\n",
-    "            elif lib == 'pybind11':\n",
-    "                cmd += ['-I', pybind11_path]\n",
-    "            elif lib == 'pybind11_sh':\n",
-    "                cmd += ['-I', pybind11_sh_path]\n",
-    "                \n",
-    "            print(' '.join(cmd))\n",
-    "            time_list = []\n",
-    "            for l in range(5):\n",
-    "                time_before = time.perf_counter()\n",
-    "                if lib == 'cython':\n",
-    "                    subprocess.check_call(['cython3', '-3',  '--cplus', fname, '-o', name + '_' + lib + '.cpp'])\n",
-    "                subprocess.check_call(cmd)\n",
-    "                time_after = time.perf_counter()\n",
-    "                time_list.append(time_after-time_before)\n",
-    "            time_list.sort()\n",
-    "                \n",
-    "            if opt_mode != 'debug':\n",
-    "                subprocess.check_call(['strip', fname_out])\n",
-    "            if i == 0:\n",
-    "                experiment_labels.append(name + ' [' + opt_mode + ']')\n",
-    "            sizes[lib].append(os.path.getsize(fname_out) / (1024 * 1024))\n",
-    "            times[lib].append(time_list[len(time_list)//2])\n",
-    "\n",
-    "\n",
-    "            \n",
-    "def gen_func(f, lib):\n",
-    "    types = [ 'uint16_t', 'int32_t', 'uint32_t', 'int64_t', 'uint64_t', 'float' ]\n",
-    "    if lib == 'boost':\n",
-    "        prefix = 'py::'\n",
-    "    else:\n",
-    "        prefix = 'm.'\n",
-    "    for i, t in enumerate(itertools.permutations(types)):\n",
-    "        args = f'{t[0]} a, {t[1]} b, {t[2]} c, {t[3]} d, {t[4]} e, {t[5]} f'\n",
-    "        if lib != 'cython':\n",
-    "            f.write('    %sdef(\"test_%04i\", +[](%s) { return a+b+c+d+e+f; });\\n' % (prefix, i, args))\n",
-    "        else:\n",
-    "            f.write('cpdef float test_%04i(%s):\\n    return a+b+c+d+e+f\\n\\n' % (i, args))\n",
-    "\n",
-    "\n",
-    "def gen_class(f, lib):\n",
-    "    types = [ 'uint16_t', 'int32_t', 'uint32_t', 'int64_t', 'uint64_t', 'float' ]\n",
-    "\n",
-    "    for i, t in enumerate(itertools.permutations(types)):\n",
-    "        if lib == 'boost':\n",
-    "            prefix = ''\n",
-    "            postfix = f', py::init<{t[0]}, {t[1]}, {t[2]}, {t[3]}, {t[4]}, {t[4]}>()'\n",
-    "            func_prefix = 'py::def'\n",
-    "\n",
-    "        else:\n",
-    "            prefix = 'm, '\n",
-    "            postfix = ''\n",
-    "            func_prefix = 'm.def'\n",
-    "\n",
-    "        if lib != 'cython':\n",
-    "            f.write(f'    struct Struct{i} {{\\n')\n",
-    "            f.write(f'        {t[0]} a; {t[1]} b; {t[2]} c; {t[3]} d; {t[4]} e; {t[5]} f;\\n')\n",
-    "            f.write(f'        Struct{i}({t[0]} a, {t[1]} b, {t[2]} c, {t[3]} d, {t[4]} e, {t[5]} f) : a(a), b(b), c(c), d(d), e(e), f(f) {{ }}\\n')\n",
-    "            f.write(f'        float sum() const {{ return a+b+c+d+e+f; }}\\n')\n",
-    "            f.write(f'    }};\\n')\n",
-    "        else:\n",
-    "            f.write(f'cdef class Struct{i}:\\n')\n",
-    "            f.write(f'    cdef {t[0]} a\\n')\n",
-    "            f.write(f'    cdef {t[1]} b\\n')\n",
-    "            f.write(f'    cdef {t[2]} c\\n')\n",
-    "            f.write(f'    cdef {t[3]} d\\n')\n",
-    "            f.write(f'    cdef {t[4]} e\\n')\n",
-    "            f.write(f'    cdef {t[5]} f\\n\\n')\n",
-    "            f.write(f'    def __cinit__(self, {t[0]} a, {t[1]} b, {t[2]} c, {t[3]} d, {t[4]} e, {t[5]} f):\\n')\n",
-    "            f.write(f'        self.a = a\\n')\n",
-    "            f.write(f'        self.b = b\\n')\n",
-    "            f.write(f'        self.c = c\\n')\n",
-    "            f.write(f'        self.d = d\\n')\n",
-    "            f.write(f'        self.e = e\\n')\n",
-    "            f.write(f'        self.f = f\\n\\n')\n",
-    "            f.write(f'    cpdef float sum(self):\\n')\n",
-    "            f.write(f'        return self.a+self.b+self.c+self.d+self.e+self.f\\n\\n')\n",
-    "            continue\n",
-    "\n",
-    "        f.write(f'    py::class_<Struct{i}>({prefix}\\\"Struct{i}\\\"{postfix})\\n')\n",
-    "        \n",
-    "        if lib != 'boost':\n",
-    "                f.write(f'        .def(py::init<{t[0]}, {t[1]}, {t[2]}, {t[3]}, {t[4]}, {t[5]}>())\\n')\n",
-    "        f.write(f'        .def(\"sum\", &Struct{i}::sum);\\n\\n')\n",
-    "        \n",
-    "        if i > 250:\n",
-    "            break;\n",
-    "        \n",
-    "        \n",
-    "gen_file('func', gen_func)\n",
-    "gen_file('class', gen_class)\n",
-    "experiment_labels = ['func [debug]', 'func [opt]', 'class [debug]', 'class [opt]']\n",
-    "\n",
-    "print(experiment_labels)\n",
-    "print(dict(sizes))\n",
-    "print(dict(times))"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "c67eac20-ffb5-4c58-ba08-64e7404a54a9",
-   "metadata": {
-    "tags": []
-   },
-   "outputs": [],
-   "source": [
-    "\n",
-    "plot_colors = {\n",
-    "    'boost': cycle[1],\n",
-    "    'pybind11': cycle[3],\n",
-    "    'pybind11_sh': cycle[5],\n",
-    "    'cython' : cycle[4],\n",
-    "    'nanobind': cycle[0]\n",
-    "}\n",
-    "plot_labels = {\n",
-    "    'boost' : 'Boost.Python',\n",
-    "    'pybind11' : 'pybind11',\n",
-    "    'pybind11_sh' : 'pybind11 + smart_holder',\n",
-    "    'cython' : 'Cython',\n",
-    "    'nanobind' : 'nanobind'\n",
-    "}\n",
-    "\n",
-    "def bars(data, ylim_scale = 1, figsize_scale = 1, width_scale=1.0, debug_shift=0.1):\n",
-    "    ylim = 0\n",
-    "    for n, d in data.items():\n",
-    "        if len(d) == 0:\n",
-    "            continue\n",
-    "        ylim = max(max(d), ylim)\n",
-    "    ylim *= ylim_scale * 1.3\n",
-    "\n",
-    "    def adj(ann):\n",
-    "        for i, a in enumerate(ann):\n",
-    "            if a.xy[1] > ylim*.9:\n",
-    "                a.xy = (a.xy[0], ylim * 0.8)\n",
-    "                if i%2 == 1:\n",
-    "                    a.set_color('white')\n",
-    "\n",
-    "    fig, ax = plt.subplots(figsize=[11.25*figsize_scale, 3*figsize_scale])\n",
-    "    width = 1.0/(len(data) + 1)*width_scale\n",
-    "    x = np.arange(4)\n",
-    "\n",
-    "    result = []\n",
-    "    for i, n in enumerate(plot_labels):\n",
-    "        d = data[n]\n",
-    "        if len(d) == 0:\n",
-    "            continue\n",
-    "\n",
-    "        col = plot_colors[n]\n",
-    "        if col != 'None':\n",
-    "            kwargs = { 'edgecolor': 'black', 'color': col }\n",
-    "        else:\n",
-    "            kwargs =  {'edgecolor': 'white', 'hatch' : '/', 'color':cycle[7]}\n",
-    "            \n",
-    "        bar = ax.bar(x+width*(i -(len(data)-1)/2), d, width, label=plot_labels[n], align='center', **kwargs)\n",
-    "        result.append(bar)\n",
-    "        \n",
-    "    ax.add_patch(Rectangle((-0.65+debug_shift, -1), 1, 28, facecolor='white', alpha=.8, edgecolor='None'))\n",
-    "    ax.add_patch(Rectangle((1.4+debug_shift, -1), 1, 25, facecolor='white', alpha=.8, edgecolor='None'))\n",
-    "\n",
-    "    for i, n in enumerate(plot_labels):\n",
-    "        d = data[n]\n",
-    "        if len(d) == 0:\n",
-    "            continue\n",
-    "\n",
-    "        bar = result[i]\n",
-    "        if n == 'nanobind':\n",
-    "            adj(ax.bar_label(bar, fmt='%.2f'))\n",
-    "        else:\n",
-    "            improvement = np.array(d) / np.array(data['nanobind'])\n",
-    "            improvement = ['%.2f\\n(x%.1f)' % (d[i], v) for i, v in enumerate(improvement)]\n",
-    "            adj(ax.bar_label(bar, labels=improvement, padding=3))\n",
-    "        \n",
-    "    ax.set_ylim(0, ylim)\n",
-    "    ax.set_xticks(x, experiment_labels)\n",
-    "    return fig, ax\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "60cb243a-e94d-4dd0-af67-91b7c5007571",
-   "metadata": {
-    "tags": []
-   },
-   "outputs": [],
-   "source": [
-    "fig, ax = bars(times, ylim_scale=0.93, figsize_scale=1.1, width_scale=1)\n",
-    "ax.set_ylabel('Time (seconds)')\n",
-    "ax.set_title('Compilation time')\n",
-    "ax.set_xlim(-0.45,3.45)\n",
-    "\n",
-    "ax.legend(loc='upper left')\n",
-    "\n",
-    "fig.tight_layout()\n",
-    "plt.savefig('times.png', facecolor='white', dpi=200, bbox_inches='tight', pad_inches = 0)\n",
-    "plt.savefig('times.svg', facecolor='white', bbox_inches='tight', pad_inches = 0)\n",
-    "plt.show()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "b23e02b4-6e98-49a3-a60f-14142757af71",
-   "metadata": {
-    "tags": []
-   },
-   "outputs": [],
-   "source": [
-    "fig, ax = bars(sizes, ylim_scale=.085, figsize_scale=1.1)\n",
-    "ax.set_ylabel('Size (MiB)')\n",
-    "ax.set_title('Binary size')\n",
-    "ax.set_xlim(-0.45,3.45)\n",
-    "ax.legend(loc='lower left')\n",
-    "\n",
-    "fig.tight_layout()\n",
-    "plt.savefig('sizes.png', facecolor='white', dpi=200, bbox_inches='tight', pad_inches = 0)\n",
-    "plt.savefig('sizes.svg', facecolor='white', bbox_inches='tight', pad_inches = 0)\n",
-    "plt.show()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "d3f3b5d2-74d6-415c-ad3d-b8fb0f37eddb",
-   "metadata": {
-    "tags": []
-   },
-   "outputs": [],
-   "source": [
-    "import cppyy\n",
-    "if not hasattr(cppyy.gbl, 'test_0000'):\n",
-    "    cppyy.include('cppyy.h')\n",
-    "\n",
-    "plot_colors = {\n",
-    "    'boost': cycle[1],\n",
-    "    'cython': cycle[4],\n",
-    "    'pybind11': cycle[3],\n",
-    "    'cppyy' : cycle[8],\n",
-    "    'python': 'None',\n",
-    "    'nanobind': cycle[0]\n",
-    "}\n",
-    "\n",
-    "plot_labels = {\n",
-    "    'boost' : 'Boost.Python',\n",
-    "    'pybind11' : 'pybind11',    \n",
-    "    'cppyy' : 'cppyy',\n",
-    "    'cython' : 'Cython',\n",
-    "    'nanobind' : 'nanobind',\n",
-    "    'python' : 'Python'\n",
-    "}\n",
-    "\n",
-    "class native_module:\n",
-    "    @staticmethod\n",
-    "    def test_0000(a, b, c, d, e, f):\n",
-    "        return a + b + c + d +e + f\n",
-    "\n",
-    "    \n",
-    "    class Struct0:\n",
-    "        def __init__(self, a, b, c, d, e, f):\n",
-    "            self.a = a\n",
-    "            self.b = b\n",
-    "            self.c = c\n",
-    "            self.d = d\n",
-    "            self.e = e\n",
-    "            self.f = f\n",
-    "\n",
-    "        def sum(self):\n",
-    "            return self.a + self.b + self.c + self.e + self.f\n",
-    "    \n",
-    "\n",
-    "rtimes = defaultdict(lambda: [])\n",
-    "for name in ['func', 'class']:\n",
-    "    its = 10000000 if name == 'func' else 2500000\n",
-    "    for lib in plot_labels:\n",
-    "        for mode in ['debug', 'opt']:\n",
-    "            if lib == 'cppyy':\n",
-    "                m = cppyy.gbl\n",
-    "            elif lib == 'nanobind_sh':\n",
-    "                continue # Performance identical, not an interesting data point\n",
-    "            elif lib == 'python':\n",
-    "                m = native_module\n",
-    "            else:\n",
-    "                m = importlib.import_module(f'{name}_{lib}_{mode}')\n",
-    "         \n",
-    "            time_list = []\n",
-    "            for i in range(5):\n",
-    "                time_before = time.perf_counter()\n",
-    "                if name == 'func':\n",
-    "                    func = m.test_0000\n",
-    "                    for i in range(its):\n",
-    "                        func(1,2,3,4,5,6)\n",
-    "                elif name == 'class':\n",
-    "                    cls = m.Struct0\n",
-    "                    sum_member = cls.sum\n",
-    "                    for i in range(its):\n",
-    "                        sum_member(cls(1,2,3,4,5,6))\n",
-    "\n",
-    "                time_after = time.perf_counter()\n",
-    "                time_list.append(time_after-time_before)\n",
-    "            time_list.sort()\n",
-    "\n",
-    "            rtimes[lib].append(time_list[len(time_list)//2])"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "5ad743ce-33c4-4dd1-8a0f-2ccbcf02aa1c",
-   "metadata": {
-    "tags": []
-   },
-   "outputs": [],
-   "source": [
-    "fig, ax = bars(rtimes, ylim_scale=.188, figsize_scale=1.25, width_scale=1, debug_shift=.1)\n",
-    "ax.set_ylabel('Time (seconds)')\n",
-    "ax.set_title('Runtime performance')\n",
-    "ax.set_xlim(-0.45,3.45)\n",
-    "ax.legend()\n",
-    "fig.tight_layout()\n",
-    "plt.savefig('perf.png', facecolor='white', dpi=200, bbox_inches='tight', pad_inches = 0)\n",
-    "plt.savefig('perf.svg', facecolor='white', bbox_inches='tight', pad_inches = 0)\n",
-    "plt.show()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "2f54fb73-d150-48c0-862f-57abdbce9875",
-   "metadata": {},
-   "outputs": [],
-   "source": []
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": "Python 3 (ipykernel)",
-   "language": "python",
-   "name": "python3"
-  },
-  "language_info": {
-   "codemirror_mode": {
-    "name": "ipython",
-    "version": 3
-   },
-   "file_extension": ".py",
-   "mimetype": "text/x-python",
-   "name": "python",
-   "nbconvert_exporter": "python",
-   "pygments_lexer": "ipython3",
-   "version": "3.10.6"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 5
-}
diff --git a/src/nanobind/docs/ndarray.rst b/src/nanobind/docs/ndarray.rst
deleted file mode 100644
index 50581d2..0000000
--- a/src/nanobind/docs/ndarray.rst
+++ /dev/null
@@ -1,714 +0,0 @@
-.. cpp:namespace:: nanobind
-
-.. _ndarray_class:
-
-The ``nb::ndarray<..>`` class
-=============================
-
-nanobind can exchange n-dimensional arrays (henceforth "**nd-arrays**") with
-popular array programming frameworks including `NumPy <https://numpy.org>`__,
-`PyTorch <https://pytorch.org>`__, `TensorFlow <https://www.tensorflow.org>`__,
-`JAX <https://jax.readthedocs.io>`__, and `CuPy <https://cupy.dev>`_. It
-supports *zero-copy* exchange using two protocols:
-
--  The classic `buffer
-   protocol <https://docs.python.org/3/c-api/buffer.html>`__.
-
--  `DLPack <https://github.com/dmlc/dlpack>`__, a
-   GPU-compatible generalization of the buffer protocol.
-
-nanobind knows how to talk to each framework and takes care of all the
-nitty-gritty details.
-
-To use this feature, you must add the include directive
-
-.. code-block:: cpp
-
-   #include <nanobind/ndarray.h>
-
-to your code. Following this, you can bind functions with
-:cpp:class:`nb::ndarray\<...\> <ndarray>`-typed parameters and return values.
-
-Array input arguments
----------------------
-
-A function that accepts an :cpp:class:`nb::ndarray\<\> <ndarray>`-typed parameter
-(i.e., *without* template parameters) can be called with *any* writable array
-from any framework regardless of the device on which it is stored. The
-following example binding declaration uses this functionality to inspect the
-properties of an arbitrary input array:
-
-.. code-block:: cpp
-
-   m.def("inspect", [](const nb::ndarray<>& a) {
-       printf("Array data pointer : %p\n", a.data());
-       printf("Array dimension : %zu\n", a.ndim());
-       for (size_t i = 0; i < a.ndim(); ++i) {
-           printf("Array dimension [%zu] : %zu\n", i, a.shape(i));
-           printf("Array stride    [%zu] : %zd\n", i, a.stride(i));
-       }
-       printf("Device ID = %u (cpu=%i, cuda=%i)\n", a.device_id(),
-           int(a.device_type() == nb::device::cpu::value),
-           int(a.device_type() == nb::device::cuda::value)
-       );
-       printf("Array dtype: int16=%i, uint32=%i, float32=%i\n",
-           a.dtype() == nb::dtype<int16_t>(),
-           a.dtype() == nb::dtype<uint32_t>(),
-           a.dtype() == nb::dtype<float>()
-       );
-   });
-
-Below is an example of what this function does when called with a NumPy
-array:
-
-.. code-block:: pycon
-
-   >>> my_module.inspect(np.array([[1,2,3], [3,4,5]], dtype=np.float32))
-   Array data pointer : 0x1c30f60
-   Array dimension : 2
-   Array dimension [0] : 2
-   Array stride    [0] : 3
-   Array dimension [1] : 3
-   Array stride    [1] : 1
-   Device ID = 0 (cpu=1, cuda=0)
-   Array dtype: int16=0, uint32=0, float32=1
-
-Array constraints
------------------
-
-In practice, it can often be useful to *constrain* what kinds of arrays
-constitute valid inputs to a function. For example, a function expecting CPU
-storage would likely crash if given a pointer to GPU memory, and nanobind
-should therefore prevent such undefined behavior. The
-:cpp:class:`nb::ndarray\<...\> <ndarray>` class accepts template arguments to
-specify such constraints. For example the binding below guarantees that the
-implementation can only be called with CPU-resident arrays with shape (·,·,3)
-containing 8-bit unsigned integers.
-
-.. code-block:: cpp
-
-   using RGBImage = nb::ndarray<uint8_t, nb::shape<-1, -1, 3>, nb::device::cpu>;
-
-   m.def("process", [](RGBImage data) {
-       // Double brightness of the MxNx3 RGB image
-       for (size_t y = 0; y < data.shape(0); ++y)
-           for (size_t x = 0; x < data.shape(1); ++x)
-               for (size_t ch = 0; ch < 3; ++ch)
-                   data(y, x, ch) = (uint8_t) std::min(255, data(y, x, ch) * 2);
-   });
-
-The above example also demonstrates the use of :cpp:func:`operator()
-<ndarray::operator()>`, which provides direct read/write access to the array
-contents assuming that they are reachable through the CPU's
-virtual address space.
-
-.. _ndarray-constraints-1:
-
-Overview
-^^^^^^^^
-
-Overall, the following kinds of constraints are available:
-
-- **Data type**: a type annotation like ``float``, ``uint8_t``, etc., constrain the
-  numerical representation of the nd-array. Complex arrays (i.e.,
-  ``std::complex<float>`` or ``std::complex<double>``) are also supported.
-
-- **Constant arrays**: further annotating the data type with ``const`` makes it possible to call
-  the function with constant arrays that do not permit write access. Without
-  the annotation, calling the binding would fail with a ``TypeError``.
-
-  You can alternatively accept constant arrays of *any type* by not specifying
-  a data type at all and instead passing the :cpp:class:`nb::ro <ro>` annotation.
-
-- **Shape**: The :cpp:class:`nb::shape <shape>` annotation (as in ``nb::shape<-1, 3>``)
-  simultaneously constrains the number of array dimensions and the size per
-  dimension. A value of ``-1`` leaves the size of the associated dimension
-  unconstrained.
-
-  :cpp:class:`nb::ndim\<N\> <ndim>` is shorter when only the dimension
-  should be constrained. For example, ``nb::ndim<3>`` is equivalent to
-  ``nb::shape<-1, -1, -1>``.
-
-- **Device tags**: annotations like :cpp:class:`nb::device::cpu <device::cpu>`
-  or :cpp:class:`nb::device::cuda <device::cuda>` constrain the source device
-  and address space.
-
-- **Memory order**: two ordering tags :cpp:class:`nb::c_contig <c_contig>` and
-  :cpp:class:`nb::f_contig <f_contig>` enforce contiguous storage in either
-  C or Fortran style.
-
-  In the case of matrices, C-contiguous implies row-major and F-contiguous
-  implies column-major storage. Without this tag, arbitrary non-contiguous
-  representations (e.g. produced by slicing operations) and other unusual
-  layouts are permitted.
-
-  This tag is mainly useful when your code directly accesses the array contents
-  via :cpp:func:`nb::ndarray\<...\>::data() <ndarray::data>`, while assuming a
-  particular layout.
-
-  A third order tag named :cpp:class:`nb::any_contig <any_contig>` accepts
-  *both* ``F``- and ``C``-contiguous arrays while rejecting non-contiguous
-  ones.
-
-Type signatures
-^^^^^^^^^^^^^^^
-
-nanobind displays array constraints in docstrings and error messages. For
-example, suppose that we now call the ``process()`` function with an invalid
-input. This produces the following error message:
-
-.. code-block:: pycon
-
-   >>> my_module.process(np.zeros(1))
-
-   TypeError: process(): incompatible function arguments. The following argument types are supported:
-   1. process(arg: ndarray[dtype=uint8, shape=(*, *, 3), device='cpu'], /) -> None
-
-   Invoked with types: numpy.ndarray
-
-Note that these type annotations are intended for humans–they will not
-currently work with automatic type checking tools like `MyPy
-<https://mypy.readthedocs.io/en/stable/>`__ (which at least for the time being
-don’t provide a portable or sufficiently flexible annotation of n-dimensional
-arrays).
-
-Overload resolution
-^^^^^^^^^^^^^^^^^^^
-
-A function binding can declare multiple overloads with different nd-array
-constraints (e.g., a CPU and a GPU implementation), in which case nanobind will
-call the first matching overload. When no perfect match can be found, nanobind
-will try each overload once more while performing basic implicit conversions:
-it will convert strided arrays into C- or F-contiguous arrays (if requested)
-and perform type conversion. This, e.g., makes it possible to call a function
-expecting a ``float32`` array with ``float64`` data. Implicit conversions
-create temporary nd-arrays containing a copy of the data, which can be
-undesirable. To suppress them, add an
-:cpp:func:`nb::arg("my_array_arg").noconvert() <arg::noconvert>` or
-:cpp:func:`"my_array_arg"_a.noconvert() <arg::noconvert>` argument annotation.
-
-Passing arrays within C++ code
-------------------------------
-
-You can think of the :cpp:class:`nb::ndarray <ndarray>` class as a
-reference-counted pointer resembling ``std::shared_ptr<T>`` that can be freely
-moved or copied. This means that there isn't a big difference between a
-function taking
-``ndarray`` by value versus taking a constant reference ``const ndarray &``
-(i.e., the former does not create an additional copy of the underlying data).
-
-Copies of the :cpp:class:`nb::ndarray <ndarray>` wrapper will point to the same
-underlying buffer and increase the reference count until they go out of scope.
-You may call freely call :cpp:class:`nb::ndarray\<...\> <ndarray>` methods from
-multithreaded code even when the `GIL
-<https://wiki.python.org/moin/GlobalInterpreterLock>`__ is not held, for
-example to examine the layout of an array and access the underlying storage.
-
-There are two exceptions to this: creating a *new* nd-array object from C++
-(discussed :ref:`later <returning-ndarrays>`) and casting it to Python via
-the :cpp:func:`ndarray::cast` function both involve Python API calls that require
-that the GIL is held.
-
-.. _returning-ndarrays:
-
-Returning arrays from C++ to Python
------------------------------------
-
-Passing an nd-array across the C++ → Python language barrier is a two-step
-process:
-
-1. Creating an :cpp:class:`nb::ndarray\<...\> <ndarray>` instance, which
-   only stores *metadata*, e.g.:
-
-   - Where is the data located in memory? (pointer address and device)
-   - What is its type and shape?
-   - Who owns this data?
-
-   An actual Python object is not yet constructed at this stage.
-
-2. Converting the :cpp:class:`nb::ndarray\<...\> <ndarray>` into a
-   Python object of the desired type (e.g. ``numpy.ndarray``).
-
-Normally, step 1 is your responsibility, while step 2 is taken care of by the
-binding layer. To understand this separation, let's look at an example. The
-``.view()`` function binding below creates a 4×4 column-major NumPy array view
-into a ``Matrix4f`` instance.
-
-.. _matrix4f-example:
-
-.. code-block:: cpp
-
-   struct Matrix4f { float m[4][4] { }; };
-
-   using Array = nb::ndarray<float, nb::numpy, nb::shape<4, 4>, nb::f_contig>;
-
-   nb::class_<Matrix4f>(m, "Matrix4f")
-       .def(nb::init<>())
-       .def("view",
-            [](Matrix4f &m){ return Array(data); },
-            nb::rv_policy::reference_internal);
-
-In this case:
-
-- step 1 is the ``Array(data)`` call in the lambda function.
-
-- step 2 occurs outside of the lambda function when the nd-array
-  :cpp:class:`nb::ndarray\<...\> <ndarray>` :ref:`type caster <type_casters>`
-  constructs a NumPy array from the metadata.
-
-Data *ownership* is an important aspect of this two-step process: because the
-NumPy array points directly into the storage of another object, nanobind must
-keep the ``Matrix4f`` instance alive as long as the NumPy array exists, which
-the :cpp:enumerator:`reference_internal <rv_policy::reference_internal>` return
-value policy signals to nanobind. More generally, wrapping an existing memory
-region without copying requires that that this memory region remains valid
-throughout the lifetime of the created array (more on this point :ref:`shortly
-<ndarray-ownership>`).
-
-Recall the discussion of the :ref:`nd-array constraint <ndarray-constraints-1>`
-template parameters. For the return path, you will generally want to add a
-*framework* template parameter to the nd-array parameters that indicates the
-desired Python type.
-
-- :cpp:class:`nb::numpy <numpy>`: create a ``numpy.ndarray``.
-- :cpp:class:`nb::pytorch <pytorch>`: create a ``torch.Tensor``.
-- :cpp:class:`nb::tensorflow <tensorflow>`: create a ``tensorflow.python.framework.ops.EagerTensor``.
-- :cpp:class:`nb::jax <jax>`: create a ``jaxlib.xla_extension.DeviceArray``.
-- :cpp:class:`nb::cupy <cupy>`: create a ``cupy.ndarray``.
-- No framework annotation. In this case, nanobind will create a raw Python
-  ``dltensor`` `capsule <https://docs.python.org/3/c-api/capsule.html>`__
-  representing the `DLPack <https://github.com/dmlc/dlpack>`__ metadata.
-
-This annotation also affects the auto-generated docstring of the function,
-which in this case becomes:
-
-.. code-block:: python
-
-   view(self) -> numpy.ndarray[float32, shape=(4, 4), order='F']
-
-Note that the framework annotation only plays a role when passing arrays from
-C++ to Python. It does not constrain the reverse direction (for example, a
-PyTorch array would still be accepted by a function taking the ``Array`` alias
-defined above as input. For this reason, you may want to add a
-:cpp:class:`nb::device::cpu <device::cpu>` device annotation).
-
-Dynamic array configurations
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-The previous example was rather simple because all the array configuration was fully known
-at compile time and specified via the :cpp:class:`nb::ndarray\<...\> <ndarray>`
-template parameters. In general, there are often dynamic aspects of the
-configuration that must be explicitly passed to the constructor. Its signature
-(with some simplifications) is given below. See the
-:ref:`ndarray::ndarray() <ndarray_dynamic_constructor>` documentation for a more detailed specification
-and another variant of the constructor.
-
-.. code-block:: cpp
-
-   ndarray(void *data,
-           std::initializer_list<size_t> shape = { },
-           handle owner = { },
-           std::initializer_list<int64_t> strides = { },
-           dlpack::dtype dtype = ...,
-           int device_type = ...,
-           int device_id = 0,
-           char order = ...) { .. }
-
-The parameters have the following role:
-
-- ``data``: CPU/GPU/.. memory address of the data.
-- ``shape``: number of dimensions and size along each axis.
-- ``owner``: a Python object owning the storage, which must be
-  kept alive while the array object exists.
-- ``strides``: specifies the data layout in memory. You only need to specify
-  this parameter if it has a non-standard ``order`` (e.g., if it is non-contiguous).
-  Note that the ``strides`` count elements, not bytes.
-- ``dtype`` data type (floating point, signed/unsigned integer), bit depth.
-- ``device_type`` and ``device_id``: device type and number, e.g., for multi-GPU setups.
-- ``order``: coefficient memory order. Default: ``'C'`` (C-style) ordering,
-  specify ``'F'`` for Fortran-style ordering.
-
-The parameters generally have inferred defaults based on the array's
-compile-time template parameters. Passing them explicitly overrides these
-defaults with information available at runtime.
-
-.. _ndarray-ownership:
-
-Data ownership
-^^^^^^^^^^^^^^
-
-Let's look at a fancier example that uses the constructor arguments explained
-above to return a dynamically sized 2D array. This example also shows another
-mechanism to express *data ownership*:
-
-.. code-block:: cpp
-
-   m.def("create_2d",
-         [](size_t rows, size_t cols) {
-             // Allocate a memory region an initialize it
-             float *data = new float[rows * cols];
-             for (size_t i = 0; i < rows * cols; ++i)
-                 data[i] = (float) i;
-
-             // Delete 'data' when the 'owner' capsule expires
-             nb::capsule owner(data, [](void *p) noexcept {
-                delete[] (float *) p;
-             });
-
-             return nb::ndarray<nb::numpy, float, nb::ndim<2>>(
-                 /* data = */ data,
-                 /* shape = */ { rows, cols },
-                 /* owner = */ owner
-             );
-   });
-
-The ``owner`` parameter should specify a Python object, whose continued
-existence keeps the underlying memory region alive. Nanobind will temporarily
-increase the ``owner`` reference count in the  :cpp:func:`ndarray::ndarray()`
-constructor and then decrease it again when the created NumPy array expires.
-
-The above example binding returns a *new* memory region that should be deleted
-when it is no longer in use. This is done by creating a
-:cpp:class:`nb::capsule`, an opaque pointer with a destructor callback that
-runs at this point and takes care of cleaning things up.
-
-If there is already an existing Python object, whose existence guarantees that
-it is safe to access the provided storage region, then you may alternatively
-pass this object as the ``owner``---nanobind will make sure that this object
-isn't deleted as long as the created array exists. If the owner is a C++ object
-with an associated Python instance, you may use :cpp:func:`nb::find() <find>`
-to look up the associated Python object. When binding methods, you can use the
-:cpp:enumerator:`reference_internal <rv_policy::reference_internal>` return
-value policy to specify the implicit ``self`` argument as the ``owner`` upon
-return, which was done in the earlier ``Matrix4f`` :ref:`example
-<matrix4f-example>`.
-
-.. warning::
-
-   If you do not specify an owner and use a return value policy like
-   :cpp:enumerator:`rv_policy::reference` (see also the the section on
-   :ref:`nd-array return value policies <ndarray_rvp>`), nanobind will assume
-   that the array storage **remains valid forever**.
-
-   This is one of the most frequent issues reported on the nanobind GitHub
-   repository: users forget to think about data ownership and run into data
-   corruption.
-
-   If there isn't anything keeping the array storage alive, it will likely be
-   released and reused at some point, while stale arrays still point to the
-   associated memory region (i.e., a classic "use-after-free" bug).
-
-In more advanced situations, it may be helpful to have a capsule that manages
-the lifetime of data structures containing *multiple* storage regions. The same
-capsule can be referenced from different nd-arrays and will call the deleter
-when all of them have expired:
-
-.. code-block:: cpp
-
-   m.def("return_multiple", []() {
-       struct Temp {
-           std::vector<float> vec_1;
-           std::vector<float> vec_2;
-       };
-
-       Temp *temp = new Temp();
-       temp->vec_1 = std::move(...);
-       temp->vec_2 = std::move(...);
-
-       nb::capsule deleter(temp, [](void *p) noexcept {
-           delete (Temp *) p;
-       });
-
-       size_t size_1 = temp->vec_1.size();
-       size_t size_2 = temp->vec_2.size();
-
-       return std::make_pair(
-           nb::ndarray<nb::pytorch, float>(temp->vec_1.data(), { size_1 }, deleter),
-           nb::ndarray<nb::pytorch, float>(temp->vec_2.data(), { size_2 }, deleter)
-       );
-   });
-
-.. _ndarray_rvp:
-
-Return value policies
-^^^^^^^^^^^^^^^^^^^^^
-
-Function bindings that return nd-arrays can specify return value policy
-annotations to determine whether or not a copy should be made. They are
-interpreted as follows:
-
-- The default :cpp:enumerator:`rv_policy::automatic` and
-  :cpp:enumerator:`rv_policy::automatic_reference` policies cause the array to
-  be copied when it has no owner and when it is not already associated with a
-  Python object.
-
-- The policy :cpp:enumerator:`rv_policy::reference` references an existing
-  memory region and never copies.
-
-- :cpp:enumerator:`rv_policy::copy` always copies.
-
-- :cpp:enumerator:`rv_policy::none` refuses the cast unless the array is
-  already associated with an existing Python object (e.g. a NumPy array), in
-  which case that object is returned.
-
-- :cpp:enumerator:`rv_policy::reference_internal` retroactively sets the
-  nd-array's ``owner`` field to a method's ``self`` argument. It fails with an
-  error if there is already a different owner.
-
-- :cpp:enumerator:`rv_policy::move` is unsupported and demoted to
-  :cpp:enumerator:`rv_policy::copy`.
-
-.. _ndarray-temporaries:
-
-Returning temporaries
-^^^^^^^^^^^^^^^^^^^^^
-
-Returning nd-arrays from temporaries (e.g. stack-allocated memory) requires
-extra precautions.
-
-.. code-block:: cpp
-   :emphasize-lines: 4,5
-
-   using Vector3f = nb::ndarray<float, nb::numpy, nb::shape<3>>;
-   m.def("return_vec3", []{
-       float data[] { 1, 2, 3 };
-       // !!! BAD don't do this !!!
-       return Vector3f(data);
-   });
-
-Recall the discussion at the :ref:`beginning <returning-ndarrays>` of this
-subsection. The :cpp:class:`nb::ndarray\<...\> <ndarray>` constructor only
-creates *metadata* describing this array, with the actual array creation
-happening *after* of the function call. That isn't safe in this case because
-``data`` is a temporary on the stack that is no longer valid once the function
-has returned. To fix this, we could use the :cpp:func:`nb::cast() <cast>`
-method to *force* the array creation in the body of the function:
-
-.. code-block:: cpp
-   :emphasize-lines: 4,5
-
-   using Vector3f = nb::ndarray<float, nb::numpy, nb::shape<3>>;
-   m.def("return_vec3", []{
-       float data[] { 1, 2, 3 };
-       // OK.
-       return nb::cast(Vector3f(data));
-   });
-
-While safe, one unfortunate aspect of this change is that the function now has
-a rather non-informative docstring ``return_vec3() -> object``, which is a
-consequence of :cpp:func:`nb::cast() <cast>` returning a generic
-:cpp:class:`nb::object <object>`.
-
-To fix this, you can use the nd-array :cpp:func:`.cast() <ndarray::cast>`
-method, which is like :cpp:func:`nb::cast() <cast>` except that it preserves
-the type signature:
-
-.. code-block:: cpp
-   :emphasize-lines: 4,5
-
-   using Vector3f = nb::ndarray<float, nb::numpy, nb::shape<3>>;
-   m.def("return_vec3", []{
-       float data[] { 1, 2, 3 };
-       // Perfect.
-       return Vector3f(data).cast();
-   });
-
-.. _ndarray-nonstandard:
-
-Nonstandard arithmetic types
-----------------------------
-
-Low or extended-precision arithmetic types (e.g., ``int128``, ``float16``,
-``bfloat16``) are sometimes used but don't have standardized C++ equivalents.
-If you wish to exchange arrays based on such types, you must register a partial
-overload of ``nanobind::detail::dtype_traits`` to inform nanobind about it.
-
-You are expressively allowed to create partial overloads of this class despite
-it being in the ``nanobind::detail`` namespace.
-
-For example, the following snippet makes ``__fp16`` (half-precision type on
-``aarch64``) available by  providing
-
-1. ``value``, a DLPack ``nanobind::dlpack::dtype`` type descriptor, and
-2. ``name``, a type name for use in docstrings and error messages.
-
-.. code-block:: cpp
-
-   namespace nanobind::detail {
-       template <> struct dtype_traits<__fp16> {
-           static constexpr dlpack::dtype value {
-               (uint8_t) dlpack::dtype_code::Float, // type code
-               16, // size in bits
-               1   // lanes (simd), usually set to 1
-           };
-           static constexpr auto name = const_name("float16");
-       };
-   }
-
-.. _ndarray-views:
-
-Fast array views
-----------------
-
-The following advice applies to performance-sensitive CPU code that reads and
-writes arrays using loops that invoke :cpp:func:`nb::ndarray\<...\>::operator()
-<ndarray::operator()>`. It does not apply to GPU arrays because they are
-usually not accessed in this way.
-
-Consider the following snippet, which fills a 2D array with data:
-
-.. code-block:: cpp
-
-   void fill(nb::ndarray<float, nb::ndim<2>, nb::c_contig, nb::device::cpu> arg) {
-       for (size_t i = 0; i < arg.shape(0); ++i)
-           for (size_t j = 0; j < arg.shape(1); ++j)
-               arg(i, j) = /* ... */;
-   }
-
-While functional, this code is not perfect. The problem is that to compute the
-address of an entry, ``operator()`` accesses the DLPack array descriptor. This
-indirection can break certain compiler optimizations.
-
-nanobind provides the method :cpp:func:`ndarray\<...\>::view() <ndarray::view>`
-to fix this. It creates a tiny data structure that provides all information
-needed to access the array contents, and which can be held within CPU
-registers. All relevant compile-time information (:cpp:class:`nb::ndim <ndim>`,
-:cpp:class:`nb::shape <shape>`, :cpp:class:`nb::c_contig <c_contig>`,
-:cpp:class:`nb::f_contig <f_contig>`) is materialized in this view, which
-enables constant propagation, auto-vectorization, and loop unrolling.
-
-An improved version of the example using such a view is shown below:
-
-.. code-block:: cpp
-
-   void fill(nb::ndarray<float, nb::ndim<2>, nb::c_contig, nb::device::cpu> arg) {
-       auto v = arg.view(); // <-- new!
-
-       for (size_t i = 0; i < v.shape(0); ++i) // Important; use 'v' instead of 'arg' everywhere in loop
-           for (size_t j = 0; j < v.shape(1); ++j)
-               v(i, j) = /* ... */;
-   }
-
-Note that the view performs no reference counting. You may not store it in a way
-that exceeds the lifetime of the original array.
-
-When using OpenMP to parallelize expensive array operations, pass the
-``firstprivate(view_1, view_2, ...)`` so that each worker thread can copy the
-view into its register file.
-
-.. code-block:: cpp
-
-   auto v = arg.view();
-   #pragma omp parallel for schedule(static) firstprivate(v)
-   for (...) { /* parallel loop */ }
-
-.. _ndarray-runtime-specialization:
-
-Specializing views at runtime
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-As mentioned earlier, element access via ``operator()`` only works when both
-the array's scalar type and its dimension are specified within the type (i.e.,
-when they are known at compile time); the same is also true for array views.
-However, sometimes, it is useful that a function can be called with different
-array types.
-
-You may use the :cpp:func:`ndarray\<...\>::view() <ndarray::view>` method to
-create *specialized* views if a run-time check determines that it is safe to
-do so. For example, the function below accepts contiguous CPU arrays and
-performs a loop over a specialized 2D ``float`` view when the array is of
-this type.
-
-.. code-block:: cpp
-
-   void fill(nb::ndarray<nb::c_contig, nb::device::cpu> arg) {
-       if (arg.dtype() == nb::dtype<float>() && arg.ndim() == 2) {
-           auto v = arg.view<float, nb::ndim<2>>(); // <-- new!
-
-           for (size_t i = 0; i < v.shape(0); ++i) {
-               for (size_t j = 0; j < v.shape(1); ++j) {
-                   v(i, j) = /* ... */;
-               }
-           }
-        } else { /* ... */ }
-   }
-
-Array libraries
----------------
-
-The Python `array API standard <https://data-apis.org/array-api/latest/purpose_and_scope.html>`__
-defines a common interface and interchange protocol for nd-array libraries. In particular, to
-support inter-framework data exchange, custom array types should implement the
-
-- `__dlpack__ <https://data-apis.org/array-api/latest/API_specification/generated/array_api.array.__dlpack__.html#array_api.array.__dlpack__>`__ and
-- `__dlpack_device__ <https://data-apis.org/array-api/latest/API_specification/generated/array_api.array.__dlpack_device__.html#array_api.array.__dlpack_device__>`__
-
-methods. This is easy thanks to the nd-array integration in nanobind. An example is shown below:
-
-.. code-block:: cpp
-
-   nb::class_<MyArray>(m, "MyArray")
-      // ...
-      .def("__dlpack__", [](nb::kwargs kwargs) {
-          return nb::ndarray<>( /* ... */);
-      })
-      .def("__dlpack_device__", []() {
-          return std::make_pair(nb::device::cpu::value, 0);
-      });
-
-Returning a raw :cpp:class:`nb::ndarray <ndarray>` without framework annotation
-will produce a DLPack capsule, which is what the interface expects.
-
-The ``kwargs`` argument can be used to provide additional parameters (for
-example to request a copy), please see the DLPack documentation for details.
-Note that nanobind does not yet implement the versioned DLPack protocol. The
-version number should be ignored for now.
-
-Frequently asked questions
---------------------------
-
-Why does my returned nd-array contain corrupt data?
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-If your nd-array bindings lead to undefined behavior (data corruption or
-crashes), then this is usually an ownership issue. Please review the section on
-:ref:`data ownership <ndarray-ownership>` for details.
-
-Why does nanobind not accept my NumPy array?
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-When binding a function that takes an ``nb::ndarray<T, ...>`` as input, nanobind
-will by default require that array to be writable. This means that the function
-cannot be called using NumPy arrays that are marked as constant.
-
-If you wish your function to be callable with constant input, either change the
-parameter to ``nb::ndarray<const T, ...>`` (if the array is parameterized by
-type), or write ``nb::ndarray<nb::ro>`` to accept a read-only array of any
-type.
-
-Limitations related to ``dtypes``
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-.. _dtype_restrictions:
-
-Libraries like `NumPy <https://numpy.org>`__ support arrays with flexible
-internal representations (*dtypes*), including
-
-- Floating point and integer arrays with various bit depths
-
-- Null-terminated strings
-
-- Arbitrary Python objects
-
-- Heterogeneous data structures composed of multiple fields
-
-nanobind's :cpp:class:`nb::ndarray\<...\> <ndarray>` is based on the `DLPack
-<https://github.com/dmlc/dlpack>`__ array exchange protocol, which causes it to
-be more restrictive. Presently supported dtypes include signed/unsigned
-integers, floating point values, complex numbers, and boolean values. Some
-:ref:`nonstandard arithmetic types <ndarray-nonstandard>` can be supported as
-well.
-
-Nanobind can receive and return *read-only* arrays via the buffer protocol when
-exhanging data with NumPy. The DLPack interface currently ignores this
-annotation.
diff --git a/src/nanobind/docs/ndarray_index.rst b/src/nanobind/docs/ndarray_index.rst
deleted file mode 100644
index 74106d4..0000000
--- a/src/nanobind/docs/ndarray_index.rst
+++ /dev/null
@@ -1,13 +0,0 @@
-.. _ndarrays:
-
-N-dimensional arrays
-====================
-
-nanobind provides two alternative interfaces to exchange array data between
-Python and C++.
-
-.. toctree::
-   :maxdepth: 1
-
-   ndarray
-   eigen
diff --git a/src/nanobind/docs/ownership.rst b/src/nanobind/docs/ownership.rst
deleted file mode 100644
index c2ca16c..0000000
--- a/src/nanobind/docs/ownership.rst
+++ /dev/null
@@ -1,400 +0,0 @@
-.. _ownership:
-
-.. cpp:namespace:: nanobind
-
-Object ownership
-================
-
-Python and C++ don't manage the lifetime and storage of objects in the same
-way. Consequently, two questions arise whenever an object crosses the language
-barrier:
-
-- Who actually *owns* this object? C++? Python? Both?!
-
-- Can we safely determine when it is no longer needed?
-
-This is important: we *must* exclude the possibility that Python destroys an
-object that is still being used by C++ (or vice versa).
-
-The :ref:`previous section <exchange>` introduced three ways of exchanging
-information between C++ and Python: :ref:`type casters <type_casters>`,
-:ref:`bindings <bindings>`, and :ref:`wrappers <wrappers>`.
-It is specifically
-:ref:`bindings <bindings>` for which these two questions must be answered.
-
-.. _ownership_problem:
-
-A problematic example
----------------------
-
-Consider the following problematic example to see what can go wrong:
-
-.. code-block:: cpp
-
-   #include <nanobind/nanobind.h>
-   namespace nb = nanobind;
-
-   struct Data { };
-   Data data; // Data global variable & function returning a pointer to it
-   Data *get_data() { return &data; }
-
-   NB_MODULE(my_ext, m) {
-       nb::class_<Data>(m, "Data");
-
-       // KABOOM, calling this function will crash the Python interpreter
-       m.def("get_data", &get_data);
-   }
-
-The bound function ``my_ext.get_data()`` returns a Python object of type
-``my_ext.Data`` that wraps the pointer ``&data`` and takes ownership of it.
-
-When Python eventually garbage collects the object, nanobind will try to free
-the (non-heap-allocated) C++ instance via ``operator delete``, causing a
-segmentation fault.
-
-To avoid this problem, we can
-
-1. **Provide more information**: the problem was that nanobind *incorrectly*
-   transferred ownership of a C++ instance to the Python side. To fix this, we
-   can add a :ref:`return value policy <rvp>` annotation that clarifies
-   what to do with the return value.
-
-2. **Make ownership transfer explicit**: C++ types passed via :ref:`unique
-   pointers <unique_ptr>` (``std::unique_ptr<T>``) make the ownership transfer
-   explicit in the type system, which would have revealed the problem in this
-   example.
-
-3. **Switch to shared ownership**: C++ types passed via :ref:`shared pointers
-   <shared_ptr>` (``std::shared_ptr<T>``), or which use :ref:`intrusive
-   reference counting <intrusive_intro>` can be shared by C++ and Python. The
-   whole issue disappears because ownership transfer is no longer needed.
-
-The remainder of this section goes through each of these options.
-
-.. _rvp:
-
-Return value policies
----------------------
-
-nanobind provides several *return value policy* annotations that can be
-passed to :func:`module_::def`, :func:`class_::def`, and :func:`cpp_function`.
-The default policy is :cpp:enumerator:`rv_policy::automatic`, which is usually
-a reasonable default (but not in this case!).
-
-In the :ref:`problematic example <ownership_problem>`, the policy
-:cpp:enumerator:`rv_policy::reference` should have been specified explicitly so
-that the global instance is only *referenced* without any implied transfer of
-ownership, i.e.:
-
-.. code-block:: cpp
-
-    m.def("get_data", &get_data, nb::rv_policy::reference);
-
-On the other hand, this is not the right policy for many other situations,
-where ignoring ownership could lead to resource leaks. As a developer using
-this library, it is important that you familiarize yourself with the different
-options below. In particular, the following policies are available:
-
-- :cpp:enumerator:`rv_policy::take_ownership`:
-  Create a thin Python object wrapper around the returned C++ instance without
-  making a copy and transfer ownership to Python. When the
-  Python wrapper is eventually garbage collected, nanobind will call the C++
-  ``delete`` operator to free the C++ instance.
-
-  In the example below, a function uses this policy to transfer ownership of a
-  heap-allocated C++ instance to Python:
-
-  .. code-block:: cpp
-
-     m.def("make_data", []{ return new Data(); }, nb::rv_policy::take_ownership);
-
-  The return value policy declaration could actually have been omitted here
-  because :cpp:enumerator:`take_ownership <rv_policy::take_ownership>` is the
-  default for *pointer return values* (see :cpp:enumerator:`automatic
-  <rv_policy::automatic>`).
-
-- :cpp:enumerator:`rv_policy::copy`:
-  Copy-construct a new Python object from the C++ instance. The copy will be
-  owned by Python, while C++ retains ownership of the original.
-
-  In the example below, a function uses this policy to return a reference to a
-  C++ instance. The owner and lifetime of such a reference may not be clear, so
-  the safest route is to make a copy.
-
-  .. code-block:: cpp
-
-     struct A {
-        B &b() { /* .. unknown code .. */ }
-     };
-
-     nb::class_<A>(m, "A")
-        .def("b", &A::b, nb::rv_policy::copy);
-
-  The return value policy declaration could actually have been omitted here
-  because :cpp:enumerator:`copy <rv_policy::copy>` is the default for *lvalue
-  reference* return values (see :cpp:enumerator:`automatic
-  <rv_policy::automatic>`).
-
-- :cpp:enumerator:`rv_policy::move`:
-  Move-construct a new Python object from the C++ instance. The new object will
-  be owned by Python, while C++ retains ownership of the original (whose
-  contents were likely invalidated by the move operation).
-
-  In the example below, a function uses this policy to return a C++ instance by
-  value. The :cpp:enumerator:`copy <rv_policy::copy>` operation mentioned above
-  would also be safe to use, but move construction has the potential of being
-  significantly more efficient.
-
-  .. code-block:: cpp
-
-     struct A {
-        B b() { return B(...); }
-     };
-
-     nb::class_<A>(m, "A")
-        .def("b", &A::b, nb::rv_policy::move);
-
-  The return value policy declaration could actually have been omitted here
-  because :cpp:enumerator:`move <rv_policy::move>` is the default for *functions
-  that return by value* (see :cpp:enumerator:`automatic
-  <rv_policy::automatic>`).
-
-- :cpp:enumerator:`rv_policy::reference`:
-  Create a thin Python object wrapper around the returned C++ instance without
-  making a copy, but *do not transfer ownership to Python*. nanobind will never
-  call the C++ ``delete`` operator, even when the wrapper expires.
-  The C++ side is responsible for destructing the C++ instance.
-
-  This return value policy is *dangerous* and should be used cautiously.
-  Undefined behavior will ensue when the C++ side deletes the instance while it
-  is still being used by Python. If you need to use this policy, combine it with
-  a :cpp:struct:`keep_alive` function binding annotation to manage the lifetime.
-  Or use the simple and safe :cpp:enumerator:`reference_internal
-  <rv_policy::reference_internal>` alternative described next.
-
-  Below is an example use of this return value policy to reference a
-  global variable that does not need ownership and lifetime management.
-
-  .. code-block:: cpp
-
-     Data data; // This is a global variable
-
-     m.def("get_data", []{ return &data; }, nb::rv_policy::reference)
-
-- :cpp:enumerator:`rv_policy::reference_internal`: A policy for *methods* that
-  expose an internal field. The lifetime of the field must match that of the
-  parent object.
-
-  The policy resembles :cpp:enumerator:`reference <rv_policy::reference>` in
-  that it creates creates a thin Python object wrapper around the returned C++
-  field without making a copy, and without transferring ownership to Python.
-
-  Furthermore, it ensures that the instance owning the field (implicit
-  ``this``/``self`` argument) cannot be garbage collected while an object
-  representing the field is alive.
-
-  The example below uses this policy to implement a *getter* that permits
-  mutable access to an internal field.
-
-  .. code-block:: cpp
-
-      struct MyClass {
-      public:
-          MyField &field() { return m_field; }
-
-      private:
-          MyField m_field;
-      };
-
-      nb::class_<MyClass>(m, "MyClass")
-         .def("field", &MyClass::field, nb::rv_policy::reference_internal);
-
-  More advanced variations of this scheme are also possible using combinations
-  of :cpp:enumerator:`reference <rv_policy::reference>` and the
-  :cpp:struct:`keep_alive` function binding annotation.
-
-- :cpp:enumerator:`rv_policy::none`: This is the most conservative policy: it
-  simply refuses the cast unless the C++ instance already has a corresponding
-  Python object, in which case the question of ownership becomes moot.
-
-- :cpp:enumerator:`rv_policy::automatic`: This is the default return value
-  policy, which falls back to :cpp:enumerator:`take_ownership
-  <rv_policy::automatic>` when the return value is a pointer,
-  :cpp:enumerator:`move <rv_policy::move>` when it is a rvalue reference, and
-  :cpp:enumerator:`copy <rv_policy::copy>` when it is a lvalue reference.
-
-- :cpp:enumerator:`rv_policy::automatic_reference`: This policy matches
-  :cpp:enumerator:`automatic <rv_policy::automatic>` but falls back to
-  :cpp:enumerator:`reference <rv_policy::refernece>` when the return value is a
-  pointer. It is the default for function arguments when calling Python
-  functions from C++ code via :cpp:func:`detail::api::operator()`. You probably
-  won't need to use this policy in your own code.
-
-.. _unique_ptr:
-
-Unique pointers
----------------
-
-Passing a STL unique pointer embodies an ownership transfer---a return value
-policy annotation is therefore not needed. To bind functions that receive or
-return ``std::unique_ptr<..>``, add the extra include directive
-
-.. code-block:: cpp
-
-   #include <nanobind/stl/unique_ptr.h>
-
-.. note::
-
-   While this this header file technically contains a :ref:`type caster
-   <type_casters>`, it is *not* affected by their usual limitations (mandatory
-   copy/conversion, inability to mutate function arguments).
-
-**Example**: The following example binds two functions that create and consume
-instances of a C++ type ``Data`` via unique pointers.
-
-.. code-block:: cpp
-
-   #include <nanobind/stl/unique_ptr.h>
-
-   namespace nb = nanobind;
-
-   NB_MODULE(my_ext, m) {
-       struct Data { };
-       nb::class_<Data>(m, "Data");
-       m.def("create", []() { return std::make_unique<Data>(); });
-       m.def("consume", [](std::unique_ptr<Data> x) { /* no-op */ });
-   }
-
-Calling a function taking a unique pointer from Python invalidates the passed
-Python object. nanobind will refuse further use of it:
-
-.. code-block:: pycon
-   :emphasize-lines: 8,9
-
-   Python 3.11.1 (main, Dec 23 2022, 09:28:24) [Clang 14.0.0 (clang-1400.0.29.202)] on darwin
-   Type "help", "copyright", "credits" or "license" for more information.
-   >>> import my_ext
-
-   >>> x = my_ext.create()
-   >>> my_ext.consume(x)
-
-   >>> my_ext.consume(x)
-   <stdin>:1: RuntimeWarning: nanobind: attempted to access an uninitialized instance of type 'my_ext.Data'!
-
-   TypeError: consume(): incompatible function arguments. The following argument types are supported:
-       1. consume(arg: my_ext.Data, /) -> None
-
-   Invoked with types: my_ext.Data
-
-We strongly recommend that you replace all use of ``std::unique_ptr<T>`` by
-``std::unique_ptr<T, nb::deleter<T>>`` in your code. Without the latter type
-declaration, which references a custom nanobind-provided deleter
-:cpp:class:`nb::deleter\<T\> <deleter>`,  nanobind cannot transfer ownership of
-objects constructed using :cpp:class:`nb::init\<...\> <init>` to C++ and will
-refuse to do so with an error message. Further detail on this special case can
-be found in the *advanced* :ref:`section <unique_ptr_adv>` on object ownership.
-
-.. _shared_ownership:
-
-Shared ownership
-----------------
-
-In a *shared ownership* model, an object can have multiple owners that each
-register their claim by holding a *reference*. The system keeps track of the
-total number of references and destroys the object once the count reaches zero.
-Passing such an object in a function call shares ownership between the caller
-and callee. nanobind makes this behavior seamless so that everything works
-regardless of whether caller/callee are written in C++ or Python.
-
-.. _shared_ptr:
-
-Shared pointers
-^^^^^^^^^^^^^^^
-
-STL shared pointers (``std::shared_ptr<T>``) allocate a separate control block to
-keep track of the reference count, which makes them very general but also slightly
-less efficient than other alternatives.
-
-nanobind's support for shared pointers requires an extra include directive:
-
-.. code-block:: cpp
-
-   #include <nanobind/stl/shared_ptr.h>
-
-.. note::
-
-   While this this header file technically contains a :ref:`type caster
-   <type_casters>`, it is *not* affected by their usual limitations (mandatory
-   copy/conversion, inability to mutate function arguments).
-
-You don't need to specify a return value policy annotation when a function
-returns a shared pointer.
-
-nanobind's implementation of ``std::shared_ptr`` support typically
-allocates a new ``shared_ptr`` control block each time a Python object
-must be converted to ``std::shared_ptr<T>``. The new ``shared_ptr``
-"owns" a reference to the Python object, and its deleter drops that
-reference.  This has the advantage that the Python portion of the
-object will be kept alive by its C++-side references (which is
-important when implementing C++ virtual methods in Python), but it can
-be inefficient when passing the same object back and forth between
-Python and C++ many times, and it means that the ``use_count()``
-method of ``std::shared_ptr`` will return a value that does not
-capture all uses. Some of these problems can be mitigated by modifying
-``T`` so that it inherits from ``std::enable_shared_from_this<T>``.
-See the :ref:`advanced section <shared_ptr_adv>` on object ownership
-for more details on the implementation.
-
-nanobind has limited support for objects that inherit from
-``std::enable_shared_from_this<T>`` to allow safe conversion of raw
-pointers to shared pointers. The safest way to deal with these objects
-is to always use ``std::make_shared<T>(...)`` when constructing them in C++,
-and always pass them across the Python/C++ boundary wrapped in an explicit
-``std::shared_ptr<T>``. If you do this, then there shouldn't be any
-surprises. If you will be passing raw ``T*`` pointers around, then
-read the :ref:`advanced section on object ownership <enable_shared_from_this>`
-for additional caveats.
-
-.. _intrusive_intro:
-
-Intrusive reference counting
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-Intrusive reference counting is the most flexible and efficient way of handling
-shared ownership. The main downside is that you must adapt the base class of
-your object hierarchy to the needs of nanobind.
-
-The core idea is to define base class (e.g. ``Object``) common to all bound
-types requiring shared ownership. That class contains a builtin atomic counter
-(e.g., ``m_ref_count``) and a Python object pointer (e.g., ``m_py_object``).
-
-.. code-block:: cpp
-
-   class Object {
-   ...
-   private:
-       mutable std::atomic<size_t> m_ref_count { 0 };
-       PyObject *m_py_object = nullptr;
-   };
-
-The core idea is that such ``Object`` instances can either be managed by C++ or
-Python. In the former case, the ``m_ref_count`` field keeps track of the number
-of outstanding references. In the latter case, reference counting is handled by
-Python, and the ``m_ref_count`` field remains unused.
-
-This is actually little wasteful---nanobind therefore ships with a more
-efficient reference counter sample implementation that supports both use cases
-while requiring only ``sizeof(void*)`` bytes of storage:
-
-.. code-block:: cpp
-
-   #include <nanobind/intrusive/counter.h>
-
-   class Object {
-   ...
-   private:
-       intrusive_counter m_ref_count;
-   };
-
-Please read the dedicated :ref:`section on intrusive reference counting
-<intrusive>` for more details on how to set this up.
diff --git a/src/nanobind/docs/ownership_adv.rst b/src/nanobind/docs/ownership_adv.rst
deleted file mode 100644
index bede697..0000000
--- a/src/nanobind/docs/ownership_adv.rst
+++ /dev/null
@@ -1,398 +0,0 @@
-.. _ownership_adv:
-
-.. cpp:namespace:: nanobind
-
-Object ownership, continued
-===========================
-
-This section covers intrusive reference counting as an alternative to shared
-pointers, and it explains the nitty-gritty details of how shared and unique
-pointer conversion is implemented in nanobind.
-
-.. _intrusive:
-
-Intrusive reference counting
-----------------------------
-
-nanobind provides a custom intrusive reference counting solution that
-completely solves the issue of shared C++/Python object ownership, while
-avoiding the overheads and complexities of traditional C++ shared pointers
-(``std::shared_ptr<T>``).
-
-The main limitation is that it requires adapting the base class of an object
-hierarchy according to the needs of nanobind, which may not always be possible.
-
-Motivation
-^^^^^^^^^^
-
-Consider the following simple class with intrusive reference counting:
-
-.. code-block:: cpp
-
-   class Object {
-   public:
-       void inc_ref() const noexcept { ++m_ref_count; }
-
-       void dec_ref() const noexcept {
-           if (--m_ref_count == 0)
-               delete this;
-       }
-
-   private:
-       mutable std::atomic<size_t> m_ref_count { 0 };
-   };
-
-It contains an atomic counter that stores the number of references. When the
-counter reaches zero, the object deallocates itself. Easy and efficient.
-
-The advantage of over ``std::shared_ptr<T>`` is that no separate control block
-must be allocated. Technical band-aids like ``std::enable_shared_from_this<T>``
-can also be avoided, since the reference count is always found in the object
-itself.
-
-However, one issue that tends to arise when a type like ``Object`` is
-wrapped using nanobind is that there are now *two* separate reference counts
-referring to the same object: one in Python’s ``PyObject``, and one in
-``Object``. This can lead to a problematic reference cycle:
-
-- Python’s ``PyObject`` needs to keep the ``Object`` instance alive so that it
-  can be safely passed to C++ functions.
-
-- The C++ ``Object`` may in turn need to keep the ``PyObject`` alive. This
-  is the case when a subclass uses *trampolines* (:c:macro:`NB_TRAMPOLINE`,
-  :c:macro:`NB_OVERRIDE`) to catch C++ virtual function calls and
-  potentially dispatch them to an overridden implementation in Python. In
-  this case, the C++ instance needs to be able to perform a function call on
-  its own Python object identity, which requires a reference.
-
-The source of the problem is that there are *two* separate counters that try
-to reason about the reference count of *one* instance, which leads to an
-uncollectable inter-language reference cycle.
-
-The solution
-^^^^^^^^^^^^
-We can solve the problem by using just one counter:
-
-- if an instance lives purely on the C++ side, the ``m_ref_count``
-  field is used to reason about the number of references.
-
-- The first time that an instance is exposed to Python (by being
-  created from Python, or by being returned from a bound C++ function),
-  lifetime management switches over to Python.
-
-The file `nanobind/intrusive/counter.h
-<https://github.com/wjakob/nanobind/blob/master/include/nanobind/intrusive/counter.h>`_
-includes an official sample implementation of this functionality. It contains an extra optimization to pack *either*
-a reference counter or a pointer to a ``PyObject*`` into a single
-``sizeof(void*)``-sized field.
-
-The most basic interface, :cpp:class:`intrusive_counter` represents an atomic
-counter that can be increased (via :cpp:func:`intrusive_counter::inc_ref()`) or
-decreased (via :cpp:func:`intrusive_counter::dec_ref()`). When the counter
-reaches zero, the object should be deleted, which ``dec_ref()`` indicates by
-returning ``true``.
-
-In addition to this simple counting mechanism, ownership of the object can also
-be transferred to Python (via :cpp:func:`intrusive_counter::set_self_py()`). In
-this case, subsequent calls to ``inc_ref()`` and ``dec_ref()`` modify the
-reference count of the underlying Python object. 
-
-To incorporate intrusive reference counting into your own project, you would
-usually add an :cpp:class:`intrusive_counter`-typed member to the base class of an object
-hierarchy and expose it as follows:
-
-.. code-block:: cpp
-
-   #include <nanobind/intrusive/counter.h>
-
-   class Object {
-   public:
-       void inc_ref() noexcept { m_ref_count.inc_ref(); }
-       bool dec_ref() noexcept { return m_ref_count.dec_ref(); }
-
-       // Important: must declare virtual destructor
-       virtual ~Object() = default;
-
-       void set_self_py(PyObject *self) noexcept {
-           m_ref_count.set_self_py(self);
-       }
-
-   private:
-       nb::intrusive_counter m_ref_count;
-   };
-
-   // Convenience function for increasing the reference count of an instance
-   inline void inc_ref(Object *o) noexcept {
-       if (o)
-          o->inc_ref();
-   }
-
-   // Convenience function for decreasing the reference count of an instance
-   // and potentially deleting it when the count reaches zero
-   inline void dec_ref(Object *o) noexcept {
-       if (o && o->dec_ref())
-           delete o;
-   }
-
-Alternatively, you could also inherit from :cpp:class:`intrusive_base`, which
-obviates the need for all of the above declarations:
-
-.. code-block:: cpp
-
-   class Object : public nb::intrusive_base {
-   public:
-       // ...
-   };
-
-The main change in the bindings is that the base class must specify a
-:cpp:class:`nb::intrusive_ptr <intrusive_ptr>` annotation to inform an instance
-that lifetime management has been taken over by Python. This annotation is
-automatically inherited by all subclasses. In the linked example, this is done
-via the ``Object::set_self_py()`` method that we can now call from the class
-binding annotation:
-
-.. code-block:: cpp
-
-   nb::class_<Object>(
-     m, "Object",
-     nb::intrusive_ptr<Object>(
-         [](Object *o, PyObject *po) noexcept { o->set_self_py(po); }));
-
-Also, somewhere in your binding initialization code, you must register Python
-reference counting hooks with the intrusive reference counter class. This
-allows its implementation of the code in ``nanobind/intrusive/counter.h`` to
-*not* depend on Python (this means that it can be used in projects where Python
-bindings are an optional component).
-
-.. code-block:: cpp
-
-   nb::intrusive_init(
-       [](PyObject *o) noexcept {
-           nb::gil_scoped_acquire guard;
-           Py_INCREF(o);
-       },
-       [](PyObject *o) noexcept {
-           nb::gil_scoped_acquire guard;
-           Py_DECREF(o);
-       });
-
-These ``counter.h`` include file references several functions that must be
-compiled somewhere inside the project, which can be accomplished by including
-the following file from a single ``.cpp`` file.
-
-.. code-block:: cpp
-
-   #include <nanobind/intrusive/counter.inl>
-
-Having to call :cpp:func:`inc_ref()` and :cpp:func:`dec_ref()` many times to
-perform manual reference counting in project code can quickly become tedious.
-Nanobind also ships with a :cpp:class:`ref\<T\> <ref>` RAII helper class to
-help with this.
-
-.. code-block:: cpp
-
-   #include <nanobind/intrusive/ref.h>
-
-   void foo() {
-       /// Assignment to ref<T> automatically increases the object's reference count
-       ref<MyObject> x = new MyObject();
-
-       // ref<T> can be used like a normal pointer
-       x->func();
-
-   } // <-- ref::~ref() calls dec_ref(), which deletes the now-unreferenced instance
-
-When the file ``nanobind/intrusive/ref.h`` is included following
-``nanobind/nanobind.h``, it also exposes a custom type caster to bind functions
-taking or returning ``ref<T>``-typed values.
-
-That's it. If you use this approach, any potential issues involving shared
-pointers, return value policies, reference leaks with trampolines, etc., can
-be avoided from the beginning.
-
-.. _shared_ptr_adv:
-
-Shared pointers, continued
---------------------------
-
-The following continues the :ref:`discussion of shared pointers <shared_ptr>`
-in the introductory section on object ownership and provides detail on how
-shared pointer conversion is *implemented* by nanobind.
-
-When the user calls a C++ function taking an argument of type
-``std::shared_ptr<T>`` from Python, ownership of that object must be
-shared between C++ to Python. nanobind does this by increasing the reference
-count of the ``PyObject`` and then creating a ``std::shared_ptr<T>`` with a new
-control block containing a custom deleter that will in turn reduce the Python
-reference count upon destruction of the shared pointer.
-
-When a C++ function returns a ``std::shared_ptr<T>``, nanobind
-checks if the instance already has a ``PyObject`` counterpart
-(nothing needs to be done in this case). Otherwise, it indicates
-shared ownership by creating a temporary ``std::shared_ptr<T>`` on
-the heap that will be destructed when the ``PyObject`` is garbage
-collected.
-
-The approach in nanobind was chosen following on discussions with `Ralf
-Grosse-Kunstleve <https://github.com/rwgk>`_; it is unusual in that multiple
-``shared_ptr`` control blocks are potentially allocated for the same object,
-which means that ``std::shared_ptr<T>::use_count()`` generally won’t show the
-true global reference count.
-
-.. _enable_shared_from_this:
-
-enable_shared_from_this
-^^^^^^^^^^^^^^^^^^^^^^^
-
-The C++ standard library class ``std::enable_shared_from_this<T>``
-allows an object that inherits from it to locate an existing
-``std::shared_ptr<T>`` that manages that object. nanobind supports
-types that inherit from ``enable_shared_from_this``, with some caveats
-described in this section.
-
-Background (not nanobind-specific): Suppose a type ``ST`` inherits
-from ``std::enable_shared_from_this<ST>``. When a raw pointer ``ST
-*obj`` or ``std::unique_ptr<ST> obj`` is wrapped in a shared pointer
-using a constructor of the form ``std::shared_ptr<ST>(obj, ...)``, a
-reference to the new ``shared_ptr``\'s control block is saved (as
-``std::weak_ptr<ST>``) inside the object. This allows new
-``shared_ptr``\s that share ownership with the existing one to be
-obtained for the same object using ``obj->shared_from_this()`` or
-``obj->weak_from_this()``.
-
-nanobind's support for ``std::enable_shared_from_this`` consists of three
-behaviors:
-
-* If a raw pointer ``ST *obj`` is returned from C++ to Python, and
-  there already exists an associated ``std::shared_ptr<ST>`` which
-  ``obj->shared_from_this()`` can locate, then nanobind will produce a
-  Python instance that shares ownership with it. The behavior is
-  identical to what would happen if the C++ code did ``return
-  obj->shared_from_this();`` (returning an explicit
-  ``std::shared_ptr<ST>`` to Python) rather than ``return obj;``.
-  The return value policy has limited effect in this case; you will get
-  shared ownership on the Python side regardless of whether you used
-  `rv_policy::take_ownership` or `rv_policy::reference`.
-  (`rv_policy::copy` and `rv_policy::move` will still create a new
-  object that has no ongoing relationship to the returned pointer.)
-
-  * Note that this behavior occurs only if such a ``std::shared_ptr<ST>``
-    already exists! If not, then nanobind behaves as it would without
-    ``enable_shared_from_this``: a raw pointer will transfer exclusive
-    ownership to Python by default, or will create a non-owning reference
-    if you use `rv_policy::reference`.
-
-* If a Python object is passed to C++ as ``std::shared_ptr<ST> obj``,
-  and there already exists an associated ``std::shared_ptr<ST>`` which
-  ``obj->shared_from_this()`` can locate, then nanobind will produce a
-  ``std::shared_ptr<ST>`` that shares ownership with it: an additional
-  reference to the same control block, rather than a new control block
-  (as would occur without ``enable_shared_from_this``). This improves
-  performance and makes the result of ``shared_ptr::use_count()`` more
-  accurate.
-
-* If a Python object is passed to C++ as ``std::shared_ptr<ST> obj``, and
-  there is no associated ``std::shared_ptr<ST>`` that
-  ``obj->shared_from_this()`` can locate, then nanobind will produce
-  a ``std::shared_ptr<ST>`` as usual (with a new control block whose deleter
-  drops a Python object reference), *and* will do so in a way that enables
-  future calls to ``obj->shared_from_this()`` to find it as long
-  as any ``shared_ptr`` that shares this control block is still alive on
-  the C++ side.
-
-  (Once all of the ``std::shared_ptr<ST>``\s that share this control block
-  have been destroyed, the underlying PyObject reference being
-  managed by the ``shared_ptr`` deleter will be dropped,
-  and ``shared_from_this()`` will stop working. It can be reenabled by
-  passing the Python object back to C++ as ``std::shared_ptr<ST>`` once more,
-  which will create another control block.)
-
-Bindings for a class that supports ``enable_shared_from_this`` will be
-slightly larger than bindings for a class that doesn't, as nanobind
-must produce type-specific code to implement the above behaviors.
-
-.. warning:: The ``shared_from_this()`` method will only work when there
-   is actually a ``std::shared_ptr`` managing the object. A nanobind
-   instance constructed from Python will not have an associated
-   ``std::shared_ptr`` yet, so ``shared_from_this()`` will throw an
-   exception if you pass such an instance to C++ using a reference or
-   raw pointer. ``shared_from_this()`` will only work when there exists
-   a corresponding live ``std::shared_ptr`` on the C++ side.
-
-   The only situation where nanobind will create the first
-   ``std::shared_ptr`` for an object (thus enabling
-   ``shared_from_this()``), even with ``enable_shared_from_this``, is
-   when a Python instance is passed to C++ as the explicit type
-   ``std::shared_ptr<T>``. If you don't do this, or if no such
-   ``std::shared_ptr`` is still alive, then ``shared_from_this()`` will
-   throw an exception. It also works to create the ``std::shared_ptr``
-   on the C++ side, such as by using a factory function which always
-   uses ``std::make_shared<T>(...)`` to construct the object, and
-   returns the resulting ``std::shared_ptr<T>`` to Python.
-
-If you need to enable ``shared_from_this`` immediately upon
-regular Python-side object construction (i.e., ``SomeType(*args)``
-rather than ``SomeType.some_fn(*args)``), you can bind a C++ function
-that returns ``std::shared_ptr<T>`` as your class's ``__new__`` method.
-See the documentation on :ref:`customizing object creation <custom_new>`.
-
-.. warning:: C++ code that receives a raw pointer ``T *obj`` *must not*
-   assume that it has exclusive ownership of ``obj``, or even that
-   ``obj`` is allocated on the C++ heap (via ``operator new``);
-   ``obj`` might instead be a subobject of a nanobind instance
-   allocated from Python. This applies even if ``T`` supports
-   ``shared_from_this()`` and there is no associated
-   ``std::shared_ptr``. Lack of a ``shared_ptr`` does *not* imply
-   exclusive ownership; it just means there's no way to share ownership
-   with whoever the current owner is.
-
-.. _unique_ptr_adv:
-
-Unique pointers
----------------
-
-The following continues the :ref:`discussion of unique pointers <unique_ptr>`
-in the introductory section on object ownership and provides detail on how
-unique pointer conversion is *implemented* by nanobind.
-
-Whereas ``std::shared_ptr<..>`` could abstract over details concerning
-storage and the deletion mechanism, this is not possible in the simpler
-``std::unique_ptr<..>``, which means that some of those details leak into
-the type signature.
-
-When the user calls a C++ function taking an argument of type ``std::unique_ptr<T,
-Deleter>`` from Python, ownership of that object must be transferred from C++ to Python.
-
-- When ``Deleter`` is ``std::default_delete<T>`` (i.e., the default
-  when no ``Deleter`` is specified), this ownership transfer is only
-  possible when the instance was originally created by a *new expression*
-  within C++ and nanobind has taken over ownership (i.e., it was created by
-  a function returning a raw pointer ``T *value`` with
-  :cpp:enumerator:`rv_policy::take_ownership`, or a function returning a
-  ``std::unique_ptr<T>``). This limitation exists because the ``Deleter``
-  will execute the statement ``delete value`` when the unique pointer
-  expires, causing undefined behavior when the object was allocated within
-  Python (the problem here is that nanobind uses the Python memory allocator
-  and furthermore co-locates Python and C++ object storage. A *delete
-  expression* cannot be used in such a case). nanobind detects this, refuses
-  unsafe conversions with a ``TypeError`` and emits a separate warning.
-
-- To enable ownership transfer under all conditions, nanobind
-  provides a custom ``Deleter`` named :cpp:class:`nb::deleter\<T\>
-  <deleter>` that uses reference counting to keep the underlying
-  ``PyObject`` alive during the lifetime of the unique pointer. Following
-  this route requires changing function signatures so that they use
-  ``std::unique_ptr<T, nb::deleter<T>>`` instead of ``std::unique_ptr<T>``.
-  This custom deleter supports ownership by both C++ and Python and can be
-  used in all situations.
-
-In both cases, a Python object may continue to exist after ownership was
-transferred to C++ side. nanobind marks this object as *invalid*: any
-operations involving it will fail with a ``TypeError``. Reverse ownership
-transfer at a later point will make it usable again.
-
-Binding functions that return a ``std::unique_ptr<T, Deleter>`` always
-works: nanobind will then acquire or reacquire ownership of the object.
-
-Deleters other than ``std::default_delete<T>`` or ``nb::deleter<T>`` are
-*not supported*.
diff --git a/src/nanobind/docs/packaging.rst b/src/nanobind/docs/packaging.rst
deleted file mode 100644
index 95d949d..0000000
--- a/src/nanobind/docs/packaging.rst
+++ /dev/null
@@ -1,332 +0,0 @@
-.. _packaging:
-
-Packaging
-=========
-
-A Python *wheel* is a self-contained binary file that bundles Python code and
-extension libraries along with metadata such as versioned package dependencies.
-Wheels are easy to download and install, and they are the recommended mechanism
-for distributing extensions created using nanobind.
-
-This section walks through the recommended sequence of steps to build wheels
-and optionally automate this process to simultaneously target many platforms
-(Linux, Windows, macOS) and processors (i386, x86_64, arm64) using the `GitHub
-Actions <https://github.com/features/actions>`__ CI service.
-
-Note that all of the recommended practices have already been implemented in the
-`nanobind_example repository <https://github.com/wjakob/nanobind_example>`_,
-which is a minimal C++ project with nanobind-based bindings. You may therefore
-prefer to clone this repository and modify its contents.
-
-Step 1: Overview
-----------------
-
-The example project has a simple directory structure:
-
-.. code-block:: text
-
-   ├── README.md
-   ├── CMakeLists.txt
-   ├── pyproject.toml
-   └── src/
-       ├── my_ext.cpp
-       └── my_ext/
-           └── __init__.py
-
-The file ``CMakeLists.txt`` contains the C++-specifics part of the build
-system, while ``pyproject.toml`` explains how to turn the example into a wheel.
-The file ``README.md`` should ideally explain how to use the project in more
-detail. Its contents are arbitrary, but the file must exist for the following
-build system to work.
-
-All source code is located in a ``src`` directory containing the Python package
-as a subdirectory.
-
-Compilation will turn ``my_ext.cpp`` into a shared library in the package
-directory, which has an underscored platform-dependent name (e.g.,
-``_my_ext_impl.cpython-311-darwin.so``) to indicate that it is an
-implementation detail. The ``src/my_ext/__init__.py`` imports the extension and
-exposes relevant functionality. In this small example project, it only contains
-a single line:
-
-.. code-block:: python
-
-   from ._my_ext_impl import hello
-
-The file ``src/my_ext.cpp`` contains minimal bindings for an example function:
-
-.. code-block:: cpp
-
-   #include <nanobind/nanobind.h>
-
-   NB_MODULE(_my_ext_impl, m) {
-       m.def("hello", []() { return "Hello world!"; });
-   }
-
-The next two steps will set up the infrastructure needed for wheel generation.
-
-Step 2: Specify build dependencies and metadata
------------------------------------------------
-
-In the root directory of the project, create a file named ``pyproject.toml``
-listing *build-time dependencies*. Note that runtime dependencies *do not* need
-to be added here. The following core dependencies are required by nanobind:
-
-.. code-block:: toml
-
-   [build-system]
-   requires = ["scikit-build-core >=0.4.3", "nanobind >=1.3.2"]
-   build-backend = "scikit_build_core.build"
-
-You may need to increase the minimum nanobind version in the above snippet if
-you are using features from versions newer than 1.3.2.
-
-Just below the list of build-time requirements, specify project metadata including:
-
-- The project's name (which must be a valid package name)
-- The version number
-- A brief (1-line) description of the project
-- The name of a more detailed README file
-- The list of authors with email addresses.
-- The software license
-- The project web page
-- Runtime dependencies, if applicable
-
-An example is shown below:
-
-.. code-block:: toml
-
-   [project]
-   name = "my_ext"
-   version = "0.0.1"
-   description = "A brief description of what this project does"
-   readme = "README.md"
-   requires-python = ">=3.8"
-   authors = [
-       { name = "Your Name", email = "your.email@address.com" },
-   ]
-   classifiers = [
-       "License :: BSD",
-   ]
-   # Optional: runtime dependency specification
-   # dependencies = [ "cryptography >=41.0" ]
-
-   [project.urls]
-   Homepage = "https://github.com/your/project"
-
-We will use `scikit-build-core
-<https://github.com/scikit-build/scikit-build-core>`__ to build wheels, and
-this tool also has its own configuration block in ``pyproject.toml``. The
-following defaults are recommended:
-
-.. code-block:: toml
-
-   [tool.scikit-build]
-   # Protect the configuration against future changes in scikit-build-core
-   minimum-version = "0.4"
-
-   # Setuptools-style build caching in a local directory
-   build-dir = "build/{wheel_tag}"
-
-   # Build stable ABI wheels for CPython 3.12+
-   wheel.py-api = "cp312"
-
-Step 3: Set up a CMake build system
------------------------------------
-
-Next, we will set up a suitable ``CMakeLists.txt`` file in the root directory.
-Since this build system is designed to be invoked through
-``scikit-build-core``, it does not make sense to perform a standalone CMake
-build. The message at the top warns users attempting to do this.
-
-.. code-block:: cmake
-
-   # Set the minimum CMake version and policies for highest tested version
-   cmake_minimum_required(VERSION 3.15...3.27)
-
-   # Set up the project and ensure there is a working C++ compiler
-   project(my_ext LANGUAGES CXX)
-
-   # Warn if the user invokes CMake directly
-   if (NOT SKBUILD)
-     message(WARNING "\
-     This CMake file is meant to be executed using 'scikit-build-core'.
-     Running it directly will almost certainly not produce the desired
-     result. If you are a user trying to install this package, use the
-     command below, which will install all necessary build dependencies,
-     compile the package in an isolated environment, and then install it.
-     =====================================================================
-      $ pip install .
-     =====================================================================
-     If you are a software developer, and this is your own package, then
-     it is usually much more efficient to install the build dependencies
-     in your environment once and use the following command that avoids
-     a costly creation of a new virtual environment at every compilation:
-     =====================================================================
-      $ pip install nanobind scikit-build-core[pyproject]
-      $ pip install --no-build-isolation -ve .
-     =====================================================================
-     You may optionally add -Ceditable.rebuild=true to auto-rebuild when
-     the package is imported. Otherwise, you need to rerun the above
-     after editing C++ files.")
-   endif()
-
-Next, import Python and nanobind including the ``Development.SABIModule``
-component that can be used to create `stable ABI
-<https://docs.python.org/3/c-api/stable.html>`__ builds.
-
-.. code-block:: cmake
-
-   # Try to import all Python components potentially needed by nanobind
-   find_package(Python 3.8
-     REQUIRED COMPONENTS Interpreter Development.Module
-     OPTIONAL_COMPONENTS Development.SABIModule)
-
-   # Import nanobind through CMake's find_package mechanism
-   find_package(nanobind CONFIG REQUIRED)
-
-The last two steps build and install the actual extension
-
-.. code-block:: cmake
-
-    # We are now ready to compile the actual extension module
-    nanobind_add_module(
-      # Name of the extension
-      _my_ext_impl
-
-      # Target the stable ABI for Python 3.12+, which reduces
-      # the number of binary wheels that must be built. This
-      # does nothing on older Python versions
-      STABLE_ABI
-
-      # Source code goes here
-      src/my_ext.cpp
-    )
-
-    # Install directive for scikit-build-core
-    install(TARGETS _my_ext_impl LIBRARY DESTINATION my_ext)
-
-
-Step 4: Install the package locally
------------------------------------
-
-To install the package, run
-
-.. code-block:: bash
-
-   $ cd <project-directory>
-   $ pip install .
-
-``pip`` will parse the ``pyproject.toml`` file and create a fresh environment
-containing all needed dependencies. Following this, you should be able to
-install and access the extension.
-
-.. code-block:: python
-
-   >>> import my_ext
-   >>> my_ext.hello()
-   'Hello world!'
-
-Alternatively, you can use the following command to generate a ``.whl`` file
-instead of installing the package.
-
-.. code-block:: bash
-
-   $ pip wheel .
-
-Step 5: Incremental rebuilds
-----------------------------
-
-The ``pip install`` and ``pip wheel`` commands are extremely conservative to
-ensure reproducible builds. They create a pristine virtual environment and
-install build-time dependencies before compiling the extension *from scratch*.
-
-It can be frustrating to wait for this lengthy sequence of steps after every
-small change to a source file during the active development phase of a project.
-To avoid this, first install the project's build dependencies, e.g.:
-
-.. code-block:: bash
-
-   $ pip install nanobind scikit-build-core[pyproject]
-
-Next, install the project without build isolation to enable incremental builds:
-
-.. code-block:: bash
-
-   $ pip install --no-build-isolation -ve .
-
-This command will need to be run after every change to reinstall the updated package.
-For an even more interactive experience, use
-
-.. code-block:: bash
-
-   $ pip install --no-build-isolation -Ceditable.rebuild=true -ve .
-
-This will automatically rebuild any code (if needed) whenever the ``my_ext``
-package is imported into a Python session.
-
-Step 6: Build wheels in the cloud
----------------------------------
-
-On my machine, the ``pip wheel`` command produces a file named
-``my_ext-0.0.1-cp311-cp311-macosx_13_0_arm64.whl`` that is specific to Python
-3.11 running on an arm64 macOS machine. Other Python versions and operating
-systems each require their own wheels, which leads to a dauntingly large build
-matrix (though nanobind's stable ABI support will help to significantly reduce
-the size of this matrix once Python 3.12 is more widespread). 
-
-Rather than building these wheels manually on different machines, it is far
-more efficient to use GitHub actions along with the powerful `cibuildwheel
-<https://cibuildwheel.readthedocs.io/en/stable/>`__ package to fully automate
-the process.
-
-To do so, create a file named ``.github/workflows/wheels.yml`` containing
-the contents of the `following file
-<https://github.com/wjakob/nanobind_example/blob/master/.github/workflows/wheels.yml>`__.
-You may want to remove the ``on: push:`` lines, otherwise, the action will run
-after every commit, which is perhaps a bit excessive. In this case, you can
-still trigger the action manually on the *Actions* tab of the GitHub project
-page.
-
-Furthermore, append the following ``cibuildwheel``-specific configuration to
-``pyproject.toml``:
-
-.. code-block:: toml
-
-    [tool.cibuildwheel]
-    # Necessary to see build output from the actual compilation
-    build-verbosity = 1
-
-    # Optional: run pytest to ensure that the package was correctly built
-    # test-command = "pytest {project}/tests"
-    # test-requires = "pytest"
-
-    # Needed for full C++17 support on macOS
-    [tool.cibuildwheel.macos.environment]
-    MACOSX_DEPLOYMENT_TARGET = "10.14"
-
-Following each run, the action provides a downloadable *build artifact*, which
-is a ZIP file containing all the individual wheel files for each platform.
-
-By default, ``cibuildwheel`` will launch a very large build matrix, and it is
-possible that your extension is not compatible with every single configuration.
-For example, suppose that the project depends on Python 3.9+ and a 64 bit
-processor. In this case, add further entries to the ``[tool.cibuildwheel]``
-block to remove incompatible configurations from the matrix:
-
-.. code-block:: toml
-
-    skip = ["cp38-*", "pp38-*"] # Skip CPython and PyPy 3.8
-    archs = ["auto64"]          # Only target 64 bit architectures
-
-The `cibuildwheel documentation
-<https://cibuildwheel.readthedocs.io/en/stable/options/>`__ explains the
-possible options.
-
-If you set up a GitHub actions `secret
-<https://docs.github.com/en/actions/security-guides/encrypted-secrets>`__ named
-``pypi_password`` containing a PyPI authentication token, the action will
-automatically upload the generated wheels to the `Python Package Index (PyPI)
-<https://pypi.org>`__ when the action is triggered by a `software release event
-<https://docs.github.com/en/repositories/releasing-projects-on-github/managing-releases-in-a-repository>`__.
-
diff --git a/src/nanobind/docs/porting.rst b/src/nanobind/docs/porting.rst
deleted file mode 100644
index 832b7ae..0000000
--- a/src/nanobind/docs/porting.rst
+++ /dev/null
@@ -1,360 +0,0 @@
-.. cpp:namespace:: nanobind
-
-.. _porting:
-
-Porting guide
-=============
-
-The API of nanobind is *extremely* similar to that of `pybind11
-<https://pybind11.readthedocs.io/en/stable/>`_, which makes porting existing
-projects easy. Parts of the nanobind documentation are almost verbatim copies
-pybind11's documentation.
-
-A number of noteworthy changes are documented below.
-
-Namespace
----------
-
-nanobind types and functions are located in the ``nanobind`` namespace. The
-following shorthand alias is recommended and used throughout the documentation:
-
-.. code-block:: cpp
-
-   namespace nb = nanobind;
-
-Name changes
-------------
-
-The following macros, types, and functions were renamed:
-
-.. list-table::
-  :widths: 42 48
-  :header-rows: 1
-
-  * - pybind11
-    - nanobind
-
-  * - ``PYBIND11_MODULE(..)``
-    - :c:macro:`NB_MODULE(..) <NB_MODULE>`
-  * - ``PYBIND11_OVERRIDE_*(..)``
-    - :c:macro:`NB_OVERRIDE_*(..) <NB_OVERRIDE>`
-  * - ``error_already_set``
-    - :cpp:class:`python_error`
-  * - ``type::of<T>()``
-    - :cpp:func:`type\<T\>() <type>`
-  * - ``type``
-    - :cpp:class:`type_object`
-  * - ``reinterpret_borrow<T>(x)``
-    - :cpp:func:`borrow\<T\>(x) <borrow>`
-  * - ``reinterpret_steal<T>(x)``
-    - :cpp:func:`steal\<T\>(x) <steal>`
-  * - ``.def_readwrite(..)``
-    - :cpp:func:`.def_rw(..) <class_::def_rw>`
-  * - ``.def_readonly(..)``
-    - :cpp:func:`.def_ro(..) <class_::def_ro>`
-  * - ``.def_property(..)``
-    - :cpp:func:`.def_prop_rw(..) <class_::def_prop_rw>`
-  * - ``.def_property_readonly(..)``
-    - :cpp:func:`.def_prop_ro(..) <class_::def_prop_ro>`
-  * - ``.def_readwrite_static(..)``
-    - :cpp:func:`.def_rw_static(..) <class_::def_rw_static>`
-  * - ``.def_readonly_static(..)``
-    - :cpp:func:`.def_ro_static(..) <class_::def_ro_static>`
-  * - ``.def_property_static(..)``
-    - :cpp:func:`.def_prop_rw_static(..) <class_::def_prop_rw_static>`
-  * - ``.def_property_readonly_static(..)``
-    - :cpp:func:`.def_prop_ro_static(..) <class_::def_prop_ro_static>`
-  * - ``register_exception<T>``
-    - :cpp:class:`exception\<T\> <exception>`
-
-
-None/null arguments
--------------------
-
-In contrast to pybind11, nanobind does *not* permit ``None``-valued function
-arguments by default. You must enable them explicitly using the
-:cpp:func:`arg::none() <arg::none>` argument annotation, e.g.:
-
-.. code-block:: cpp
-
-   m.def("func", &func, "arg"_a.none());
-
-It is also possible to set a ``None`` default value, in which case the
-:cpp:func:`.none() <arg::none>` annotation can be omitted.
-
-.. code-block:: cpp
-
-   m.def("func", &func, "arg"_a = nb::none());
-
-``None``-valued arguments are only supported by two of the three parameter
-passing styles described in the section on :ref:`information exchange
-<exchange>`. In particular, they are supported by :ref:`bindings <bindings>`
-and :ref:`wrappers <wrappers>`, *but not* by :ref:`type casters
-<type_casters>`.
-
-Shared pointers and holders
----------------------------
-
-When nanobind instantiates a C++ type within Python, the resulting instance
-data is stored *within* the created Python object ("``PyObject``").
-Alternatively, when an already existing C++ instance is transferred to Python
-via a function return value and :cpp:enumerator:`rv_policy::reference`,
-:cpp:enumerator:`rv_policy::reference_internal`, or
-:cpp:enumerator:`rv_policy::take_ownership`, nanobind creates a smaller wrapper
-``PyObject`` that only stores a pointer to the instance data.
-
-This is *very different* from pybind11, where the instance ``PyObject``
-contained a *holder type* (typically ``std::unique_ptr<T>``) storing a pointer
-to the instance data. Dealing with holders caused inefficiencies and introduced
-complexity; they were therefore removed in nanobind. This has implications on
-object ownership, shared ownership, and interactions with C++ shared/unique
-pointers. The :ref:`intermediate <ownership>` and :ref:`advanced
-<ownership_adv>` sections on object ownership provide further detail.
-
-The gist is that it is no longer necessary to specify holder types in the type
-declaration:
-
-*pybind11*:
-
-.. code-block:: cpp
-
-   py::class_<MyType, std::shared_ptr<MyType>>(m, "MyType")
-
-*nanobind*:
-
-.. code-block:: cpp
-
-   nb::class_<MyType>(m, "MyType")
-
-To bind functions that exchange shared/unique pointers, you must add one or
-both of the following include directives to your code:
-
-.. code-block:: cpp
-
-   #include <nanobind/stl/unique_ptr.h>
-   #include <nanobind/stl/shared_ptr.h>
-
-Binding functions that take ``std::unique_ptr<T>`` arguments involves some
-limitations that can be avoided by changing their signatures to
-``std::unique_ptr<T, nb::deleter<T>>`` (:ref:`details <unique_ptr>`).
-
-Use of ``std::enable_shared_from_this<T>`` is permitted, but since
-nanobind does not use holder types, an object
-constructed in Python will typically not have any associated
-``std::shared_ptr<T>`` until it is passed to a C++ function that
-accepts ``std::shared_ptr<T>``. That means a C++ function that accepts
-a raw ``T*`` and calls ``shared_from_this()`` on it might stop working
-when ported from pybind11 to nanobind. You can solve this problem
-by always passing such objects across the Python/C++ boundary as
-``std::shared_ptr<T>`` rather than as ``T*``. See the :ref:`advanced section
-on object ownership <enable_shared_from_this>` for more details.
-
-Custom constructors
--------------------
-In pybind11, custom constructors (i.e. ones that do not already exist in the
-C++ class) could be specified as a lambda function returning an instance of
-the desired type.
-
-.. code-block:: cpp
-
-   py::class_<MyType>(m, "MyType")
-       .def(py::init([](int) { return MyType(...); }));
-
-Unfortunately, the implementation of this feature was quite complex and
-often required further internal calls to the move or copy
-constructor. nanobind instead reverts to how pybind11 originally
-implemented this feature using in-place construction (`placement
-new <https://en.wikipedia.org/wiki/Placement_syntax>`_):
-
-.. code-block:: cpp
-
-   nb::class_<MyType>(m, "MyType")
-       .def("__init__", [](MyType *t) { new (t) MyType(...); });
-
-The provided lambda function will be called with a pointer to uninitialized
-memory that has already been allocated (this memory region is co-located
-with the Python object for reasons of efficiency). The lambda function can
-then either run an in-place constructor and return normally (in which case
-the instance is assumed to be correctly constructed) or fail by raising an
-exception.
-
-To turn an existing factory function into a constructor, you will need to
-combine the above pattern with an invocation of the move/copy-constructor,
-e.g.:
-
-.. code-block:: cpp
-
-   nb::class_<MyType>(m, "MyType")
-       .def("__init__", [](MyType *t) { new (t) MyType(MyType::create()); });
-
-Implicit conversions
---------------------
-
-In pybind11, implicit conversions were specified using a follow-up function
-call. This also works in nanobind, but it is recommended that you already
-specify them within the constructor declaration:
-
-*pybind11*:
-
-.. code-block:: cpp
-
-   py::class_<MyType>(m, "MyType")
-       .def(py::init<MyOtherType>());
-
-   py::implicitly_convertible<MyOtherType, MyType>();
-
-*nanobind*:
-
-.. code-block:: cpp
-
-   nb::class_<MyType>(m, "MyType")
-       .def(nb::init_implicit<MyOtherType>());
-
-
-Trampoline classes
-------------------
-Trampolines, i.e., polymorphic class implementations that forward virtual
-function calls to Python, now require an extra :c:macro:`NB_TRAMPOLINE(parent,
-size) <NB_TRAMPOLINE()>` declaration, where ``parent`` refers to the parent class
-and ``size`` is at least as big as the number of :c:macro:`NB_OVERRIDE_*() <NB_OVERRIDE>`
-calls. nanobind caches information to enable efficient function dispatch, for
-which it must know the number of trampoline "slots".
-
-The macro ``PYBIND11_OVERRIDE_*(..)`` required the base type and return value
-as the first two arguments. This information is no longer needed in nanobind,
-and the arguments should be removed in :c:macro:`NB_OVERRIDE_*()
-<NB_OVERRIDE>`:
-
-An example:
-
-.. code-block:: cpp
-
-   struct PyAnimal : Animal {
-       NB_TRAMPOLINE(Animal, 1);
-
-       std::string name() const override {
-           NB_OVERRIDE(name);
-       }
-   };
-
-Trampoline declarations with an insufficient size may eventually trigger a
-Python ``RuntimeError`` exception with a descriptive label, e.g.:
-
-.. code-block:: text
-
-   nanobind::detail::get_trampoline('PyAnimal::what()'): the trampoline ran out of
-   slots (you will need to increase the value provided to the NB_TRAMPOLINE() macro)
-
-Iterator bindings
------------------
-
-Use of the :cpp:func:`nb::make_iterator() <make_iterator>`,
-:cpp:func:`nb::make_key_iterator() <make_key_iterator>`, and
-:cpp:func:`nb::make_value_iterator() <make_value_iterator>` functions requires
-including the additional header file ``nanobind/make_iterator.h``. The
-interface of these functions has also slightly changed: all take a Python scope
-and a name as first and second arguments, which are used to permanently
-"install" the iterator type (which is created on demand). See the `test suite
-<https://github.com/wjakob/nanobind/blob/master/tests/test_make_iterator.cpp>`_
-for a worked out example.
-
-Type casters
-------------
-
-The API of custom type casters has changed *significantly*. The following
-changes are needed:
-
-- ``load()`` was renamed to ``from_python()``. The function now takes an extra
-  ``uint8_t flags`` parameter (instead ``bool convert``, which is now
-  represented by the flag ``nb::detail::cast_flags::convert``). A
-  ``cleanup_list *`` pointer keeps track of Python temporaries that are created
-  by the conversion, and which need to be deallocated after a function call has
-  taken place.
-
-  ``flags`` and ``cleanup`` should be passed to any recursive usage of
-  ``type_caster::from_python()``. If casting fails due to a Python exception,
-  the function should clear it (``PyErr_Clear()``) and return ``false``. If a
-  severe error condition arises that should be reported, use Python warning API
-  calls for this, e.g. ``PyErr_WarnFormat()``.
-
-- ``cast()`` was renamed to ``from_cpp()``. The function takes a return value
-  policy (as before) and a ``cleanup_list *`` pointer. If casting fails due to
-  a Python exception, the function should *leave the error set* (note the
-  asymmetry compared to ``from_python()``) and return ``nullptr``.
-
-Note that the cleanup list is only available when ``from_python()`` or
-``from_cpp()`` are called as part of function dispatch, while usage by
-:cpp:func:`nb::cast() <cast>` may set ``cleanup`` to ``nullptr`` if implicit
-conversions are not enabled. This case should be handled gracefully by refusing
-the conversion if the cleanup list is absolutely required.
-
-Type casters may not raise C++ exceptions. Both ``from_python()`` and
-``from_cpp()`` must be annotated with ``noexcept``. Exceptions or failure
-conditions caused by a conversion should instead be caught *within* the
-function body and handled as follows:
-
-- ``from_python()``: return ``false``. That's it. (Failed Python to C++
-  conversion occur all the time while dispatching calls, causing nanobind
-  to simply move to the next function overload. Dedicated error reporting would
-  add undesirable overheads). In case of a severe internal error, use the
-  CPython warning API (e.g., ``PyErr_Warn()``) to notify the user.
-
-- ``from_cpp()``: a failure here is more serious, since a return value of a
-  successfully evaluated cannot be converted, causing the call to fail. To
-  provide further detail, use the CPython error API (e.g., ``PyErr_Format()``)
-  and return an invalid handle (``return nb::handle();``).
-
-The ``std::pair<T1, T2>`` type caster (`link
-<https://github.com/wjakob/nanobind/blob/master/include/nanobind/stl/pair.h>`_)
-may be useful as a starting point of custom implementations.
-
-.. _removed:
-
-Removed features
-----------------
-
-A number of pybind11 features are unavailable in nanobind. The list below
-uses the following symbols:
-
-- ○: This removal is a design choice. Use pybind11 if you need this feature.
-- ●: Unclear, to be discussed.
-
-Removed features include:
-
-- ○ **Multiple inheritance**: this feature was a persistent source of
-  complexity in pybind11 and it is one of the main casualties in creating
-  nanobind.
-- ○ **Holders**: nanobind instances co-locate instance data with a Python
-  object instead of accessing it via a holder type. This is a major difference
-  compared to pybind11 and will require changes to binding code that used
-  custom holders (e.g. unique or shared pointers). The :ref:`intermediate
-  <ownership>` and :ref:`advanced <ownership_adv>` sections on object ownership
-  provide further detail.
-- ○ **Multi-intepreter, Embedding**: The ability to embed Python in an
-  executable or run several independent Python interpreters in the same process
-  is unsupported. Nanobind caters to bindings only. Multi-interpreter support
-  would require TLS lookups for nanobind data structures, which is undesirable.
-- ○ **Function binding annotations**: The ``pos_only`` argument
-  annotation was removed. However, the same behavior can be achieved by
-  creating unnamed arguments; see the discussion in the section on
-  :ref:`keyword-only arguments <kw_only>`.
-- ○ **Metaclasses**: creating types with custom metaclasses is unsupported.
-- ○ **Module-local bindings**: support was removed (both for types and exceptions).
-- ○ **Custom allocation**: C++ classes with an overloaded or deleted ``operator
-  new`` / ``operator delete`` are not supported.
-- ○ **Compilation**: workarounds for buggy or non-standard-compliant
-  compilers were removed and will not be reintroduced.
-- ○ The ``options`` class for customizing docstring generation was removed.
-- ○ The NumPy array class (``py::array``) was removed in exchange for a more
-  powerful alternative (:cpp:class:`nb::ndarray\<..\> <nanobind::ndarray>`)
-  that additionally supports CPU/GPU tensors produced by various frameworks
-  (NumPy, PyTorch, TensorFlow, JAX, etc.). Its API is not compatible with
-  pybind11, however.
-- ● Buffer protocol binding (``.def_buffer()``) was removed in favor of
-  :cpp:class:`nb::ndarray\<..\> <nanobind::ndarray>`.
-- ● Support for evaluating Python files was removed.
-
-Bullet points marked with ● may be reintroduced eventually, but this will
-need to be done in a careful opt-in manner that does not affect code
-complexity, binary size, and compilation/runtime performance of basic bindings
-that don't depend on these features.
diff --git a/src/nanobind/docs/pypy.rst b/src/nanobind/docs/pypy.rst
deleted file mode 100644
index 15a6190..0000000
--- a/src/nanobind/docs/pypy.rst
+++ /dev/null
@@ -1,23 +0,0 @@
-:orphan:
-
-.. cpp:namespace:: nanobind
-
-.. _pypy_issues:
-
-PyPy support
-------------
-
-PyPy 7.3.10 and newer versions are supported, though with some limitations:
-
-1. When nanobind types occur in reference cycles, then those cycles are not
-   collectable and will be leaked. This is a limitation of PyPy's ``cpyext``
-   layer that was reported in `PyPy issue #3849
-   <https://foss.heptapod.net/pypy/pypy/-/issues/3849>`_. Note that this would
-   only affects users that use the :cpp:class:`nb::type_slots() <type_slots>`
-   feature to implement a custom ``Py_tp_traverse`` or ``Py_tp_clear`` slot.
-
-2. nanobind normally complains about any reference leaks involving instances,
-   functions, and types when the interpreter shuts down. PyPy lacks the final
-   garbage collection step that is needed to identify such leaks See `PyPy
-   issue #3855 <https://foss.heptapod.net/pypy/pypy/-/issues/3855>`_. Those
-   those checks therefore had to be disabled when compiling for PyPy.
diff --git a/src/nanobind/docs/refleaks.rst b/src/nanobind/docs/refleaks.rst
deleted file mode 100644
index 1624fa8..0000000
--- a/src/nanobind/docs/refleaks.rst
+++ /dev/null
@@ -1,485 +0,0 @@
-.. _refleaks:
-
-.. cpp:namespace:: nanobind
-
-Reference leaks
-===============
-
-When the Python interpreter shuts down, nanobind may generate warnings similar
-to the following:
-
-.. code-block:: text
-
-   nanobind: leaked 1 instances!
-    - leaked instance 0x102123728 of type "my_ext.MyClass"
-   nanobind: leaked 1 types!
-    - leaked type "my_ext.MyClass"
-   nanobind: leaked 1 functions!
-    - leaked function "__init__"
-
-   nanobind: this is likely caused by a reference counting issue in the binding code.
-   See https://nanobind.readthedocs.io/en/latest/refleaks.html
-
-Reference leaks are the most frequently reported issue in this project—please
-read this page carefully before opening a bug report.
-
-If you are a user of an extension experiencing this issue (e.g., ``my_ext`` in the
-example above), **do not open a nanobind issue**. Instead, inform the extension
-maintainers and direct them to this page.
-
-Why are these warnings generated?
----------------------------------
-
-nanobind registers a callback that runs once Python has fully shut down. If any
-nanobind-created instances, functions, or types still exist at this point,
-something has gone wrong—they should have been automatically deleted by
-Python's garbage collector.
-
-As Python objects can reference significant amounts of memory (e.g.,
-large CPU or GPU tensors), an inability to delete them is potentially very bad.
-
-Although leaks aren't always a serious problem, the decision was made to have
-nanobind complain noisily about their presence to to encourage early detection
-and resolution. Other binding tools do not report leaks, allowing them to
-accumulate unnoticed until they cause serious problems.
-
-Disabling leak warnings
------------------------
-
-Ignorance is bliss. If you prefer to simply not see these messages, you can
-easily disable them by calling :cpp:func:`nb::set_leak_warnings()
-<set_leak_warnings>` in your binding code:
-
-.. code-block:: cpp
-
-   NB_MODULE(my_ext, m) {
-       nb::set_leak_warnings(false);
-       // ...
-    }
-
-Note that is a *global flag* shared by all nanobind extension libraries in the
-same ABI domain. When changing global flags, please isolate your extension from
-others by passing the ``NB_DOMAIN`` parameter to the
-:cmake:command:`nanobind_add_module()` CMake command:
-
-.. code-block:: cmake
-
-   nanobind_add_module(
-     my_module
-     NB_DOMAIN my_abi_domain
-     extension_file.cpp)
-
-Some projects choose to activate leak warnings for internal builds but disable
-them for wheels uploaded to PyPI, as they can be confusing to end users.
-
-Reference counting fundamentals
--------------------------------
-
-Let's begin with some background material to understand the cause of these warnings.
-
-Each Python object tracks its *reference count*—the number of places it is
-used. When this count reaches zero, the object is automatically deallocated.
-
-This mechanism is simple and efficient but it fails in the presence of
-reference cycles, where objects indirectly references themselves (e.g., A → B → C →
-A). In this case, the reference count never reaches zero, and reference
-counting alone does not suffice to free the cycle (even if ``A``, ``B``, and
-``C`` are not used anywhere else).
-
-In such cases, Python's cyclic *garbage collector* must step in. The garbage
-collector periodically sweeps through all Python objects to find and break up
-any cycles that are not referenced by other objects. To do its job, it must
-know how objects are connected to each other.
-
-For pure Python code, this works seamlessly. Consider the following snippet:
-
-.. code-block:: python
-
-   l = []       # 'l' ref. count = 1
-   l.append(l)  # 'l' ref. count = 2
-   del l        # 'l' ref. count = 1
-
-Following the last line, the reference count of ``l`` remains ``1`` due to the
-self-reference. Python's garbage collector will eventually visit the list and
-its elements, identify the cycle, and delete it.
-
-Sources of reference leaks
---------------------------
-
-Under-defined types impede Python's ability to detect cycles, which can causes
-leaks. However, user-defined types alone aren't enough---a specific mixture of
-ingredients is needed to cause leaks. The following subsections review several
-troublesome constructions.
-
-Class members
-^^^^^^^^^^^^^
-
-Consider this nanobind extension:
-
-.. code-block:: cpp
-
-   #include <nanobind/nanobind.h>
-
-   namespace nb = nanobind;
-
-   struct Wrapper { nb::object value; };
-
-   NB_MODULE(my_ext, m) {
-       nb::class_<Wrapper>(m, "Wrapper")
-           .def(nb::init<>())
-           .def_rw("value", &Wrapper::value);
-   }
-
-Now, run the following Python code.
-
-.. code-block:: pycon
-
-   >>> import my_ext
-   >>> w = my_ext.Wrapper()
-   >>> w.value = w
-
-This triggers a leak warning:
-
-.. code-block:: text
-
-   nanobind: leaked 1 instances!
-    - leaked instance 0x104d63728 of type "my_ext.Wrapper"
-   nanobind: leaked 1 types!
-    - leaked type "my_ext.Wrapper"
-   nanobind: leaked 3 functions!
-    - leaked function ""
-    - leaked function ""
-    - leaked function "__init__"
-
-This resembles the previous example with a self-referential list,
-except that a user-defined ``Wrapper`` type is now used instead.
-
-The first message ("*leaked instance*") warns that a Python object of type
-``Wrapper`` was not freed during the Python interpreter shutdown. This instance
-in turn references other objects, which also become part of the leak:
-
-- ``w`` implicitly references the underlying type object ``my_ext.Wrapper``.
-
-- ``my_ext.Wrapper`` references several methods: ``__init__``, and anonymous
-  setter/getter functions.
-
-The root of the problem here is that Python lacks the ability to peek inside
-the C++ ``Wrapper`` class to examine its connectivity. Therefore, it cannot
-detect and free the cycle.
-
-The fact that we are storing a ``nb::object`` in the C++ instance is
-irrelevant---the same issue would have occurred when using
-``std::shared_ptr<Wrapper>`` or an intrusively reference-counted object.
-
-
-Function objects
-^^^^^^^^^^^^^^^^
-
-Functions are often a source of reference cycles. Let's reuse the earlier
-example but instead assign a local function ``g`` to ``w.value``.
-
-.. code-block:: pycon
-
-   >>> def f():
-   ...     w = my_ext.Wrapper()
-   ...     def g():
-   ...         return w
-   ...     w.value = g
-   ...
-   >>> f()
-
-This code behaves very badly: every call to ``f()`` will leak an uncollectable cycle.
-
-The local function ``g()`` is a `function closure
-<https://en.wikipedia.org/wiki/Closure_(computer_programming)>`_. That is to
-say, besides being a function, it additionally captures variable state, in this
-case the variable ``w``. This creates an inter-language ``Wrapper`` →
-``function`` → ``Wrapper`` cycle.
-
-Here is another tricky case: let's move the code back to the top level and
-create a dummy function that doesn't reference anything.
-
-.. code-block:: python
-
-   >>> def f():
-   ...     pass
-   ...
-   >>> w = my_ext.Wrapper()
-   >>> w.value = f
-
-Given that the function is now empty, we may be tempted to assume that this
-should fix the leak. However, this intuition is incorrect:
-
-.. code-block:: text
-
-   nanobind: leaked 1 instances!
-    - leaked instance 0x104d63728 of type "my_ext.Wrapper"
-   nanobind: leaked 1 types!
-    - leaked type "my_ext.Wrapper"
-   nanobind: leaked 3 functions!
-    - leaked function ""
-    - leaked function ""
-    - leaked function "__init__"
-
-The reference cycle consists of:
-
-- ``w`` (``Wrapper`` instance) → ``f`` (Python function object).
-- ``f`` (Python function object) → ``globals()``.
-- ``globals()`` → ``w`` (``Wrapper`` instance).
-
-Functions *implicitly* depend on the global module namespace, which in turn
-associates the name ``w`` with the instance. Reference leaks involving globals
-can be especially noisy because they can pull in thousands of other objects
-that dangle from the uncollectable cycle.
-
-Modifying ``Wrapper`` so that it uses an STL function object does not help.
-
-.. code-block:: cpp
-
-   #include <nanobind/stl/functional.h>
-
-   struct Wrapper {
-       std::function<void()> value;
-   };
-
-This produces same cycle, just with more layers of indirection:
-
-- ``w`` → ``std::function<void()>`` instance
-- ``std::function<void()>`` instance → nanobind function dispatch object
-- nanobind function dispatch object → ``f``.
-- ``f`` → ``globals()``.
-- ``globals()`` → ``w``.
-
-It is easy to encounter such cycles when binding C++ classes with callbacks
-that invoke Python functions. An example would be a button class in a GUI
-framework that allows the user to assign a button press handler.
-
-Default arguments
-^^^^^^^^^^^^^^^^^
-
-Here is another subtle case, where the ``Wrapper`` constructor was modified
-to set a default argument.
-
-.. code-block:: cpp
-
-   struct Wrapper { nb::object value; };
-
-   NB_MODULE(my_ext, m) {
-       nb::class_<Wrapper>(m, "Wrapper")
-           .def(nb::init<Wrapper>() = Wrapper());
-   }
-
-Now, we *don't even need to use* the ``Wrapper`` type.
-
-.. code-block:: python
-
-   import my_ext
-
-Its mere presence produces a leak:
-
-.. code-block:: text
-
-   nanobind: leaked 1 instances!
-    - leaked instance 0x1035fbb68 of type "my_ext.Wrapper"
-   nanobind: leaked 1 types!
-    - leaked type "my_ext.Wrapper"
-   nanobind: leaked 1 functions!
-    - leaked function "__init__"
-
-The reference cycle here is as follows:
-
-- ``my_ext.Wrapper`` type → ``my_ext.Wrapper.__init__`` function
-- ``my_ext.Wrapper.__init__`` function → ``my_ext.Wrapper`` instance (the constructed default argument)
-- ``my_ext.Wrapper`` instance → ``my_ext.Wrapper`` type (instances implictly reference their type)
-
-Default arguments in general are harmless. However, default arguments that
-introduce cycles between instance and type objects can cause uncollectable cycles.
-
-.. _fixing_refleaks:
-
-Fixing reference leaks
-----------------------
-
-As the above examples hopefully demonstrate, this can be quite the
-minefield---and these were "easy" cycles with only only a few hops. In
-practice, leaks can be significantly more complex.
-
-For this reason, it is recommended that you *immediately* investigate and
-squash leaks when they occur, especially while things are still under control
-(i.e., when there is only a single source of leaks). Start by building your
-extension in debug mode, in which case Dr.Jit will exhaustively print warnings
-about all leaked instances/type.
-
-Look at the listed types and think about what objects they reference directly
-or indirectly. C++ code that stores Python functions (i.e., callbacks) is
-especially suspect, since functions can implicitly depend on globals and other
-state through theyr closure object. Does a simple ``import`` statement suffice to
-cause leaks? This might implicate default function arguments.
-
-Once you have identified a type binding as likely culprit, you must tell Python
-how to traverse instances of this type to break cycles. nanobind provides no
-abstractions for this at the moment. You must drop down to the CPython API
-level and declare two callbacks (referred to as *type slots*):
-
-- ``tp_traverse``: Python's GC will call this function to discover references
-  of user-defined types.
-
-- ``tp_clear``: Python's GC will call this function to break collectable cycles.
-
-In particular, *all* types in the cycle must implement the ``tp_traverse``
-*type slot*, and *at least one* of them must implement the ``tp_clear`` type
-slot.
-
-Here is an example of the required code for a ``Wrapper`` type:
-
-.. code-block:: cpp
-
-   struct Wrapper { std::shared_ptr<Wrapper> value; };
-
-   int wrapper_tp_traverse(PyObject *self, visitproc visit, void *arg) {
-       // On Python 3.9+, we must traverse the implicit dependency
-       // of an object on its associated type object.
-       #if PY_VERSION_HEX >= 0x03090000
-           Py_VISIT(Py_TYPE(self));
-       #endif
-
-       // The tp_traverse method may be called after __new__ but before or during
-       // __init__, before the C++ constructor has been completed. We must not
-       // inspect the C++ state if the constructor has not yet completed.
-       if (!nb::inst_ready(self)) {
-          return 0;
-       }
-
-       // Get the C++ object associated with 'self' (this always succeeds)
-       Wrapper *w = nb::inst_ptr<Wrapper>(self);
-
-       // If w->value has an associated Python object, return it.
-       // If not, value.ptr() will equal NULL, which is also fine.
-       nb::handle value = nb::find(w->value);
-
-       // Inform the Python GC about the instance
-       Py_VISIT(value.ptr());
-
-       return 0;
-   }
-
-   int wrapper_tp_clear(PyObject *self) {
-       // Get the C++ object associated with 'self' (this always succeeds)
-       Wrapper *w = nb::inst_ptr<Wrapper>(self);
-
-       // Break the reference cycle!
-       w->value = {};
-
-       return 0;
-   }
-
-   // Table of custom type slots we want to install
-   PyType_Slot wrapper_slots[] = {
-       { Py_tp_traverse, (void *) wrapper_tp_traverse },
-       { Py_tp_clear, (void *) wrapper_tp_clear },
-       { 0, 0 }
-   };
-
-The types ``visitproc``, ``PyType_Slot``, and macro ``Py_VISIT()`` are part of
-the Python C API.
-
-The expression :cpp:func:`nb::inst_ptr\<Wrapper\>(self) <inst_ptr>` efficiently
-returns the C++ instance associated with a Python object and is explained in
-the documentation about nanobind's :cpp:ref:`low level interface <lowlevel>`.
-
-Note the use of the :cpp:func:`nb::find() <find>` function, which behaves like
-:cpp:func:`nb::cast() <cast>` by returning the Python object associated with a
-C++ instance. The main difference is that :cpp:func:`nb::cast() <cast>` will
-create the Python object if it doesn't exist, while :cpp:func:`nb::find()
-<find>` returns a ``nullptr`` object in that case. When given a
-``std::function<>`` instance, :cpp:func:`nb::find() <find>` retrieves the
-associated Python ``function`` object (if present), which means that the
-``wrapper_tp_traverse()`` works for all of the examples shown in this
-documentation section.
-
-To activate this machinery, the ``Wrapper`` type bindings must be made aware of
-these extra type slots via :cpp:class:`nb::type_slots <type_slots>`:
-
-.. code-block:: cpp
-
-   nb::class_<Wrapper>(m, "Wrapper", nb::type_slots(slots))
-
-With this change, the cycle can be garbage-collected, and the leak warnings
-disappear.
-
-.. note::
-
-   When targeting free-threaded Python, it is important that the ``tp_traverse``
-   callback does not hold additional references to the objects being traversed.
-
-   A previous version of this documentation page suggested the following
-
-   .. code-block:: cpp
-
-      nb::object value = nb::find(w->value);
-      Py_VISIT(value.ptr());
-
-   However, these now have to change to
-
-   .. code-block:: cpp
-
-      nb::handle value = nb::find(w->value);
-      Py_VISIT(value.ptr());
-
-
-Additional sources of leaks
----------------------------
-
-In most of cases, leaks are caused by cycles, and the text above explains
-how deal with them. For completeness, let's consider some other possibilities.
-
-- **Reference counting bugs**.  If you write raw Python C API code or use the
-  nanobind wrappers including functions like ``Py_[X]INCREF()``,
-  ``Py_[X]DECREF()``, :cpp:func:`nb::steal() <steal>`, :cpp:func:`nb::borrow()
-  <borrow>`, :cpp:func:`.dec_ref() <detail::api::dec_ref>`,
-  :cpp:func:`.inc_ref() <detail::api::inc_ref>`
-  , etc., then incorrect
-  use of such calls can cause a reference to leak that prevents the associated
-  object from being deleted.
-
-- **Interactions with other tools that leak references**. Python extension
-  libraries---especially *huge* ones with C library components like PyTorch,
-  Tensorflow, etc., have been observed to leak references to nanobind
-  objects.
-
-  Some of these frameworks cache JIT-compiled functions based on the arguments
-  with which they were called, and such caching schemes could leak references
-  to nanobind types if they aren't cleaned up by the responsible extensions
-  (this is a hypothesis). In this case, the leak would be benign---even so, it
-  should be fixed in the responsible framework so that leak warnings aren't
-  cluttered with flukes and can be more broadly useful.
-
-- **Older Python versions**: Very old Python versions (e.g., 3.8) don't
-  do a good job cleaning up global references when the interpreter shuts down.
-  The following code may leak a reference if it is a top-level statement in a
-  Python file or the REPL.
-
-  .. code-block:: python
-
-     a = my_ext.MyObject()
-
-  Such a warning is benign and does not indicate an actual leak. It simply
-  highlights a flaws in the interpreter shutdown logic of old Python versions.
-  Wrap your code into a function to address this issue even on such versions:
-
-  .. code-block:: python
-
-     def run():
-         a = my_ext.MyObject()
-         # ...
-
-     if __name__ == '__main__':
-         run()
-
-- **Exceptions**. Some exceptions such as ``AttributeError`` have been observed
-  to hold references, e.g. to the object which lacked the desired attribute. If
-  the last exception raised by the program references a nanobind instance, then
-  this may be reported as a leak since Python finalization appears not to
-  release the exception object. See `issue #376
-  <https://github.com/wjakob/nanobind/issues/376>`__ for a discussion.
-
diff --git a/src/nanobind/docs/release.rst b/src/nanobind/docs/release.rst
deleted file mode 100644
index 9cf66f6..0000000
--- a/src/nanobind/docs/release.rst
+++ /dev/null
@@ -1,25 +0,0 @@
-How to make a new release?
---------------------------
-
-1. Ensure that the full version of nanobind is checked out (including the
-   ``robin_map`` submodule)
-
-2. Run ``python src/version.py -w X.Y.Z``
-
-3. Add release date to ``docs/changelog.rst``.
-
-4. Update ``setup.py`` if new directories were added (see ``package_data``).
-   Update ``cmake/nanobind-config.cmake`` if new C++ source or header files
-   were added.
-
-5. Commit: ``git commit -am "vX.Y.Z release"``
-
-6. Tag: ``git tag -a vX.Y.Z -m "vX.Y.Z release"``
-
-7. Push: ``git push`` and ``git push --tags``
-
-8. Run ``pipx run build``
-
-9. Upload: ``twine upload --repository nanobind <filename>``
-
-10. Run ``python src/version.py -w X.Y.Zdev1``
diff --git a/src/nanobind/docs/requirements.txt b/src/nanobind/docs/requirements.txt
deleted file mode 100644
index 601bd4d..0000000
--- a/src/nanobind/docs/requirements.txt
+++ /dev/null
@@ -1,5 +0,0 @@
-furo
-sphinx==6.1.3
-sphinx-copybutton==0.5.1
-sphinxcontrib-moderncmakedomain==3.25.0
-sphinxcontrib-svg2pdfconverter==1.2.2
diff --git a/src/nanobind/docs/typing.rst b/src/nanobind/docs/typing.rst
deleted file mode 100644
index 391971e..0000000
--- a/src/nanobind/docs/typing.rst
+++ /dev/null
@@ -1,674 +0,0 @@
-.. cpp:namespace:: nanobind
-
-.. _typing:
-
-Typing
-======
-
-This section covers three broad typing-related topics:
-
-1. How to create rich type annotation in C++ bindings so that projects
-   using them can be effectively type-checked.
-
-2. How to :ref:`automatically generate stub files <stubs>` that are needed to
-   enable static type checking and autocompletion in Python IDEs.
-
-3. How to write :ref:`pattern files <pattern_files>` to handle advanced use
-   cases requiring significant stub customization.
-
-Signature customization
------------------------
-
-In larger binding projects, some customization of function or class signatures
-is often needed so that static type checkers can effectively use the generated
-stubs.
-
-.. _typing_signature_functions:
-
-Functions
-^^^^^^^^^
-
-Nanobind generates typed function signatures automatically, but these are not
-always satisfactory. For example, the following function binding
-
-.. code-block:: cpp
-
-   nb::class_<Int>(m, "Int")
-       .def(nb::self == nb::self);
-
-is likely to be rejected because the default ``__eq__`` function signature
-
-.. code-block:: text
-
-   __eq__(self, arg: Int, /) -> bool
-
-is more specific than that of the parent class ``object``:
-
-.. code-block:: text
-
-   __eq__(self, arg: object, /) -> bool
-
-In this case, a static type checker like `MyPy
-<https://github.com/python/mypy>`__ will report a failure:
-
-.. code-block:: text
-
-    error: Argument 1 of "__eq__" is incompatible with supertype "object"; supertype defines the argument type as "object"  [override]
-
-To handle such cases, you can use the :cpp:class:`nb::sig <sig>`
-attribute to overrides the function signature with a custom string.
-
-.. code-block:: cpp
-
-   nb::class_<Int>(m, "Int")
-       .def(nb::self == nb::self,
-            nb::sig("def __eq__(self, arg: object, /) -> bool"));
-
-The argument must be a valid Python function signature of the form ``def
-name(...) -> ...`` without trailing colon (``":"``) and newlines, where
-``name`` must furthermore match the name given to the binding declaration. In
-this case, the name is implicitly given by the operator. It must match
-``"name"`` in the case of ``.def("name", ...)``-style bindings with an explicit
-name. The signature can span multiple lines, e.g., to prefix one or more
-decorators.
-
-The modified signature is shown in generated stubs, docstrings, and error
-messages (e.g., when a function receives incompatible arguments).
-
-In cases where a custom signature is only needed to tweak how nanobind renders
-the signature of a default argument, the more targeted
-:cpp:func:`nb::arg("name").sig("signature") <arg::sig>` annotation is
-preferable to :cpp:class:`nb::sig <sig>`.
-
-.. _typing_signature_classes:
-
-Classes
-^^^^^^^
-
-Signature customization is also available for class bindings, though only
-stubs are affected in this case.
-
-Consider the example below, which defines an iterable vector type storing
-integers. Suppose that ``GeneralIterator`` iterates over arbitrary data and
-does not provide a useful ``int``-typed signature.
-
-.. code-block:: cpp
-
-   using IntVec = std::vector<int>;
-
-   nb::class_<IntVec>(m, "IntVec")
-      .def("__iter__",
-           [](const IntVec &v) -> GeneralIterator { ... })
-
-It may be useful to inherit from ``collections.abc.Iterable[int]`` to
-communicate more information to static type checkers, but such a Python → C++
-inheritance chain is not permitted by nanobind.
-
-.. _typing_liberties:
-
-Stubs often take certain liberties in deviating somewhat from the precise type
-signature of the underlying implementation, which is fine as long as this
-improves the capabilities of the type checker (the stubs are only used by the
-static type checking phase, which never imports the actual extension).
-
-Here, we could specify
-
-.. code-block:: cpp
-
-   nb::class_<IntVec>(m, "IntVec",
-                      nb::sig("class IntVec(collections.abc.Iterable[int])"));
-
-This is technically a lie. Such shenanigans are worthwhile because they can
-greatly improve the development experience (e.g. `VS Code
-<https://code.visualstudio.com>`__ autocomplete) involving compiled extensions.
-
-The supplied signature string must be a valid Python class signature of the
-form ``class ClassName(...)`` excluding trailing colon (``":"``) and newline,
-where ``ClassName`` must furthermore match the name provided in the main class
-binding declaration.
-The signature can span multiple lines, e.g., to prefix one or more decorators.
-
-Generic types
--------------
-
-.. _typing_generics_parameterizing:
-
-Parameterizing generic types
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-Various standard Python types are `generic
-<https://typing.readthedocs.io/en/latest/spec/generics.html>`__ can be
-parameterized to improve the effectiveness of static type checkers such as
-`MyPy <https://github.com/python/mypy>`__. In the presence of such a
-specialization, a type checker can, e.g., infer that the variable ``a`` below
-is of type ``int``.
-
-.. code-block:: python
-
-   def f() -> list[int]: ...
-
-   a = f()[0]
-
-This is even supported for *abstract types*---for example,
-``collections.abc.Mapping[str, int]`` indicates an abstract mapping from
-strings to integers.
-
-nanobind provides the template class :cpp:class:`nb::typed\<T, Ts...\> <typed>`
-to generate parameterized type annotations in C++ bindings. For example, the
-argument and return value of the following function binding reproduces the
-exact list and mapping types mentioned above.
-
-.. code-block:: cpp
-
-   m.def("f", [](nb::typed<nb::mapping, nb::str, int> arg)
-               -> nb::typed<nb::list, int> { ... });
-
-(Usually, :cpp:class:`nb::typed\<T, Ts...\> <typed>` would be applied to
-:ref:`wrapper <wrappers>` types, though this is not a strict limitation.)
-
-An important limitation of this feature is that it *only* affects function
-signatures. Nanobind will (as always) ensure that ``f`` can only be called with
-a ``nb::mapping``, but it will *not* insert additional runtime checks to verify that
-``arg`` indeed maps strings to integers. It is the responsibility of the
-function to perform these checks and, if needed, to raise a
-:cpp:func:`nb::type_error <type_error>`.
-
-The parameterized C++ type :cpp:class:`nb::typed\<T, Ts...\> <typed>`
-subclasses the type ``T`` and can be used interchangeably with ``T``. The other
-arguments (``Ts...``) are used to generate a Python type signature but have no
-other effect (for example, parameterizing by ``str`` on the Python end can
-alternatively be achieved by passing ``nb::str``, ``std::string``, or ``const
-char*`` as part of the ``Ts...`` parameter pack).
-
-There are two special forms of ``nb::typed<T, Ts...>`` that will be rendered
-as something other than ``T[Ts...]``:
-
-* In some cases, a function may wish to accept or return an arbitrary
-  Python object, but generate signatures that describe it as some more
-  specific type  ``T``. The types ``nb::typed<nb::object, T>`` and
-  ``nb::typed<nb::handle, T>`` will be rendered as ``T`` rather than
-  as the nonsensical ``object[T]`` that they would be without this rule.
-  (If you want nanobind to check that an argument is actually of type ``T``,
-  while still giving you a generic Python object to work with,
-  then use :cpp:class:`nb::handle_t\<T\> <handle_t>` instead.)
-
-* Type parameters for ``nb::callable`` can be provided using a C++ function
-  signature, since there would otherwise be no way to express the nested
-  brackets used in Python callable signatures. In order to express the Python type
-  ``Callable[[str, float], int]``, which is a function taking two parameters
-  (string and float) and returning an integer, you might write
-  ``nb::typed<nb::callable, int(nb::str, float)>``. For a callable type
-  that accepts any arguments, like ``Callable[..., int]``, use a C-style
-  variadic function signature: ``nb::typed<nb::callable, int(...)>``.
-  (The latter could also be written without this special support, as
-  ``nb::typed<nb::callable, nb::ellipsis, int>``.)
-
-.. _typing_generics_creating:
-
-Creating generic types
-^^^^^^^^^^^^^^^^^^^^^^
-
-Python types inheriting from `types.Generic
-<https://docs.python.org/3/library/typing.html#typing.Generic>`__ can be
-*parameterized* by other types including generic `type variables
-<https://docs.python.org/3/library/typing.html#typing.TypeVar>`__ that act as
-placeholders. Such constructions enable more effective static type checking. In
-the snippet below, tools like `MyPy <https://github.com/python/mypy>`__ or
-`PyRight <https://github.com/microsoft/pyright>`__ can infer that ``x`` and
-``y`` have types ``Wrapper[int]`` and ``int``, respectively.
-
-.. code-block:: python
-
-   import typing
-
-   # 1. Instantiate a placeholder type ("type variable") used below
-   T = typing.TypeVar("T")
-
-   # 2. Create a generic type by inheriting from typing.Generic
-   class Wrapper(typing.Generic[T]):
-       # The constructor references the placeholder type
-       def __init__(self, value: T):
-           self.value = value
-
-       # .. this type is then preserved in the getter
-       def get(self) -> T:
-           return self.value
-
-   # Based on the typed constructor, MyPy knows that 'x' has type 'Wrapper[int]'
-   x = Wrapper(3)
-
-   # Based on the typed 'Wrapped.get' method, 'y' is inferred to have type 'int'
-   y = x.get()
-
-Note that parameterization of a generic type doesn't generate new code or
-modify its functionality. It is not to be confused with C++ template
-instantiation. The feature only exists to propagate fine-grained type
-information and thereby aid static type checking.
-
-Similar functionality can also be supported in nanobind-based binding projects.
-This looks as follows:
-
-.. code-block:: cpp
-
-   #include <nanobind/typing.h> // needed by nb::type_var below
-
-   struct Wrapper {
-       nb::object value;
-   };
-
-   NB_MODULE(my_ext, m) {
-       // 1. Instantiate a placeholder type ("type variable") used below
-       m.attr("T") = nb::type_var("T");
-
-       // 2. Create a generic type, and indicate in generated stubs
-       //    that it derives from Generic[T]
-       nb::class_<Wrapper> wrapper(m, "Wrapper", nb::is_generic(),
-                                   nb::sig("class Wrapper(typing.Generic[T])"))
-           .def(nb::init<nb::object>(),
-                nb::sig("def __init__(self, arg: T, /) -> None"))
-           .def("get", [](Wrapper &w) { return w.value; },
-                nb::sig("def get(self, /) -> T"));
-   }
-
-This involves the following steps:
-
-- The :cpp:func:`nb::type_var <type_var>` constructor generates a type variable
-  analogous to the previous Python snippet and assigns it to the name ``"T"``
-  within the module.
-
-- If we were to follow the previous Python example, the next step would require
-  defining ``Wrapper`` as a subclass of ``typing.Generic[T]``. However, this
-  isn't possible because nanobind-based classes cannot derive from Python
-  types.
-
-- The solution to this problem takes the following :ref:`liberties
-  <typing_liberties>`:
-
-  - It passes the :cpp:class:`nb::is_generic <is_generic>` annotation to the
-    :cpp:class:`nb::class_\<...\> <class_>` constructor, causing the addition
-    of a ``__class_getattr__`` member that enables type parameterization.
-    Following this step, an expression like ``Wrapper[int]`` becomes valid and
-    returns a ``typing.TypeAlias`` (in other words, the behavior is *as if* we
-    had derived from ``typing.Generic[T]``).
-
-    However, `MyPy <https://github.com/python/mypy>`__ and similar tools don't
-    quite know what to do with custom types overriding ``__class_getattr__``
-    themselves, since the official parameterization mechanism is to subclass
-    ``typing.Generic``.
-
-  - Therefore, we *lie* about this in the stub and declare
-    ``typing.Generic[T]`` as a base class. Only static type checkers will
-    see this information, and it helps them to interpret how the type works.
-
-  - That's it!
-
-You may also extend parameterized forms of such generic types:
-
-.. code-block:: cpp
-
-   nb::class_<Subclass>(m, "Subclass", wrapper[nb::type<Foo>()]);
-
-nanobind's stub generator will render this as ``class Subclass(Wrapper[Foo]):``.
-
-Any-typed return values
-^^^^^^^^^^^^^^^^^^^^^^^
-
-The return value of a function can sometimes be unclear (dynamic), in which
-case it can be helpful to declare ``typing.Any`` as a pragmatic return type
-(this effectively disables analysis of the return value in static type
-checkers). nanobind provides a :py:class:`nb::any <any>` wrapper type that is
-equivalent to :py:class:`nb::object <object>` except that its type signature
-renders as ``typing.Any`` to facilitate this.
-
-.. _stubs:
-
-Stub generation
----------------
-
-A *stub file* provides a *typed* and potentially documented summary of a
-module's class, function, and variable declarations. Stub files have the
-extension ``.pyi`` and are often shipped along with Python extensions. They
-are needed to enable autocompletion and static type checking in tools like
-`Visual Studio Code <https://code.visualstudio.com>`__, `MyPy
-<https://github.com/python/mypy>`__, `PyRight
-<https://github.com/microsoft/pyright>`__ and `PyType
-<https://github.com/google/pytype>`__.
-
-Take for example the following function:
-
-.. code-block:: python
-
-   def square(x: int) -> int:
-       '''Return the square of the input'''
-       return x*x
-
-The associated default stub removes the body, while retaining the docstring:
-
-.. code-block:: python
-
-   def square(x: int) -> int:
-       '''Return the square of the input'''
-
-An undocumented stub replaces the entire body with the Python ellipsis object
-(``...``).
-
-.. code-block:: python
-
-   def square(x: int) -> int: ...
-
-Complex default arguments are often also abbreviated with ``...`` to improve
-the readability of signatures. You can read more about stub files in the
-`typing documentation
-<https://typing.readthedocs.io/en/latest/source/stubs.html>`__ and the `MyPy
-documentation <https://mypy.readthedocs.io/en/stable/stubs.html>`__.
-
-nanobind's ``stubgen`` tool automates the process of stub generation to turn
-modules containing a mixture of ordinary Python code and C++ bindings into an
-associated ``.pyi`` file.
-
-The main challenge here is that C++ bindings are unlike ordinary Python
-objects, which causes standard mechanisms to extract their signature to fail.
-Existing tools like MyPy's `stubgen
-<https://mypy.readthedocs.io/en/stable/stubgen.html>`__ and `pybind11-stubgen
-<https://github.com/sizmailov/pybind11-stubgen>`__ must therefore parse
-docstrings to infer function signatures, which is brittle and does not always
-produce high-quality output.
-
-nanobind functions expose a ``__nb_signature__`` property, which provides
-structured information about typed function signatures, overload chains, and
-default arguments. nanobind's ``stubgen`` leverages this information to
-reliably generate high-quality stubs that are usable by static type checkers.
-
-There are three ways to interface with the stub generator described in
-the following subsections.
-
-CMake interface
-^^^^^^^^^^^^^^^
-
-nanobind's CMake interface provides the :cmake:command:`nanobind_add_stub`
-command for stub generation at build or install time. It generates a single
-stub at a time--more complex cases involving large numbers of stubs are easily
-handled using standard CMake constructs (e.g. a ``foreach()`` loop).
-
-The command requires a target name (e.g., ``my_ext_stub``) that must be unique
-but has no other significance. Once all dependencies (``DEPENDS`` parameter)
-are met, it will invoke ``stubgen`` to turn a single module (``MODULE``
-parameter) into a stub file (``OUTPUT`` parameter).
-
-For this to work, the module must be importable. ``stubgen`` will add all paths
-specified as part of the ``PYTHON_PATH`` parameter and then execute ``import
-my_ext``, raising an error if this fails.
-
-.. code-block:: cmake
-
-   nanobind_add_stub(
-     my_ext_stub
-     MODULE my_ext
-     OUTPUT my_ext.pyi
-     PYTHON_PATH $<TARGET_FILE_DIR:my_ext>
-     DEPENDS my_ext
-   )
-
-Typed extensions normally identify themselves via the presence of an empty file
-named ``py.typed`` in each module directory. :cmake:command:`nanobind_add_stub`
-can optionally generate this file as well.
-
-.. code-block:: cmake
-
-   nanobind_add_stub(
-     ...
-     MARKER_FILE py.typed
-     ...
-   )
-
-CMake tracks the generated outputs in its dependency graph. The combination of
-compiled extension module, stub, and marker file can subsequently be installed
-by subsequent ``install()`` directives.
-
-.. code-block:: cmake
-
-  install(TARGETS my_ext DESTINATION ".")
-  install(FILES py.typed my_ext.pyi DESTINATION ".")
-
-In certain situations, it may be tricky to import an extension that is built
-but not yet installed to its final destination. To handle such cases, specify
-the ``INSTALL_TIME`` parameter to :cmake:command:`nanobind_add_stub` to delay
-stub generation to the installation phase.
-
-.. code-block:: cmake
-
-    install(TARGETS my_ext DESTINATION ".")
-
-    nanobind_add_stub(
-      my_ext_stub
-      INSTALL_TIME
-      MODULE my_ext
-      OUTPUT my_ext.pyi
-      PYTHON_PATH "."
-    )
-
-This requires several changes:
-
-1. ``PYTHON_PATH`` must be adjusted so that it references a location relative
-   to ``CMAKE_INSTALL_PREFIX`` from which the installed module is importable.
-
-2. The :cmake:command:`nanobind_add_stub` command should be preceded by
-   ``install(TARGETS my_ext)`` and ``install(FILES`` commands that place all
-   data (compiled extension files, plain Python code, etc.) needed to bring the
-   module into an importable state.
-
-   Place all relevant ``install()`` directives within the same
-   ``CMakeLists.txt`` file to ensure that these steps are executed
-   sequentially.
-
-3. Dependencies (``DEPENDS``) no longer need to be listed. These are build-time
-   constraints that do not apply in the installation phase.
-
-4. The output file path (``OUTPUT``) is relative to ``CMAKE_INSTALL_PREFIX``
-   and may need adjustments as well.
-
-The :cmake:command:`nanobind_add_stub` command has a few other options, please
-refer to its documentation for details.
-
-Command line interface
-^^^^^^^^^^^^^^^^^^^^^^
-
-Alternatively, you can invoke ``stubgen`` on the command line. The nanobind
-package must be installed for this to work, e.g., via ``pip install nanobind``.
-The command line interface is also able to generate multiple stubs at once
-(simply specify ``-m MODULE`` several times).
-
-.. code-block:: bash
-
-   $ python -m nanobind.stubgen -m my_ext -M py.typed
-   Module "my_ext" ..
-     - importing ..
-     - analyzing ..
-     - writing stub "my_ext.pyi" ..
-     - writing marker file "py.typed" ..
-
-Unless an output file (``-o``) or output directory (``-O``) is specified, this
-places the ``.pyi`` files directly into the module. Existing stubs are
-overwritten without warning.
-
-The program has the following command line options:
-
-.. code-block:: text
-
-   usage: python -m nanobind.stubgen [-h] [-o FILE] [-O PATH] [-i PATH] [-m MODULE]
-                                     [-r] [-M FILE] [-P] [-D] [-q]
-
-   Generate stubs for nanobind-based extensions.
-
-   options:
-     -h, --help                    show this help message and exit
-     -o FILE, --output-file FILE   write generated stubs to the specified file
-     -O PATH, --output-dir PATH    write generated stubs to the specified directory
-     -i PATH, --import PATH        add the directory to the Python import path (can
-                                   specify multiple times)
-     -m MODULE, --module MODULE    generate a stub for the specified module (can
-                                   specify multiple times)
-     -r, --recursive               recursively process submodules
-     -M FILE, --marker-file FILE   generate a marker file (usually named 'py.typed')
-     -p FILE, --pattern-file FILE  apply the given patterns to the generated stub
-                                   (see the docs for syntax)
-     -P, --include-private         include private members (with single leading or
-                                   trailing underscore)
-     -D, --exclude-docstrings      exclude docstrings from the generated stub
-     -q, --quiet                   do not generate any output in the absence of failures
-
-
-Python interface
-^^^^^^^^^^^^^^^^
-
-Finally, you can import ``stubgen`` into your own Python programs and use it to
-programmatically generate stubs with a finer degree of control.
-
-To do so, construct an instance of the ``StubGen`` class and repeatedly call
-``.put()`` to register modules or contents within the modules (specific
-methods, classes, etc.). Afterwards, the ``.get()`` method returns a string
-containing the stub declarations.
-
-
-.. code-block:: python
-
-   from nanobind.stubgen import StubGen
-   import my_module
-
-   sg = StubGen()
-   sg.put(my_module)
-   print(sg.get())
-
-Note that for now, the ``nanobind.stubgen.StubGen`` API is considered
-experimental and not subject to the semantic versioning policy used by the
-nanobind project.
-
-.. _pattern_files:
-
-Pattern files
--------------
-
-In complex binding projects requiring static type checking, the previously
-discussed mechanisms for controlling typed signatures (:cpp:class:`nb::sig
-<sig>`, :cpp:class:`nb::typed <typed>`) may be insufficient. Two common reasons
-are as follows:
-
-- the ``@typing.overload`` chain associated with a function may sometimes
-  require significant deviations from the actual overloads present on the C++
-  side.
-
-- Some members of a module could be inherited from existing Python packages or
-  extension libraries, in which case patching their signature via
-  :cpp:class:`nb::sig <sig>` is not even an option.
-
-``stubgen`` supports *pattern files* as a last-resort solution to handle such
-advanced needs. These are files written in a *domain-specific language* (DSL)
-that specifies replacement patterns to dynamically rewrite stubs during
-generation. To use one, simply add it to the :cmake:command:`nanobind_add_stub`
-command.
-
-.. code-block:: cmake
-
-   nanobind_add_stub(
-     ...
-     PATTERN_FILE  <PATH>
-     ...
-   )
-
-A pattern file contains sequence of patterns. Each pattern consists of a query
-and an indented replacement block to be applied when the query matches.
-
-.. code-block:: text
-
-   # This is the first pattern
-   query 1:
-       replacement 1
-
-   # And this is the second one
-   query 2:
-       replacement 2
-
-Empty lines and lines beginning with ``#`` are ignored. The amount of
-indentation is arbitrary: ``stubgen`` will re-indent the replacement as needed
-based on where the query matched.
-
-When the stub generator traverses the module, it computes the *fully qualified
-name* of every type, function, property, etc. (for example:
-``"my_ext.MyClass.my_function"``). The queries in a pattern file are checked
-against these qualified names one by one until the first one matches.
-
-For example, suppose that we had the following lackluster stub entry:
-
-.. code-block:: python
-
-   class MyClass:
-       def my_function(arg: object) -> object: ...
-
-The pattern below matches this function stub and inserts an alternative with
-two typed overloads.
-
-.. code-block:: text
-
-   my_ext.MyClass.my_function:
-       @overload
-       def my_function(arg: int) -> int:
-           """A helpful docstring"""
-
-       @overload
-       def my_function(arg: str) -> str: ...
-
-Patterns can also *remove* entries, by simply not specifying a replacement
-block. Also, queries don't have to match the entire qualified name. For
-example, the following pattern deletes all occurrences of anything
-containing the string ``secret`` somewhere in its name
-
-.. code-block:: text
-
-   secret:
-
-In fact (you may have guessed it), the queries are *regular expressions*! The
-query supports all features of Python's builtin `re
-<https://docs.python.org/3/library/re.html>`__ library.
-
-When the query uses *groups*, the replacement block may access the contents of
-each numbered group using using the syntax ``\1``, ``\2``, etc. This permits
-writing generic patterns that can be applied to a number of stub entries at
-once:
-
-.. code-block:: text
-
-   __(eq|ne)__:
-       def __\1__(self, arg, /) -> bool: ...
-
-Named groups are also supported:
-
-.. code-block:: text
-
-   __(?P<op>eq|ne)__:
-       def __\op__(self, arg, /) -> bool : ...
-
-Finally, sometimes, it is desirable to rewrite only the signature of a function
-in a stub but to keep its docstring so that it doesn't have to be copied into
-the pattern file. The special escape code ``\doc`` references the previously
-existing docstring.
-
-.. code-block:: text
-
-   my_ext.lookup:
-       def lookup(array: Array[T], index: int) -> T:
-           \doc
-
-If your replacement rule requires additional types to work (e.g., from ``typing.*``),
-you may use the special ``\from`` escape code to import them:
-
-.. code-block:: text
-
-   @overload
-   my_ext.lookup:
-       \from typing import Optional as _Opt, Literal
-       def lookup(array: Array[T], index: Literal[0] = 0) -> _Opt[T]:
-           \doc
-
-You may also add free-form text the beginning or the end of the generated stub.
-To do so, add an entry that matches on ``module_name.__prefix__`` or
-``module_name.__suffix__``.
diff --git a/src/nanobind/docs/utilities.rst b/src/nanobind/docs/utilities.rst
deleted file mode 100644
index eebf6d3..0000000
--- a/src/nanobind/docs/utilities.rst
+++ /dev/null
@@ -1,59 +0,0 @@
-.. cpp:namespace:: nanobind
-
-.. _utilities:
-
-Utilities
-==========
-
-.. _utilities_eval:
-
-Evaluating Python expressions from strings
-------------------------------------------
-
-nanobind provides the :cpp:func:`eval` and :cpp:func:`exec` functions to
-evaluate Python expressions and statements. The following example illustrates
-how they can be used.
-
-.. code-block:: cpp
-
-    // At beginning of file
-    #include <nanobind/eval.h>
-
-    ...
-
-    // Evaluate in scope of main module
-    nb::object scope = nb::module_::import_("__main__").attr("__dict__");
-
-    // Evaluate an isolated expression
-    int result = nb::eval("my_variable + 10", scope).cast<int>();
-
-    // Evaluate a sequence of statements
-    nb::exec(
-        "print('Hello')\n"
-        "print('world!');",
-        scope);
-
-C++11 raw string literals are also supported and quite handy for this purpose.
-The only requirement is that the first statement must be on a new line
-following the raw string delimiter ``R"(``, ensuring all lines have common
-leading indent:
-
-.. code-block:: cpp
-
-    nb::exec(R"(
-        x = get_answer()
-        if x == 42:
-            print('Hello World!')
-        else:
-            print('Bye!')
-        )", scope
-    );
-
-.. note::
-
-    :cpp:func:`eval` accepts a template parameter that describes how the
-    string/file should be interpreted. Possible choices include ``eval_expr``
-    (isolated expression), ``eval_single_statement`` (a single statement,
-    return value is always ``none``), and ``eval_statements`` (sequence of
-    statements, return value is always ``none``). `eval` defaults to
-    ``eval_expr`` and `exec` is just a shortcut for ``eval<eval_statements>``.
diff --git a/src/nanobind/docs/why.rst b/src/nanobind/docs/why.rst
deleted file mode 100644
index 5f58e2c..0000000
--- a/src/nanobind/docs/why.rst
+++ /dev/null
@@ -1,252 +0,0 @@
-.. _why:
-
-.. cpp:namespace:: nanobind
-
-Why another binding library?
-============================
-
-I started the `pybind11 <http://github.com/pybind/pybind11>`__ project back in
-2015 to generate better C++/Python bindings for a project I had been working
-on. Thanks to many amazing contributions by others, pybind11 has since become a
-core dependency of software used across the world including flagship projects
-like `PyTorch <https://pytorch.org>`__ and `Tensorflow
-<https://www.tensorflow.org>`__. Every day, it is downloaded over 400'000 times.
-Hundreds of contributed extensions and generalizations address use cases of
-this diverse audience. However, all of this success also came with costs: the
-complexity of the library grew tremendously, which had a negative impact on
-efficiency.
-
-Curiously, the situation now is reminiscent of 2015: binding generation with
-existing tools (`Boost.Python <https://github.com/boostorg/python>`__, `pybind11
-<http://github.com/pybind/pybind11>`__) is slow and produces enormous binaries
-with overheads on runtime performance. At the same time, key improvements in
-C++17 and Python 3.8 provide opportunities for drastic simplifications.
-Therefore, I am starting *another* binding project. This time, the scope is
-intentionally limited so that this doesn't turn into an endless cycle.
-
-So what is different?
----------------------
-
-nanobind is highly related to pybind11 and inherits most of its conventions
-and syntax. The main difference is a change in philosophy: pybind11 must
-deal with *all of C++* to bind legacy codebases, while nanobind targets
-a smaller C++ subset. *The codebase has to adapt to the binding tool and not
-the other way around*, which allows nanobind to be simpler and faster. Pull
-requests with extensions and generalizations to handle subtle fringe cases were
-welcomed in pybind11, but they will likely be rejected in this project.
-
-An overview of removed features is provided in a :ref:`separate section
-<removed>`. Besides feature removal, the rewrite was also an opportunity to
-address :ref:`long-standing performance issues <perf_improvements>` and add a
-number of :ref:`major quality-of-life improvements <major_additions>` and
-:ref:`smaller features <minor_additions>`.
-
-.. _perf_improvements:
-
-Performance improvements
-------------------------
-
-The :ref:`benchmark section <benchmarks>` evaluates the impact of the following
-performance improvements:
-
-- **Compact objects**: C++ objects are now co-located with the Python object
-  whenever possible (less pointer chasing compared to pybind11). The
-  per-instance overhead for wrapping a C++ type into a Python object shrinks by
-  a factor of 2.3x. (pybind11: 56 bytes, nanobind: 24 bytes.)
-
-- **Compact functions**: C++ function binding information is now co-located
-  with the Python function object (less pointer chasing).
-
-- **Compact types**: C++ type binding information is now co-located with the Python type object
-  (less pointer chasing, fewer hashtable lookups).
-
-- **Fast hash table**: nanobind upgrades several important internal
-  associative data structures that previously used ``std::unordered_map`` to a
-  more efficient alternative (`tsl::robin_map
-  <https://github.com/Tessil/robin-map>`__, which is included as a git
-  submodule).
-
-- **Vector calls**: function calls from/to Python are realized using `PEP 590
-  vector calls <https://www.python.org/dev/peps/pep-0590>`__, which gives a nice
-  speed boost. The main function dispatch loop no longer allocates heap memory.
-
-- **Library component**: pybind11 was designed as a header-only library, which
-  is generally a good thing because it simplifies the compilation workflow.
-  However, one major downside of this is that a large amount of redundant code
-  has to be compiled in each binding file (e.g., the function dispatch loop and
-  all of the related internal data structures). nanobind compiles a separate
-  shared or static support library ("*libnanobind*") and links it against the
-  binding code to avoid redundant compilation. The CMake interface
-  :cmake:command:`nanobind_add_module()` fully automates these extra
-  steps.
-
-- **Smaller headers**: ``#include <pybind11/pybind11.h>`` pulls in a large
-  portion of the STL (about 2.1 MiB of headers with Clang and libc++). nanobind
-  minimizes STL usage to avoid this problem. Type casters even for for basic
-  types like ``std::string`` require an explicit opt-in by including an extra
-  header file (e.g. ``#include <nanobind/stl/string.h>``).
-
-- **Simpler compilation**: pybind11 was dependent on *link time optimization*
-  (LTO) to produce reasonably-sized bindings, which makes linking a build time
-  bottleneck. With nanobind's split into a precompiled library and minimal
-  metatemplating, LTO is no longer crucial and can be skipped.
-
-- **Free-threading**: Python 3.13+ supports a free-threaded mode that removes
-  the *Global Interpreter Lock* (GIL). Both pybind11 and nanobind support
-  free-threading as of recently. When comparing the two, nanobind provides
-  better multi-core scaling using a localized locking scheme. In pybind11, lock
-  contention on a central ``internals`` data structure used in every binding
-  operation becomes a bottleneck in practice.
-
-- **Lifetime management**: nanobind maintains efficient internal data
-  structures for lifetime management (needed for :cpp:class:`nb::keep_alive
-  <keep_alive>`, :cpp:enumerator:`nb::rv_policy::reference_internal
-  <rv_policy::reference_internal>`, the ``std::shared_ptr`` interface, etc.).
-  With these changes, bound types no longer need to be weak-referenceable,
-  which saves a pointer per instance.
-
-.. _major_additions:
-
-Major additions
----------------
-
-nanobind includes a number of quality-of-life improvements for developers:
-
-- **N-dimensional arrays**: nanobind can exchange data with modern array programming
-  frameworks. It uses either `DLPack <https://github.com/dmlc/dlpack>`__ or the
-  `buffer protocol <https://docs.python.org/3/c-api/buffer.html>`__ to achieve
-  *zero-copy* CPU/GPU array exchange with frameworks like `NumPy
-  <https://numpy.org>`__, `PyTorch <https://pytorch.org>`__, `TensorFlow
-  <https://www.tensorflow.org>`__, `JAX <https://jax.readthedocs.io>`__, etc. See
-  the :ref:`section on n-dimensional arrays <ndarrays>` for details.
-
-- **Stable ABI**: nanobind can target Python's `stable ABI interface
-  <https://docs.python.org/3/c-api/stable.html>`__ starting with Python 3.12.
-  This means that extension modules will be compatible with future version of
-  Python without having to compile separate binaries per interpreter. That
-  vision is still relatively far out, however: it will require Python 3.12+ to
-  be widely deployed.
-
-- **Stub generation**: nanobind ships with a custom :ref:`stub generator
-  <stubs>` and CMake integration to automatically create high quality stubs as
-  part of the build process. `Stubs
-  <https://typing.readthedocs.io/en/latest/source/stubs.html>`__ make compiled
-  extension code compatible with visual autocomplete in editors like `Visual
-  Studio Code <https://code.visualstudio.com>`__ and static type checkers like
-  `MyPy <https://github.com/python/mypy>`__, `PyRight
-  <https://github.com/microsoft/pyright>`__ and `PyType
-  <https://github.com/google/pytype>`__.
-
-- **Smart pointers, ownership, etc.**: corner cases in pybind11 related to
-  smart/unique pointers and callbacks could lead to undefined behavior. A later
-  pybind11 redesign (``smart_holder``) was able to address these problems, but
-  this came at the cost of further increased runtime overheads. The object
-  ownership model of nanobind avoids this undefined behavior without penalizing
-  runtime performance.
-
-- **Leak warnings**: When the Python interpreter shuts down, nanobind reports
-  instance, type, and function leaks related to bindings, which is useful for
-  tracking down reference counting issues.  If these warnings are undesired,
-  call :cpp:func:`nb::set_leak_warnings(false) <set_leak_warnings>`. nanobind
-  also fully deletes its internal data structures when the Python interpreter
-  terminates, which avoids memory leak reports in tools like *valgrind*.
-
-- **Better docstrings**: pybind11 pre-renders docstrings while the binding code
-  runs. In other words, every call to ``.def(...)`` to bind a function
-  immediately creates the underlying docstring. When a function takes a C++
-  type as parameter that is not yet registered in pybind11, the docstring will
-  include a C++ type name (e.g. ``std::vector<int, std::allocator<int>>``),
-  which can look rather ugly. pybind11 binding declarations must be carefully
-  arranged to work around this issue.
-
-  nanobind avoids the issue altogether by not pre-rendering docstrings: they
-  are created on the fly when queried. nanobind also has improved
-  out-of-the-box compatibility with documentation generation tools like `Sphinx
-  <https://www.sphinx-doc.org/en/master/>`__.
-
-- **Low-level API**: nanobind exposes an optional low-level API to provide
-  fine-grained control over diverse aspects including :ref:`instance creation
-  <lowlevel>`, :ref:`type creation <typeslots>`, and it can store
-  :ref:`supplemental data <supplement>` in types. The low-level API provides a
-  useful escape hatch to pursue advanced projects that were not foreseen in
-  the design of this library.
-
-.. _minor_additions:
-
-Minor additions
----------------
-
-The following lists minor-but-useful additions relative to pybind11.
-
-- **Finding Python objects associated with a C++ instance**: In addition to all
-  of the return value policies supported by pybind11, nanobind provides one
-  additional policy named :cpp:enumerator:`nb::rv_policy::none
-  <rv_policy::none>` that *only* succeeds when the return value is already a
-  known/registered Python object. In other words, this policy will never
-  attempt to move, copy, or reference a C++ instance by constructing a new
-  Python object.
-
-  The new :cpp:func:`nb::find() <find>` function encapsulates this behavior. It
-  resembles :cpp:func:`nb::cast() <cast>` in the sense that it returns the
-  Python object associated with a C++ instance. But while :cpp:func:`nb::cast()
-  <cast>` will create that Python object if it doesn't yet exist,
-  :cpp:func:`nb::find() <find>` will return a ``nullptr`` object. This function
-  is useful to interface with Python's :ref:`cyclic garbage collector
-  <fixing_refleaks>`.
-
-- **Parameterized wrappers**: The :cpp:class:`nb::handle_t\<T\> <handle_t>` type
-  behaves just like the :cpp:class:`nb::handle <handle>` class and wraps a
-  ``PyObject *`` pointer. However, when binding a function that takes such an
-  argument, nanobind will only call the associated function overload when the
-  underlying Python object wraps a C++ instance of type ``T``.
-
-  Similarly, the :cpp:class:`nb::type_object_t\<T\> <type_object_t>` type
-  behaves just like the :cpp:class:`nb::type_object <type_object>` class and
-  wraps a ``PyTypeObject *`` pointer. However, when binding a function that
-  takes such an argument, nanobind will only call the associated function
-  overload when the underlying Python type object is a subtype of the C++ type
-  ``T``.
-
-  Finally, the :cpp:class:`nb::typed\<T, Ts...\> <typed>` annotation can 
-  parameterize any other type. The feature exists to improve the
-  expressiveness of type signatures (e.g., to turn ``list`` into
-  ``list[int]``). Note, however, that nanobind does not perform additional
-  runtime checks in this case. Please see the section on :ref:`parameterizing
-  generics <typing_generics_parameterizing>` for further details.
-
-- **Signature overrides**: it may sometimes be necessary to tweak the
-  type signature of a class or function to provide richer type information to
-  static type checkers like `MyPy <https://github.com/python/mypy>`__ or
-  `PyRight <https://github.com/microsoft/pyright>`__. In such cases, specify
-  the :cpp:class:`nb::sig <signature>` attribute to override the default
-  nanobind-provided signature.
-
-  For example, the following function signature annotation creates an overload
-  that should only be called with an ``1``-valued integer literal. While the
-  function also includes a runtime check, a static type checker can now ensure
-  that this error condition cannot possibly be triggered by a given piece of code.
-
-  .. code-block:: cpp
-
-     m.def("f",
-           [](int arg) {
-               if (arg != 1)
-                  nb::raise("invalid input");
-               return arg;
-           },
-           nb::sig("def f(arg: typing.Literal[1], /) -> int"));
-
-  Please see the section on :ref:`customizing function signatures
-  <typing_signature_functions>` and :ref:`class signatures
-  <typing_signature_classes>` for further details.
-
-TLDR
-----
-
-My recommendation is that current pybind11 users look into migrating to
-nanobind. Fixing all the long-standing issues in pybind11 (see above list)
-would require a substantial redesign and years of careful work by a team of C++
-metaprogramming experts. At the same time, changing anything in pybind11 is
-extremely hard because of the large number of downstream users and their
-requirements on API/ABI stability. I personally don't have the time and
-energy to fix pybind11 and have moved my focus to this project.
diff --git a/src/nanobind/ext/robin_map/.clang-format b/src/nanobind/ext/robin_map/.clang-format
deleted file mode 100644
index f6cb8ad..0000000
--- a/src/nanobind/ext/robin_map/.clang-format
+++ /dev/null
@@ -1 +0,0 @@
-BasedOnStyle: Google
diff --git a/src/nanobind/ext/robin_map/.codecov.yml b/src/nanobind/ext/robin_map/.codecov.yml
deleted file mode 100644
index 92a0a4a..0000000
--- a/src/nanobind/ext/robin_map/.codecov.yml
+++ /dev/null
@@ -1,5 +0,0 @@
-comment: off
-coverage:
-  status:
-    project: off
-    patch: off
diff --git a/src/nanobind/ext/robin_map/.github/workflows/ci.yml b/src/nanobind/ext/robin_map/.github/workflows/ci.yml
deleted file mode 100644
index 96b698a..0000000
--- a/src/nanobind/ext/robin_map/.github/workflows/ci.yml
+++ /dev/null
@@ -1,136 +0,0 @@
-name: CI
-
-on: [push, pull_request, release]
-
-jobs:
-  build:
-    strategy:
-      fail-fast: false
-      matrix:
-        config:
-        - {
-            name: linux-x64-gcc,
-            os: ubuntu-latest,
-            cxx: g++,
-            cmake-build-type: Release
-          }
-        - {
-            name: linux-x64-gcc-no-exceptions,
-            os: ubuntu-latest,
-            cxx: g++,
-            cxx-flags: -fno-exceptions,
-            cmake-build-type: Release
-          }
-        - {
-            name: linux-x64-clang,
-            os: ubuntu-latest,
-            cxx: clang++,
-            cmake-build-type: Release
-          }
-        - {
-            name: macos-x64-gcc,
-            os:  macos-13,
-            cxx: g++,
-            cmake-build-type: Release
-          }
-        - {
-            name: macos-x64-clang,
-            os:  macos-13,
-            cxx: clang++,
-            cmake-build-type: Release
-          }
-        - {
-            name: linux-x64-clang-sanitize,
-            os: ubuntu-latest,
-            cxx: clang++,
-            cxx-flags: "-fsanitize=address,undefined",
-            cmake-build-type: Release
-          }
-        - {
-            name: linux-x64-gcc-coverage,
-            os: ubuntu-latest,
-            cxx: g++,
-            cxx-flags: --coverage,
-            gcov-tool: gcov,
-            cmake-build-type: Debug
-          }
-        - {
-            name: windows-x64-vs-2019,
-            os: windows-2019,
-            cmake-build-type: Release,
-            cmake-generator: Visual Studio 16 2019,
-            cmake-platform: x64,
-            vcpkg-triplet: x64-windows-static-md
-          }
-        - {
-            name: windows-x86-vs-2019,
-            os: windows-2019,
-            cmake-build-type: Release,
-            cmake-generator: Visual Studio 16 2019,
-            cmake-platform: Win32,
-            vcpkg-triplet: x86-windows-static-md
-          }
-        - {
-            name: windows-x64-vs-2022,
-            os: windows-2022,
-            cmake-build-type: Release,
-            cmake-generator: Visual Studio 17 2022,
-            cmake-platform: x64,
-            vcpkg-triplet: x64-windows-static-md
-          }
-        - {
-            name: windows-x86-vs-2022,
-            os: windows-2022,
-            cmake-build-type: Release,
-            cmake-generator: Visual Studio 17 2022,
-            cmake-platform: Win32,
-            vcpkg-triplet: x86-windows-static-md
-          }
-    name: ${{matrix.config.name}}
-    runs-on: ${{matrix.config.os}}
-    steps:
-    - uses: actions/checkout@v2
-
-    # Windows
-    - name: Install boost (Windows)
-      run: vcpkg install boost-test:${{matrix.config.vcpkg-triplet}}
-      if: runner.os == 'Windows'
-
-    - name: Configure CMake (Windows)
-      run: cmake -G "${{matrix.config.cmake-generator}}" -A ${{matrix.config.cmake-platform}} -DCMAKE_BUILD_TYPE=${{matrix.config.cmake-build-type}} -DCMAKE_TOOLCHAIN_FILE="$env:VCPKG_INSTALLATION_ROOT/scripts/buildsystems/vcpkg.cmake" -DVCPKG_TARGET_TRIPLET=${{matrix.config.vcpkg-triplet}} -S ${{github.workspace}}/tests -B ${{github.workspace}}/build
-      if: runner.os == 'Windows'
-
-    - name: Build (Windows)
-      run: cmake --build ${{github.workspace}}/build --config ${{matrix.config.cmake-build-type}} --verbose
-      if: runner.os == 'Windows'
-
-    - name: Test (Windows)
-      run: ${{github.workspace}}/build/${{matrix.config.cmake-build-type}}/tsl_robin_map_tests.exe
-      if: runner.os == 'Windows'
-
-    # Linux or macOS
-    - name: Install boost (Linux or macOS)
-      run: vcpkg install boost-test
-      if: runner.os == 'Linux' || runner.os == 'macOS'
-
-    - name: Configure CMake (Linux or macOS)
-      run: cmake -DCMAKE_BUILD_TYPE=${{matrix.config.cmake-build-type}} -DCMAKE_TOOLCHAIN_FILE="$VCPKG_INSTALLATION_ROOT/scripts/buildsystems/vcpkg.cmake" -S ${{github.workspace}}/tests -B ${{github.workspace}}/build
-      env:
-        CXX: ${{matrix.config.cxx}}
-        CXXFLAGS: ${{matrix.config.cxx-flags}}
-      if: runner.os == 'Linux' || runner.os == 'macOS'
-
-    - name: Build (Linux or macOS)
-      run: cmake --build ${{github.workspace}}/build --verbose
-      if: runner.os == 'Linux' || runner.os == 'macOS'
-
-    - name: Test (Linux or macOS)
-      run: ${{github.workspace}}/build/tsl_robin_map_tests
-      if: runner.os == 'Linux' || runner.os == 'macOS'
-
-    - name: Coverage
-      run: |
-        sudo apt-get install -y lcov
-        lcov -c -b ${{github.workspace}}/include -d ${{github.workspace}}/build -o ${{github.workspace}}/coverage.info --no-external --gcov-tool ${{matrix.config.gcov-tool}}
-        bash <(curl -s https://codecov.io/bash) -f ${{github.workspace}}/coverage.info
-      if: ${{matrix.config.name == 'linux-x64-gcc-coverage'}}
diff --git a/src/nanobind/ext/robin_map/CMakeLists.txt b/src/nanobind/ext/robin_map/CMakeLists.txt
deleted file mode 100644
index be1a3ff..0000000
--- a/src/nanobind/ext/robin_map/CMakeLists.txt
+++ /dev/null
@@ -1,87 +0,0 @@
-cmake_minimum_required(VERSION 3.5)
-
-project(tsl-robin-map VERSION 1.4.0 LANGUAGES CXX)
-
-include(GNUInstallDirs)
-
-
-set(IS_MAIN_PROJECT FALSE)
-if(CMAKE_SOURCE_DIR STREQUAL PROJECT_SOURCE_DIR)
-  set(IS_MAIN_PROJECT TRUE)
-endif()
-
-# Enable the install target if the project is used main project (disable by default if subproject)
-option(TSL_ROBIN_MAP_ENABLE_INSTALL "Enable install target" ${IS_MAIN_PROJECT})
-
-
-add_library(robin_map INTERFACE)
-# Use tsl::robin_map as target, more consistent with other libraries conventions (Boost, Qt, ...)
-add_library(tsl::robin_map ALIAS robin_map)
-
-target_include_directories(robin_map INTERFACE
-                           "$<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>"
-                           "$<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}>")
-
-list(APPEND headers "${CMAKE_CURRENT_SOURCE_DIR}/include/tsl/robin_growth_policy.h"
-                    "${CMAKE_CURRENT_SOURCE_DIR}/include/tsl/robin_hash.h"
-                    "${CMAKE_CURRENT_SOURCE_DIR}/include/tsl/robin_map.h"
-                    "${CMAKE_CURRENT_SOURCE_DIR}/include/tsl/robin_set.h")
-target_sources(robin_map INTERFACE "$<BUILD_INTERFACE:${headers}>")
-
-if(MSVC)
-    target_sources(robin_map INTERFACE
-                   "$<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/tsl-robin-map.natvis>"
-                   "$<INSTALL_INTERFACE:${CMAKE_INSTALL_DATAROOTDIR}/tsl-robin-map.natvis>")
-endif()
-
-# Installation
-if(TSL_ROBIN_MAP_ENABLE_INSTALL)
-    include(CMakePackageConfigHelpers)
-
-    ## Install include directory and potential natvis file
-    install(DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}/include/tsl"
-            DESTINATION "${CMAKE_INSTALL_INCLUDEDIR}")
-
-    if(MSVC)
-        install(FILES "${CMAKE_CURRENT_SOURCE_DIR}/tsl-robin-map.natvis"
-                DESTINATION "${CMAKE_INSTALL_DATAROOTDIR}")
-    endif()
-
-
-
-    ## Create and install tsl-robin-mapConfig.cmake
-    configure_package_config_file("${CMAKE_CURRENT_SOURCE_DIR}/cmake/tsl-robin-mapConfig.cmake.in"
-                                  "${CMAKE_CURRENT_BINARY_DIR}/tsl-robin-mapConfig.cmake"
-                                  INSTALL_DESTINATION "${CMAKE_INSTALL_DATAROOTDIR}/cmake/tsl-robin-map")
-
-    install(FILES "${CMAKE_CURRENT_BINARY_DIR}/tsl-robin-mapConfig.cmake"
-            DESTINATION "${CMAKE_INSTALL_DATAROOTDIR}/cmake/tsl-robin-map")
-
-
-    ## Create local tsl-robin-mapTargets.cmake
-    export(TARGETS robin_map NAMESPACE tsl:: FILE "${CMAKE_CURRENT_BINARY_DIR}/tsl-robin-mapTargets.cmake")
-
-    ## Create and install global tsl-robin-mapTargets.cmake
-    install(TARGETS robin_map
-            EXPORT tsl-robin-mapTargets)
-
-    install(EXPORT tsl-robin-mapTargets
-            NAMESPACE tsl::
-            DESTINATION "${CMAKE_INSTALL_DATAROOTDIR}/cmake/tsl-robin-map")
-
-
-
-    ## Create and install tsl-robin-mapConfigVersion.cmake
-    # tsl-robin-map is header-only and does not depend on the architecture.
-    # Remove CMAKE_SIZEOF_VOID_P from tsl-robin-mapConfigVersion.cmake so that a
-    # tsl-robin-mapConfig.cmake generated for a 64 bit target can be used for 32 bit
-    # targets and vice versa.
-    set(CMAKE_SIZEOF_VOID_P_BACKUP ${CMAKE_SIZEOF_VOID_P})
-    unset(CMAKE_SIZEOF_VOID_P)
-    write_basic_package_version_file("${CMAKE_CURRENT_BINARY_DIR}/tsl-robin-mapConfigVersion.cmake"
-                                     COMPATIBILITY SameMajorVersion)
-    set(CMAKE_SIZEOF_VOID_P ${CMAKE_SIZEOF_VOID_P_BACKUP})
-
-    install(FILES "${CMAKE_CURRENT_BINARY_DIR}/tsl-robin-mapConfigVersion.cmake"
-            DESTINATION "${CMAKE_INSTALL_DATAROOTDIR}/cmake/tsl-robin-map")
-endif()
diff --git a/src/nanobind/ext/robin_map/LICENSE b/src/nanobind/ext/robin_map/LICENSE
deleted file mode 100644
index e9c5ae9..0000000
--- a/src/nanobind/ext/robin_map/LICENSE
+++ /dev/null
@@ -1,21 +0,0 @@
-MIT License
-
-Copyright (c) 2017 Thibaut Goetghebuer-Planchon <tessil@gmx.com>
-
-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.
diff --git a/src/nanobind/ext/robin_map/README.md b/src/nanobind/ext/robin_map/README.md
deleted file mode 100644
index 09fc544..0000000
--- a/src/nanobind/ext/robin_map/README.md
+++ /dev/null
@@ -1,521 +0,0 @@
-[![CI](https://github.com/Tessil/robin-map/actions/workflows/ci.yml/badge.svg?branch=master)](https://github.com/Tessil/robin-map/actions/workflows/ci.yml)
-
-## A C++ implementation of a fast hash map and hash set using robin hood hashing
-
-The robin-map library is a C++ implementation of a fast hash map and hash set using open-addressing and linear robin hood hashing with backward shift deletion to resolve collisions.
-
-Four classes are provided: `tsl::robin_map`, `tsl::robin_set`, `tsl::robin_pg_map` and `tsl::robin_pg_set`. The first two are faster and use a power of two growth policy, the last two use a prime growth policy instead and are able to cope better with a poor hash function. Use the prime version if there is a chance of repeating patterns in the lower bits of your hash (e.g. you are storing pointers with an identity hash function). See [GrowthPolicy](#growth-policy) for details.
-
-A **benchmark** of `tsl::robin_map` against other hash maps may be found [here](https://tessil.github.io/2016/08/29/benchmark-hopscotch-map.html). This page also gives some advices on which hash table structure you should try for your use case (useful if you are a bit lost with the multiple hash tables implementations in the `tsl` namespace).
-
-### Key features
-
-- Header-only library, just add the [include](include/) directory to your include path and you are ready to go. If you use CMake, you can also use the `tsl::robin_map` exported target from the [CMakeLists.txt](CMakeLists.txt).
-- Fast hash table, check the [benchmark](https://tessil.github.io/2016/08/29/benchmark-hopscotch-map.html) for some numbers.
-- Support for move-only and non-default constructible key/value.
-- Support for heterogeneous lookups allowing the usage of `find` with a type different than `Key` (e.g. if you have a map that uses `std::unique_ptr<foo>` as key, you can use a `foo*` or a `std::uintptr_t` as key parameter to `find` without constructing a `std::unique_ptr<foo>`, see [example](#heterogeneous-lookups)).
-- No need to reserve any sentinel value from the keys.
-- Possibility to store the hash value alongside the stored key-value for faster rehash and lookup if the hash or the key equal functions are expensive to compute. Note that hash may be stored even if not asked explicitly when the library can detect that it will have no impact on the size of the structure in memory due to alignment. See the [StoreHash](https://tessil.github.io/robin-map/classtsl_1_1robin__map.html#details) template parameter for details.
-- If the hash is known before a lookup, it is possible to pass it as parameter to speed-up the lookup (see `precalculated_hash` parameter in [API](https://tessil.github.io/robin-map/classtsl_1_1robin__map.html#a35021b11aabb61820236692a54b3a0f8)).
-- Support for efficient serialization and deserialization (see [example](#serialization) and the `serialize/deserialize` methods in the [API](https://tessil.github.io/robin-map/classtsl_1_1robin__map.html) for details).
-- The library can be used with exceptions disabled (through `-fno-exceptions` option on Clang and GCC, without an `/EH` option on MSVC or simply by defining `TSL_NO_EXCEPTIONS`). `std::terminate` is used in replacement of the `throw` instruction when exceptions are disabled.
-- API closely similar to `std::unordered_map` and `std::unordered_set`.
-
-### Differences compared to `std::unordered_map`
-
-`tsl::robin_map` tries to have an interface similar to `std::unordered_map`, but some differences exist.
-- The **strong exception guarantee only holds** if the following statement is true `std::is_nothrow_swappable<value_type>::value && std::is_nothrow_move_constructible<value_type>::value` (where `value_type` is `Key` for `tsl::robin_set` and `std::pair<Key, T>` for `tsl::robin_map`). Otherwise if an exception is thrown during the swap or the move, the structure may end up in a undefined state. Note that per the standard, a `value_type` with a noexcept copy constructor and no move constructor also satisfies this condition and will thus guarantee the strong exception guarantee for the structure (see [API](https://tessil.github.io/robin-map/classtsl_1_1robin__map.html#details) for details).
-- The type `Key`, and also `T` in case of map, must be swappable. They must also be copy and/or move constructible.
-- Iterator invalidation doesn't behave in the same way, any operation modifying the hash table invalidate them (see [API](https://tessil.github.io/robin-map/classtsl_1_1robin__map.html#details) for details).
-- References and pointers to keys or values in the map are invalidated in the same way as iterators to these keys-values.
-- For iterators of `tsl::robin_map`, `operator*()` and `operator->()` return a reference and a pointer to `const std::pair<Key, T>` instead of `std::pair<const Key, T>` making the value `T` not modifiable. To modify the value you have to call the `value()` method of the iterator to get a mutable reference. Example:
-```c++
-tsl::robin_map<int, int> map = {{1, 1}, {2, 1}, {3, 1}};
-for(auto it = map.begin(); it != map.end(); ++it) {
-    //it->second = 2; // Illegal
-    it.value() = 2; // Ok
-}
-```
-- No support for some buckets related methods (like `bucket_size`, `bucket`, ...).
-
-These differences also apply between `std::unordered_set` and `tsl::robin_set`.
-
-Thread-safety guarantees are the same as `std::unordered_map/set` (i.e. possible to have multiple readers with no writer).
-
-### Growth policy
-
-The library supports multiple growth policies through the `GrowthPolicy` template parameter. Three policies are provided by the library but you can easily implement your own if needed.
-
-* **[tsl::rh::power_of_two_growth_policy.](https://tessil.github.io/robin-map/classtsl_1_1rh_1_1power__of__two__growth__policy.html)** Default policy used by `tsl::robin_map/set`. This policy keeps the size of the bucket array of the hash table to a power of two. This constraint allows the policy to avoid the usage of the slow modulo operation to map a hash to a bucket, instead of <code>hash % 2<sup>n</sup></code>, it uses <code>hash & (2<sup>n</sup> - 1)</code> (see [fast modulo](https://en.wikipedia.org/wiki/Modulo_operation#Performance_issues)). Fast but this may cause a lot of collisions with a poor hash function as the modulo with a power of two only masks the most significant bits in the end.
-* **[tsl::rh::prime_growth_policy.](https://tessil.github.io/robin-map/classtsl_1_1rh_1_1prime__growth__policy.html)** Default policy used by `tsl::robin_pg_map/set`. The policy keeps the size of the bucket array of the hash table to a prime number. When mapping a hash to a bucket, using a prime number as modulo will result in a better distribution of the hash across the buckets even with a poor hash function. To allow the compiler to optimize the modulo operation, the policy use a lookup table with constant primes modulos (see [API](https://tessil.github.io/robin-map/classtsl_1_1rh_1_1prime__growth__policy.html#details) for details). Slower than `tsl::rh::power_of_two_growth_policy` but more secure.
-* **[tsl::rh::mod_growth_policy.](https://tessil.github.io/robin-map/classtsl_1_1rh_1_1mod__growth__policy.html)** The policy grows the map by a customizable growth factor passed in parameter. It then just use the modulo operator to map a hash to a bucket. Slower but more flexible.
-
-
-To implement your own policy, you have to implement the following interface.
-
-```c++
-struct custom_policy {
-    // Called on hash table construction and rehash, min_bucket_count_in_out is the minimum buckets
-    // that the hash table needs. The policy can change it to a higher number of buckets if needed 
-    // and the hash table will use this value as bucket count. If 0 bucket is asked, then the value
-    // must stay at 0.
-    explicit custom_policy(std::size_t& min_bucket_count_in_out);
-    
-    // Return the bucket [0, bucket_count()) to which the hash belongs. 
-    // If bucket_count() is 0, it must always return 0.
-    std::size_t bucket_for_hash(std::size_t hash) const noexcept;
-    
-    // Return the number of buckets that should be used on next growth
-    std::size_t next_bucket_count() const;
-    
-    // Maximum number of buckets supported by the policy
-    std::size_t max_bucket_count() const;
-    
-    // Reset the growth policy as if the policy was created with a bucket count of 0.
-    // After a clear, the policy must always return 0 when bucket_for_hash() is called.
-    void clear() noexcept;
-}
-```
-
-### Installation
-
-To use robin-map, just add the [include](include/) directory to your include path. It is a **header-only** library.
-
-If you use CMake, you can also use the `tsl::robin_map` exported target from the [CMakeLists.txt](CMakeLists.txt) with `target_link_libraries`. 
-```cmake
-# Example where the robin-map project is stored in a third-party directory
-add_subdirectory(third-party/robin-map)
-target_link_libraries(your_target PRIVATE tsl::robin_map)  
-```
-
-If the project has been installed through `make install`, you can also use `find_package(tsl-robin-map REQUIRED)` instead of `add_subdirectory`.
-
-The library is available in [vcpkg](https://github.com/Microsoft/vcpkg/tree/master/ports/robin-map) and [conan](https://conan.io/center/tsl-robin-map). It's also present in [Debian](https://packages.debian.org/buster/robin-map-dev), [Ubuntu](https://packages.ubuntu.com/disco/robin-map-dev) and [Fedora](https://apps.fedoraproject.org/packages/robin-map-devel) package repositories.
-
-The code should work with any C++17 standard-compliant compiler.
-
-To run the tests you will need the Boost Test library and CMake.
-
-```bash
-git clone https://github.com/Tessil/robin-map.git
-cd robin-map/tests
-mkdir build
-cd build
-cmake ..
-cmake --build .
-./tsl_robin_map_tests
-```
-
-### Usage
-
-The API can be found [here](https://tessil.github.io/robin-map/). 
-
-All methods are not documented yet, but they replicate the behavior of the ones in `std::unordered_map` and `std::unordered_set`, except if specified otherwise.
-
-
-### Example
-
-```c++
-#include <cstdint>
-#include <iostream>
-#include <string>
-#include <tsl/robin_map.h>
-#include <tsl/robin_set.h>
-
-int main() {
-    tsl::robin_map<std::string, int> map = {{"a", 1}, {"b", 2}};
-    map["c"] = 3;
-    map["d"] = 4;
-    
-    map.insert({"e", 5});
-    map.erase("b");
-    
-    for(auto it = map.begin(); it != map.end(); ++it) {
-        //it->second += 2; // Not valid.
-        it.value() += 2;
-    }
-    
-    // {d, 6} {a, 3} {e, 7} {c, 5}
-    for(const auto& key_value : map) {
-        std::cout << "{" << key_value.first << ", " << key_value.second << "}" << std::endl;
-    }
-    
-        
-    if(map.find("a") != map.end()) {
-        std::cout << "Found \"a\"." << std::endl;
-    }
-    
-    const std::size_t precalculated_hash = std::hash<std::string>()("a");
-    // If we already know the hash beforehand, we can pass it in parameter to speed-up lookups.
-    if(map.find("a", precalculated_hash) != map.end()) {
-        std::cout << "Found \"a\" with hash " << precalculated_hash << "." << std::endl;
-    }
-    
-    
-    /*
-     * Calculating the hash and comparing two std::string may be slow. 
-     * We can store the hash of each std::string in the hash map to make 
-     * the inserts and lookups faster by setting StoreHash to true.
-     */ 
-    tsl::robin_map<std::string, int, std::hash<std::string>, 
-                   std::equal_to<std::string>,
-                   std::allocator<std::pair<std::string, int>>,
-                   true> map2;
-                       
-    map2["a"] = 1;
-    map2["b"] = 2;
-    
-    // {a, 1} {b, 2}
-    for(const auto& key_value : map2) {
-        std::cout << "{" << key_value.first << ", " << key_value.second << "}" << std::endl;
-    }
-    
-    
-    
-    
-    tsl::robin_set<int> set;
-    set.insert({1, 9, 0});
-    set.insert({2, -1, 9});
-    
-    // {0} {1} {2} {9} {-1}
-    for(const auto& key : set) {
-        std::cout << "{" << key << "}" << std::endl;
-    }
-}  
-```
-
-#### Heterogeneous lookups
-
-Heterogeneous overloads allow the usage of other types than `Key` for lookup and erase operations as long as the used types are hashable and comparable to `Key`.
-
-To activate the heterogeneous overloads in `tsl::robin_map/set`, the qualified-id `KeyEqual::is_transparent` must be valid. It works the same way as for [`std::map::find`](http://en.cppreference.com/w/cpp/container/map/find). You can either use [`std::equal_to<>`](http://en.cppreference.com/w/cpp/utility/functional/equal_to_void) or define your own function object.
-
-Both `KeyEqual` and `Hash` will need to be able to deal with the different types.
-
-```c++
-#include <functional>
-#include <iostream>
-#include <string>
-#include <tsl/robin_map.h>
-
-
-struct employee {
-    employee(int id, std::string name) : m_id(id), m_name(std::move(name)) {
-    }
-    
-    // Either we include the comparators in the class and we use `std::equal_to<>`...
-    friend bool operator==(const employee& empl, int empl_id) {
-        return empl.m_id == empl_id;
-    }
-    
-    friend bool operator==(int empl_id, const employee& empl) {
-        return empl_id == empl.m_id;
-    }
-    
-    friend bool operator==(const employee& empl1, const employee& empl2) {
-        return empl1.m_id == empl2.m_id;
-    }
-    
-    
-    int m_id;
-    std::string m_name;
-};
-
-// ... or we implement a separate class to compare employees.
-struct equal_employee {
-    using is_transparent = void;
-    
-    bool operator()(const employee& empl, int empl_id) const {
-        return empl.m_id == empl_id;
-    }
-    
-    bool operator()(int empl_id, const employee& empl) const {
-        return empl_id == empl.m_id;
-    }
-    
-    bool operator()(const employee& empl1, const employee& empl2) const {
-        return empl1.m_id == empl2.m_id;
-    }
-};
-
-struct hash_employee {
-    std::size_t operator()(const employee& empl) const {
-        return std::hash<int>()(empl.m_id);
-    }
-    
-    std::size_t operator()(int id) const {
-        return std::hash<int>()(id);
-    }
-};
-
-
-int main() {
-    // Use std::equal_to<> which will automatically deduce and forward the parameters
-    tsl::robin_map<employee, int, hash_employee, std::equal_to<>> map; 
-    map.insert({employee(1, "John Doe"), 2001});
-    map.insert({employee(2, "Jane Doe"), 2002});
-    map.insert({employee(3, "John Smith"), 2003});
-
-    // John Smith 2003
-    auto it = map.find(3);
-    if(it != map.end()) {
-        std::cout << it->first.m_name << " " << it->second << std::endl;
-    }
-
-    map.erase(1);
-
-
-
-    // Use a custom KeyEqual which has an is_transparent member type
-    tsl::robin_map<employee, int, hash_employee, equal_employee> map2;
-    map2.insert({employee(4, "Johnny Doe"), 2004});
-
-    // 2004
-    std::cout << map2.at(4) << std::endl;
-}  
-```
-
-#### Serialization
-
-The library provides an efficient way to serialize and deserialize a map or a set so that it can be saved to a file or send through the network.
-To do so, it requires the user to provide a function object for both serialization and deserialization.
-
-```c++
-struct serializer {
-    // Must support the following types for U: std::int16_t, std::uint32_t, 
-    // std::uint64_t, float and std::pair<Key, T> if a map is used or Key for 
-    // a set.
-    template<typename U>
-    void operator()(const U& value);
-};
-```
-
-```c++
-struct deserializer {
-    // Must support the following types for U: std::int16_t, std::uint32_t, 
-    // std::uint64_t, float and std::pair<Key, T> if a map is used or Key for 
-    // a set.
-    template<typename U>
-    U operator()();
-};
-```
-
-Note that the implementation leaves binary compatibility (endianness, float binary representation, size of int, ...) of the types it serializes/deserializes in the hands of the provided function objects if compatibility is required.
-
-More details regarding the `serialize` and `deserialize` methods can be found in the [API](https://tessil.github.io/robin-map/classtsl_1_1robin__map.html).
-
-```c++
-#include <cassert>
-#include <cstdint>
-#include <fstream>
-#include <type_traits>
-#include <tsl/robin_map.h>
-
-
-class serializer {
-public:
-    serializer(const char* file_name) {
-        m_ostream.exceptions(m_ostream.badbit | m_ostream.failbit);
-        m_ostream.open(file_name, std::ios::binary);
-    }
-    
-    template<class T,
-             typename std::enable_if<std::is_arithmetic<T>::value>::type* = nullptr>
-    void operator()(const T& value) {
-        m_ostream.write(reinterpret_cast<const char*>(&value), sizeof(T));
-    }
-    
-    void operator()(const std::pair<std::int64_t, std::int64_t>& value) {
-        (*this)(value.first);
-        (*this)(value.second);
-    }
-
-private:
-    std::ofstream m_ostream;
-};
-
-class deserializer {
-public:
-    deserializer(const char* file_name) {
-        m_istream.exceptions(m_istream.badbit | m_istream.failbit | m_istream.eofbit);
-        m_istream.open(file_name, std::ios::binary);
-    }
-    
-    template<class T>
-    T operator()() {
-        T value;
-        deserialize(value);
-        
-        return value;
-    }
-    
-private:
-    template<class T,
-             typename std::enable_if<std::is_arithmetic<T>::value>::type* = nullptr>
-    void deserialize(T& value) {
-        m_istream.read(reinterpret_cast<char*>(&value), sizeof(T));
-    }
-    
-    void deserialize(std::pair<std::int64_t, std::int64_t>& value) {
-        deserialize(value.first);
-        deserialize(value.second);
-    }
-
-private:
-    std::ifstream m_istream;
-};
-
-
-int main() {
-    const tsl::robin_map<std::int64_t, std::int64_t> map = {{1, -1}, {2, -2}, {3, -3}, {4, -4}};
-    
-    
-    const char* file_name = "robin_map.data";
-    {
-        serializer serial(file_name);
-        map.serialize(serial);
-    }
-    
-    {
-        deserializer dserial(file_name);
-        auto map_deserialized = tsl::robin_map<std::int64_t, std::int64_t>::deserialize(dserial);
-        
-        assert(map == map_deserialized);
-    }
-    
-    {
-        deserializer dserial(file_name);
-        
-        /**
-         * If the serialized and deserialized map are hash compatibles (see conditions in API), 
-         * setting the argument to true speed-up the deserialization process as we don't have 
-         * to recalculate the hash of each key. We also know how much space each bucket needs.
-         */
-        const bool hash_compatible = true;
-        auto map_deserialized = 
-            tsl::robin_map<std::int64_t, std::int64_t>::deserialize(dserial, hash_compatible);
-        
-        assert(map == map_deserialized);
-    }
-} 
-```
-
-##### Serialization with Boost Serialization and compression with zlib
-
-It is possible to use a serialization library to avoid the boilerplate. 
-
-The following example uses Boost Serialization with the Boost zlib compression stream to reduce the size of the resulting serialized file. The example requires C++20 due to the usage of the template parameter list syntax in lambdas, but it can be adapted to less recent versions.
-
-```c++
-#include <boost/archive/binary_iarchive.hpp>
-#include <boost/archive/binary_oarchive.hpp>
-#include <boost/iostreams/filter/zlib.hpp>
-#include <boost/iostreams/filtering_stream.hpp>
-#include <boost/serialization/split_free.hpp>
-#include <boost/serialization/utility.hpp>
-#include <cassert>
-#include <cstdint>
-#include <fstream>
-#include <tsl/robin_map.h>
-
-
-namespace boost { namespace serialization {
-    template<class Archive, class Key, class T>
-    void serialize(Archive & ar, tsl::robin_map<Key, T>& map, const unsigned int version) {
-        split_free(ar, map, version); 
-    }
-
-    template<class Archive, class Key, class T>
-    void save(Archive & ar, const tsl::robin_map<Key, T>& map, const unsigned int /*version*/) {
-        auto serializer = [&ar](const auto& v) { ar & v; };
-        map.serialize(serializer);
-    }
-
-    template<class Archive, class Key, class T>
-    void load(Archive & ar, tsl::robin_map<Key, T>& map, const unsigned int /*version*/) {
-        auto deserializer = [&ar]<typename U>() { U u; ar & u; return u; };
-        map = tsl::robin_map<Key, T>::deserialize(deserializer);
-    }
-}}
-
-
-int main() {
-    tsl::robin_map<std::int64_t, std::int64_t> map = {{1, -1}, {2, -2}, {3, -3}, {4, -4}};
-    
-    
-    const char* file_name = "robin_map.data";
-    {
-        std::ofstream ofs;
-        ofs.exceptions(ofs.badbit | ofs.failbit);
-        ofs.open(file_name, std::ios::binary);
-        
-        boost::iostreams::filtering_ostream fo;
-        fo.push(boost::iostreams::zlib_compressor());
-        fo.push(ofs);
-        
-        boost::archive::binary_oarchive oa(fo);
-        
-        oa << map;
-    }
-    
-    {
-        std::ifstream ifs;
-        ifs.exceptions(ifs.badbit | ifs.failbit | ifs.eofbit);
-        ifs.open(file_name, std::ios::binary);
-        
-        boost::iostreams::filtering_istream fi;
-        fi.push(boost::iostreams::zlib_decompressor());
-        fi.push(ifs);
-        
-        boost::archive::binary_iarchive ia(fi);
-     
-        tsl::robin_map<std::int64_t, std::int64_t> map_deserialized;   
-        ia >> map_deserialized;
-        
-        assert(map == map_deserialized);
-    }
-}
-```
-
-#### Performance pitfalls
-
-Two potential performance pitfalls involving `tsl::robin_map` and
-`tsl::robin_set` are noteworthy:
-
-1. *Bad hashes*. Hash functions that produce many collisions can lead to the
-   following surprising behavior: when the number of collisions exceeds a
-   certain threshold, the hash table will automatically expand to fix the
-   problem. However, in degenerate cases, this expansion might have _no effect_
-   on the collision count, causing a failure mode where a linear sequence of
-   insertion leads to exponential storage growth.
-
-   This case has mainly been observed when using the default power-of-two
-   growth strategy with the default STL `std::hash<T>` for arithmetic types
-   `T`, which is often an identity! See issue
-   [#39](https://github.com/Tessil/robin-map/issues/39) for an example. The
-   solution is simple: use a better hash function and/or `tsl::robin_pg_set` /
-   `tsl::robin_pg_map`.
-
-2. *Element erasure and low load factors*. `tsl::robin_map` and
-   `tsl::robin_set` mirror the STL map/set API, which exposes an `iterator
-   erase(iterator)` method that removes an element at a certain position,
-   returning a valid iterator that points to the next element.
-
-   Constructing this new iterator object requires walking to the next nonempty
-   bucket in the table, which can be a expensive operation when the hash table
-   has a low *load factor* (i.e., when `capacity()` is much larger then
-   `size()`).
-
-   The `erase()` method furthermore never shrinks & re-hashes the table as
-   this is not permitted by the specification of this function. A linear
-   sequence of random removals without intermediate insertions can then lead to
-   a degenerate case with quadratic runtime cost.
-
-   In such cases, an iterator return value is often not even needed, so the
-   cost is entirely unnecessary. Both `tsl::robin_set` and `tsl::robin_map`
-   therefore provide an alternative erasure method `void erase_fast(iterator)`
-   that does not return an iterator to avoid having to find the next element.
-
-### License
-
-The code is licensed under the MIT license, see the [LICENSE file](LICENSE) for details.
diff --git a/src/nanobind/ext/robin_map/cmake/tsl-robin-mapConfig.cmake.in b/src/nanobind/ext/robin_map/cmake/tsl-robin-mapConfig.cmake.in
deleted file mode 100644
index d2ce233..0000000
--- a/src/nanobind/ext/robin_map/cmake/tsl-robin-mapConfig.cmake.in
+++ /dev/null
@@ -1,9 +0,0 @@
-# This module sets the following variables:
-# * tsl-robin-map_FOUND - true if tsl-robin-map found on the system
-# * tsl-robin-map_INCLUDE_DIRS - the directory containing tsl-robin-map headers
-@PACKAGE_INIT@
-
-if(NOT TARGET tsl::robin_map)
-  include("${CMAKE_CURRENT_LIST_DIR}/tsl-robin-mapTargets.cmake")
-  get_target_property(tsl-robin-map_INCLUDE_DIRS tsl::robin_map INTERFACE_INCLUDE_DIRECTORIES)
-endif()
diff --git a/src/nanobind/ext/robin_map/doxygen.conf b/src/nanobind/ext/robin_map/doxygen.conf
deleted file mode 100644
index 534fdb5..0000000
--- a/src/nanobind/ext/robin_map/doxygen.conf
+++ /dev/null
@@ -1,2483 +0,0 @@
-# Doxyfile 1.8.11
-
-# This file describes the settings to be used by the documentation system
-# doxygen (www.doxygen.org) for a project.
-#
-# All text after a double hash (##) is considered a comment and is placed in
-# front of the TAG it is preceding.
-#
-# All text after a single hash (#) is considered a comment and will be ignored.
-# The format is:
-# TAG = value [value, ...]
-# For lists, items can also be appended using:
-# TAG += value [value, ...]
-# Values that contain spaces should be placed between quotes (\" \").
-
-#---------------------------------------------------------------------------
-# Project related configuration options
-#---------------------------------------------------------------------------
-
-# This tag specifies the encoding used for all characters in the config file
-# that follow. The default is UTF-8 which is also the encoding used for all text
-# before the first occurrence of this tag. Doxygen uses libiconv (or the iconv
-# built into libc) for the transcoding. See http://www.gnu.org/software/libiconv
-# for the list of possible encodings.
-# The default value is: UTF-8.
-
-DOXYFILE_ENCODING      = UTF-8
-
-# The PROJECT_NAME tag is a single word (or a sequence of words surrounded by
-# double-quotes, unless you are using Doxywizard) that should identify the
-# project for which the documentation is generated. This name is used in the
-# title of most generated pages and in a few other places.
-# The default value is: My Project.
-
-PROJECT_NAME           = robin-map
-
-# The PROJECT_NUMBER tag can be used to enter a project or revision number. This
-# could be handy for archiving the generated documentation or if some version
-# control system is used.
-
-PROJECT_NUMBER         = 
-
-# Using the PROJECT_BRIEF tag one can provide an optional one line description
-# for a project that appears at the top of each page and should give viewer a
-# quick idea about the purpose of the project. Keep the description short.
-
-PROJECT_BRIEF          = 
-
-# With the PROJECT_LOGO tag one can specify a logo or an icon that is included
-# in the documentation. The maximum height of the logo should not exceed 55
-# pixels and the maximum width should not exceed 200 pixels. Doxygen will copy
-# the logo to the output directory.
-
-PROJECT_LOGO           = 
-
-# The OUTPUT_DIRECTORY tag is used to specify the (relative or absolute) path
-# into which the generated documentation will be written. If a relative path is
-# entered, it will be relative to the location where doxygen was started. If
-# left blank the current directory will be used.
-
-OUTPUT_DIRECTORY       = doc/
-
-# If the CREATE_SUBDIRS tag is set to YES then doxygen will create 4096 sub-
-# directories (in 2 levels) under the output directory of each output format and
-# will distribute the generated files over these directories. Enabling this
-# option can be useful when feeding doxygen a huge amount of source files, where
-# putting all generated files in the same directory would otherwise causes
-# performance problems for the file system.
-# The default value is: NO.
-
-CREATE_SUBDIRS         = NO
-
-# If the ALLOW_UNICODE_NAMES tag is set to YES, doxygen will allow non-ASCII
-# characters to appear in the names of generated files. If set to NO, non-ASCII
-# characters will be escaped, for example _xE3_x81_x84 will be used for Unicode
-# U+3044.
-# The default value is: NO.
-
-ALLOW_UNICODE_NAMES    = NO
-
-# The OUTPUT_LANGUAGE tag is used to specify the language in which all
-# documentation generated by doxygen is written. Doxygen will use this
-# information to generate all constant output in the proper language.
-# Possible values are: Afrikaans, Arabic, Armenian, Brazilian, Catalan, Chinese,
-# Chinese-Traditional, Croatian, Czech, Danish, Dutch, English (United States),
-# Esperanto, Farsi (Persian), Finnish, French, German, Greek, Hungarian,
-# Indonesian, Italian, Japanese, Japanese-en (Japanese with English messages),
-# Korean, Korean-en (Korean with English messages), Latvian, Lithuanian,
-# Macedonian, Norwegian, Persian (Farsi), Polish, Portuguese, Romanian, Russian,
-# Serbian, Serbian-Cyrillic, Slovak, Slovene, Spanish, Swedish, Turkish,
-# Ukrainian and Vietnamese.
-# The default value is: English.
-
-OUTPUT_LANGUAGE        = English
-
-# If the BRIEF_MEMBER_DESC tag is set to YES, doxygen will include brief member
-# descriptions after the members that are listed in the file and class
-# documentation (similar to Javadoc). Set to NO to disable this.
-# The default value is: YES.
-
-BRIEF_MEMBER_DESC      = YES
-
-# If the REPEAT_BRIEF tag is set to YES, doxygen will prepend the brief
-# description of a member or function before the detailed description
-#
-# Note: If both HIDE_UNDOC_MEMBERS and BRIEF_MEMBER_DESC are set to NO, the
-# brief descriptions will be completely suppressed.
-# The default value is: YES.
-
-REPEAT_BRIEF           = YES
-
-# This tag implements a quasi-intelligent brief description abbreviator that is
-# used to form the text in various listings. Each string in this list, if found
-# as the leading text of the brief description, will be stripped from the text
-# and the result, after processing the whole list, is used as the annotated
-# text. Otherwise, the brief description is used as-is. If left blank, the
-# following values are used ($name is automatically replaced with the name of
-# the entity):The $name class, The $name widget, The $name file, is, provides,
-# specifies, contains, represents, a, an and the.
-
-ABBREVIATE_BRIEF       = "The $name class" \
-                         "The $name widget" \
-                         "The $name file" \
-                         is \
-                         provides \
-                         specifies \
-                         contains \
-                         represents \
-                         a \
-                         an \
-                         the
-
-# If the ALWAYS_DETAILED_SEC and REPEAT_BRIEF tags are both set to YES then
-# doxygen will generate a detailed section even if there is only a brief
-# description.
-# The default value is: NO.
-
-ALWAYS_DETAILED_SEC    = NO
-
-# If the INLINE_INHERITED_MEMB tag is set to YES, doxygen will show all
-# inherited members of a class in the documentation of that class as if those
-# members were ordinary class members. Constructors, destructors and assignment
-# operators of the base classes will not be shown.
-# The default value is: NO.
-
-INLINE_INHERITED_MEMB  = NO
-
-# If the FULL_PATH_NAMES tag is set to YES, doxygen will prepend the full path
-# before files name in the file list and in the header files. If set to NO the
-# shortest path that makes the file name unique will be used
-# The default value is: YES.
-
-FULL_PATH_NAMES        = YES
-
-# The STRIP_FROM_PATH tag can be used to strip a user-defined part of the path.
-# Stripping is only done if one of the specified strings matches the left-hand
-# part of the path. The tag can be used to show relative paths in the file list.
-# If left blank the directory from which doxygen is run is used as the path to
-# strip.
-#
-# Note that you can specify absolute paths here, but also relative paths, which
-# will be relative from the directory where doxygen is started.
-# This tag requires that the tag FULL_PATH_NAMES is set to YES.
-
-STRIP_FROM_PATH        = 
-
-# The STRIP_FROM_INC_PATH tag can be used to strip a user-defined part of the
-# path mentioned in the documentation of a class, which tells the reader which
-# header file to include in order to use a class. If left blank only the name of
-# the header file containing the class definition is used. Otherwise one should
-# specify the list of include paths that are normally passed to the compiler
-# using the -I flag.
-
-STRIP_FROM_INC_PATH    = 
-
-# If the SHORT_NAMES tag is set to YES, doxygen will generate much shorter (but
-# less readable) file names. This can be useful is your file systems doesn't
-# support long names like on DOS, Mac, or CD-ROM.
-# The default value is: NO.
-
-SHORT_NAMES            = NO
-
-# If the JAVADOC_AUTOBRIEF tag is set to YES then doxygen will interpret the
-# first line (until the first dot) of a Javadoc-style comment as the brief
-# description. If set to NO, the Javadoc-style will behave just like regular Qt-
-# style comments (thus requiring an explicit @brief command for a brief
-# description.)
-# The default value is: NO.
-
-JAVADOC_AUTOBRIEF      = NO
-
-# If the QT_AUTOBRIEF tag is set to YES then doxygen will interpret the first
-# line (until the first dot) of a Qt-style comment as the brief description. If
-# set to NO, the Qt-style will behave just like regular Qt-style comments (thus
-# requiring an explicit \brief command for a brief description.)
-# The default value is: NO.
-
-QT_AUTOBRIEF           = NO
-
-# The MULTILINE_CPP_IS_BRIEF tag can be set to YES to make doxygen treat a
-# multi-line C++ special comment block (i.e. a block of //! or /// comments) as
-# a brief description. This used to be the default behavior. The new default is
-# to treat a multi-line C++ comment block as a detailed description. Set this
-# tag to YES if you prefer the old behavior instead.
-#
-# Note that setting this tag to YES also means that rational rose comments are
-# not recognized any more.
-# The default value is: NO.
-
-MULTILINE_CPP_IS_BRIEF = NO
-
-# If the INHERIT_DOCS tag is set to YES then an undocumented member inherits the
-# documentation from any documented member that it re-implements.
-# The default value is: YES.
-
-INHERIT_DOCS           = YES
-
-# If the SEPARATE_MEMBER_PAGES tag is set to YES then doxygen will produce a new
-# page for each member. If set to NO, the documentation of a member will be part
-# of the file/class/namespace that contains it.
-# The default value is: NO.
-
-SEPARATE_MEMBER_PAGES  = NO
-
-# The TAB_SIZE tag can be used to set the number of spaces in a tab. Doxygen
-# uses this value to replace tabs by spaces in code fragments.
-# Minimum value: 1, maximum value: 16, default value: 4.
-
-TAB_SIZE               = 4
-
-# This tag can be used to specify a number of aliases that act as commands in
-# the documentation. An alias has the form:
-# name=value
-# For example adding
-# "sideeffect=@par Side Effects:\n"
-# will allow you to put the command \sideeffect (or @sideeffect) in the
-# documentation, which will result in a user-defined paragraph with heading
-# "Side Effects:". You can put \n's in the value part of an alias to insert
-# newlines.
-
-ALIASES                = 
-
-# This tag can be used to specify a number of word-keyword mappings (TCL only).
-# A mapping has the form "name=value". For example adding "class=itcl::class"
-# will allow you to use the command class in the itcl::class meaning.
-
-TCL_SUBST              = 
-
-# Set the OPTIMIZE_OUTPUT_FOR_C tag to YES if your project consists of C sources
-# only. Doxygen will then generate output that is more tailored for C. For
-# instance, some of the names that are used will be different. The list of all
-# members will be omitted, etc.
-# The default value is: NO.
-
-OPTIMIZE_OUTPUT_FOR_C  = NO
-
-# Set the OPTIMIZE_OUTPUT_JAVA tag to YES if your project consists of Java or
-# Python sources only. Doxygen will then generate output that is more tailored
-# for that language. For instance, namespaces will be presented as packages,
-# qualified scopes will look different, etc.
-# The default value is: NO.
-
-OPTIMIZE_OUTPUT_JAVA   = NO
-
-# Set the OPTIMIZE_FOR_FORTRAN tag to YES if your project consists of Fortran
-# sources. Doxygen will then generate output that is tailored for Fortran.
-# The default value is: NO.
-
-OPTIMIZE_FOR_FORTRAN   = NO
-
-# Set the OPTIMIZE_OUTPUT_VHDL tag to YES if your project consists of VHDL
-# sources. Doxygen will then generate output that is tailored for VHDL.
-# The default value is: NO.
-
-OPTIMIZE_OUTPUT_VHDL   = NO
-
-# Doxygen selects the parser to use depending on the extension of the files it
-# parses. With this tag you can assign which parser to use for a given
-# extension. Doxygen has a built-in mapping, but you can override or extend it
-# using this tag. The format is ext=language, where ext is a file extension, and
-# language is one of the parsers supported by doxygen: IDL, Java, Javascript,
-# C#, C, C++, D, PHP, Objective-C, Python, Fortran (fixed format Fortran:
-# FortranFixed, free formatted Fortran: FortranFree, unknown formatted Fortran:
-# Fortran. In the later case the parser tries to guess whether the code is fixed
-# or free formatted code, this is the default for Fortran type files), VHDL. For
-# instance to make doxygen treat .inc files as Fortran files (default is PHP),
-# and .f files as C (default is Fortran), use: inc=Fortran f=C.
-#
-# Note: For files without extension you can use no_extension as a placeholder.
-#
-# Note that for custom extensions you also need to set FILE_PATTERNS otherwise
-# the files are not read by doxygen.
-
-EXTENSION_MAPPING      = 
-
-# If the MARKDOWN_SUPPORT tag is enabled then doxygen pre-processes all comments
-# according to the Markdown format, which allows for more readable
-# documentation. See http://daringfireball.net/projects/markdown/ for details.
-# The output of markdown processing is further processed by doxygen, so you can
-# mix doxygen, HTML, and XML commands with Markdown formatting. Disable only in
-# case of backward compatibilities issues.
-# The default value is: YES.
-
-MARKDOWN_SUPPORT       = YES
-
-# When enabled doxygen tries to link words that correspond to documented
-# classes, or namespaces to their corresponding documentation. Such a link can
-# be prevented in individual cases by putting a % sign in front of the word or
-# globally by setting AUTOLINK_SUPPORT to NO.
-# The default value is: YES.
-
-AUTOLINK_SUPPORT       = YES
-
-# If you use STL classes (i.e. std::string, std::vector, etc.) but do not want
-# to include (a tag file for) the STL sources as input, then you should set this
-# tag to YES in order to let doxygen match functions declarations and
-# definitions whose arguments contain STL classes (e.g. func(std::string);
-# versus func(std::string) {}). This also make the inheritance and collaboration
-# diagrams that involve STL classes more complete and accurate.
-# The default value is: NO.
-
-BUILTIN_STL_SUPPORT    = NO
-
-# If you use Microsoft's C++/CLI language, you should set this option to YES to
-# enable parsing support.
-# The default value is: NO.
-
-CPP_CLI_SUPPORT        = NO
-
-# Set the SIP_SUPPORT tag to YES if your project consists of sip (see:
-# http://www.riverbankcomputing.co.uk/software/sip/intro) sources only. Doxygen
-# will parse them like normal C++ but will assume all classes use public instead
-# of private inheritance when no explicit protection keyword is present.
-# The default value is: NO.
-
-SIP_SUPPORT            = NO
-
-# For Microsoft's IDL there are propget and propput attributes to indicate
-# getter and setter methods for a property. Setting this option to YES will make
-# doxygen to replace the get and set methods by a property in the documentation.
-# This will only work if the methods are indeed getting or setting a simple
-# type. If this is not the case, or you want to show the methods anyway, you
-# should set this option to NO.
-# The default value is: YES.
-
-IDL_PROPERTY_SUPPORT   = YES
-
-# If member grouping is used in the documentation and the DISTRIBUTE_GROUP_DOC
-# tag is set to YES then doxygen will reuse the documentation of the first
-# member in the group (if any) for the other members of the group. By default
-# all members of a group must be documented explicitly.
-# The default value is: NO.
-
-DISTRIBUTE_GROUP_DOC   = NO
-
-# If one adds a struct or class to a group and this option is enabled, then also
-# any nested class or struct is added to the same group. By default this option
-# is disabled and one has to add nested compounds explicitly via \ingroup.
-# The default value is: NO.
-
-GROUP_NESTED_COMPOUNDS = NO
-
-# Set the SUBGROUPING tag to YES to allow class member groups of the same type
-# (for instance a group of public functions) to be put as a subgroup of that
-# type (e.g. under the Public Functions section). Set it to NO to prevent
-# subgrouping. Alternatively, this can be done per class using the
-# \nosubgrouping command.
-# The default value is: YES.
-
-SUBGROUPING            = YES
-
-# When the INLINE_GROUPED_CLASSES tag is set to YES, classes, structs and unions
-# are shown inside the group in which they are included (e.g. using \ingroup)
-# instead of on a separate page (for HTML and Man pages) or section (for LaTeX
-# and RTF).
-#
-# Note that this feature does not work in combination with
-# SEPARATE_MEMBER_PAGES.
-# The default value is: NO.
-
-INLINE_GROUPED_CLASSES = NO
-
-# When the INLINE_SIMPLE_STRUCTS tag is set to YES, structs, classes, and unions
-# with only public data fields or simple typedef fields will be shown inline in
-# the documentation of the scope in which they are defined (i.e. file,
-# namespace, or group documentation), provided this scope is documented. If set
-# to NO, structs, classes, and unions are shown on a separate page (for HTML and
-# Man pages) or section (for LaTeX and RTF).
-# The default value is: NO.
-
-INLINE_SIMPLE_STRUCTS  = NO
-
-# When TYPEDEF_HIDES_STRUCT tag is enabled, a typedef of a struct, union, or
-# enum is documented as struct, union, or enum with the name of the typedef. So
-# typedef struct TypeS {} TypeT, will appear in the documentation as a struct
-# with name TypeT. When disabled the typedef will appear as a member of a file,
-# namespace, or class. And the struct will be named TypeS. This can typically be
-# useful for C code in case the coding convention dictates that all compound
-# types are typedef'ed and only the typedef is referenced, never the tag name.
-# The default value is: NO.
-
-TYPEDEF_HIDES_STRUCT   = NO
-
-# The size of the symbol lookup cache can be set using LOOKUP_CACHE_SIZE. This
-# cache is used to resolve symbols given their name and scope. Since this can be
-# an expensive process and often the same symbol appears multiple times in the
-# code, doxygen keeps a cache of pre-resolved symbols. If the cache is too small
-# doxygen will become slower. If the cache is too large, memory is wasted. The
-# cache size is given by this formula: 2^(16+LOOKUP_CACHE_SIZE). The valid range
-# is 0..9, the default is 0, corresponding to a cache size of 2^16=65536
-# symbols. At the end of a run doxygen will report the cache usage and suggest
-# the optimal cache size from a speed point of view.
-# Minimum value: 0, maximum value: 9, default value: 0.
-
-LOOKUP_CACHE_SIZE      = 0
-
-#---------------------------------------------------------------------------
-# Build related configuration options
-#---------------------------------------------------------------------------
-
-# If the EXTRACT_ALL tag is set to YES, doxygen will assume all entities in
-# documentation are documented, even if no documentation was available. Private
-# class members and static file members will be hidden unless the
-# EXTRACT_PRIVATE respectively EXTRACT_STATIC tags are set to YES.
-# Note: This will also disable the warnings about undocumented members that are
-# normally produced when WARNINGS is set to YES.
-# The default value is: NO.
-
-EXTRACT_ALL            = YES
-
-# If the EXTRACT_PRIVATE tag is set to YES, all private members of a class will
-# be included in the documentation.
-# The default value is: NO.
-
-EXTRACT_PRIVATE        = NO
-
-# If the EXTRACT_PACKAGE tag is set to YES, all members with package or internal
-# scope will be included in the documentation.
-# The default value is: NO.
-
-EXTRACT_PACKAGE        = NO
-
-# If the EXTRACT_STATIC tag is set to YES, all static members of a file will be
-# included in the documentation.
-# The default value is: NO.
-
-EXTRACT_STATIC         = NO
-
-# If the EXTRACT_LOCAL_CLASSES tag is set to YES, classes (and structs) defined
-# locally in source files will be included in the documentation. If set to NO,
-# only classes defined in header files are included. Does not have any effect
-# for Java sources.
-# The default value is: YES.
-
-EXTRACT_LOCAL_CLASSES  = YES
-
-# This flag is only useful for Objective-C code. If set to YES, local methods,
-# which are defined in the implementation section but not in the interface are
-# included in the documentation. If set to NO, only methods in the interface are
-# included.
-# The default value is: NO.
-
-EXTRACT_LOCAL_METHODS  = NO
-
-# If this flag is set to YES, the members of anonymous namespaces will be
-# extracted and appear in the documentation as a namespace called
-# 'anonymous_namespace{file}', where file will be replaced with the base name of
-# the file that contains the anonymous namespace. By default anonymous namespace
-# are hidden.
-# The default value is: NO.
-
-EXTRACT_ANON_NSPACES   = NO
-
-# If the HIDE_UNDOC_MEMBERS tag is set to YES, doxygen will hide all
-# undocumented members inside documented classes or files. If set to NO these
-# members will be included in the various overviews, but no documentation
-# section is generated. This option has no effect if EXTRACT_ALL is enabled.
-# The default value is: NO.
-
-HIDE_UNDOC_MEMBERS     = NO
-
-# If the HIDE_UNDOC_CLASSES tag is set to YES, doxygen will hide all
-# undocumented classes that are normally visible in the class hierarchy. If set
-# to NO, these classes will be included in the various overviews. This option
-# has no effect if EXTRACT_ALL is enabled.
-# The default value is: NO.
-
-HIDE_UNDOC_CLASSES     = NO
-
-# If the HIDE_FRIEND_COMPOUNDS tag is set to YES, doxygen will hide all friend
-# (class|struct|union) declarations. If set to NO, these declarations will be
-# included in the documentation.
-# The default value is: NO.
-
-HIDE_FRIEND_COMPOUNDS  = NO
-
-# If the HIDE_IN_BODY_DOCS tag is set to YES, doxygen will hide any
-# documentation blocks found inside the body of a function. If set to NO, these
-# blocks will be appended to the function's detailed documentation block.
-# The default value is: NO.
-
-HIDE_IN_BODY_DOCS      = NO
-
-# The INTERNAL_DOCS tag determines if documentation that is typed after a
-# \internal command is included. If the tag is set to NO then the documentation
-# will be excluded. Set it to YES to include the internal documentation.
-# The default value is: NO.
-
-INTERNAL_DOCS          = NO
-
-# If the CASE_SENSE_NAMES tag is set to NO then doxygen will only generate file
-# names in lower-case letters. If set to YES, upper-case letters are also
-# allowed. This is useful if you have classes or files whose names only differ
-# in case and if your file system supports case sensitive file names. Windows
-# and Mac users are advised to set this option to NO.
-# The default value is: system dependent.
-
-CASE_SENSE_NAMES       = NO
-
-# If the HIDE_SCOPE_NAMES tag is set to NO then doxygen will show members with
-# their full class and namespace scopes in the documentation. If set to YES, the
-# scope will be hidden.
-# The default value is: NO.
-
-HIDE_SCOPE_NAMES       = NO
-
-# If the HIDE_COMPOUND_REFERENCE tag is set to NO (default) then doxygen will
-# append additional text to a page's title, such as Class Reference. If set to
-# YES the compound reference will be hidden.
-# The default value is: NO.
-
-HIDE_COMPOUND_REFERENCE= NO
-
-# If the SHOW_INCLUDE_FILES tag is set to YES then doxygen will put a list of
-# the files that are included by a file in the documentation of that file.
-# The default value is: YES.
-
-SHOW_INCLUDE_FILES     = YES
-
-# If the SHOW_GROUPED_MEMB_INC tag is set to YES then Doxygen will add for each
-# grouped member an include statement to the documentation, telling the reader
-# which file to include in order to use the member.
-# The default value is: NO.
-
-SHOW_GROUPED_MEMB_INC  = NO
-
-# If the FORCE_LOCAL_INCLUDES tag is set to YES then doxygen will list include
-# files with double quotes in the documentation rather than with sharp brackets.
-# The default value is: NO.
-
-FORCE_LOCAL_INCLUDES   = NO
-
-# If the INLINE_INFO tag is set to YES then a tag [inline] is inserted in the
-# documentation for inline members.
-# The default value is: YES.
-
-INLINE_INFO            = YES
-
-# If the SORT_MEMBER_DOCS tag is set to YES then doxygen will sort the
-# (detailed) documentation of file and class members alphabetically by member
-# name. If set to NO, the members will appear in declaration order.
-# The default value is: YES.
-
-SORT_MEMBER_DOCS       = YES
-
-# If the SORT_BRIEF_DOCS tag is set to YES then doxygen will sort the brief
-# descriptions of file, namespace and class members alphabetically by member
-# name. If set to NO, the members will appear in declaration order. Note that
-# this will also influence the order of the classes in the class list.
-# The default value is: NO.
-
-SORT_BRIEF_DOCS        = NO
-
-# If the SORT_MEMBERS_CTORS_1ST tag is set to YES then doxygen will sort the
-# (brief and detailed) documentation of class members so that constructors and
-# destructors are listed first. If set to NO the constructors will appear in the
-# respective orders defined by SORT_BRIEF_DOCS and SORT_MEMBER_DOCS.
-# Note: If SORT_BRIEF_DOCS is set to NO this option is ignored for sorting brief
-# member documentation.
-# Note: If SORT_MEMBER_DOCS is set to NO this option is ignored for sorting
-# detailed member documentation.
-# The default value is: NO.
-
-SORT_MEMBERS_CTORS_1ST = NO
-
-# If the SORT_GROUP_NAMES tag is set to YES then doxygen will sort the hierarchy
-# of group names into alphabetical order. If set to NO the group names will
-# appear in their defined order.
-# The default value is: NO.
-
-SORT_GROUP_NAMES       = NO
-
-# If the SORT_BY_SCOPE_NAME tag is set to YES, the class list will be sorted by
-# fully-qualified names, including namespaces. If set to NO, the class list will
-# be sorted only by class name, not including the namespace part.
-# Note: This option is not very useful if HIDE_SCOPE_NAMES is set to YES.
-# Note: This option applies only to the class list, not to the alphabetical
-# list.
-# The default value is: NO.
-
-SORT_BY_SCOPE_NAME     = NO
-
-# If the STRICT_PROTO_MATCHING option is enabled and doxygen fails to do proper
-# type resolution of all parameters of a function it will reject a match between
-# the prototype and the implementation of a member function even if there is
-# only one candidate or it is obvious which candidate to choose by doing a
-# simple string match. By disabling STRICT_PROTO_MATCHING doxygen will still
-# accept a match between prototype and implementation in such cases.
-# The default value is: NO.
-
-STRICT_PROTO_MATCHING  = NO
-
-# The GENERATE_TODOLIST tag can be used to enable (YES) or disable (NO) the todo
-# list. This list is created by putting \todo commands in the documentation.
-# The default value is: YES.
-
-GENERATE_TODOLIST      = YES
-
-# The GENERATE_TESTLIST tag can be used to enable (YES) or disable (NO) the test
-# list. This list is created by putting \test commands in the documentation.
-# The default value is: YES.
-
-GENERATE_TESTLIST      = YES
-
-# The GENERATE_BUGLIST tag can be used to enable (YES) or disable (NO) the bug
-# list. This list is created by putting \bug commands in the documentation.
-# The default value is: YES.
-
-GENERATE_BUGLIST       = YES
-
-# The GENERATE_DEPRECATEDLIST tag can be used to enable (YES) or disable (NO)
-# the deprecated list. This list is created by putting \deprecated commands in
-# the documentation.
-# The default value is: YES.
-
-GENERATE_DEPRECATEDLIST= YES
-
-# The ENABLED_SECTIONS tag can be used to enable conditional documentation
-# sections, marked by \if <section_label> ... \endif and \cond <section_label>
-# ... \endcond blocks.
-
-ENABLED_SECTIONS       = 
-
-# The MAX_INITIALIZER_LINES tag determines the maximum number of lines that the
-# initial value of a variable or macro / define can have for it to appear in the
-# documentation. If the initializer consists of more lines than specified here
-# it will be hidden. Use a value of 0 to hide initializers completely. The
-# appearance of the value of individual variables and macros / defines can be
-# controlled using \showinitializer or \hideinitializer command in the
-# documentation regardless of this setting.
-# Minimum value: 0, maximum value: 10000, default value: 30.
-
-MAX_INITIALIZER_LINES  = 30
-
-# Set the SHOW_USED_FILES tag to NO to disable the list of files generated at
-# the bottom of the documentation of classes and structs. If set to YES, the
-# list will mention the files that were used to generate the documentation.
-# The default value is: YES.
-
-SHOW_USED_FILES        = YES
-
-# Set the SHOW_FILES tag to NO to disable the generation of the Files page. This
-# will remove the Files entry from the Quick Index and from the Folder Tree View
-# (if specified).
-# The default value is: YES.
-
-SHOW_FILES             = YES
-
-# Set the SHOW_NAMESPACES tag to NO to disable the generation of the Namespaces
-# page. This will remove the Namespaces entry from the Quick Index and from the
-# Folder Tree View (if specified).
-# The default value is: YES.
-
-SHOW_NAMESPACES        = YES
-
-# The FILE_VERSION_FILTER tag can be used to specify a program or script that
-# doxygen should invoke to get the current version for each file (typically from
-# the version control system). Doxygen will invoke the program by executing (via
-# popen()) the command command input-file, where command is the value of the
-# FILE_VERSION_FILTER tag, and input-file is the name of an input file provided
-# by doxygen. Whatever the program writes to standard output is used as the file
-# version. For an example see the documentation.
-
-FILE_VERSION_FILTER    = 
-
-# The LAYOUT_FILE tag can be used to specify a layout file which will be parsed
-# by doxygen. The layout file controls the global structure of the generated
-# output files in an output format independent way. To create the layout file
-# that represents doxygen's defaults, run doxygen with the -l option. You can
-# optionally specify a file name after the option, if omitted DoxygenLayout.xml
-# will be used as the name of the layout file.
-#
-# Note that if you run doxygen from a directory containing a file called
-# DoxygenLayout.xml, doxygen will parse it automatically even if the LAYOUT_FILE
-# tag is left empty.
-
-LAYOUT_FILE            = 
-
-# The CITE_BIB_FILES tag can be used to specify one or more bib files containing
-# the reference definitions. This must be a list of .bib files. The .bib
-# extension is automatically appended if omitted. This requires the bibtex tool
-# to be installed. See also http://en.wikipedia.org/wiki/BibTeX for more info.
-# For LaTeX the style of the bibliography can be controlled using
-# LATEX_BIB_STYLE. To use this feature you need bibtex and perl available in the
-# search path. See also \cite for info how to create references.
-
-CITE_BIB_FILES         = 
-
-#---------------------------------------------------------------------------
-# Configuration options related to warning and progress messages
-#---------------------------------------------------------------------------
-
-# The QUIET tag can be used to turn on/off the messages that are generated to
-# standard output by doxygen. If QUIET is set to YES this implies that the
-# messages are off.
-# The default value is: NO.
-
-QUIET                  = NO
-
-# The WARNINGS tag can be used to turn on/off the warning messages that are
-# generated to standard error (stderr) by doxygen. If WARNINGS is set to YES
-# this implies that the warnings are on.
-#
-# Tip: Turn warnings on while writing the documentation.
-# The default value is: YES.
-
-WARNINGS               = YES
-
-# If the WARN_IF_UNDOCUMENTED tag is set to YES then doxygen will generate
-# warnings for undocumented members. If EXTRACT_ALL is set to YES then this flag
-# will automatically be disabled.
-# The default value is: YES.
-
-WARN_IF_UNDOCUMENTED   = YES
-
-# If the WARN_IF_DOC_ERROR tag is set to YES, doxygen will generate warnings for
-# potential errors in the documentation, such as not documenting some parameters
-# in a documented function, or documenting parameters that don't exist or using
-# markup commands wrongly.
-# The default value is: YES.
-
-WARN_IF_DOC_ERROR      = YES
-
-# This WARN_NO_PARAMDOC option can be enabled to get warnings for functions that
-# are documented, but have no documentation for their parameters or return
-# value. If set to NO, doxygen will only warn about wrong or incomplete
-# parameter documentation, but not about the absence of documentation.
-# The default value is: NO.
-
-WARN_NO_PARAMDOC       = NO
-
-# If the WARN_AS_ERROR tag is set to YES then doxygen will immediately stop when
-# a warning is encountered.
-# The default value is: NO.
-
-WARN_AS_ERROR          = NO
-
-# The WARN_FORMAT tag determines the format of the warning messages that doxygen
-# can produce. The string should contain the $file, $line, and $text tags, which
-# will be replaced by the file and line number from which the warning originated
-# and the warning text. Optionally the format may contain $version, which will
-# be replaced by the version of the file (if it could be obtained via
-# FILE_VERSION_FILTER)
-# The default value is: $file:$line: $text.
-
-WARN_FORMAT            = "$file:$line: $text"
-
-# The WARN_LOGFILE tag can be used to specify a file to which warning and error
-# messages should be written. If left blank the output is written to standard
-# error (stderr).
-
-WARN_LOGFILE           = 
-
-#---------------------------------------------------------------------------
-# Configuration options related to the input files
-#---------------------------------------------------------------------------
-
-# The INPUT tag is used to specify the files and/or directories that contain
-# documented source files. You may enter file names like myfile.cpp or
-# directories like /usr/src/myproject. Separate the files or directories with
-# spaces. See also FILE_PATTERNS and EXTENSION_MAPPING
-# Note: If this tag is empty the current directory is searched.
-
-INPUT                  = include/tsl/ README.md
-
-# This tag can be used to specify the character encoding of the source files
-# that doxygen parses. Internally doxygen uses the UTF-8 encoding. Doxygen uses
-# libiconv (or the iconv built into libc) for the transcoding. See the libiconv
-# documentation (see: http://www.gnu.org/software/libiconv) for the list of
-# possible encodings.
-# The default value is: UTF-8.
-
-INPUT_ENCODING         = UTF-8
-
-# If the value of the INPUT tag contains directories, you can use the
-# FILE_PATTERNS tag to specify one or more wildcard patterns (like *.cpp and
-# *.h) to filter out the source-files in the directories.
-#
-# Note that for custom extensions or not directly supported extensions you also
-# need to set EXTENSION_MAPPING for the extension otherwise the files are not
-# read by doxygen.
-#
-# If left blank the following patterns are tested:*.c, *.cc, *.cxx, *.cpp,
-# *.c++, *.java, *.ii, *.ixx, *.ipp, *.i++, *.inl, *.idl, *.ddl, *.odl, *.h,
-# *.hh, *.hxx, *.hpp, *.h++, *.cs, *.d, *.php, *.php4, *.php5, *.phtml, *.inc,
-# *.m, *.markdown, *.md, *.mm, *.dox, *.py, *.pyw, *.f90, *.f, *.for, *.tcl,
-# *.vhd, *.vhdl, *.ucf, *.qsf, *.as and *.js.
-
-FILE_PATTERNS          = *.c \
-                         *.cc \
-                         *.cxx \
-                         *.cpp \
-                         *.c++ \
-                         *.java \
-                         *.ii \
-                         *.ixx \
-                         *.ipp \
-                         *.i++ \
-                         *.inl \
-                         *.idl \
-                         *.ddl \
-                         *.odl \
-                         *.h \
-                         *.hh \
-                         *.hxx \
-                         *.hpp \
-                         *.h++ \
-                         *.cs \
-                         *.d \
-                         *.php \
-                         *.php4 \
-                         *.php5 \
-                         *.phtml \
-                         *.inc \
-                         *.m \
-                         *.markdown \
-                         *.md \
-                         *.mm \
-                         *.dox \
-                         *.py \
-                         *.pyw \
-                         *.f90 \
-                         *.f \
-                         *.for \
-                         *.tcl \
-                         *.vhd \
-                         *.vhdl \
-                         *.ucf \
-                         *.qsf \
-                         *.as \
-                         *.js
-
-# The RECURSIVE tag can be used to specify whether or not subdirectories should
-# be searched for input files as well.
-# The default value is: NO.
-
-RECURSIVE              = YES
-
-# The EXCLUDE tag can be used to specify files and/or directories that should be
-# excluded from the INPUT source files. This way you can easily exclude a
-# subdirectory from a directory tree whose root is specified with the INPUT tag.
-#
-# Note that relative paths are relative to the directory from which doxygen is
-# run.
-
-EXCLUDE                = 
-
-# The EXCLUDE_SYMLINKS tag can be used to select whether or not files or
-# directories that are symbolic links (a Unix file system feature) are excluded
-# from the input.
-# The default value is: NO.
-
-EXCLUDE_SYMLINKS       = NO
-
-# If the value of the INPUT tag contains directories, you can use the
-# EXCLUDE_PATTERNS tag to specify one or more wildcard patterns to exclude
-# certain files from those directories.
-#
-# Note that the wildcards are matched against the file with absolute path, so to
-# exclude all test directories for example use the pattern */test/*
-
-EXCLUDE_PATTERNS       = 
-
-# The EXCLUDE_SYMBOLS tag can be used to specify one or more symbol names
-# (namespaces, classes, functions, etc.) that should be excluded from the
-# output. The symbol name can be a fully qualified name, a word, or if the
-# wildcard * is used, a substring. Examples: ANamespace, AClass,
-# AClass::ANamespace, ANamespace::*Test
-#
-# Note that the wildcards are matched against the file with absolute path, so to
-# exclude all test directories use the pattern */test/*
-
-EXCLUDE_SYMBOLS        = \
-tsl::detail_robin_hash::has_is_transparent* \
-tsl::detail_robin_hash::make_void* \
-tsl::detail_robin_hash::is_power_of_two_policy* \
-tsl::detail_robin_hash::bucket_entry*
-
-# The EXAMPLE_PATH tag can be used to specify one or more files or directories
-# that contain example code fragments that are included (see the \include
-# command).
-
-EXAMPLE_PATH           = 
-
-# If the value of the EXAMPLE_PATH tag contains directories, you can use the
-# EXAMPLE_PATTERNS tag to specify one or more wildcard pattern (like *.cpp and
-# *.h) to filter out the source-files in the directories. If left blank all
-# files are included.
-
-EXAMPLE_PATTERNS       = *
-
-# If the EXAMPLE_RECURSIVE tag is set to YES then subdirectories will be
-# searched for input files to be used with the \include or \dontinclude commands
-# irrespective of the value of the RECURSIVE tag.
-# The default value is: NO.
-
-EXAMPLE_RECURSIVE      = NO
-
-# The IMAGE_PATH tag can be used to specify one or more files or directories
-# that contain images that are to be included in the documentation (see the
-# \image command).
-
-IMAGE_PATH             = 
-
-# The INPUT_FILTER tag can be used to specify a program that doxygen should
-# invoke to filter for each input file. Doxygen will invoke the filter program
-# by executing (via popen()) the command:
-#
-# <filter> <input-file>
-#
-# where <filter> is the value of the INPUT_FILTER tag, and <input-file> is the
-# name of an input file. Doxygen will then use the output that the filter
-# program writes to standard output. If FILTER_PATTERNS is specified, this tag
-# will be ignored.
-#
-# Note that the filter must not add or remove lines; it is applied before the
-# code is scanned, but not when the output code is generated. If lines are added
-# or removed, the anchors will not be placed correctly.
-#
-# Note that for custom extensions or not directly supported extensions you also
-# need to set EXTENSION_MAPPING for the extension otherwise the files are not
-# properly processed by doxygen.
-
-INPUT_FILTER           = 
-
-# The FILTER_PATTERNS tag can be used to specify filters on a per file pattern
-# basis. Doxygen will compare the file name with each pattern and apply the
-# filter if there is a match. The filters are a list of the form: pattern=filter
-# (like *.cpp=my_cpp_filter). See INPUT_FILTER for further information on how
-# filters are used. If the FILTER_PATTERNS tag is empty or if none of the
-# patterns match the file name, INPUT_FILTER is applied.
-#
-# Note that for custom extensions or not directly supported extensions you also
-# need to set EXTENSION_MAPPING for the extension otherwise the files are not
-# properly processed by doxygen.
-
-FILTER_PATTERNS        = 
-
-# If the FILTER_SOURCE_FILES tag is set to YES, the input filter (if set using
-# INPUT_FILTER) will also be used to filter the input files that are used for
-# producing the source files to browse (i.e. when SOURCE_BROWSER is set to YES).
-# The default value is: NO.
-
-FILTER_SOURCE_FILES    = NO
-
-# The FILTER_SOURCE_PATTERNS tag can be used to specify source filters per file
-# pattern. A pattern will override the setting for FILTER_PATTERN (if any) and
-# it is also possible to disable source filtering for a specific pattern using
-# *.ext= (so without naming a filter).
-# This tag requires that the tag FILTER_SOURCE_FILES is set to YES.
-
-FILTER_SOURCE_PATTERNS = 
-
-# If the USE_MDFILE_AS_MAINPAGE tag refers to the name of a markdown file that
-# is part of the input, its contents will be placed on the main page
-# (index.html). This can be useful if you have a project on for instance GitHub
-# and want to reuse the introduction page also for the doxygen output.
-
-USE_MDFILE_AS_MAINPAGE = README.md
-
-#---------------------------------------------------------------------------
-# Configuration options related to source browsing
-#---------------------------------------------------------------------------
-
-# If the SOURCE_BROWSER tag is set to YES then a list of source files will be
-# generated. Documented entities will be cross-referenced with these sources.
-#
-# Note: To get rid of all source code in the generated output, make sure that
-# also VERBATIM_HEADERS is set to NO.
-# The default value is: NO.
-
-SOURCE_BROWSER         = NO
-
-# Setting the INLINE_SOURCES tag to YES will include the body of functions,
-# classes and enums directly into the documentation.
-# The default value is: NO.
-
-INLINE_SOURCES         = NO
-
-# Setting the STRIP_CODE_COMMENTS tag to YES will instruct doxygen to hide any
-# special comment blocks from generated source code fragments. Normal C, C++ and
-# Fortran comments will always remain visible.
-# The default value is: YES.
-
-STRIP_CODE_COMMENTS    = YES
-
-# If the REFERENCED_BY_RELATION tag is set to YES then for each documented
-# function all documented functions referencing it will be listed.
-# The default value is: NO.
-
-REFERENCED_BY_RELATION = NO
-
-# If the REFERENCES_RELATION tag is set to YES then for each documented function
-# all documented entities called/used by that function will be listed.
-# The default value is: NO.
-
-REFERENCES_RELATION    = NO
-
-# If the REFERENCES_LINK_SOURCE tag is set to YES and SOURCE_BROWSER tag is set
-# to YES then the hyperlinks from functions in REFERENCES_RELATION and
-# REFERENCED_BY_RELATION lists will link to the source code. Otherwise they will
-# link to the documentation.
-# The default value is: YES.
-
-REFERENCES_LINK_SOURCE = YES
-
-# If SOURCE_TOOLTIPS is enabled (the default) then hovering a hyperlink in the
-# source code will show a tooltip with additional information such as prototype,
-# brief description and links to the definition and documentation. Since this
-# will make the HTML file larger and loading of large files a bit slower, you
-# can opt to disable this feature.
-# The default value is: YES.
-# This tag requires that the tag SOURCE_BROWSER is set to YES.
-
-SOURCE_TOOLTIPS        = YES
-
-# If the USE_HTAGS tag is set to YES then the references to source code will
-# point to the HTML generated by the htags(1) tool instead of doxygen built-in
-# source browser. The htags tool is part of GNU's global source tagging system
-# (see http://www.gnu.org/software/global/global.html). You will need version
-# 4.8.6 or higher.
-#
-# To use it do the following:
-# - Install the latest version of global
-# - Enable SOURCE_BROWSER and USE_HTAGS in the config file
-# - Make sure the INPUT points to the root of the source tree
-# - Run doxygen as normal
-#
-# Doxygen will invoke htags (and that will in turn invoke gtags), so these
-# tools must be available from the command line (i.e. in the search path).
-#
-# The result: instead of the source browser generated by doxygen, the links to
-# source code will now point to the output of htags.
-# The default value is: NO.
-# This tag requires that the tag SOURCE_BROWSER is set to YES.
-
-USE_HTAGS              = NO
-
-# If the VERBATIM_HEADERS tag is set the YES then doxygen will generate a
-# verbatim copy of the header file for each class for which an include is
-# specified. Set to NO to disable this.
-# See also: Section \class.
-# The default value is: YES.
-
-VERBATIM_HEADERS       = YES
-
-# If the CLANG_ASSISTED_PARSING tag is set to YES then doxygen will use the
-# clang parser (see: http://clang.llvm.org/) for more accurate parsing at the
-# cost of reduced performance. This can be particularly helpful with template
-# rich C++ code for which doxygen's built-in parser lacks the necessary type
-# information.
-# Note: The availability of this option depends on whether or not doxygen was
-# generated with the -Duse-libclang=ON option for CMake.
-# The default value is: NO.
-
-CLANG_ASSISTED_PARSING = YES
-
-# If clang assisted parsing is enabled you can provide the compiler with command
-# line options that you would normally use when invoking the compiler. Note that
-# the include paths will already be set by doxygen for the files and directories
-# specified with INPUT and INCLUDE_PATH.
-# This tag requires that the tag CLANG_ASSISTED_PARSING is set to YES.
-
-CLANG_OPTIONS          = -std=c++17
-
-#---------------------------------------------------------------------------
-# Configuration options related to the alphabetical class index
-#---------------------------------------------------------------------------
-
-# If the ALPHABETICAL_INDEX tag is set to YES, an alphabetical index of all
-# compounds will be generated. Enable this if the project contains a lot of
-# classes, structs, unions or interfaces.
-# The default value is: YES.
-
-ALPHABETICAL_INDEX     = YES
-
-# The COLS_IN_ALPHA_INDEX tag can be used to specify the number of columns in
-# which the alphabetical index list will be split.
-# Minimum value: 1, maximum value: 20, default value: 5.
-# This tag requires that the tag ALPHABETICAL_INDEX is set to YES.
-
-COLS_IN_ALPHA_INDEX    = 5
-
-# In case all classes in a project start with a common prefix, all classes will
-# be put under the same header in the alphabetical index. The IGNORE_PREFIX tag
-# can be used to specify a prefix (or a list of prefixes) that should be ignored
-# while generating the index headers.
-# This tag requires that the tag ALPHABETICAL_INDEX is set to YES.
-
-IGNORE_PREFIX          = 
-
-#---------------------------------------------------------------------------
-# Configuration options related to the HTML output
-#---------------------------------------------------------------------------
-
-# If the GENERATE_HTML tag is set to YES, doxygen will generate HTML output
-# The default value is: YES.
-
-GENERATE_HTML          = YES
-
-# The HTML_OUTPUT tag is used to specify where the HTML docs will be put. If a
-# relative path is entered the value of OUTPUT_DIRECTORY will be put in front of
-# it.
-# The default directory is: html.
-# This tag requires that the tag GENERATE_HTML is set to YES.
-
-HTML_OUTPUT            = html
-
-# The HTML_FILE_EXTENSION tag can be used to specify the file extension for each
-# generated HTML page (for example: .htm, .php, .asp).
-# The default value is: .html.
-# This tag requires that the tag GENERATE_HTML is set to YES.
-
-HTML_FILE_EXTENSION    = .html
-
-# The HTML_HEADER tag can be used to specify a user-defined HTML header file for
-# each generated HTML page. If the tag is left blank doxygen will generate a
-# standard header.
-#
-# To get valid HTML the header file that includes any scripts and style sheets
-# that doxygen needs, which is dependent on the configuration options used (e.g.
-# the setting GENERATE_TREEVIEW). It is highly recommended to start with a
-# default header using
-# doxygen -w html new_header.html new_footer.html new_stylesheet.css
-# YourConfigFile
-# and then modify the file new_header.html. See also section "Doxygen usage"
-# for information on how to generate the default header that doxygen normally
-# uses.
-# Note: The header is subject to change so you typically have to regenerate the
-# default header when upgrading to a newer version of doxygen. For a description
-# of the possible markers and block names see the documentation.
-# This tag requires that the tag GENERATE_HTML is set to YES.
-
-HTML_HEADER            = 
-
-# The HTML_FOOTER tag can be used to specify a user-defined HTML footer for each
-# generated HTML page. If the tag is left blank doxygen will generate a standard
-# footer. See HTML_HEADER for more information on how to generate a default
-# footer and what special commands can be used inside the footer. See also
-# section "Doxygen usage" for information on how to generate the default footer
-# that doxygen normally uses.
-# This tag requires that the tag GENERATE_HTML is set to YES.
-
-HTML_FOOTER            = 
-
-# The HTML_STYLESHEET tag can be used to specify a user-defined cascading style
-# sheet that is used by each HTML page. It can be used to fine-tune the look of
-# the HTML output. If left blank doxygen will generate a default style sheet.
-# See also section "Doxygen usage" for information on how to generate the style
-# sheet that doxygen normally uses.
-# Note: It is recommended to use HTML_EXTRA_STYLESHEET instead of this tag, as
-# it is more robust and this tag (HTML_STYLESHEET) will in the future become
-# obsolete.
-# This tag requires that the tag GENERATE_HTML is set to YES.
-
-HTML_STYLESHEET        = 
-
-# The HTML_EXTRA_STYLESHEET tag can be used to specify additional user-defined
-# cascading style sheets that are included after the standard style sheets
-# created by doxygen. Using this option one can overrule certain style aspects.
-# This is preferred over using HTML_STYLESHEET since it does not replace the
-# standard style sheet and is therefore more robust against future updates.
-# Doxygen will copy the style sheet files to the output directory.
-# Note: The order of the extra style sheet files is of importance (e.g. the last
-# style sheet in the list overrules the setting of the previous ones in the
-# list). For an example see the documentation.
-# This tag requires that the tag GENERATE_HTML is set to YES.
-
-HTML_EXTRA_STYLESHEET  = 
-
-# The HTML_EXTRA_FILES tag can be used to specify one or more extra images or
-# other source files which should be copied to the HTML output directory. Note
-# that these files will be copied to the base HTML output directory. Use the
-# $relpath^ marker in the HTML_HEADER and/or HTML_FOOTER files to load these
-# files. In the HTML_STYLESHEET file, use the file name only. Also note that the
-# files will be copied as-is; there are no commands or markers available.
-# This tag requires that the tag GENERATE_HTML is set to YES.
-
-HTML_EXTRA_FILES       = 
-
-# The HTML_COLORSTYLE_HUE tag controls the color of the HTML output. Doxygen
-# will adjust the colors in the style sheet and background images according to
-# this color. Hue is specified as an angle on a colorwheel, see
-# http://en.wikipedia.org/wiki/Hue for more information. For instance the value
-# 0 represents red, 60 is yellow, 120 is green, 180 is cyan, 240 is blue, 300
-# purple, and 360 is red again.
-# Minimum value: 0, maximum value: 359, default value: 220.
-# This tag requires that the tag GENERATE_HTML is set to YES.
-
-HTML_COLORSTYLE_HUE    = 220
-
-# The HTML_COLORSTYLE_SAT tag controls the purity (or saturation) of the colors
-# in the HTML output. For a value of 0 the output will use grayscales only. A
-# value of 255 will produce the most vivid colors.
-# Minimum value: 0, maximum value: 255, default value: 100.
-# This tag requires that the tag GENERATE_HTML is set to YES.
-
-HTML_COLORSTYLE_SAT    = 100
-
-# The HTML_COLORSTYLE_GAMMA tag controls the gamma correction applied to the
-# luminance component of the colors in the HTML output. Values below 100
-# gradually make the output lighter, whereas values above 100 make the output
-# darker. The value divided by 100 is the actual gamma applied, so 80 represents
-# a gamma of 0.8, The value 220 represents a gamma of 2.2, and 100 does not
-# change the gamma.
-# Minimum value: 40, maximum value: 240, default value: 80.
-# This tag requires that the tag GENERATE_HTML is set to YES.
-
-HTML_COLORSTYLE_GAMMA  = 80
-
-# If the HTML_TIMESTAMP tag is set to YES then the footer of each generated HTML
-# page will contain the date and time when the page was generated. Setting this
-# to YES can help to show when doxygen was last run and thus if the
-# documentation is up to date.
-# The default value is: NO.
-# This tag requires that the tag GENERATE_HTML is set to YES.
-
-HTML_TIMESTAMP         = NO
-
-# If the HTML_DYNAMIC_SECTIONS tag is set to YES then the generated HTML
-# documentation will contain sections that can be hidden and shown after the
-# page has loaded.
-# The default value is: NO.
-# This tag requires that the tag GENERATE_HTML is set to YES.
-
-HTML_DYNAMIC_SECTIONS  = NO
-
-# With HTML_INDEX_NUM_ENTRIES one can control the preferred number of entries
-# shown in the various tree structured indices initially; the user can expand
-# and collapse entries dynamically later on. Doxygen will expand the tree to
-# such a level that at most the specified number of entries are visible (unless
-# a fully collapsed tree already exceeds this amount). So setting the number of
-# entries 1 will produce a full collapsed tree by default. 0 is a special value
-# representing an infinite number of entries and will result in a full expanded
-# tree by default.
-# Minimum value: 0, maximum value: 9999, default value: 100.
-# This tag requires that the tag GENERATE_HTML is set to YES.
-
-HTML_INDEX_NUM_ENTRIES = 100
-
-# If the GENERATE_DOCSET tag is set to YES, additional index files will be
-# generated that can be used as input for Apple's Xcode 3 integrated development
-# environment (see: http://developer.apple.com/tools/xcode/), introduced with
-# OSX 10.5 (Leopard). To create a documentation set, doxygen will generate a
-# Makefile in the HTML output directory. Running make will produce the docset in
-# that directory and running make install will install the docset in
-# ~/Library/Developer/Shared/Documentation/DocSets so that Xcode will find it at
-# startup. See http://developer.apple.com/tools/creatingdocsetswithdoxygen.html
-# for more information.
-# The default value is: NO.
-# This tag requires that the tag GENERATE_HTML is set to YES.
-
-GENERATE_DOCSET        = NO
-
-# This tag determines the name of the docset feed. A documentation feed provides
-# an umbrella under which multiple documentation sets from a single provider
-# (such as a company or product suite) can be grouped.
-# The default value is: Doxygen generated docs.
-# This tag requires that the tag GENERATE_DOCSET is set to YES.
-
-DOCSET_FEEDNAME        = "Doxygen generated docs"
-
-# This tag specifies a string that should uniquely identify the documentation
-# set bundle. This should be a reverse domain-name style string, e.g.
-# com.mycompany.MyDocSet. Doxygen will append .docset to the name.
-# The default value is: org.doxygen.Project.
-# This tag requires that the tag GENERATE_DOCSET is set to YES.
-
-DOCSET_BUNDLE_ID       = org.doxygen.Project
-
-# The DOCSET_PUBLISHER_ID tag specifies a string that should uniquely identify
-# the documentation publisher. This should be a reverse domain-name style
-# string, e.g. com.mycompany.MyDocSet.documentation.
-# The default value is: org.doxygen.Publisher.
-# This tag requires that the tag GENERATE_DOCSET is set to YES.
-
-DOCSET_PUBLISHER_ID    = org.doxygen.Publisher
-
-# The DOCSET_PUBLISHER_NAME tag identifies the documentation publisher.
-# The default value is: Publisher.
-# This tag requires that the tag GENERATE_DOCSET is set to YES.
-
-DOCSET_PUBLISHER_NAME  = Publisher
-
-# If the GENERATE_HTMLHELP tag is set to YES then doxygen generates three
-# additional HTML index files: index.hhp, index.hhc, and index.hhk. The
-# index.hhp is a project file that can be read by Microsoft's HTML Help Workshop
-# (see: http://www.microsoft.com/en-us/download/details.aspx?id=21138) on
-# Windows.
-#
-# The HTML Help Workshop contains a compiler that can convert all HTML output
-# generated by doxygen into a single compiled HTML file (.chm). Compiled HTML
-# files are now used as the Windows 98 help format, and will replace the old
-# Windows help format (.hlp) on all Windows platforms in the future. Compressed
-# HTML files also contain an index, a table of contents, and you can search for
-# words in the documentation. The HTML workshop also contains a viewer for
-# compressed HTML files.
-# The default value is: NO.
-# This tag requires that the tag GENERATE_HTML is set to YES.
-
-GENERATE_HTMLHELP      = NO
-
-# The CHM_FILE tag can be used to specify the file name of the resulting .chm
-# file. You can add a path in front of the file if the result should not be
-# written to the html output directory.
-# This tag requires that the tag GENERATE_HTMLHELP is set to YES.
-
-CHM_FILE               = 
-
-# The HHC_LOCATION tag can be used to specify the location (absolute path
-# including file name) of the HTML help compiler (hhc.exe). If non-empty,
-# doxygen will try to run the HTML help compiler on the generated index.hhp.
-# The file has to be specified with full path.
-# This tag requires that the tag GENERATE_HTMLHELP is set to YES.
-
-HHC_LOCATION           = 
-
-# The GENERATE_CHI flag controls if a separate .chi index file is generated
-# (YES) or that it should be included in the master .chm file (NO).
-# The default value is: NO.
-# This tag requires that the tag GENERATE_HTMLHELP is set to YES.
-
-GENERATE_CHI           = NO
-
-# The CHM_INDEX_ENCODING is used to encode HtmlHelp index (hhk), content (hhc)
-# and project file content.
-# This tag requires that the tag GENERATE_HTMLHELP is set to YES.
-
-CHM_INDEX_ENCODING     = 
-
-# The BINARY_TOC flag controls whether a binary table of contents is generated
-# (YES) or a normal table of contents (NO) in the .chm file. Furthermore it
-# enables the Previous and Next buttons.
-# The default value is: NO.
-# This tag requires that the tag GENERATE_HTMLHELP is set to YES.
-
-BINARY_TOC             = NO
-
-# The TOC_EXPAND flag can be set to YES to add extra items for group members to
-# the table of contents of the HTML help documentation and to the tree view.
-# The default value is: NO.
-# This tag requires that the tag GENERATE_HTMLHELP is set to YES.
-
-TOC_EXPAND             = NO
-
-# If the GENERATE_QHP tag is set to YES and both QHP_NAMESPACE and
-# QHP_VIRTUAL_FOLDER are set, an additional index file will be generated that
-# can be used as input for Qt's qhelpgenerator to generate a Qt Compressed Help
-# (.qch) of the generated HTML documentation.
-# The default value is: NO.
-# This tag requires that the tag GENERATE_HTML is set to YES.
-
-GENERATE_QHP           = NO
-
-# If the QHG_LOCATION tag is specified, the QCH_FILE tag can be used to specify
-# the file name of the resulting .qch file. The path specified is relative to
-# the HTML output folder.
-# This tag requires that the tag GENERATE_QHP is set to YES.
-
-QCH_FILE               = 
-
-# The QHP_NAMESPACE tag specifies the namespace to use when generating Qt Help
-# Project output. For more information please see Qt Help Project / Namespace
-# (see: http://qt-project.org/doc/qt-4.8/qthelpproject.html#namespace).
-# The default value is: org.doxygen.Project.
-# This tag requires that the tag GENERATE_QHP is set to YES.
-
-QHP_NAMESPACE          = org.doxygen.Project
-
-# The QHP_VIRTUAL_FOLDER tag specifies the namespace to use when generating Qt
-# Help Project output. For more information please see Qt Help Project / Virtual
-# Folders (see: http://qt-project.org/doc/qt-4.8/qthelpproject.html#virtual-
-# folders).
-# The default value is: doc.
-# This tag requires that the tag GENERATE_QHP is set to YES.
-
-QHP_VIRTUAL_FOLDER     = doc
-
-# If the QHP_CUST_FILTER_NAME tag is set, it specifies the name of a custom
-# filter to add. For more information please see Qt Help Project / Custom
-# Filters (see: http://qt-project.org/doc/qt-4.8/qthelpproject.html#custom-
-# filters).
-# This tag requires that the tag GENERATE_QHP is set to YES.
-
-QHP_CUST_FILTER_NAME   = 
-
-# The QHP_CUST_FILTER_ATTRS tag specifies the list of the attributes of the
-# custom filter to add. For more information please see Qt Help Project / Custom
-# Filters (see: http://qt-project.org/doc/qt-4.8/qthelpproject.html#custom-
-# filters).
-# This tag requires that the tag GENERATE_QHP is set to YES.
-
-QHP_CUST_FILTER_ATTRS  = 
-
-# The QHP_SECT_FILTER_ATTRS tag specifies the list of the attributes this
-# project's filter section matches. Qt Help Project / Filter Attributes (see:
-# http://qt-project.org/doc/qt-4.8/qthelpproject.html#filter-attributes).
-# This tag requires that the tag GENERATE_QHP is set to YES.
-
-QHP_SECT_FILTER_ATTRS  = 
-
-# The QHG_LOCATION tag can be used to specify the location of Qt's
-# qhelpgenerator. If non-empty doxygen will try to run qhelpgenerator on the
-# generated .qhp file.
-# This tag requires that the tag GENERATE_QHP is set to YES.
-
-QHG_LOCATION           = 
-
-# If the GENERATE_ECLIPSEHELP tag is set to YES, additional index files will be
-# generated, together with the HTML files, they form an Eclipse help plugin. To
-# install this plugin and make it available under the help contents menu in
-# Eclipse, the contents of the directory containing the HTML and XML files needs
-# to be copied into the plugins directory of eclipse. The name of the directory
-# within the plugins directory should be the same as the ECLIPSE_DOC_ID value.
-# After copying Eclipse needs to be restarted before the help appears.
-# The default value is: NO.
-# This tag requires that the tag GENERATE_HTML is set to YES.
-
-GENERATE_ECLIPSEHELP   = NO
-
-# A unique identifier for the Eclipse help plugin. When installing the plugin
-# the directory name containing the HTML and XML files should also have this
-# name. Each documentation set should have its own identifier.
-# The default value is: org.doxygen.Project.
-# This tag requires that the tag GENERATE_ECLIPSEHELP is set to YES.
-
-ECLIPSE_DOC_ID         = org.doxygen.Project
-
-# If you want full control over the layout of the generated HTML pages it might
-# be necessary to disable the index and replace it with your own. The
-# DISABLE_INDEX tag can be used to turn on/off the condensed index (tabs) at top
-# of each HTML page. A value of NO enables the index and the value YES disables
-# it. Since the tabs in the index contain the same information as the navigation
-# tree, you can set this option to YES if you also set GENERATE_TREEVIEW to YES.
-# The default value is: NO.
-# This tag requires that the tag GENERATE_HTML is set to YES.
-
-DISABLE_INDEX          = NO
-
-# The GENERATE_TREEVIEW tag is used to specify whether a tree-like index
-# structure should be generated to display hierarchical information. If the tag
-# value is set to YES, a side panel will be generated containing a tree-like
-# index structure (just like the one that is generated for HTML Help). For this
-# to work a browser that supports JavaScript, DHTML, CSS and frames is required
-# (i.e. any modern browser). Windows users are probably better off using the
-# HTML help feature. Via custom style sheets (see HTML_EXTRA_STYLESHEET) one can
-# further fine-tune the look of the index. As an example, the default style
-# sheet generated by doxygen has an example that shows how to put an image at
-# the root of the tree instead of the PROJECT_NAME. Since the tree basically has
-# the same information as the tab index, you could consider setting
-# DISABLE_INDEX to YES when enabling this option.
-# The default value is: NO.
-# This tag requires that the tag GENERATE_HTML is set to YES.
-
-GENERATE_TREEVIEW      = NO
-
-# The ENUM_VALUES_PER_LINE tag can be used to set the number of enum values that
-# doxygen will group on one line in the generated HTML documentation.
-#
-# Note that a value of 0 will completely suppress the enum values from appearing
-# in the overview section.
-# Minimum value: 0, maximum value: 20, default value: 4.
-# This tag requires that the tag GENERATE_HTML is set to YES.
-
-ENUM_VALUES_PER_LINE   = 4
-
-# If the treeview is enabled (see GENERATE_TREEVIEW) then this tag can be used
-# to set the initial width (in pixels) of the frame in which the tree is shown.
-# Minimum value: 0, maximum value: 1500, default value: 250.
-# This tag requires that the tag GENERATE_HTML is set to YES.
-
-TREEVIEW_WIDTH         = 250
-
-# If the EXT_LINKS_IN_WINDOW option is set to YES, doxygen will open links to
-# external symbols imported via tag files in a separate window.
-# The default value is: NO.
-# This tag requires that the tag GENERATE_HTML is set to YES.
-
-EXT_LINKS_IN_WINDOW    = NO
-
-# Use this tag to change the font size of LaTeX formulas included as images in
-# the HTML documentation. When you change the font size after a successful
-# doxygen run you need to manually remove any form_*.png images from the HTML
-# output directory to force them to be regenerated.
-# Minimum value: 8, maximum value: 50, default value: 10.
-# This tag requires that the tag GENERATE_HTML is set to YES.
-
-FORMULA_FONTSIZE       = 10
-
-# Use the FORMULA_TRANPARENT tag to determine whether or not the images
-# generated for formulas are transparent PNGs. Transparent PNGs are not
-# supported properly for IE 6.0, but are supported on all modern browsers.
-#
-# Note that when changing this option you need to delete any form_*.png files in
-# the HTML output directory before the changes have effect.
-# The default value is: YES.
-# This tag requires that the tag GENERATE_HTML is set to YES.
-
-FORMULA_TRANSPARENT    = YES
-
-# Enable the USE_MATHJAX option to render LaTeX formulas using MathJax (see
-# http://www.mathjax.org) which uses client side Javascript for the rendering
-# instead of using pre-rendered bitmaps. Use this if you do not have LaTeX
-# installed or if you want to formulas look prettier in the HTML output. When
-# enabled you may also need to install MathJax separately and configure the path
-# to it using the MATHJAX_RELPATH option.
-# The default value is: NO.
-# This tag requires that the tag GENERATE_HTML is set to YES.
-
-USE_MATHJAX            = NO
-
-# When MathJax is enabled you can set the default output format to be used for
-# the MathJax output. See the MathJax site (see:
-# http://docs.mathjax.org/en/latest/output.html) for more details.
-# Possible values are: HTML-CSS (which is slower, but has the best
-# compatibility), NativeMML (i.e. MathML) and SVG.
-# The default value is: HTML-CSS.
-# This tag requires that the tag USE_MATHJAX is set to YES.
-
-MATHJAX_FORMAT         = HTML-CSS
-
-# When MathJax is enabled you need to specify the location relative to the HTML
-# output directory using the MATHJAX_RELPATH option. The destination directory
-# should contain the MathJax.js script. For instance, if the mathjax directory
-# is located at the same level as the HTML output directory, then
-# MATHJAX_RELPATH should be ../mathjax. The default value points to the MathJax
-# Content Delivery Network so you can quickly see the result without installing
-# MathJax. However, it is strongly recommended to install a local copy of
-# MathJax from http://www.mathjax.org before deployment.
-# The default value is: http://cdn.mathjax.org/mathjax/latest.
-# This tag requires that the tag USE_MATHJAX is set to YES.
-
-MATHJAX_RELPATH        = http://cdn.mathjax.org/mathjax/latest
-
-# The MATHJAX_EXTENSIONS tag can be used to specify one or more MathJax
-# extension names that should be enabled during MathJax rendering. For example
-# MATHJAX_EXTENSIONS = TeX/AMSmath TeX/AMSsymbols
-# This tag requires that the tag USE_MATHJAX is set to YES.
-
-MATHJAX_EXTENSIONS     = 
-
-# The MATHJAX_CODEFILE tag can be used to specify a file with javascript pieces
-# of code that will be used on startup of the MathJax code. See the MathJax site
-# (see: http://docs.mathjax.org/en/latest/output.html) for more details. For an
-# example see the documentation.
-# This tag requires that the tag USE_MATHJAX is set to YES.
-
-MATHJAX_CODEFILE       = 
-
-# When the SEARCHENGINE tag is enabled doxygen will generate a search box for
-# the HTML output. The underlying search engine uses javascript and DHTML and
-# should work on any modern browser. Note that when using HTML help
-# (GENERATE_HTMLHELP), Qt help (GENERATE_QHP), or docsets (GENERATE_DOCSET)
-# there is already a search function so this one should typically be disabled.
-# For large projects the javascript based search engine can be slow, then
-# enabling SERVER_BASED_SEARCH may provide a better solution. It is possible to
-# search using the keyboard; to jump to the search box use <access key> + S
-# (what the <access key> is depends on the OS and browser, but it is typically
-# <CTRL>, <ALT>/<option>, or both). Inside the search box use the <cursor down
-# key> to jump into the search results window, the results can be navigated
-# using the <cursor keys>. Press <Enter> to select an item or <escape> to cancel
-# the search. The filter options can be selected when the cursor is inside the
-# search box by pressing <Shift>+<cursor down>. Also here use the <cursor keys>
-# to select a filter and <Enter> or <escape> to activate or cancel the filter
-# option.
-# The default value is: YES.
-# This tag requires that the tag GENERATE_HTML is set to YES.
-
-SEARCHENGINE           = NO
-
-# When the SERVER_BASED_SEARCH tag is enabled the search engine will be
-# implemented using a web server instead of a web client using Javascript. There
-# are two flavors of web server based searching depending on the EXTERNAL_SEARCH
-# setting. When disabled, doxygen will generate a PHP script for searching and
-# an index file used by the script. When EXTERNAL_SEARCH is enabled the indexing
-# and searching needs to be provided by external tools. See the section
-# "External Indexing and Searching" for details.
-# The default value is: NO.
-# This tag requires that the tag SEARCHENGINE is set to YES.
-
-SERVER_BASED_SEARCH    = NO
-
-# When EXTERNAL_SEARCH tag is enabled doxygen will no longer generate the PHP
-# script for searching. Instead the search results are written to an XML file
-# which needs to be processed by an external indexer. Doxygen will invoke an
-# external search engine pointed to by the SEARCHENGINE_URL option to obtain the
-# search results.
-#
-# Doxygen ships with an example indexer (doxyindexer) and search engine
-# (doxysearch.cgi) which are based on the open source search engine library
-# Xapian (see: http://xapian.org/).
-#
-# See the section "External Indexing and Searching" for details.
-# The default value is: NO.
-# This tag requires that the tag SEARCHENGINE is set to YES.
-
-EXTERNAL_SEARCH        = NO
-
-# The SEARCHENGINE_URL should point to a search engine hosted by a web server
-# which will return the search results when EXTERNAL_SEARCH is enabled.
-#
-# Doxygen ships with an example indexer (doxyindexer) and search engine
-# (doxysearch.cgi) which are based on the open source search engine library
-# Xapian (see: http://xapian.org/). See the section "External Indexing and
-# Searching" for details.
-# This tag requires that the tag SEARCHENGINE is set to YES.
-
-SEARCHENGINE_URL       = 
-
-# When SERVER_BASED_SEARCH and EXTERNAL_SEARCH are both enabled the unindexed
-# search data is written to a file for indexing by an external tool. With the
-# SEARCHDATA_FILE tag the name of this file can be specified.
-# The default file is: searchdata.xml.
-# This tag requires that the tag SEARCHENGINE is set to YES.
-
-SEARCHDATA_FILE        = searchdata.xml
-
-# When SERVER_BASED_SEARCH and EXTERNAL_SEARCH are both enabled the
-# EXTERNAL_SEARCH_ID tag can be used as an identifier for the project. This is
-# useful in combination with EXTRA_SEARCH_MAPPINGS to search through multiple
-# projects and redirect the results back to the right project.
-# This tag requires that the tag SEARCHENGINE is set to YES.
-
-EXTERNAL_SEARCH_ID     = 
-
-# The EXTRA_SEARCH_MAPPINGS tag can be used to enable searching through doxygen
-# projects other than the one defined by this configuration file, but that are
-# all added to the same external search index. Each project needs to have a
-# unique id set via EXTERNAL_SEARCH_ID. The search mapping then maps the id of
-# to a relative location where the documentation can be found. The format is:
-# EXTRA_SEARCH_MAPPINGS = tagname1=loc1 tagname2=loc2 ...
-# This tag requires that the tag SEARCHENGINE is set to YES.
-
-EXTRA_SEARCH_MAPPINGS  = 
-
-#---------------------------------------------------------------------------
-# Configuration options related to the LaTeX output
-#---------------------------------------------------------------------------
-
-# If the GENERATE_LATEX tag is set to YES, doxygen will generate LaTeX output.
-# The default value is: YES.
-
-GENERATE_LATEX         = NO
-
-# The LATEX_OUTPUT tag is used to specify where the LaTeX docs will be put. If a
-# relative path is entered the value of OUTPUT_DIRECTORY will be put in front of
-# it.
-# The default directory is: latex.
-# This tag requires that the tag GENERATE_LATEX is set to YES.
-
-LATEX_OUTPUT           = latex
-
-# The LATEX_CMD_NAME tag can be used to specify the LaTeX command name to be
-# invoked.
-#
-# Note that when enabling USE_PDFLATEX this option is only used for generating
-# bitmaps for formulas in the HTML output, but not in the Makefile that is
-# written to the output directory.
-# The default file is: latex.
-# This tag requires that the tag GENERATE_LATEX is set to YES.
-
-LATEX_CMD_NAME         = latex
-
-# The MAKEINDEX_CMD_NAME tag can be used to specify the command name to generate
-# index for LaTeX.
-# The default file is: makeindex.
-# This tag requires that the tag GENERATE_LATEX is set to YES.
-
-MAKEINDEX_CMD_NAME     = makeindex
-
-# If the COMPACT_LATEX tag is set to YES, doxygen generates more compact LaTeX
-# documents. This may be useful for small projects and may help to save some
-# trees in general.
-# The default value is: NO.
-# This tag requires that the tag GENERATE_LATEX is set to YES.
-
-COMPACT_LATEX          = NO
-
-# The PAPER_TYPE tag can be used to set the paper type that is used by the
-# printer.
-# Possible values are: a4 (210 x 297 mm), letter (8.5 x 11 inches), legal (8.5 x
-# 14 inches) and executive (7.25 x 10.5 inches).
-# The default value is: a4.
-# This tag requires that the tag GENERATE_LATEX is set to YES.
-
-PAPER_TYPE             = a4
-
-# The EXTRA_PACKAGES tag can be used to specify one or more LaTeX package names
-# that should be included in the LaTeX output. The package can be specified just
-# by its name or with the correct syntax as to be used with the LaTeX
-# \usepackage command. To get the times font for instance you can specify :
-# EXTRA_PACKAGES=times or EXTRA_PACKAGES={times}
-# To use the option intlimits with the amsmath package you can specify:
-# EXTRA_PACKAGES=[intlimits]{amsmath}
-# If left blank no extra packages will be included.
-# This tag requires that the tag GENERATE_LATEX is set to YES.
-
-EXTRA_PACKAGES         = 
-
-# The LATEX_HEADER tag can be used to specify a personal LaTeX header for the
-# generated LaTeX document. The header should contain everything until the first
-# chapter. If it is left blank doxygen will generate a standard header. See
-# section "Doxygen usage" for information on how to let doxygen write the
-# default header to a separate file.
-#
-# Note: Only use a user-defined header if you know what you are doing! The
-# following commands have a special meaning inside the header: $title,
-# $datetime, $date, $doxygenversion, $projectname, $projectnumber,
-# $projectbrief, $projectlogo. Doxygen will replace $title with the empty
-# string, for the replacement values of the other commands the user is referred
-# to HTML_HEADER.
-# This tag requires that the tag GENERATE_LATEX is set to YES.
-
-LATEX_HEADER           = 
-
-# The LATEX_FOOTER tag can be used to specify a personal LaTeX footer for the
-# generated LaTeX document. The footer should contain everything after the last
-# chapter. If it is left blank doxygen will generate a standard footer. See
-# LATEX_HEADER for more information on how to generate a default footer and what
-# special commands can be used inside the footer.
-#
-# Note: Only use a user-defined footer if you know what you are doing!
-# This tag requires that the tag GENERATE_LATEX is set to YES.
-
-LATEX_FOOTER           = 
-
-# The LATEX_EXTRA_STYLESHEET tag can be used to specify additional user-defined
-# LaTeX style sheets that are included after the standard style sheets created
-# by doxygen. Using this option one can overrule certain style aspects. Doxygen
-# will copy the style sheet files to the output directory.
-# Note: The order of the extra style sheet files is of importance (e.g. the last
-# style sheet in the list overrules the setting of the previous ones in the
-# list).
-# This tag requires that the tag GENERATE_LATEX is set to YES.
-
-LATEX_EXTRA_STYLESHEET = 
-
-# The LATEX_EXTRA_FILES tag can be used to specify one or more extra images or
-# other source files which should be copied to the LATEX_OUTPUT output
-# directory. Note that the files will be copied as-is; there are no commands or
-# markers available.
-# This tag requires that the tag GENERATE_LATEX is set to YES.
-
-LATEX_EXTRA_FILES      = 
-
-# If the PDF_HYPERLINKS tag is set to YES, the LaTeX that is generated is
-# prepared for conversion to PDF (using ps2pdf or pdflatex). The PDF file will
-# contain links (just like the HTML output) instead of page references. This
-# makes the output suitable for online browsing using a PDF viewer.
-# The default value is: YES.
-# This tag requires that the tag GENERATE_LATEX is set to YES.
-
-PDF_HYPERLINKS         = YES
-
-# If the USE_PDFLATEX tag is set to YES, doxygen will use pdflatex to generate
-# the PDF file directly from the LaTeX files. Set this option to YES, to get a
-# higher quality PDF documentation.
-# The default value is: YES.
-# This tag requires that the tag GENERATE_LATEX is set to YES.
-
-USE_PDFLATEX           = YES
-
-# If the LATEX_BATCHMODE tag is set to YES, doxygen will add the \batchmode
-# command to the generated LaTeX files. This will instruct LaTeX to keep running
-# if errors occur, instead of asking the user for help. This option is also used
-# when generating formulas in HTML.
-# The default value is: NO.
-# This tag requires that the tag GENERATE_LATEX is set to YES.
-
-LATEX_BATCHMODE        = NO
-
-# If the LATEX_HIDE_INDICES tag is set to YES then doxygen will not include the
-# index chapters (such as File Index, Compound Index, etc.) in the output.
-# The default value is: NO.
-# This tag requires that the tag GENERATE_LATEX is set to YES.
-
-LATEX_HIDE_INDICES     = NO
-
-# If the LATEX_SOURCE_CODE tag is set to YES then doxygen will include source
-# code with syntax highlighting in the LaTeX output.
-#
-# Note that which sources are shown also depends on other settings such as
-# SOURCE_BROWSER.
-# The default value is: NO.
-# This tag requires that the tag GENERATE_LATEX is set to YES.
-
-LATEX_SOURCE_CODE      = NO
-
-# The LATEX_BIB_STYLE tag can be used to specify the style to use for the
-# bibliography, e.g. plainnat, or ieeetr. See
-# http://en.wikipedia.org/wiki/BibTeX and \cite for more info.
-# The default value is: plain.
-# This tag requires that the tag GENERATE_LATEX is set to YES.
-
-LATEX_BIB_STYLE        = plain
-
-# If the LATEX_TIMESTAMP tag is set to YES then the footer of each generated
-# page will contain the date and time when the page was generated. Setting this
-# to NO can help when comparing the output of multiple runs.
-# The default value is: NO.
-# This tag requires that the tag GENERATE_LATEX is set to YES.
-
-LATEX_TIMESTAMP        = NO
-
-#---------------------------------------------------------------------------
-# Configuration options related to the RTF output
-#---------------------------------------------------------------------------
-
-# If the GENERATE_RTF tag is set to YES, doxygen will generate RTF output. The
-# RTF output is optimized for Word 97 and may not look too pretty with other RTF
-# readers/editors.
-# The default value is: NO.
-
-GENERATE_RTF           = NO
-
-# The RTF_OUTPUT tag is used to specify where the RTF docs will be put. If a
-# relative path is entered the value of OUTPUT_DIRECTORY will be put in front of
-# it.
-# The default directory is: rtf.
-# This tag requires that the tag GENERATE_RTF is set to YES.
-
-RTF_OUTPUT             = rtf
-
-# If the COMPACT_RTF tag is set to YES, doxygen generates more compact RTF
-# documents. This may be useful for small projects and may help to save some
-# trees in general.
-# The default value is: NO.
-# This tag requires that the tag GENERATE_RTF is set to YES.
-
-COMPACT_RTF            = NO
-
-# If the RTF_HYPERLINKS tag is set to YES, the RTF that is generated will
-# contain hyperlink fields. The RTF file will contain links (just like the HTML
-# output) instead of page references. This makes the output suitable for online
-# browsing using Word or some other Word compatible readers that support those
-# fields.
-#
-# Note: WordPad (write) and others do not support links.
-# The default value is: NO.
-# This tag requires that the tag GENERATE_RTF is set to YES.
-
-RTF_HYPERLINKS         = NO
-
-# Load stylesheet definitions from file. Syntax is similar to doxygen's config
-# file, i.e. a series of assignments. You only have to provide replacements,
-# missing definitions are set to their default value.
-#
-# See also section "Doxygen usage" for information on how to generate the
-# default style sheet that doxygen normally uses.
-# This tag requires that the tag GENERATE_RTF is set to YES.
-
-RTF_STYLESHEET_FILE    = 
-
-# Set optional variables used in the generation of an RTF document. Syntax is
-# similar to doxygen's config file. A template extensions file can be generated
-# using doxygen -e rtf extensionFile.
-# This tag requires that the tag GENERATE_RTF is set to YES.
-
-RTF_EXTENSIONS_FILE    = 
-
-# If the RTF_SOURCE_CODE tag is set to YES then doxygen will include source code
-# with syntax highlighting in the RTF output.
-#
-# Note that which sources are shown also depends on other settings such as
-# SOURCE_BROWSER.
-# The default value is: NO.
-# This tag requires that the tag GENERATE_RTF is set to YES.
-
-RTF_SOURCE_CODE        = NO
-
-#---------------------------------------------------------------------------
-# Configuration options related to the man page output
-#---------------------------------------------------------------------------
-
-# If the GENERATE_MAN tag is set to YES, doxygen will generate man pages for
-# classes and files.
-# The default value is: NO.
-
-GENERATE_MAN           = NO
-
-# The MAN_OUTPUT tag is used to specify where the man pages will be put. If a
-# relative path is entered the value of OUTPUT_DIRECTORY will be put in front of
-# it. A directory man3 will be created inside the directory specified by
-# MAN_OUTPUT.
-# The default directory is: man.
-# This tag requires that the tag GENERATE_MAN is set to YES.
-
-MAN_OUTPUT             = man
-
-# The MAN_EXTENSION tag determines the extension that is added to the generated
-# man pages. In case the manual section does not start with a number, the number
-# 3 is prepended. The dot (.) at the beginning of the MAN_EXTENSION tag is
-# optional.
-# The default value is: .3.
-# This tag requires that the tag GENERATE_MAN is set to YES.
-
-MAN_EXTENSION          = .3
-
-# The MAN_SUBDIR tag determines the name of the directory created within
-# MAN_OUTPUT in which the man pages are placed. If defaults to man followed by
-# MAN_EXTENSION with the initial . removed.
-# This tag requires that the tag GENERATE_MAN is set to YES.
-
-MAN_SUBDIR             = 
-
-# If the MAN_LINKS tag is set to YES and doxygen generates man output, then it
-# will generate one additional man file for each entity documented in the real
-# man page(s). These additional files only source the real man page, but without
-# them the man command would be unable to find the correct page.
-# The default value is: NO.
-# This tag requires that the tag GENERATE_MAN is set to YES.
-
-MAN_LINKS              = NO
-
-#---------------------------------------------------------------------------
-# Configuration options related to the XML output
-#---------------------------------------------------------------------------
-
-# If the GENERATE_XML tag is set to YES, doxygen will generate an XML file that
-# captures the structure of the code including all documentation.
-# The default value is: NO.
-
-GENERATE_XML           = NO
-
-# The XML_OUTPUT tag is used to specify where the XML pages will be put. If a
-# relative path is entered the value of OUTPUT_DIRECTORY will be put in front of
-# it.
-# The default directory is: xml.
-# This tag requires that the tag GENERATE_XML is set to YES.
-
-XML_OUTPUT             = xml
-
-# If the XML_PROGRAMLISTING tag is set to YES, doxygen will dump the program
-# listings (including syntax highlighting and cross-referencing information) to
-# the XML output. Note that enabling this will significantly increase the size
-# of the XML output.
-# The default value is: YES.
-# This tag requires that the tag GENERATE_XML is set to YES.
-
-XML_PROGRAMLISTING     = YES
-
-#---------------------------------------------------------------------------
-# Configuration options related to the DOCBOOK output
-#---------------------------------------------------------------------------
-
-# If the GENERATE_DOCBOOK tag is set to YES, doxygen will generate Docbook files
-# that can be used to generate PDF.
-# The default value is: NO.
-
-GENERATE_DOCBOOK       = NO
-
-# The DOCBOOK_OUTPUT tag is used to specify where the Docbook pages will be put.
-# If a relative path is entered the value of OUTPUT_DIRECTORY will be put in
-# front of it.
-# The default directory is: docbook.
-# This tag requires that the tag GENERATE_DOCBOOK is set to YES.
-
-DOCBOOK_OUTPUT         = docbook
-
-# If the DOCBOOK_PROGRAMLISTING tag is set to YES, doxygen will include the
-# program listings (including syntax highlighting and cross-referencing
-# information) to the DOCBOOK output. Note that enabling this will significantly
-# increase the size of the DOCBOOK output.
-# The default value is: NO.
-# This tag requires that the tag GENERATE_DOCBOOK is set to YES.
-
-DOCBOOK_PROGRAMLISTING = NO
-
-#---------------------------------------------------------------------------
-# Configuration options for the AutoGen Definitions output
-#---------------------------------------------------------------------------
-
-# If the GENERATE_AUTOGEN_DEF tag is set to YES, doxygen will generate an
-# AutoGen Definitions (see http://autogen.sf.net) file that captures the
-# structure of the code including all documentation. Note that this feature is
-# still experimental and incomplete at the moment.
-# The default value is: NO.
-
-GENERATE_AUTOGEN_DEF   = NO
-
-#---------------------------------------------------------------------------
-# Configuration options related to the Perl module output
-#---------------------------------------------------------------------------
-
-# If the GENERATE_PERLMOD tag is set to YES, doxygen will generate a Perl module
-# file that captures the structure of the code including all documentation.
-#
-# Note that this feature is still experimental and incomplete at the moment.
-# The default value is: NO.
-
-GENERATE_PERLMOD       = NO
-
-# If the PERLMOD_LATEX tag is set to YES, doxygen will generate the necessary
-# Makefile rules, Perl scripts and LaTeX code to be able to generate PDF and DVI
-# output from the Perl module output.
-# The default value is: NO.
-# This tag requires that the tag GENERATE_PERLMOD is set to YES.
-
-PERLMOD_LATEX          = NO
-
-# If the PERLMOD_PRETTY tag is set to YES, the Perl module output will be nicely
-# formatted so it can be parsed by a human reader. This is useful if you want to
-# understand what is going on. On the other hand, if this tag is set to NO, the
-# size of the Perl module output will be much smaller and Perl will parse it
-# just the same.
-# The default value is: YES.
-# This tag requires that the tag GENERATE_PERLMOD is set to YES.
-
-PERLMOD_PRETTY         = YES
-
-# The names of the make variables in the generated doxyrules.make file are
-# prefixed with the string contained in PERLMOD_MAKEVAR_PREFIX. This is useful
-# so different doxyrules.make files included by the same Makefile don't
-# overwrite each other's variables.
-# This tag requires that the tag GENERATE_PERLMOD is set to YES.
-
-PERLMOD_MAKEVAR_PREFIX = 
-
-#---------------------------------------------------------------------------
-# Configuration options related to the preprocessor
-#---------------------------------------------------------------------------
-
-# If the ENABLE_PREPROCESSING tag is set to YES, doxygen will evaluate all
-# C-preprocessor directives found in the sources and include files.
-# The default value is: YES.
-
-ENABLE_PREPROCESSING   = YES
-
-# If the MACRO_EXPANSION tag is set to YES, doxygen will expand all macro names
-# in the source code. If set to NO, only conditional compilation will be
-# performed. Macro expansion can be done in a controlled way by setting
-# EXPAND_ONLY_PREDEF to YES.
-# The default value is: NO.
-# This tag requires that the tag ENABLE_PREPROCESSING is set to YES.
-
-MACRO_EXPANSION        = NO
-
-# If the EXPAND_ONLY_PREDEF and MACRO_EXPANSION tags are both set to YES then
-# the macro expansion is limited to the macros specified with the PREDEFINED and
-# EXPAND_AS_DEFINED tags.
-# The default value is: NO.
-# This tag requires that the tag ENABLE_PREPROCESSING is set to YES.
-
-EXPAND_ONLY_PREDEF     = NO
-
-# If the SEARCH_INCLUDES tag is set to YES, the include files in the
-# INCLUDE_PATH will be searched if a #include is found.
-# The default value is: YES.
-# This tag requires that the tag ENABLE_PREPROCESSING is set to YES.
-
-SEARCH_INCLUDES        = YES
-
-# The INCLUDE_PATH tag can be used to specify one or more directories that
-# contain include files that are not input files but should be processed by the
-# preprocessor.
-# This tag requires that the tag SEARCH_INCLUDES is set to YES.
-
-INCLUDE_PATH           = 
-
-# You can use the INCLUDE_FILE_PATTERNS tag to specify one or more wildcard
-# patterns (like *.h and *.hpp) to filter out the header-files in the
-# directories. If left blank, the patterns specified with FILE_PATTERNS will be
-# used.
-# This tag requires that the tag ENABLE_PREPROCESSING is set to YES.
-
-INCLUDE_FILE_PATTERNS  = 
-
-# The PREDEFINED tag can be used to specify one or more macro names that are
-# defined before the preprocessor is started (similar to the -D option of e.g.
-# gcc). The argument of the tag is a list of macros of the form: name or
-# name=definition (no spaces). If the definition and the "=" are omitted, "=1"
-# is assumed. To prevent a macro definition from being undefined via #undef or
-# recursively expanded use the := operator instead of the = operator.
-# This tag requires that the tag ENABLE_PREPROCESSING is set to YES.
-
-PREDEFINED             = 
-
-# If the MACRO_EXPANSION and EXPAND_ONLY_PREDEF tags are set to YES then this
-# tag can be used to specify a list of macro names that should be expanded. The
-# macro definition that is found in the sources will be used. Use the PREDEFINED
-# tag if you want to use a different macro definition that overrules the
-# definition found in the source code.
-# This tag requires that the tag ENABLE_PREPROCESSING is set to YES.
-
-EXPAND_AS_DEFINED      = 
-
-# If the SKIP_FUNCTION_MACROS tag is set to YES then doxygen's preprocessor will
-# remove all references to function-like macros that are alone on a line, have
-# an all uppercase name, and do not end with a semicolon. Such function macros
-# are typically used for boiler-plate code, and will confuse the parser if not
-# removed.
-# The default value is: YES.
-# This tag requires that the tag ENABLE_PREPROCESSING is set to YES.
-
-SKIP_FUNCTION_MACROS   = YES
-
-#---------------------------------------------------------------------------
-# Configuration options related to external references
-#---------------------------------------------------------------------------
-
-# The TAGFILES tag can be used to specify one or more tag files. For each tag
-# file the location of the external documentation should be added. The format of
-# a tag file without this location is as follows:
-# TAGFILES = file1 file2 ...
-# Adding location for the tag files is done as follows:
-# TAGFILES = file1=loc1 "file2 = loc2" ...
-# where loc1 and loc2 can be relative or absolute paths or URLs. See the
-# section "Linking to external documentation" for more information about the use
-# of tag files.
-# Note: Each tag file must have a unique name (where the name does NOT include
-# the path). If a tag file is not located in the directory in which doxygen is
-# run, you must also specify the path to the tagfile here.
-
-TAGFILES               = 
-
-# When a file name is specified after GENERATE_TAGFILE, doxygen will create a
-# tag file that is based on the input files it reads. See section "Linking to
-# external documentation" for more information about the usage of tag files.
-
-GENERATE_TAGFILE       = 
-
-# If the ALLEXTERNALS tag is set to YES, all external class will be listed in
-# the class index. If set to NO, only the inherited external classes will be
-# listed.
-# The default value is: NO.
-
-ALLEXTERNALS           = NO
-
-# If the EXTERNAL_GROUPS tag is set to YES, all external groups will be listed
-# in the modules index. If set to NO, only the current project's groups will be
-# listed.
-# The default value is: YES.
-
-EXTERNAL_GROUPS        = YES
-
-# If the EXTERNAL_PAGES tag is set to YES, all external pages will be listed in
-# the related pages index. If set to NO, only the current project's pages will
-# be listed.
-# The default value is: YES.
-
-EXTERNAL_PAGES         = YES
-
-# The PERL_PATH should be the absolute path and name of the perl script
-# interpreter (i.e. the result of 'which perl').
-# The default file (with absolute path) is: /usr/bin/perl.
-
-PERL_PATH              = /usr/bin/perl
-
-#---------------------------------------------------------------------------
-# Configuration options related to the dot tool
-#---------------------------------------------------------------------------
-
-# If the CLASS_DIAGRAMS tag is set to YES, doxygen will generate a class diagram
-# (in HTML and LaTeX) for classes with base or super classes. Setting the tag to
-# NO turns the diagrams off. Note that this option also works with HAVE_DOT
-# disabled, but it is recommended to install and use dot, since it yields more
-# powerful graphs.
-# The default value is: YES.
-
-CLASS_DIAGRAMS         = NO
-
-# You can define message sequence charts within doxygen comments using the \msc
-# command. Doxygen will then run the mscgen tool (see:
-# http://www.mcternan.me.uk/mscgen/)) to produce the chart and insert it in the
-# documentation. The MSCGEN_PATH tag allows you to specify the directory where
-# the mscgen tool resides. If left empty the tool is assumed to be found in the
-# default search path.
-
-MSCGEN_PATH            = 
-
-# You can include diagrams made with dia in doxygen documentation. Doxygen will
-# then run dia to produce the diagram and insert it in the documentation. The
-# DIA_PATH tag allows you to specify the directory where the dia binary resides.
-# If left empty dia is assumed to be found in the default search path.
-
-DIA_PATH               = 
-
-# If set to YES the inheritance and collaboration graphs will hide inheritance
-# and usage relations if the target is undocumented or is not a class.
-# The default value is: YES.
-
-HIDE_UNDOC_RELATIONS   = YES
-
-# If you set the HAVE_DOT tag to YES then doxygen will assume the dot tool is
-# available from the path. This tool is part of Graphviz (see:
-# http://www.graphviz.org/), a graph visualization toolkit from AT&T and Lucent
-# Bell Labs. The other options in this section have no effect if this option is
-# set to NO
-# The default value is: YES.
-
-HAVE_DOT               = NO
-
-# The DOT_NUM_THREADS specifies the number of dot invocations doxygen is allowed
-# to run in parallel. When set to 0 doxygen will base this on the number of
-# processors available in the system. You can set it explicitly to a value
-# larger than 0 to get control over the balance between CPU load and processing
-# speed.
-# Minimum value: 0, maximum value: 32, default value: 0.
-# This tag requires that the tag HAVE_DOT is set to YES.
-
-DOT_NUM_THREADS        = 0
-
-# When you want a differently looking font in the dot files that doxygen
-# generates you can specify the font name using DOT_FONTNAME. You need to make
-# sure dot is able to find the font, which can be done by putting it in a
-# standard location or by setting the DOTFONTPATH environment variable or by
-# setting DOT_FONTPATH to the directory containing the font.
-# The default value is: Helvetica.
-# This tag requires that the tag HAVE_DOT is set to YES.
-
-DOT_FONTNAME           = Helvetica
-
-# The DOT_FONTSIZE tag can be used to set the size (in points) of the font of
-# dot graphs.
-# Minimum value: 4, maximum value: 24, default value: 10.
-# This tag requires that the tag HAVE_DOT is set to YES.
-
-DOT_FONTSIZE           = 10
-
-# By default doxygen will tell dot to use the default font as specified with
-# DOT_FONTNAME. If you specify a different font using DOT_FONTNAME you can set
-# the path where dot can find it using this tag.
-# This tag requires that the tag HAVE_DOT is set to YES.
-
-DOT_FONTPATH           = 
-
-# If the CLASS_GRAPH tag is set to YES then doxygen will generate a graph for
-# each documented class showing the direct and indirect inheritance relations.
-# Setting this tag to YES will force the CLASS_DIAGRAMS tag to NO.
-# The default value is: YES.
-# This tag requires that the tag HAVE_DOT is set to YES.
-
-CLASS_GRAPH            = YES
-
-# If the COLLABORATION_GRAPH tag is set to YES then doxygen will generate a
-# graph for each documented class showing the direct and indirect implementation
-# dependencies (inheritance, containment, and class references variables) of the
-# class with other documented classes.
-# The default value is: YES.
-# This tag requires that the tag HAVE_DOT is set to YES.
-
-COLLABORATION_GRAPH    = YES
-
-# If the GROUP_GRAPHS tag is set to YES then doxygen will generate a graph for
-# groups, showing the direct groups dependencies.
-# The default value is: YES.
-# This tag requires that the tag HAVE_DOT is set to YES.
-
-GROUP_GRAPHS           = YES
-
-# If the UML_LOOK tag is set to YES, doxygen will generate inheritance and
-# collaboration diagrams in a style similar to the OMG's Unified Modeling
-# Language.
-# The default value is: NO.
-# This tag requires that the tag HAVE_DOT is set to YES.
-
-UML_LOOK               = NO
-
-# If the UML_LOOK tag is enabled, the fields and methods are shown inside the
-# class node. If there are many fields or methods and many nodes the graph may
-# become too big to be useful. The UML_LIMIT_NUM_FIELDS threshold limits the
-# number of items for each type to make the size more manageable. Set this to 0
-# for no limit. Note that the threshold may be exceeded by 50% before the limit
-# is enforced. So when you set the threshold to 10, up to 15 fields may appear,
-# but if the number exceeds 15, the total amount of fields shown is limited to
-# 10.
-# Minimum value: 0, maximum value: 100, default value: 10.
-# This tag requires that the tag HAVE_DOT is set to YES.
-
-UML_LIMIT_NUM_FIELDS   = 10
-
-# If the TEMPLATE_RELATIONS tag is set to YES then the inheritance and
-# collaboration graphs will show the relations between templates and their
-# instances.
-# The default value is: NO.
-# This tag requires that the tag HAVE_DOT is set to YES.
-
-TEMPLATE_RELATIONS     = NO
-
-# If the INCLUDE_GRAPH, ENABLE_PREPROCESSING and SEARCH_INCLUDES tags are set to
-# YES then doxygen will generate a graph for each documented file showing the
-# direct and indirect include dependencies of the file with other documented
-# files.
-# The default value is: YES.
-# This tag requires that the tag HAVE_DOT is set to YES.
-
-INCLUDE_GRAPH          = YES
-
-# If the INCLUDED_BY_GRAPH, ENABLE_PREPROCESSING and SEARCH_INCLUDES tags are
-# set to YES then doxygen will generate a graph for each documented file showing
-# the direct and indirect include dependencies of the file with other documented
-# files.
-# The default value is: YES.
-# This tag requires that the tag HAVE_DOT is set to YES.
-
-INCLUDED_BY_GRAPH      = YES
-
-# If the CALL_GRAPH tag is set to YES then doxygen will generate a call
-# dependency graph for every global function or class method.
-#
-# Note that enabling this option will significantly increase the time of a run.
-# So in most cases it will be better to enable call graphs for selected
-# functions only using the \callgraph command. Disabling a call graph can be
-# accomplished by means of the command \hidecallgraph.
-# The default value is: NO.
-# This tag requires that the tag HAVE_DOT is set to YES.
-
-CALL_GRAPH             = NO
-
-# If the CALLER_GRAPH tag is set to YES then doxygen will generate a caller
-# dependency graph for every global function or class method.
-#
-# Note that enabling this option will significantly increase the time of a run.
-# So in most cases it will be better to enable caller graphs for selected
-# functions only using the \callergraph command. Disabling a caller graph can be
-# accomplished by means of the command \hidecallergraph.
-# The default value is: NO.
-# This tag requires that the tag HAVE_DOT is set to YES.
-
-CALLER_GRAPH           = NO
-
-# If the GRAPHICAL_HIERARCHY tag is set to YES then doxygen will graphical
-# hierarchy of all classes instead of a textual one.
-# The default value is: YES.
-# This tag requires that the tag HAVE_DOT is set to YES.
-
-GRAPHICAL_HIERARCHY    = YES
-
-# If the DIRECTORY_GRAPH tag is set to YES then doxygen will show the
-# dependencies a directory has on other directories in a graphical way. The
-# dependency relations are determined by the #include relations between the
-# files in the directories.
-# The default value is: YES.
-# This tag requires that the tag HAVE_DOT is set to YES.
-
-DIRECTORY_GRAPH        = YES
-
-# The DOT_IMAGE_FORMAT tag can be used to set the image format of the images
-# generated by dot. For an explanation of the image formats see the section
-# output formats in the documentation of the dot tool (Graphviz (see:
-# http://www.graphviz.org/)).
-# Note: If you choose svg you need to set HTML_FILE_EXTENSION to xhtml in order
-# to make the SVG files visible in IE 9+ (other browsers do not have this
-# requirement).
-# Possible values are: png, png:cairo, png:cairo:cairo, png:cairo:gd, png:gd,
-# png:gd:gd, jpg, jpg:cairo, jpg:cairo:gd, jpg:gd, jpg:gd:gd, gif, gif:cairo,
-# gif:cairo:gd, gif:gd, gif:gd:gd, svg, png:gd, png:gd:gd, png:cairo,
-# png:cairo:gd, png:cairo:cairo, png:cairo:gdiplus, png:gdiplus and
-# png:gdiplus:gdiplus.
-# The default value is: png.
-# This tag requires that the tag HAVE_DOT is set to YES.
-
-DOT_IMAGE_FORMAT       = png
-
-# If DOT_IMAGE_FORMAT is set to svg, then this option can be set to YES to
-# enable generation of interactive SVG images that allow zooming and panning.
-#
-# Note that this requires a modern browser other than Internet Explorer. Tested
-# and working are Firefox, Chrome, Safari, and Opera.
-# Note: For IE 9+ you need to set HTML_FILE_EXTENSION to xhtml in order to make
-# the SVG files visible. Older versions of IE do not have SVG support.
-# The default value is: NO.
-# This tag requires that the tag HAVE_DOT is set to YES.
-
-INTERACTIVE_SVG        = NO
-
-# The DOT_PATH tag can be used to specify the path where the dot tool can be
-# found. If left blank, it is assumed the dot tool can be found in the path.
-# This tag requires that the tag HAVE_DOT is set to YES.
-
-DOT_PATH               = 
-
-# The DOTFILE_DIRS tag can be used to specify one or more directories that
-# contain dot files that are included in the documentation (see the \dotfile
-# command).
-# This tag requires that the tag HAVE_DOT is set to YES.
-
-DOTFILE_DIRS           = 
-
-# The MSCFILE_DIRS tag can be used to specify one or more directories that
-# contain msc files that are included in the documentation (see the \mscfile
-# command).
-
-MSCFILE_DIRS           = 
-
-# The DIAFILE_DIRS tag can be used to specify one or more directories that
-# contain dia files that are included in the documentation (see the \diafile
-# command).
-
-DIAFILE_DIRS           = 
-
-# When using plantuml, the PLANTUML_JAR_PATH tag should be used to specify the
-# path where java can find the plantuml.jar file. If left blank, it is assumed
-# PlantUML is not used or called during a preprocessing step. Doxygen will
-# generate a warning when it encounters a \startuml command in this case and
-# will not generate output for the diagram.
-
-PLANTUML_JAR_PATH      = 
-
-# When using plantuml, the specified paths are searched for files specified by
-# the !include statement in a plantuml block.
-
-PLANTUML_INCLUDE_PATH  = 
-
-# The DOT_GRAPH_MAX_NODES tag can be used to set the maximum number of nodes
-# that will be shown in the graph. If the number of nodes in a graph becomes
-# larger than this value, doxygen will truncate the graph, which is visualized
-# by representing a node as a red box. Note that doxygen if the number of direct
-# children of the root node in a graph is already larger than
-# DOT_GRAPH_MAX_NODES then the graph will not be shown at all. Also note that
-# the size of a graph can be further restricted by MAX_DOT_GRAPH_DEPTH.
-# Minimum value: 0, maximum value: 10000, default value: 50.
-# This tag requires that the tag HAVE_DOT is set to YES.
-
-DOT_GRAPH_MAX_NODES    = 50
-
-# The MAX_DOT_GRAPH_DEPTH tag can be used to set the maximum depth of the graphs
-# generated by dot. A depth value of 3 means that only nodes reachable from the
-# root by following a path via at most 3 edges will be shown. Nodes that lay
-# further from the root node will be omitted. Note that setting this option to 1
-# or 2 may greatly reduce the computation time needed for large code bases. Also
-# note that the size of a graph can be further restricted by
-# DOT_GRAPH_MAX_NODES. Using a depth of 0 means no depth restriction.
-# Minimum value: 0, maximum value: 1000, default value: 0.
-# This tag requires that the tag HAVE_DOT is set to YES.
-
-MAX_DOT_GRAPH_DEPTH    = 0
-
-# Set the DOT_TRANSPARENT tag to YES to generate images with a transparent
-# background. This is disabled by default, because dot on Windows does not seem
-# to support this out of the box.
-#
-# Warning: Depending on the platform used, enabling this option may lead to
-# badly anti-aliased labels on the edges of a graph (i.e. they become hard to
-# read).
-# The default value is: NO.
-# This tag requires that the tag HAVE_DOT is set to YES.
-
-DOT_TRANSPARENT        = NO
-
-# Set the DOT_MULTI_TARGETS tag to YES to allow dot to generate multiple output
-# files in one run (i.e. multiple -o and -T options on the command line). This
-# makes dot run faster, but since only newer versions of dot (>1.8.10) support
-# this, this feature is disabled by default.
-# The default value is: NO.
-# This tag requires that the tag HAVE_DOT is set to YES.
-
-DOT_MULTI_TARGETS      = NO
-
-# If the GENERATE_LEGEND tag is set to YES doxygen will generate a legend page
-# explaining the meaning of the various boxes and arrows in the dot generated
-# graphs.
-# The default value is: YES.
-# This tag requires that the tag HAVE_DOT is set to YES.
-
-GENERATE_LEGEND        = YES
-
-# If the DOT_CLEANUP tag is set to YES, doxygen will remove the intermediate dot
-# files that are used to generate the various graphs.
-# The default value is: YES.
-# This tag requires that the tag HAVE_DOT is set to YES.
-
-DOT_CLEANUP            = YES
diff --git a/src/nanobind/ext/robin_map/include/tsl/robin_growth_policy.h b/src/nanobind/ext/robin_map/include/tsl/robin_growth_policy.h
deleted file mode 100644
index 787e19e..0000000
--- a/src/nanobind/ext/robin_map/include/tsl/robin_growth_policy.h
+++ /dev/null
@@ -1,415 +0,0 @@
-/**
- * MIT License
- *
- * Copyright (c) 2017 Thibaut Goetghebuer-Planchon <tessil@gmx.com>
- *
- * 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.
- */
-#ifndef TSL_ROBIN_GROWTH_POLICY_H
-#define TSL_ROBIN_GROWTH_POLICY_H
-
-#include <algorithm>
-#include <array>
-#include <climits>
-#include <cmath>
-#include <cstddef>
-#include <cstdint>
-#include <iterator>
-#include <limits>
-#include <ratio>
-#include <stdexcept>
-
-// A change of the major version indicates an API and/or ABI break (change of
-// in-memory layout of the data structure)
-#define TSL_RH_VERSION_MAJOR 1
-// A change of the minor version indicates the addition of a feature without
-// impact on the API/ABI
-#define TSL_RH_VERSION_MINOR 4
-// A change of the patch version indicates a bugfix without additional
-// functionality
-#define TSL_RH_VERSION_PATCH 0
-
-#ifdef TSL_DEBUG
-#define tsl_rh_assert(expr) assert(expr)
-#else
-#define tsl_rh_assert(expr) (static_cast<void>(0))
-#endif
-
-/**
- * If exceptions are enabled, throw the exception passed in parameter, otherwise
- * call std::terminate.
- */
-#if (defined(__cpp_exceptions) || defined(__EXCEPTIONS) || \
-     (defined(_MSC_VER) && defined(_CPPUNWIND))) &&        \
-    !defined(TSL_NO_EXCEPTIONS)
-#define TSL_RH_THROW_OR_TERMINATE(ex, msg) throw ex(msg)
-#else
-#define TSL_RH_NO_EXCEPTIONS
-#ifdef TSL_DEBUG
-#include <iostream>
-#define TSL_RH_THROW_OR_TERMINATE(ex, msg) \
-  do {                                     \
-    std::cerr << msg << std::endl;         \
-    std::terminate();                      \
-  } while (0)
-#else
-#define TSL_RH_THROW_OR_TERMINATE(ex, msg) std::terminate()
-#endif
-#endif
-
-#if defined(__GNUC__) || defined(__clang__)
-#define TSL_RH_LIKELY(exp) (__builtin_expect(!!(exp), true))
-#else
-#define TSL_RH_LIKELY(exp) (exp)
-#endif
-
-#define TSL_RH_UNUSED(x) static_cast<void>(x)
-
-namespace tsl {
-namespace rh {
-
-/**
- * Grow the hash table by a factor of GrowthFactor keeping the bucket count to a
- * power of two. It allows the table to use a mask operation instead of a modulo
- * operation to map a hash to a bucket.
- *
- * GrowthFactor must be a power of two >= 2.
- */
-template <std::size_t GrowthFactor>
-class power_of_two_growth_policy {
- public:
-  /**
-   * Called on the hash table creation and on rehash. The number of buckets for
-   * the table is passed in parameter. This number is a minimum, the policy may
-   * update this value with a higher value if needed (but not lower).
-   *
-   * If 0 is given, min_bucket_count_in_out must still be 0 after the policy
-   * creation and bucket_for_hash must always return 0 in this case.
-   */
-  explicit power_of_two_growth_policy(std::size_t& min_bucket_count_in_out) {
-    if (min_bucket_count_in_out > max_bucket_count()) {
-      TSL_RH_THROW_OR_TERMINATE(std::length_error,
-                                "The hash table exceeds its maximum size.");
-    }
-
-    if (min_bucket_count_in_out > 0) {
-      min_bucket_count_in_out =
-          round_up_to_power_of_two(min_bucket_count_in_out);
-      m_mask = min_bucket_count_in_out - 1;
-    } else {
-      m_mask = 0;
-    }
-  }
-
-  /**
-   * Return the bucket [0, bucket_count()) to which the hash belongs.
-   * If bucket_count() is 0, it must always return 0.
-   */
-  std::size_t bucket_for_hash(std::size_t hash) const noexcept {
-    return hash & m_mask;
-  }
-
-  /**
-   * Return the number of buckets that should be used on next growth.
-   */
-  std::size_t next_bucket_count() const {
-    if ((m_mask + 1) > max_bucket_count() / GrowthFactor) {
-      TSL_RH_THROW_OR_TERMINATE(std::length_error,
-                                "The hash table exceeds its maximum size.");
-    }
-
-    return (m_mask + 1) * GrowthFactor;
-  }
-
-  /**
-   * Return the maximum number of buckets supported by the policy.
-   */
-  std::size_t max_bucket_count() const {
-    // Largest power of two.
-    return (std::numeric_limits<std::size_t>::max() / 2) + 1;
-  }
-
-  /**
-   * Reset the growth policy as if it was created with a bucket count of 0.
-   * After a clear, the policy must always return 0 when bucket_for_hash is
-   * called.
-   */
-  void clear() noexcept { m_mask = 0; }
-
- private:
-  static std::size_t round_up_to_power_of_two(std::size_t value) {
-    if (is_power_of_two(value)) {
-      return value;
-    }
-
-    if (value == 0) {
-      return 1;
-    }
-
-    --value;
-    for (std::size_t i = 1; i < sizeof(std::size_t) * CHAR_BIT; i *= 2) {
-      value |= value >> i;
-    }
-
-    return value + 1;
-  }
-
-  static constexpr bool is_power_of_two(std::size_t value) {
-    return value != 0 && (value & (value - 1)) == 0;
-  }
-
- protected:
-  static_assert(is_power_of_two(GrowthFactor) && GrowthFactor >= 2,
-                "GrowthFactor must be a power of two >= 2.");
-
-  std::size_t m_mask;
-};
-
-/**
- * Grow the hash table by GrowthFactor::num / GrowthFactor::den and use a modulo
- * to map a hash to a bucket. Slower but it can be useful if you want a slower
- * growth.
- */
-template <class GrowthFactor = std::ratio<3, 2>>
-class mod_growth_policy {
- public:
-  explicit mod_growth_policy(std::size_t& min_bucket_count_in_out) {
-    if (min_bucket_count_in_out > max_bucket_count()) {
-      TSL_RH_THROW_OR_TERMINATE(std::length_error,
-                                "The hash table exceeds its maximum size.");
-    }
-
-    if (min_bucket_count_in_out > 0) {
-      m_mod = min_bucket_count_in_out;
-    } else {
-      m_mod = 1;
-    }
-  }
-
-  std::size_t bucket_for_hash(std::size_t hash) const noexcept {
-    return hash % m_mod;
-  }
-
-  std::size_t next_bucket_count() const {
-    if (m_mod == max_bucket_count()) {
-      TSL_RH_THROW_OR_TERMINATE(std::length_error,
-                                "The hash table exceeds its maximum size.");
-    }
-
-    const double next_bucket_count =
-        std::ceil(double(m_mod) * REHASH_SIZE_MULTIPLICATION_FACTOR);
-    if (!std::isnormal(next_bucket_count)) {
-      TSL_RH_THROW_OR_TERMINATE(std::length_error,
-                                "The hash table exceeds its maximum size.");
-    }
-
-    if (next_bucket_count > double(max_bucket_count())) {
-      return max_bucket_count();
-    } else {
-      return std::size_t(next_bucket_count);
-    }
-  }
-
-  std::size_t max_bucket_count() const { return MAX_BUCKET_COUNT; }
-
-  void clear() noexcept { m_mod = 1; }
-
- private:
-  static constexpr double REHASH_SIZE_MULTIPLICATION_FACTOR =
-      1.0 * GrowthFactor::num / GrowthFactor::den;
-  static const std::size_t MAX_BUCKET_COUNT =
-      std::size_t(double(std::numeric_limits<std::size_t>::max() /
-                         REHASH_SIZE_MULTIPLICATION_FACTOR));
-
-  static_assert(REHASH_SIZE_MULTIPLICATION_FACTOR >= 1.1,
-                "Growth factor should be >= 1.1.");
-
-  std::size_t m_mod;
-};
-
-namespace detail {
-
-#if SIZE_MAX >= ULLONG_MAX
-#define TSL_RH_NB_PRIMES 51
-#elif SIZE_MAX >= ULONG_MAX
-#define TSL_RH_NB_PRIMES 40
-#else
-#define TSL_RH_NB_PRIMES 23
-#endif
-
-inline constexpr std::array<std::size_t, TSL_RH_NB_PRIMES> PRIMES = {{
-    1u,
-    5u,
-    17u,
-    29u,
-    37u,
-    53u,
-    67u,
-    79u,
-    97u,
-    131u,
-    193u,
-    257u,
-    389u,
-    521u,
-    769u,
-    1031u,
-    1543u,
-    2053u,
-    3079u,
-    6151u,
-    12289u,
-    24593u,
-    49157u,
-#if SIZE_MAX >= ULONG_MAX
-    98317ul,
-    196613ul,
-    393241ul,
-    786433ul,
-    1572869ul,
-    3145739ul,
-    6291469ul,
-    12582917ul,
-    25165843ul,
-    50331653ul,
-    100663319ul,
-    201326611ul,
-    402653189ul,
-    805306457ul,
-    1610612741ul,
-    3221225473ul,
-    4294967291ul,
-#endif
-#if SIZE_MAX >= ULLONG_MAX
-    6442450939ull,
-    12884901893ull,
-    25769803751ull,
-    51539607551ull,
-    103079215111ull,
-    206158430209ull,
-    412316860441ull,
-    824633720831ull,
-    1649267441651ull,
-    3298534883309ull,
-    6597069766657ull,
-#endif
-}};
-
-template <unsigned int IPrime>
-static constexpr std::size_t mod(std::size_t hash) {
-  return hash % PRIMES[IPrime];
-}
-
-// MOD_PRIME[iprime](hash) returns hash % PRIMES[iprime]. This table allows for
-// faster modulo as the compiler can optimize the modulo code better with a
-// constant known at the compilation.
-inline constexpr std::array<std::size_t (*)(std::size_t), TSL_RH_NB_PRIMES>
-    MOD_PRIME = {{
-        &mod<0>,  &mod<1>,  &mod<2>,  &mod<3>,  &mod<4>,  &mod<5>,
-        &mod<6>,  &mod<7>,  &mod<8>,  &mod<9>,  &mod<10>, &mod<11>,
-        &mod<12>, &mod<13>, &mod<14>, &mod<15>, &mod<16>, &mod<17>,
-        &mod<18>, &mod<19>, &mod<20>, &mod<21>, &mod<22>,
-#if SIZE_MAX >= ULONG_MAX
-        &mod<23>, &mod<24>, &mod<25>, &mod<26>, &mod<27>, &mod<28>,
-        &mod<29>, &mod<30>, &mod<31>, &mod<32>, &mod<33>, &mod<34>,
-        &mod<35>, &mod<36>, &mod<37>, &mod<38>, &mod<39>,
-#endif
-#if SIZE_MAX >= ULLONG_MAX
-        &mod<40>, &mod<41>, &mod<42>, &mod<43>, &mod<44>, &mod<45>,
-        &mod<46>, &mod<47>, &mod<48>, &mod<49>, &mod<50>,
-#endif
-    }};
-
-}  // namespace detail
-
-/**
- * Grow the hash table by using prime numbers as bucket count. Slower than
- * tsl::rh::power_of_two_growth_policy in general but will probably distribute
- * the values around better in the buckets with a poor hash function.
- *
- * To allow the compiler to optimize the modulo operation, a lookup table is
- * used with constant primes numbers.
- *
- * With a switch the code would look like:
- * \code
- * switch(iprime) { // iprime is the current prime of the hash table
- *     case 0: hash % 5ul;
- *             break;
- *     case 1: hash % 17ul;
- *             break;
- *     case 2: hash % 29ul;
- *             break;
- *     ...
- * }
- * \endcode
- *
- * Due to the constant variable in the modulo the compiler is able to optimize
- * the operation by a series of multiplications, substractions and shifts.
- *
- * The 'hash % 5' could become something like 'hash - (hash * 0xCCCCCCCD) >> 34)
- * * 5' in a 64 bits environment.
- */
-class prime_growth_policy {
- public:
-  explicit prime_growth_policy(std::size_t& min_bucket_count_in_out) {
-    auto it_prime = std::lower_bound(
-        detail::PRIMES.begin(), detail::PRIMES.end(), min_bucket_count_in_out);
-    if (it_prime == detail::PRIMES.end()) {
-      TSL_RH_THROW_OR_TERMINATE(std::length_error,
-                                "The hash table exceeds its maximum size.");
-    }
-
-    m_iprime = static_cast<unsigned int>(
-        std::distance(detail::PRIMES.begin(), it_prime));
-    if (min_bucket_count_in_out > 0) {
-      min_bucket_count_in_out = *it_prime;
-    } else {
-      min_bucket_count_in_out = 0;
-    }
-  }
-
-  std::size_t bucket_for_hash(std::size_t hash) const noexcept {
-    return detail::MOD_PRIME[m_iprime](hash);
-  }
-
-  std::size_t next_bucket_count() const {
-    if (m_iprime + 1 >= detail::PRIMES.size()) {
-      TSL_RH_THROW_OR_TERMINATE(std::length_error,
-                                "The hash table exceeds its maximum size.");
-    }
-
-    return detail::PRIMES[m_iprime + 1];
-  }
-
-  std::size_t max_bucket_count() const { return detail::PRIMES.back(); }
-
-  void clear() noexcept { m_iprime = 0; }
-
- private:
-  unsigned int m_iprime;
-
-  static_assert(std::numeric_limits<decltype(m_iprime)>::max() >=
-                    detail::PRIMES.size(),
-                "The type of m_iprime is not big enough.");
-};
-
-}  // namespace rh
-}  // namespace tsl
-
-#endif
diff --git a/src/nanobind/ext/robin_map/include/tsl/robin_hash.h b/src/nanobind/ext/robin_map/include/tsl/robin_hash.h
deleted file mode 100644
index 163e0e2..0000000
--- a/src/nanobind/ext/robin_map/include/tsl/robin_hash.h
+++ /dev/null
@@ -1,1589 +0,0 @@
-/**
- * MIT License
- *
- * Copyright (c) 2017 Thibaut Goetghebuer-Planchon <tessil@gmx.com>
- *
- * 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.
- */
-#ifndef TSL_ROBIN_HASH_H
-#define TSL_ROBIN_HASH_H
-
-#include <algorithm>
-#include <cassert>
-#include <cmath>
-#include <cstddef>
-#include <cstdint>
-#include <exception>
-#include <iterator>
-#include <limits>
-#include <memory>
-#include <new>
-#include <stdexcept>
-#include <tuple>
-#include <type_traits>
-#include <utility>
-#include <vector>
-
-#include "robin_growth_policy.h"
-
-namespace tsl {
-
-namespace detail_robin_hash {
-
-template <typename T>
-struct make_void {
-  using type = void;
-};
-
-template <typename T, typename = void>
-struct has_is_transparent : std::false_type {};
-
-template <typename T>
-struct has_is_transparent<T,
-                          typename make_void<typename T::is_transparent>::type>
-    : std::true_type {};
-
-template <typename U>
-struct is_power_of_two_policy : std::false_type {};
-
-template <std::size_t GrowthFactor>
-struct is_power_of_two_policy<tsl::rh::power_of_two_growth_policy<GrowthFactor>>
-    : std::true_type {};
-
-template <typename T, typename U>
-static T numeric_cast(U value,
-                      const char* error_message = "numeric_cast() failed.") {
-  T ret = static_cast<T>(value);
-  if (static_cast<U>(ret) != value) {
-    TSL_RH_THROW_OR_TERMINATE(std::runtime_error, error_message);
-  }
-
-  const bool is_same_signedness =
-      (std::is_unsigned<T>::value && std::is_unsigned<U>::value) ||
-      (std::is_signed<T>::value && std::is_signed<U>::value);
-  if (!is_same_signedness && (ret < T{}) != (value < U{})) {
-    TSL_RH_THROW_OR_TERMINATE(std::runtime_error, error_message);
-  }
-
-  TSL_RH_UNUSED(error_message);
-
-  return ret;
-}
-
-template <class T, class Deserializer>
-static T deserialize_value(Deserializer& deserializer) {
-  // MSVC < 2017 is not conformant, circumvent the problem by removing the
-  // template keyword
-#if defined(_MSC_VER) && _MSC_VER < 1910
-  return deserializer.Deserializer::operator()<T>();
-#else
-  return deserializer.Deserializer::template operator()<T>();
-#endif
-}
-
-/**
- * Fixed size type used to represent size_type values on serialization. Need to
- * be big enough to represent a std::size_t on 32 and 64 bits platforms, and
- * must be the same size on both platforms.
- */
-using slz_size_type = std::uint64_t;
-static_assert(std::numeric_limits<slz_size_type>::max() >=
-                  std::numeric_limits<std::size_t>::max(),
-              "slz_size_type must be >= std::size_t");
-
-using truncated_hash_type = std::uint32_t;
-
-/**
- * Helper class that stores a truncated hash if StoreHash is true and nothing
- * otherwise.
- */
-template <bool StoreHash>
-class bucket_entry_hash {
- public:
-  bool bucket_hash_equal(std::size_t /*hash*/) const noexcept { return true; }
-
-  truncated_hash_type truncated_hash() const noexcept { return 0; }
-
- protected:
-  void set_hash(truncated_hash_type /*hash*/) noexcept {}
-};
-
-template <>
-class bucket_entry_hash<true> {
- public:
-  bool bucket_hash_equal(std::size_t hash) const noexcept {
-    return m_hash == truncated_hash_type(hash);
-  }
-
-  truncated_hash_type truncated_hash() const noexcept { return m_hash; }
-
- protected:
-  void set_hash(truncated_hash_type hash) noexcept {
-    m_hash = truncated_hash_type(hash);
-  }
-
- private:
-  truncated_hash_type m_hash;
-};
-
-/**
- * Each bucket entry has:
- * - A value of type `ValueType`.
- * - An integer to store how far the value of the bucket, if any, is from its
- * ideal bucket (ex: if the current bucket 5 has the value 'foo' and
- * `hash('foo') % nb_buckets` == 3, `dist_from_ideal_bucket()` will return 2 as
- * the current value of the bucket is two buckets away from its ideal bucket) If
- * there is no value in the bucket (i.e. `empty()` is true)
- * `dist_from_ideal_bucket()` will be < 0.
- * - A marker which tells us if the bucket is the last bucket of the bucket
- * array (useful for the iterator of the hash table).
- * - If `StoreHash` is true, 32 bits of the hash of the value, if any, are also
- * stored in the bucket. If the size of the hash is more than 32 bits, it is
- * truncated. We don't store the full hash as storing the hash is a potential
- * opportunity to use the unused space due to the alignment of the bucket_entry
- * structure. We can thus potentially store the hash without any extra space
- *   (which would not be possible with 64 bits of the hash).
- */
-template <typename ValueType, bool StoreHash>
-class bucket_entry : public bucket_entry_hash<StoreHash> {
-  using bucket_hash = bucket_entry_hash<StoreHash>;
-
- public:
-  using value_type = ValueType;
-  using distance_type = std::int16_t;
-
-  bucket_entry() noexcept
-      : bucket_hash(),
-        m_dist_from_ideal_bucket(EMPTY_MARKER_DIST_FROM_IDEAL_BUCKET),
-        m_last_bucket(false) {
-    tsl_rh_assert(empty());
-  }
-
-  bucket_entry(bool last_bucket) noexcept
-      : bucket_hash(),
-        m_dist_from_ideal_bucket(EMPTY_MARKER_DIST_FROM_IDEAL_BUCKET),
-        m_last_bucket(last_bucket) {
-    tsl_rh_assert(empty());
-  }
-
-  bucket_entry(const bucket_entry& other) noexcept(
-      std::is_nothrow_copy_constructible<value_type>::value)
-      : bucket_hash(other),
-        m_dist_from_ideal_bucket(EMPTY_MARKER_DIST_FROM_IDEAL_BUCKET),
-        m_last_bucket(other.m_last_bucket) {
-    if (!other.empty()) {
-      ::new (static_cast<void*>(std::addressof(m_value)))
-          value_type(other.value());
-      m_dist_from_ideal_bucket = other.m_dist_from_ideal_bucket;
-    }
-    tsl_rh_assert(empty() == other.empty());
-  }
-
-  /**
-   * Never really used, but still necessary as we must call resize on an empty
-   * `std::vector<bucket_entry>`. and we need to support move-only types. See
-   * robin_hash constructor for details.
-   */
-  bucket_entry(bucket_entry&& other) noexcept(
-      std::is_nothrow_move_constructible<value_type>::value)
-      : bucket_hash(std::move(other)),
-        m_dist_from_ideal_bucket(EMPTY_MARKER_DIST_FROM_IDEAL_BUCKET),
-        m_last_bucket(other.m_last_bucket) {
-    if (!other.empty()) {
-      ::new (static_cast<void*>(std::addressof(m_value)))
-          value_type(std::move(other.value()));
-      m_dist_from_ideal_bucket = other.m_dist_from_ideal_bucket;
-    }
-    tsl_rh_assert(empty() == other.empty());
-  }
-
-  bucket_entry& operator=(const bucket_entry& other) noexcept(
-      std::is_nothrow_copy_constructible<value_type>::value) {
-    if (this != &other) {
-      clear();
-
-      bucket_hash::operator=(other);
-      if (!other.empty()) {
-        ::new (static_cast<void*>(std::addressof(m_value)))
-            value_type(other.value());
-      }
-
-      m_dist_from_ideal_bucket = other.m_dist_from_ideal_bucket;
-      m_last_bucket = other.m_last_bucket;
-    }
-
-    return *this;
-  }
-
-  bucket_entry& operator=(bucket_entry&&) = delete;
-
-  ~bucket_entry() noexcept { clear(); }
-
-  void clear() noexcept {
-    if (!empty()) {
-      destroy_value();
-      m_dist_from_ideal_bucket = EMPTY_MARKER_DIST_FROM_IDEAL_BUCKET;
-    }
-  }
-
-  bool empty() const noexcept {
-    return m_dist_from_ideal_bucket == EMPTY_MARKER_DIST_FROM_IDEAL_BUCKET;
-  }
-
-  value_type& value() noexcept {
-    tsl_rh_assert(!empty());
-    return *std::launder(
-        reinterpret_cast<value_type*>(std::addressof(m_value)));
-  }
-
-  const value_type& value() const noexcept {
-    tsl_rh_assert(!empty());
-    return *std::launder(
-        reinterpret_cast<const value_type*>(std::addressof(m_value)));
-  }
-
-  distance_type dist_from_ideal_bucket() const noexcept {
-    return m_dist_from_ideal_bucket;
-  }
-
-  bool last_bucket() const noexcept { return m_last_bucket; }
-
-  void set_as_last_bucket() noexcept { m_last_bucket = true; }
-
-  template <typename... Args>
-  void set_value_of_empty_bucket(distance_type dist_from_ideal_bucket,
-                                 truncated_hash_type hash,
-                                 Args&&... value_type_args) {
-    tsl_rh_assert(dist_from_ideal_bucket >= 0);
-    tsl_rh_assert(empty());
-
-    ::new (static_cast<void*>(std::addressof(m_value)))
-        value_type(std::forward<Args>(value_type_args)...);
-    this->set_hash(hash);
-    m_dist_from_ideal_bucket = dist_from_ideal_bucket;
-
-    tsl_rh_assert(!empty());
-  }
-
-  void swap_with_value_in_bucket(distance_type& dist_from_ideal_bucket,
-                                 truncated_hash_type& hash, value_type& value) {
-    tsl_rh_assert(!empty());
-    tsl_rh_assert(dist_from_ideal_bucket > m_dist_from_ideal_bucket);
-
-    using std::swap;
-    swap(value, this->value());
-    swap(dist_from_ideal_bucket, m_dist_from_ideal_bucket);
-
-    if (StoreHash) {
-      const truncated_hash_type tmp_hash = this->truncated_hash();
-      this->set_hash(hash);
-      hash = tmp_hash;
-    } else {
-      // Avoid warning of unused variable if StoreHash is false
-      TSL_RH_UNUSED(hash);
-    }
-  }
-
-  static truncated_hash_type truncate_hash(std::size_t hash) noexcept {
-    return truncated_hash_type(hash);
-  }
-
- private:
-  void destroy_value() noexcept {
-    tsl_rh_assert(!empty());
-    value().~value_type();
-  }
-
- public:
-  static const distance_type EMPTY_MARKER_DIST_FROM_IDEAL_BUCKET = -1;
-  static const distance_type DIST_FROM_IDEAL_BUCKET_LIMIT = 8192;
-  static_assert(DIST_FROM_IDEAL_BUCKET_LIMIT <=
-                    std::numeric_limits<distance_type>::max() - 1,
-                "DIST_FROM_IDEAL_BUCKET_LIMIT must be <= "
-                "std::numeric_limits<distance_type>::max() - 1.");
-
- private:
-  distance_type m_dist_from_ideal_bucket;
-  bool m_last_bucket;
-  alignas(value_type) unsigned char m_value[sizeof(value_type)];
-};
-
-/**
- * Internal common class used by `robin_map` and `robin_set`.
- *
- * ValueType is what will be stored by `robin_hash` (usually `std::pair<Key, T>`
- * for map and `Key` for set).
- *
- * `KeySelect` should be a `FunctionObject` which takes a `ValueType` in
- * parameter and returns a reference to the key.
- *
- * `ValueSelect` should be a `FunctionObject` which takes a `ValueType` in
- * parameter and returns a reference to the value. `ValueSelect` should be void
- * if there is no value (in a set for example).
- *
- * The strong exception guarantee only holds if the expression
- * `std::is_nothrow_swappable<ValueType>::value &&
- * std::is_nothrow_move_constructible<ValueType>::value` is true.
- *
- * Behaviour is undefined if the destructor of `ValueType` throws.
- */
-template <class ValueType, class KeySelect, class ValueSelect, class Hash,
-          class KeyEqual, class Allocator, bool StoreHash, class GrowthPolicy>
-class robin_hash : private Hash, private KeyEqual, private GrowthPolicy {
- private:
-  template <typename U>
-  using has_mapped_type =
-      typename std::integral_constant<bool, !std::is_same<U, void>::value>;
-
-  static_assert(
-      noexcept(std::declval<GrowthPolicy>().bucket_for_hash(std::size_t(0))),
-      "GrowthPolicy::bucket_for_hash must be noexcept.");
-  static_assert(noexcept(std::declval<GrowthPolicy>().clear()),
-                "GrowthPolicy::clear must be noexcept.");
-
- public:
-  template <bool IsConst>
-  class robin_iterator;
-
-  using key_type = typename KeySelect::key_type;
-  using value_type = ValueType;
-  using size_type = std::size_t;
-  using difference_type = std::ptrdiff_t;
-  using hasher = Hash;
-  using key_equal = KeyEqual;
-  using allocator_type = Allocator;
-  using reference = value_type&;
-  using const_reference = const value_type&;
-  using pointer = value_type*;
-  using const_pointer = const value_type*;
-  using iterator = robin_iterator<false>;
-  using const_iterator = robin_iterator<true>;
-
- private:
-  /**
-   * Either store the hash because we are asked by the `StoreHash` template
-   * parameter or store the hash because it doesn't cost us anything in size and
-   * can be used to speed up rehash.
-   */
-  static constexpr bool STORE_HASH =
-      StoreHash ||
-      ((sizeof(tsl::detail_robin_hash::bucket_entry<value_type, true>) ==
-        sizeof(tsl::detail_robin_hash::bucket_entry<value_type, false>)) &&
-       (sizeof(std::size_t) == sizeof(truncated_hash_type) ||
-        is_power_of_two_policy<GrowthPolicy>::value) &&
-       // Don't store the hash for primitive types with default hash.
-       (!std::is_arithmetic<key_type>::value ||
-        !std::is_same<Hash, std::hash<key_type>>::value));
-
-  /**
-   * Only use the stored hash on lookup if we are explicitly asked. We are not
-   * sure how slow the KeyEqual operation is. An extra comparison may slow
-   * things down with a fast KeyEqual.
-   */
-  static constexpr bool USE_STORED_HASH_ON_LOOKUP = StoreHash;
-
-  /**
-   * We can only use the hash on rehash if the size of the hash type is the same
-   * as the stored one or if we use a power of two modulo. In the case of the
-   * power of two modulo, we just mask the least significant bytes, we just have
-   * to check that the truncated_hash_type didn't truncated more bytes.
-   */
-  static bool USE_STORED_HASH_ON_REHASH(size_type bucket_count) {
-    if (STORE_HASH && sizeof(std::size_t) == sizeof(truncated_hash_type)) {
-      TSL_RH_UNUSED(bucket_count);
-      return true;
-    } else if (STORE_HASH && is_power_of_two_policy<GrowthPolicy>::value) {
-      return bucket_count == 0 ||
-             (bucket_count - 1) <=
-                 std::numeric_limits<truncated_hash_type>::max();
-    } else {
-      TSL_RH_UNUSED(bucket_count);
-      return false;
-    }
-  }
-
-  using bucket_entry =
-      tsl::detail_robin_hash::bucket_entry<value_type, STORE_HASH>;
-  using distance_type = typename bucket_entry::distance_type;
-
-  using buckets_allocator = typename std::allocator_traits<
-      allocator_type>::template rebind_alloc<bucket_entry>;
-  using buckets_container_type = std::vector<bucket_entry, buckets_allocator>;
-
- public:
-  /**
-   * The 'operator*()' and 'operator->()' methods return a const reference and
-   * const pointer respectively to the stored value type.
-   *
-   * In case of a map, to get a mutable reference to the value associated to a
-   * key (the '.second' in the stored pair), you have to call 'value()'.
-   *
-   * The main reason for this is that if we returned a `std::pair<Key, T>&`
-   * instead of a `const std::pair<Key, T>&`, the user may modify the key which
-   * will put the map in a undefined state.
-   */
-  template <bool IsConst>
-  class robin_iterator {
-    friend class robin_hash;
-
-   private:
-    using bucket_entry_ptr =
-        typename std::conditional<IsConst, const bucket_entry*,
-                                  bucket_entry*>::type;
-
-    robin_iterator(bucket_entry_ptr bucket) noexcept : m_bucket(bucket) {}
-
-   public:
-    using iterator_category = std::forward_iterator_tag;
-    using value_type = const typename robin_hash::value_type;
-    using difference_type = std::ptrdiff_t;
-    using reference = value_type&;
-    using pointer = value_type*;
-
-    robin_iterator() noexcept {}
-
-    // Copy constructor from iterator to const_iterator.
-    template <bool TIsConst = IsConst,
-              typename std::enable_if<TIsConst>::type* = nullptr>
-    robin_iterator(const robin_iterator<!TIsConst>& other) noexcept
-        : m_bucket(other.m_bucket) {}
-
-    robin_iterator(const robin_iterator& other) = default;
-    robin_iterator(robin_iterator&& other) = default;
-    robin_iterator& operator=(const robin_iterator& other) = default;
-    robin_iterator& operator=(robin_iterator&& other) = default;
-
-    const typename robin_hash::key_type& key() const {
-      return KeySelect()(m_bucket->value());
-    }
-
-    template <class U = ValueSelect,
-              typename std::enable_if<has_mapped_type<U>::value &&
-                                      IsConst>::type* = nullptr>
-    const typename U::value_type& value() const {
-      return U()(m_bucket->value());
-    }
-
-    template <class U = ValueSelect,
-              typename std::enable_if<has_mapped_type<U>::value &&
-                                      !IsConst>::type* = nullptr>
-    typename U::value_type& value() const {
-      return U()(m_bucket->value());
-    }
-
-    reference operator*() const { return m_bucket->value(); }
-
-    pointer operator->() const { return std::addressof(m_bucket->value()); }
-
-    robin_iterator& operator++() {
-      while (true) {
-        if (m_bucket->last_bucket()) {
-          ++m_bucket;
-          return *this;
-        }
-
-        ++m_bucket;
-        if (!m_bucket->empty()) {
-          return *this;
-        }
-      }
-    }
-
-    robin_iterator operator++(int) {
-      robin_iterator tmp(*this);
-      ++*this;
-
-      return tmp;
-    }
-
-    friend bool operator==(const robin_iterator& lhs,
-                           const robin_iterator& rhs) {
-      return lhs.m_bucket == rhs.m_bucket;
-    }
-
-    friend bool operator!=(const robin_iterator& lhs,
-                           const robin_iterator& rhs) {
-      return !(lhs == rhs);
-    }
-
-   private:
-    bucket_entry_ptr m_bucket;
-  };
-
- public:
-  robin_hash(size_type bucket_count, const Hash& hash, const KeyEqual& equal,
-             const Allocator& alloc,
-             float min_load_factor = DEFAULT_MIN_LOAD_FACTOR,
-             float max_load_factor = DEFAULT_MAX_LOAD_FACTOR)
-      : Hash(hash),
-        KeyEqual(equal),
-        GrowthPolicy(bucket_count),
-        m_buckets_data(bucket_count, alloc),
-        m_buckets(m_buckets_data.empty() ? static_empty_bucket_ptr()
-                                         : m_buckets_data.data()),
-        m_bucket_count(bucket_count),
-        m_nb_elements(0),
-        m_grow_on_next_insert(false),
-        m_try_shrink_on_next_insert(false) {
-    if (bucket_count > max_bucket_count()) {
-      TSL_RH_THROW_OR_TERMINATE(std::length_error,
-                                "The map exceeds its maximum bucket count.");
-    }
-
-    if (m_bucket_count > 0) {
-      tsl_rh_assert(!m_buckets_data.empty());
-      m_buckets_data.back().set_as_last_bucket();
-    }
-
-    this->min_load_factor(min_load_factor);
-    this->max_load_factor(max_load_factor);
-  }
-
-  robin_hash(const robin_hash& other)
-      : Hash(other),
-        KeyEqual(other),
-        GrowthPolicy(other),
-        m_buckets_data(other.m_buckets_data),
-        m_buckets(m_buckets_data.empty() ? static_empty_bucket_ptr()
-                                         : m_buckets_data.data()),
-        m_bucket_count(other.m_bucket_count),
-        m_nb_elements(other.m_nb_elements),
-        m_load_threshold(other.m_load_threshold),
-        m_min_load_factor(other.m_min_load_factor),
-        m_max_load_factor(other.m_max_load_factor),
-        m_grow_on_next_insert(other.m_grow_on_next_insert),
-        m_try_shrink_on_next_insert(other.m_try_shrink_on_next_insert) {}
-
-  robin_hash(robin_hash&& other) noexcept(
-      std::is_nothrow_move_constructible<
-          Hash>::value&& std::is_nothrow_move_constructible<KeyEqual>::value&&
-          std::is_nothrow_move_constructible<GrowthPolicy>::value&&
-              std::is_nothrow_move_constructible<buckets_container_type>::value)
-      : Hash(std::move(static_cast<Hash&>(other))),
-        KeyEqual(std::move(static_cast<KeyEqual&>(other))),
-        GrowthPolicy(std::move(static_cast<GrowthPolicy&>(other))),
-        m_buckets_data(std::move(other.m_buckets_data)),
-        m_buckets(m_buckets_data.empty() ? static_empty_bucket_ptr()
-                                         : m_buckets_data.data()),
-        m_bucket_count(other.m_bucket_count),
-        m_nb_elements(other.m_nb_elements),
-        m_load_threshold(other.m_load_threshold),
-        m_min_load_factor(other.m_min_load_factor),
-        m_max_load_factor(other.m_max_load_factor),
-        m_grow_on_next_insert(other.m_grow_on_next_insert),
-        m_try_shrink_on_next_insert(other.m_try_shrink_on_next_insert) {
-    other.clear_and_shrink();
-  }
-
-  robin_hash& operator=(const robin_hash& other) {
-    if (&other != this) {
-      Hash::operator=(other);
-      KeyEqual::operator=(other);
-      GrowthPolicy::operator=(other);
-
-      m_buckets_data = other.m_buckets_data;
-      m_buckets = m_buckets_data.empty() ? static_empty_bucket_ptr()
-                                         : m_buckets_data.data();
-      m_bucket_count = other.m_bucket_count;
-      m_nb_elements = other.m_nb_elements;
-
-      m_load_threshold = other.m_load_threshold;
-      m_min_load_factor = other.m_min_load_factor;
-      m_max_load_factor = other.m_max_load_factor;
-
-      m_grow_on_next_insert = other.m_grow_on_next_insert;
-      m_try_shrink_on_next_insert = other.m_try_shrink_on_next_insert;
-    }
-
-    return *this;
-  }
-
-  robin_hash& operator=(robin_hash&& other) {
-    other.swap(*this);
-    other.clear_and_shrink();
-
-    return *this;
-  }
-
-  allocator_type get_allocator() const {
-    return m_buckets_data.get_allocator();
-  }
-
-  /*
-   * Iterators
-   */
-  iterator begin() noexcept {
-    std::size_t i = 0;
-    while (i < m_bucket_count && m_buckets[i].empty()) {
-      i++;
-    }
-
-    return iterator(m_buckets + i);
-  }
-
-  const_iterator begin() const noexcept { return cbegin(); }
-
-  const_iterator cbegin() const noexcept {
-    std::size_t i = 0;
-    while (i < m_bucket_count && m_buckets[i].empty()) {
-      i++;
-    }
-
-    return const_iterator(m_buckets + i);
-  }
-
-  iterator end() noexcept { return iterator(m_buckets + m_bucket_count); }
-
-  const_iterator end() const noexcept { return cend(); }
-
-  const_iterator cend() const noexcept {
-    return const_iterator(m_buckets + m_bucket_count);
-  }
-
-  /*
-   * Capacity
-   */
-  bool empty() const noexcept { return m_nb_elements == 0; }
-
-  size_type size() const noexcept { return m_nb_elements; }
-
-  size_type max_size() const noexcept { return m_buckets_data.max_size(); }
-
-  /*
-   * Modifiers
-   */
-  void clear() noexcept {
-    if (m_min_load_factor > 0.0f) {
-      clear_and_shrink();
-    } else {
-      for (auto& bucket : m_buckets_data) {
-        bucket.clear();
-      }
-
-      m_nb_elements = 0;
-      m_grow_on_next_insert = false;
-    }
-  }
-
-  template <typename P>
-  std::pair<iterator, bool> insert(P&& value) {
-    return insert_impl(KeySelect()(value), std::forward<P>(value));
-  }
-
-  template <typename P>
-  iterator insert_hint(const_iterator hint, P&& value) {
-    if (hint != cend() &&
-        compare_keys(KeySelect()(*hint), KeySelect()(value))) {
-      return mutable_iterator(hint);
-    }
-
-    return insert(std::forward<P>(value)).first;
-  }
-
-  template <class InputIt>
-  void insert(InputIt first, InputIt last) {
-    if (std::is_base_of<
-            std::forward_iterator_tag,
-            typename std::iterator_traits<InputIt>::iterator_category>::value) {
-      const auto nb_elements_insert = std::distance(first, last);
-      const size_type nb_free_buckets = m_load_threshold - size();
-      tsl_rh_assert(m_load_threshold >= size());
-
-      if (nb_elements_insert > 0 &&
-          nb_free_buckets < size_type(nb_elements_insert)) {
-        reserve(size() + size_type(nb_elements_insert));
-      }
-    }
-
-    for (; first != last; ++first) {
-      insert(*first);
-    }
-  }
-
-  template <class K, class M>
-  std::pair<iterator, bool> insert_or_assign(K&& key, M&& obj) {
-    auto it = try_emplace(std::forward<K>(key), std::forward<M>(obj));
-    if (!it.second) {
-      it.first.value() = std::forward<M>(obj);
-    }
-
-    return it;
-  }
-
-  template <class K, class M>
-  iterator insert_or_assign(const_iterator hint, K&& key, M&& obj) {
-    if (hint != cend() && compare_keys(KeySelect()(*hint), key)) {
-      auto it = mutable_iterator(hint);
-      it.value() = std::forward<M>(obj);
-
-      return it;
-    }
-
-    return insert_or_assign(std::forward<K>(key), std::forward<M>(obj)).first;
-  }
-
-  template <class... Args>
-  std::pair<iterator, bool> emplace(Args&&... args) {
-    return insert(value_type(std::forward<Args>(args)...));
-  }
-
-  template <class... Args>
-  iterator emplace_hint(const_iterator hint, Args&&... args) {
-    return insert_hint(hint, value_type(std::forward<Args>(args)...));
-  }
-
-  template <class K, class... Args>
-  std::pair<iterator, bool> try_emplace(K&& key, Args&&... args) {
-    return insert_impl(key, std::piecewise_construct,
-                       std::forward_as_tuple(std::forward<K>(key)),
-                       std::forward_as_tuple(std::forward<Args>(args)...));
-  }
-
-  template <class K, class... Args>
-  iterator try_emplace_hint(const_iterator hint, K&& key, Args&&... args) {
-    if (hint != cend() && compare_keys(KeySelect()(*hint), key)) {
-      return mutable_iterator(hint);
-    }
-
-    return try_emplace(std::forward<K>(key), std::forward<Args>(args)...).first;
-  }
-
-  void erase_fast(iterator pos) {
-    erase_from_bucket(pos);
-  }
-
-  /**
-   * Here to avoid `template<class K> size_type erase(const K& key)` being used
-   * when we use an `iterator` instead of a `const_iterator`.
-   */
-  iterator erase(iterator pos) {
-    erase_from_bucket(pos);
-
-    /**
-     * Erase bucket used a backward shift after clearing the bucket.
-     * Check if there is a new value in the bucket, if not get the next
-     * non-empty.
-     */
-    if (pos.m_bucket->empty()) {
-      ++pos;
-    }
-
-    return pos;
-  }
-
-  iterator erase(const_iterator pos) { return erase(mutable_iterator(pos)); }
-
-  iterator erase(const_iterator first, const_iterator last) {
-    if (first == last) {
-      return mutable_iterator(first);
-    }
-
-    auto first_mutable = mutable_iterator(first);
-    auto last_mutable = mutable_iterator(last);
-    for (auto it = first_mutable.m_bucket; it != last_mutable.m_bucket; ++it) {
-      if (!it->empty()) {
-        it->clear();
-        m_nb_elements--;
-      }
-    }
-
-    if (last_mutable == end()) {
-      m_try_shrink_on_next_insert = true;
-      return end();
-    }
-
-    /*
-     * Backward shift on the values which come after the deleted values.
-     * We try to move the values closer to their ideal bucket.
-     */
-    std::size_t icloser_bucket =
-        static_cast<std::size_t>(first_mutable.m_bucket - m_buckets);
-    std::size_t ito_move_closer_value =
-        static_cast<std::size_t>(last_mutable.m_bucket - m_buckets);
-    tsl_rh_assert(ito_move_closer_value > icloser_bucket);
-
-    const std::size_t ireturn_bucket =
-        ito_move_closer_value -
-        std::min(
-            ito_move_closer_value - icloser_bucket,
-            std::size_t(
-                m_buckets[ito_move_closer_value].dist_from_ideal_bucket()));
-
-    while (ito_move_closer_value < m_bucket_count &&
-           m_buckets[ito_move_closer_value].dist_from_ideal_bucket() > 0) {
-      icloser_bucket =
-          ito_move_closer_value -
-          std::min(
-              ito_move_closer_value - icloser_bucket,
-              std::size_t(
-                  m_buckets[ito_move_closer_value].dist_from_ideal_bucket()));
-
-      tsl_rh_assert(m_buckets[icloser_bucket].empty());
-      const distance_type new_distance = distance_type(
-          m_buckets[ito_move_closer_value].dist_from_ideal_bucket() -
-          (ito_move_closer_value - icloser_bucket));
-      m_buckets[icloser_bucket].set_value_of_empty_bucket(
-          new_distance, m_buckets[ito_move_closer_value].truncated_hash(),
-          std::move(m_buckets[ito_move_closer_value].value()));
-      m_buckets[ito_move_closer_value].clear();
-
-      ++icloser_bucket;
-      ++ito_move_closer_value;
-    }
-
-    m_try_shrink_on_next_insert = true;
-
-    return iterator(m_buckets + ireturn_bucket);
-  }
-
-  template <class K>
-  size_type erase(const K& key) {
-    return erase(key, hash_key(key));
-  }
-
-  template <class K>
-  size_type erase(const K& key, std::size_t hash) {
-    auto it = find(key, hash);
-    if (it != end()) {
-      erase_from_bucket(it);
-      return 1;
-    } else {
-      return 0;
-    }
-  }
-
-  void swap(robin_hash& other) {
-    using std::swap;
-
-    swap(static_cast<Hash&>(*this), static_cast<Hash&>(other));
-    swap(static_cast<KeyEqual&>(*this), static_cast<KeyEqual&>(other));
-    swap(static_cast<GrowthPolicy&>(*this), static_cast<GrowthPolicy&>(other));
-    swap(m_buckets_data, other.m_buckets_data);
-    swap(m_buckets, other.m_buckets);
-    swap(m_bucket_count, other.m_bucket_count);
-    swap(m_nb_elements, other.m_nb_elements);
-    swap(m_load_threshold, other.m_load_threshold);
-    swap(m_min_load_factor, other.m_min_load_factor);
-    swap(m_max_load_factor, other.m_max_load_factor);
-    swap(m_grow_on_next_insert, other.m_grow_on_next_insert);
-    swap(m_try_shrink_on_next_insert, other.m_try_shrink_on_next_insert);
-  }
-
-  /*
-   * Lookup
-   */
-  template <class K, class U = ValueSelect,
-            typename std::enable_if<has_mapped_type<U>::value>::type* = nullptr>
-  typename U::value_type& at(const K& key) {
-    return at(key, hash_key(key));
-  }
-
-  template <class K, class U = ValueSelect,
-            typename std::enable_if<has_mapped_type<U>::value>::type* = nullptr>
-  typename U::value_type& at(const K& key, std::size_t hash) {
-    return const_cast<typename U::value_type&>(
-        static_cast<const robin_hash*>(this)->at(key, hash));
-  }
-
-  template <class K, class U = ValueSelect,
-            typename std::enable_if<has_mapped_type<U>::value>::type* = nullptr>
-  const typename U::value_type& at(const K& key) const {
-    return at(key, hash_key(key));
-  }
-
-  template <class K, class U = ValueSelect,
-            typename std::enable_if<has_mapped_type<U>::value>::type* = nullptr>
-  const typename U::value_type& at(const K& key, std::size_t hash) const {
-    auto it = find(key, hash);
-    if (it != cend()) {
-      return it.value();
-    } else {
-      TSL_RH_THROW_OR_TERMINATE(std::out_of_range, "Couldn't find key.");
-    }
-  }
-
-  template <class K, class U = ValueSelect,
-            typename std::enable_if<has_mapped_type<U>::value>::type* = nullptr>
-  typename U::value_type& operator[](K&& key) {
-    return try_emplace(std::forward<K>(key)).first.value();
-  }
-
-  template <class K>
-  size_type count(const K& key) const {
-    return count(key, hash_key(key));
-  }
-
-  template <class K>
-  size_type count(const K& key, std::size_t hash) const {
-    if (find(key, hash) != cend()) {
-      return 1;
-    } else {
-      return 0;
-    }
-  }
-
-  template <class K>
-  iterator find(const K& key) {
-    return find_impl(key, hash_key(key));
-  }
-
-  template <class K>
-  iterator find(const K& key, std::size_t hash) {
-    return find_impl(key, hash);
-  }
-
-  template <class K>
-  const_iterator find(const K& key) const {
-    return find_impl(key, hash_key(key));
-  }
-
-  template <class K>
-  const_iterator find(const K& key, std::size_t hash) const {
-    return find_impl(key, hash);
-  }
-
-  template <class K>
-  bool contains(const K& key) const {
-    return contains(key, hash_key(key));
-  }
-
-  template <class K>
-  bool contains(const K& key, std::size_t hash) const {
-    return count(key, hash) != 0;
-  }
-
-  template <class K>
-  std::pair<iterator, iterator> equal_range(const K& key) {
-    return equal_range(key, hash_key(key));
-  }
-
-  template <class K>
-  std::pair<iterator, iterator> equal_range(const K& key, std::size_t hash) {
-    iterator it = find(key, hash);
-    return std::make_pair(it, (it == end()) ? it : std::next(it));
-  }
-
-  template <class K>
-  std::pair<const_iterator, const_iterator> equal_range(const K& key) const {
-    return equal_range(key, hash_key(key));
-  }
-
-  template <class K>
-  std::pair<const_iterator, const_iterator> equal_range(
-      const K& key, std::size_t hash) const {
-    const_iterator it = find(key, hash);
-    return std::make_pair(it, (it == cend()) ? it : std::next(it));
-  }
-
-  /*
-   * Bucket interface
-   */
-  size_type bucket_count() const { return m_bucket_count; }
-
-  size_type max_bucket_count() const {
-    return std::min(GrowthPolicy::max_bucket_count(),
-                    m_buckets_data.max_size());
-  }
-
-  /*
-   * Hash policy
-   */
-  float load_factor() const {
-    if (bucket_count() == 0) {
-      return 0;
-    }
-
-    return float(m_nb_elements) / float(bucket_count());
-  }
-
-  float min_load_factor() const { return m_min_load_factor; }
-
-  float max_load_factor() const { return m_max_load_factor; }
-
-  void min_load_factor(float ml) {
-    m_min_load_factor = std::clamp(ml, float(MINIMUM_MIN_LOAD_FACTOR),
-                                   float(MAXIMUM_MIN_LOAD_FACTOR));
-  }
-
-  void max_load_factor(float ml) {
-    m_max_load_factor = std::clamp(ml, float(MINIMUM_MAX_LOAD_FACTOR),
-                                   float(MAXIMUM_MAX_LOAD_FACTOR));
-    m_load_threshold = size_type(float(bucket_count()) * m_max_load_factor);
-    tsl_rh_assert(bucket_count() == 0 || m_load_threshold < bucket_count());
-  }
-
-  void rehash(size_type count_) {
-    count_ = std::max(count_,
-                      size_type(std::ceil(float(size()) / max_load_factor())));
-    rehash_impl(count_);
-  }
-
-  void reserve(size_type count_) {
-    rehash(size_type(std::ceil(float(count_) / max_load_factor())));
-  }
-
-  /*
-   * Observers
-   */
-  hasher hash_function() const { return static_cast<const Hash&>(*this); }
-
-  key_equal key_eq() const { return static_cast<const KeyEqual&>(*this); }
-
-  /*
-   * Other
-   */
-  iterator mutable_iterator(const_iterator pos) {
-    return iterator(const_cast<bucket_entry*>(pos.m_bucket));
-  }
-
-  template <class Serializer>
-  void serialize(Serializer& serializer) const {
-    serialize_impl(serializer);
-  }
-
-  template <class Deserializer>
-  void deserialize(Deserializer& deserializer, bool hash_compatible) {
-    deserialize_impl(deserializer, hash_compatible);
-  }
-
- private:
-  template <class K>
-  std::size_t hash_key(const K& key) const {
-    return Hash::operator()(key);
-  }
-
-  template <class K1, class K2>
-  bool compare_keys(const K1& key1, const K2& key2) const {
-    return KeyEqual::operator()(key1, key2);
-  }
-
-  std::size_t bucket_for_hash(std::size_t hash) const {
-    const std::size_t bucket = GrowthPolicy::bucket_for_hash(hash);
-    tsl_rh_assert(bucket < m_bucket_count ||
-                  (bucket == 0 && m_bucket_count == 0));
-
-    return bucket;
-  }
-
-  template <class U = GrowthPolicy,
-            typename std::enable_if<is_power_of_two_policy<U>::value>::type* =
-                nullptr>
-  std::size_t next_bucket(std::size_t index) const noexcept {
-    tsl_rh_assert(index < bucket_count());
-
-    return (index + 1) & this->m_mask;
-  }
-
-  template <class U = GrowthPolicy,
-            typename std::enable_if<!is_power_of_two_policy<U>::value>::type* =
-                nullptr>
-  std::size_t next_bucket(std::size_t index) const noexcept {
-    tsl_rh_assert(index < bucket_count());
-
-    index++;
-    return (index != bucket_count()) ? index : 0;
-  }
-
-  template <class K>
-  iterator find_impl(const K& key, std::size_t hash) {
-    return mutable_iterator(
-        static_cast<const robin_hash*>(this)->find(key, hash));
-  }
-
-  template <class K>
-  const_iterator find_impl(const K& key, std::size_t hash) const {
-    std::size_t ibucket = bucket_for_hash(hash);
-    distance_type dist_from_ideal_bucket = 0;
-
-    while (dist_from_ideal_bucket <=
-           m_buckets[ibucket].dist_from_ideal_bucket()) {
-      if (TSL_RH_LIKELY(
-              (!USE_STORED_HASH_ON_LOOKUP ||
-               m_buckets[ibucket].bucket_hash_equal(hash)) &&
-              compare_keys(KeySelect()(m_buckets[ibucket].value()), key))) {
-        return const_iterator(m_buckets + ibucket);
-      }
-
-      ibucket = next_bucket(ibucket);
-      dist_from_ideal_bucket++;
-    }
-
-    return cend();
-  }
-
-  void erase_from_bucket(iterator pos) {
-    pos.m_bucket->clear();
-    m_nb_elements--;
-
-    /**
-     * Backward shift, swap the empty bucket, previous_ibucket, with the values
-     * on its right, ibucket, until we cross another empty bucket or if the
-     * other bucket has a distance_from_ideal_bucket == 0.
-     *
-     * We try to move the values closer to their ideal bucket.
-     */
-    std::size_t previous_ibucket =
-        static_cast<std::size_t>(pos.m_bucket - m_buckets);
-    std::size_t ibucket = next_bucket(previous_ibucket);
-
-    while (m_buckets[ibucket].dist_from_ideal_bucket() > 0) {
-      tsl_rh_assert(m_buckets[previous_ibucket].empty());
-
-      const distance_type new_distance =
-          distance_type(m_buckets[ibucket].dist_from_ideal_bucket() - 1);
-      m_buckets[previous_ibucket].set_value_of_empty_bucket(
-          new_distance, m_buckets[ibucket].truncated_hash(),
-          std::move(m_buckets[ibucket].value()));
-      m_buckets[ibucket].clear();
-
-      previous_ibucket = ibucket;
-      ibucket = next_bucket(ibucket);
-    }
-    m_try_shrink_on_next_insert = true;
-  }
-
-  template <class K, class... Args>
-  std::pair<iterator, bool> insert_impl(const K& key,
-                                        Args&&... value_type_args) {
-    const std::size_t hash = hash_key(key);
-
-    std::size_t ibucket = bucket_for_hash(hash);
-    distance_type dist_from_ideal_bucket = 0;
-
-    while (dist_from_ideal_bucket <=
-           m_buckets[ibucket].dist_from_ideal_bucket()) {
-      if ((!USE_STORED_HASH_ON_LOOKUP ||
-           m_buckets[ibucket].bucket_hash_equal(hash)) &&
-          compare_keys(KeySelect()(m_buckets[ibucket].value()), key)) {
-        return std::make_pair(iterator(m_buckets + ibucket), false);
-      }
-
-      ibucket = next_bucket(ibucket);
-      dist_from_ideal_bucket++;
-    }
-
-    while (rehash_on_extreme_load(dist_from_ideal_bucket)) {
-      ibucket = bucket_for_hash(hash);
-      dist_from_ideal_bucket = 0;
-
-      while (dist_from_ideal_bucket <=
-             m_buckets[ibucket].dist_from_ideal_bucket()) {
-        ibucket = next_bucket(ibucket);
-        dist_from_ideal_bucket++;
-      }
-    }
-
-    if (m_buckets[ibucket].empty()) {
-      m_buckets[ibucket].set_value_of_empty_bucket(
-          dist_from_ideal_bucket, bucket_entry::truncate_hash(hash),
-          std::forward<Args>(value_type_args)...);
-    } else {
-      insert_value(ibucket, dist_from_ideal_bucket,
-                   bucket_entry::truncate_hash(hash),
-                   std::forward<Args>(value_type_args)...);
-    }
-
-    m_nb_elements++;
-    /*
-     * The value will be inserted in ibucket in any case, either because it was
-     * empty or by stealing the bucket (robin hood).
-     */
-    return std::make_pair(iterator(m_buckets + ibucket), true);
-  }
-
-  template <class... Args>
-  void insert_value(std::size_t ibucket, distance_type dist_from_ideal_bucket,
-                    truncated_hash_type hash, Args&&... value_type_args) {
-    value_type value(std::forward<Args>(value_type_args)...);
-    insert_value_impl(ibucket, dist_from_ideal_bucket, hash, value);
-  }
-
-  void insert_value(std::size_t ibucket, distance_type dist_from_ideal_bucket,
-                    truncated_hash_type hash, value_type&& value) {
-    insert_value_impl(ibucket, dist_from_ideal_bucket, hash, value);
-  }
-
-  /*
-   * We don't use `value_type&& value` as last argument due to a bug in MSVC
-   * when `value_type` is a pointer, The compiler is not able to see the
-   * difference between `std::string*` and `std::string*&&` resulting in a
-   * compilation error.
-   *
-   * The `value` will be in a moved state at the end of the function.
-   */
-  void insert_value_impl(std::size_t ibucket,
-                         distance_type dist_from_ideal_bucket,
-                         truncated_hash_type hash, value_type& value) {
-    tsl_rh_assert(dist_from_ideal_bucket >
-                  m_buckets[ibucket].dist_from_ideal_bucket());
-    m_buckets[ibucket].swap_with_value_in_bucket(dist_from_ideal_bucket, hash,
-                                                 value);
-    ibucket = next_bucket(ibucket);
-    dist_from_ideal_bucket++;
-
-    while (!m_buckets[ibucket].empty()) {
-      if (dist_from_ideal_bucket >
-          m_buckets[ibucket].dist_from_ideal_bucket()) {
-        if (dist_from_ideal_bucket >
-            bucket_entry::DIST_FROM_IDEAL_BUCKET_LIMIT) {
-          /**
-           * The number of probes is really high, rehash the map on the next
-           * insert. Difficult to do now as rehash may throw an exception.
-           */
-          m_grow_on_next_insert = true;
-        }
-
-        m_buckets[ibucket].swap_with_value_in_bucket(dist_from_ideal_bucket,
-                                                     hash, value);
-      }
-
-      ibucket = next_bucket(ibucket);
-      dist_from_ideal_bucket++;
-    }
-
-    m_buckets[ibucket].set_value_of_empty_bucket(dist_from_ideal_bucket, hash,
-                                                 std::move(value));
-  }
-
-  void rehash_impl(size_type count_) {
-    robin_hash new_table(count_, static_cast<Hash&>(*this),
-                         static_cast<KeyEqual&>(*this), get_allocator(),
-                         m_min_load_factor, m_max_load_factor);
-    tsl_rh_assert(size() <= new_table.m_load_threshold);
-
-    const bool use_stored_hash =
-        USE_STORED_HASH_ON_REHASH(new_table.bucket_count());
-    for (auto& bucket : m_buckets_data) {
-      if (bucket.empty()) {
-        continue;
-      }
-
-      const std::size_t hash =
-          use_stored_hash ? bucket.truncated_hash()
-                          : new_table.hash_key(KeySelect()(bucket.value()));
-
-      new_table.insert_value_on_rehash(new_table.bucket_for_hash(hash), 0,
-                                       bucket_entry::truncate_hash(hash),
-                                       std::move(bucket.value()));
-    }
-
-    new_table.m_nb_elements = m_nb_elements;
-    new_table.swap(*this);
-  }
-
-  void clear_and_shrink() noexcept {
-    GrowthPolicy::clear();
-    m_buckets_data.clear();
-    m_buckets = static_empty_bucket_ptr();
-    m_bucket_count = 0;
-    m_nb_elements = 0;
-    m_load_threshold = 0;
-    m_grow_on_next_insert = false;
-    m_try_shrink_on_next_insert = false;
-  }
-
-  void insert_value_on_rehash(std::size_t ibucket,
-                              distance_type dist_from_ideal_bucket,
-                              truncated_hash_type hash, value_type&& value) {
-    while (true) {
-      if (dist_from_ideal_bucket >
-          m_buckets[ibucket].dist_from_ideal_bucket()) {
-        if (m_buckets[ibucket].empty()) {
-          m_buckets[ibucket].set_value_of_empty_bucket(dist_from_ideal_bucket,
-                                                       hash, std::move(value));
-          return;
-        } else {
-          m_buckets[ibucket].swap_with_value_in_bucket(dist_from_ideal_bucket,
-                                                       hash, value);
-        }
-      }
-
-      dist_from_ideal_bucket++;
-      ibucket = next_bucket(ibucket);
-    }
-  }
-
-  /**
-   * Grow the table if m_grow_on_next_insert is true or we reached the
-   * max_load_factor. Shrink the table if m_try_shrink_on_next_insert is true
-   * (an erase occurred) and we're below the min_load_factor.
-   *
-   * Return true if the table has been rehashed.
-   */
-  bool rehash_on_extreme_load(distance_type curr_dist_from_ideal_bucket) {
-    if (m_grow_on_next_insert ||
-        curr_dist_from_ideal_bucket >
-            bucket_entry::DIST_FROM_IDEAL_BUCKET_LIMIT ||
-        size() >= m_load_threshold) {
-      rehash_impl(GrowthPolicy::next_bucket_count());
-      m_grow_on_next_insert = false;
-
-      return true;
-    }
-
-    if (m_try_shrink_on_next_insert) {
-      m_try_shrink_on_next_insert = false;
-      if (m_min_load_factor != 0.0f && load_factor() < m_min_load_factor) {
-        reserve(size() + 1);
-
-        return true;
-      }
-    }
-
-    return false;
-  }
-
-  template <class Serializer>
-  void serialize_impl(Serializer& serializer) const {
-    const slz_size_type version = SERIALIZATION_PROTOCOL_VERSION;
-    serializer(version);
-
-    // Indicate if the truncated hash of each bucket is stored. Use a
-    // std::int16_t instead of a bool to avoid the need for the serializer to
-    // support an extra 'bool' type.
-    const std::int16_t hash_stored_for_bucket =
-        static_cast<std::int16_t>(STORE_HASH);
-    serializer(hash_stored_for_bucket);
-
-    const slz_size_type nb_elements = m_nb_elements;
-    serializer(nb_elements);
-
-    const slz_size_type bucket_count = m_buckets_data.size();
-    serializer(bucket_count);
-
-    const float min_load_factor = m_min_load_factor;
-    serializer(min_load_factor);
-
-    const float max_load_factor = m_max_load_factor;
-    serializer(max_load_factor);
-
-    for (const bucket_entry& bucket : m_buckets_data) {
-      if (bucket.empty()) {
-        const std::int16_t empty_bucket =
-            bucket_entry::EMPTY_MARKER_DIST_FROM_IDEAL_BUCKET;
-        serializer(empty_bucket);
-      } else {
-        const std::int16_t dist_from_ideal_bucket =
-            bucket.dist_from_ideal_bucket();
-        serializer(dist_from_ideal_bucket);
-        if (STORE_HASH) {
-          const std::uint32_t truncated_hash = bucket.truncated_hash();
-          serializer(truncated_hash);
-        }
-        serializer(bucket.value());
-      }
-    }
-  }
-
-  template <class Deserializer>
-  void deserialize_impl(Deserializer& deserializer, bool hash_compatible) {
-    tsl_rh_assert(m_buckets_data.empty());  // Current hash table must be empty
-
-    const slz_size_type version =
-        deserialize_value<slz_size_type>(deserializer);
-    // For now we only have one version of the serialization protocol.
-    // If it doesn't match there is a problem with the file.
-    if (version != SERIALIZATION_PROTOCOL_VERSION) {
-      TSL_RH_THROW_OR_TERMINATE(std::runtime_error,
-                                "Can't deserialize the ordered_map/set. "
-                                "The protocol version header is invalid.");
-    }
-
-    const bool hash_stored_for_bucket =
-        deserialize_value<std::int16_t>(deserializer) ? true : false;
-    if (hash_compatible && STORE_HASH != hash_stored_for_bucket) {
-      TSL_RH_THROW_OR_TERMINATE(
-          std::runtime_error,
-          "Can't deserialize a map with a different StoreHash "
-          "than the one used during the serialization when "
-          "hash compatibility is used");
-    }
-
-    const slz_size_type nb_elements =
-        deserialize_value<slz_size_type>(deserializer);
-    const slz_size_type bucket_count_ds =
-        deserialize_value<slz_size_type>(deserializer);
-    const float min_load_factor = deserialize_value<float>(deserializer);
-    const float max_load_factor = deserialize_value<float>(deserializer);
-
-    if (min_load_factor < MINIMUM_MIN_LOAD_FACTOR ||
-        min_load_factor > MAXIMUM_MIN_LOAD_FACTOR) {
-      TSL_RH_THROW_OR_TERMINATE(
-          std::runtime_error,
-          "Invalid min_load_factor. Check that the serializer "
-          "and deserializer support floats correctly as they "
-          "can be converted implicitly to ints.");
-    }
-
-    if (max_load_factor < MINIMUM_MAX_LOAD_FACTOR ||
-        max_load_factor > MAXIMUM_MAX_LOAD_FACTOR) {
-      TSL_RH_THROW_OR_TERMINATE(
-          std::runtime_error,
-          "Invalid max_load_factor. Check that the serializer "
-          "and deserializer support floats correctly as they "
-          "can be converted implicitly to ints.");
-    }
-
-    this->min_load_factor(min_load_factor);
-    this->max_load_factor(max_load_factor);
-
-    if (bucket_count_ds == 0) {
-      tsl_rh_assert(nb_elements == 0);
-      return;
-    }
-
-    if (!hash_compatible) {
-      reserve(numeric_cast<size_type>(nb_elements,
-                                      "Deserialized nb_elements is too big."));
-      for (slz_size_type ibucket = 0; ibucket < bucket_count_ds; ibucket++) {
-        const distance_type dist_from_ideal_bucket =
-            deserialize_value<std::int16_t>(deserializer);
-        if (dist_from_ideal_bucket !=
-            bucket_entry::EMPTY_MARKER_DIST_FROM_IDEAL_BUCKET) {
-          if (hash_stored_for_bucket) {
-            TSL_RH_UNUSED(deserialize_value<std::uint32_t>(deserializer));
-          }
-
-          insert(deserialize_value<value_type>(deserializer));
-        }
-      }
-
-      tsl_rh_assert(nb_elements == size());
-    } else {
-      m_bucket_count = numeric_cast<size_type>(
-          bucket_count_ds, "Deserialized bucket_count is too big.");
-      // Recompute m_load_threshold, during max_load_factor() the bucket count
-      // was still 0 which would trigger rehash on first insert
-      m_load_threshold = size_type(float(bucket_count()) * m_max_load_factor);
-
-      GrowthPolicy::operator=(GrowthPolicy(m_bucket_count));
-      // GrowthPolicy should not modify the bucket count we got from
-      // deserialization
-      if (m_bucket_count != bucket_count_ds) {
-        TSL_RH_THROW_OR_TERMINATE(std::runtime_error,
-                                  "The GrowthPolicy is not the same even "
-                                  "though hash_compatible is true.");
-      }
-
-      m_nb_elements = numeric_cast<size_type>(
-          nb_elements, "Deserialized nb_elements is too big.");
-      m_buckets_data.resize(m_bucket_count);
-      m_buckets = m_buckets_data.data();
-
-      for (bucket_entry& bucket : m_buckets_data) {
-        const distance_type dist_from_ideal_bucket =
-            deserialize_value<std::int16_t>(deserializer);
-        if (dist_from_ideal_bucket !=
-            bucket_entry::EMPTY_MARKER_DIST_FROM_IDEAL_BUCKET) {
-          truncated_hash_type truncated_hash = 0;
-          if (hash_stored_for_bucket) {
-            tsl_rh_assert(hash_stored_for_bucket);
-            truncated_hash = deserialize_value<std::uint32_t>(deserializer);
-          }
-
-          bucket.set_value_of_empty_bucket(
-              dist_from_ideal_bucket, truncated_hash,
-              deserialize_value<value_type>(deserializer));
-        }
-      }
-
-      if (!m_buckets_data.empty()) {
-        m_buckets_data.back().set_as_last_bucket();
-      }
-    }
-  }
-
- public:
-  static const size_type DEFAULT_INIT_BUCKETS_SIZE = 0;
-
-  static constexpr float DEFAULT_MAX_LOAD_FACTOR = 0.5f;
-  static constexpr float MINIMUM_MAX_LOAD_FACTOR = 0.2f;
-  static constexpr float MAXIMUM_MAX_LOAD_FACTOR = 0.95f;
-
-  static constexpr float DEFAULT_MIN_LOAD_FACTOR = 0.0f;
-  static constexpr float MINIMUM_MIN_LOAD_FACTOR = 0.0f;
-  static constexpr float MAXIMUM_MIN_LOAD_FACTOR = 0.15f;
-
-  static_assert(MINIMUM_MAX_LOAD_FACTOR < MAXIMUM_MAX_LOAD_FACTOR,
-                "MINIMUM_MAX_LOAD_FACTOR should be < MAXIMUM_MAX_LOAD_FACTOR");
-  static_assert(MINIMUM_MIN_LOAD_FACTOR < MAXIMUM_MIN_LOAD_FACTOR,
-                "MINIMUM_MIN_LOAD_FACTOR should be < MAXIMUM_MIN_LOAD_FACTOR");
-  static_assert(MAXIMUM_MIN_LOAD_FACTOR < MINIMUM_MAX_LOAD_FACTOR,
-                "MAXIMUM_MIN_LOAD_FACTOR should be < MINIMUM_MAX_LOAD_FACTOR");
-
- private:
-  /**
-   * Protocol version currenlty used for serialization.
-   */
-  static const slz_size_type SERIALIZATION_PROTOCOL_VERSION = 1;
-
-  /**
-   * Return an always valid pointer to an static empty bucket_entry with
-   * last_bucket() == true.
-   */
-  bucket_entry* static_empty_bucket_ptr() noexcept {
-    static bucket_entry empty_bucket(true);
-    tsl_rh_assert(empty_bucket.empty());
-    return &empty_bucket;
-  }
-
- private:
-  buckets_container_type m_buckets_data;
-
-  /**
-   * Points to m_buckets_data.data() if !m_buckets_data.empty() otherwise points
-   * to static_empty_bucket_ptr. This variable is useful to avoid the cost of
-   * checking if m_buckets_data is empty when trying to find an element.
-   *
-   * TODO Remove m_buckets_data and only use a pointer instead of a
-   * pointer+vector to save some space in the robin_hash object. Manage the
-   * Allocator manually.
-   */
-  bucket_entry* m_buckets;
-
-  /**
-   * Used a lot in find, avoid the call to m_buckets_data.size() which is a bit
-   * slower.
-   */
-  size_type m_bucket_count;
-
-  size_type m_nb_elements;
-
-  size_type m_load_threshold;
-
-  float m_min_load_factor;
-  float m_max_load_factor;
-
-  bool m_grow_on_next_insert;
-
-  /**
-   * We can't shrink down the map on erase operations as the erase methods need
-   * to return the next iterator. Shrinking the map would invalidate all the
-   * iterators and we could not return the next iterator in a meaningful way, On
-   * erase, we thus just indicate on erase that we should try to shrink the hash
-   * table on the next insert if we go below the min_load_factor.
-   */
-  bool m_try_shrink_on_next_insert;
-};
-
-}  // namespace detail_robin_hash
-
-}  // namespace tsl
-
-#endif
diff --git a/src/nanobind/ext/robin_map/include/tsl/robin_map.h b/src/nanobind/ext/robin_map/include/tsl/robin_map.h
deleted file mode 100644
index b594810..0000000
--- a/src/nanobind/ext/robin_map/include/tsl/robin_map.h
+++ /dev/null
@@ -1,815 +0,0 @@
-/**
- * MIT License
- *
- * Copyright (c) 2017 Thibaut Goetghebuer-Planchon <tessil@gmx.com>
- *
- * 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.
- */
-#ifndef TSL_ROBIN_MAP_H
-#define TSL_ROBIN_MAP_H
-
-#include <cstddef>
-#include <functional>
-#include <initializer_list>
-#include <memory>
-#include <type_traits>
-#include <utility>
-
-#include "robin_hash.h"
-
-namespace tsl {
-
-/**
- * Implementation of a hash map using open-addressing and the robin hood hashing
- * algorithm with backward shift deletion.
- *
- * For operations modifying the hash map (insert, erase, rehash, ...), the
- * strong exception guarantee is only guaranteed when the expression
- * `std::is_nothrow_swappable<std::pair<Key, T>>::value &&
- * std::is_nothrow_move_constructible<std::pair<Key, T>>::value` is true,
- * otherwise if an exception is thrown during the swap or the move, the hash map
- * may end up in a undefined state. Per the standard a `Key` or `T` with a
- * noexcept copy constructor and no move constructor also satisfies the
- * `std::is_nothrow_move_constructible<std::pair<Key, T>>::value` criterion (and
- * will thus guarantee the strong exception for the map).
- *
- * When `StoreHash` is true, 32 bits of the hash are stored alongside the
- * values. It can improve the performance during lookups if the `KeyEqual`
- * function takes time (if it engenders a cache-miss for example) as we then
- * compare the stored hashes before comparing the keys. When
- * `tsl::rh::power_of_two_growth_policy` is used as `GrowthPolicy`, it may also
- * speed-up the rehash process as we can avoid to recalculate the hash. When it
- * is detected that storing the hash will not incur any memory penalty due to
- * alignment (i.e. `sizeof(tsl::detail_robin_hash::bucket_entry<ValueType,
- * true>) == sizeof(tsl::detail_robin_hash::bucket_entry<ValueType, false>)`)
- * and `tsl::rh::power_of_two_growth_policy` is used, the hash will be stored
- * even if `StoreHash` is false so that we can speed-up the rehash (but it will
- * not be used on lookups unless `StoreHash` is true).
- *
- * `GrowthPolicy` defines how the map grows and consequently how a hash value is
- * mapped to a bucket. By default the map uses
- * `tsl::rh::power_of_two_growth_policy`. This policy keeps the number of
- * buckets to a power of two and uses a mask to map the hash to a bucket instead
- * of the slow modulo. Other growth policies are available and you may define
- * your own growth policy, check `tsl::rh::power_of_two_growth_policy` for the
- * interface.
- *
- * `std::pair<Key, T>` must be swappable.
- *
- * `Key` and `T` must be copy and/or move constructible.
- *
- * If the destructor of `Key` or `T` throws an exception, the behaviour of the
- * class is undefined.
- *
- * Iterators invalidation:
- *  - clear, operator=, reserve, rehash: always invalidate the iterators.
- *  - insert, emplace, emplace_hint, operator[]: if there is an effective
- * insert, invalidate the iterators.
- *  - erase: always invalidate the iterators.
- */
-template <class Key, class T, class Hash = std::hash<Key>,
-          class KeyEqual = std::equal_to<Key>,
-          class Allocator = std::allocator<std::pair<Key, T>>,
-          bool StoreHash = false,
-          class GrowthPolicy = tsl::rh::power_of_two_growth_policy<2>>
-class robin_map {
- private:
-  template <typename U>
-  using has_is_transparent = tsl::detail_robin_hash::has_is_transparent<U>;
-
-  class KeySelect {
-   public:
-    using key_type = Key;
-
-    const key_type& operator()(
-        const std::pair<Key, T>& key_value) const noexcept {
-      return key_value.first;
-    }
-
-    key_type& operator()(std::pair<Key, T>& key_value) noexcept {
-      return key_value.first;
-    }
-  };
-
-  class ValueSelect {
-   public:
-    using value_type = T;
-
-    const value_type& operator()(
-        const std::pair<Key, T>& key_value) const noexcept {
-      return key_value.second;
-    }
-
-    value_type& operator()(std::pair<Key, T>& key_value) noexcept {
-      return key_value.second;
-    }
-  };
-
-  using ht = detail_robin_hash::robin_hash<std::pair<Key, T>, KeySelect,
-                                           ValueSelect, Hash, KeyEqual,
-                                           Allocator, StoreHash, GrowthPolicy>;
-
- public:
-  using key_type = typename ht::key_type;
-  using mapped_type = T;
-  using value_type = typename ht::value_type;
-  using size_type = typename ht::size_type;
-  using difference_type = typename ht::difference_type;
-  using hasher = typename ht::hasher;
-  using key_equal = typename ht::key_equal;
-  using allocator_type = typename ht::allocator_type;
-  using reference = typename ht::reference;
-  using const_reference = typename ht::const_reference;
-  using pointer = typename ht::pointer;
-  using const_pointer = typename ht::const_pointer;
-  using iterator = typename ht::iterator;
-  using const_iterator = typename ht::const_iterator;
-
- public:
-  /*
-   * Constructors
-   */
-  robin_map() : robin_map(ht::DEFAULT_INIT_BUCKETS_SIZE) {}
-
-  explicit robin_map(size_type bucket_count, const Hash& hash = Hash(),
-                     const KeyEqual& equal = KeyEqual(),
-                     const Allocator& alloc = Allocator())
-      : m_ht(bucket_count, hash, equal, alloc) {}
-
-  robin_map(size_type bucket_count, const Allocator& alloc)
-      : robin_map(bucket_count, Hash(), KeyEqual(), alloc) {}
-
-  robin_map(size_type bucket_count, const Hash& hash, const Allocator& alloc)
-      : robin_map(bucket_count, hash, KeyEqual(), alloc) {}
-
-  explicit robin_map(const Allocator& alloc)
-      : robin_map(ht::DEFAULT_INIT_BUCKETS_SIZE, alloc) {}
-
-  template <class InputIt>
-  robin_map(InputIt first, InputIt last,
-            size_type bucket_count = ht::DEFAULT_INIT_BUCKETS_SIZE,
-            const Hash& hash = Hash(), const KeyEqual& equal = KeyEqual(),
-            const Allocator& alloc = Allocator())
-      : robin_map(bucket_count, hash, equal, alloc) {
-    insert(first, last);
-  }
-
-  template <class InputIt>
-  robin_map(InputIt first, InputIt last, size_type bucket_count,
-            const Allocator& alloc)
-      : robin_map(first, last, bucket_count, Hash(), KeyEqual(), alloc) {}
-
-  template <class InputIt>
-  robin_map(InputIt first, InputIt last, size_type bucket_count,
-            const Hash& hash, const Allocator& alloc)
-      : robin_map(first, last, bucket_count, hash, KeyEqual(), alloc) {}
-
-  robin_map(std::initializer_list<value_type> init,
-            size_type bucket_count = ht::DEFAULT_INIT_BUCKETS_SIZE,
-            const Hash& hash = Hash(), const KeyEqual& equal = KeyEqual(),
-            const Allocator& alloc = Allocator())
-      : robin_map(init.begin(), init.end(), bucket_count, hash, equal, alloc) {}
-
-  robin_map(std::initializer_list<value_type> init, size_type bucket_count,
-            const Allocator& alloc)
-      : robin_map(init.begin(), init.end(), bucket_count, Hash(), KeyEqual(),
-                  alloc) {}
-
-  robin_map(std::initializer_list<value_type> init, size_type bucket_count,
-            const Hash& hash, const Allocator& alloc)
-      : robin_map(init.begin(), init.end(), bucket_count, hash, KeyEqual(),
-                  alloc) {}
-
-  robin_map& operator=(std::initializer_list<value_type> ilist) {
-    m_ht.clear();
-
-    m_ht.reserve(ilist.size());
-    m_ht.insert(ilist.begin(), ilist.end());
-
-    return *this;
-  }
-
-  allocator_type get_allocator() const { return m_ht.get_allocator(); }
-
-  /*
-   * Iterators
-   */
-  iterator begin() noexcept { return m_ht.begin(); }
-  const_iterator begin() const noexcept { return m_ht.begin(); }
-  const_iterator cbegin() const noexcept { return m_ht.cbegin(); }
-
-  iterator end() noexcept { return m_ht.end(); }
-  const_iterator end() const noexcept { return m_ht.end(); }
-  const_iterator cend() const noexcept { return m_ht.cend(); }
-
-  /*
-   * Capacity
-   */
-  bool empty() const noexcept { return m_ht.empty(); }
-  size_type size() const noexcept { return m_ht.size(); }
-  size_type max_size() const noexcept { return m_ht.max_size(); }
-
-  /*
-   * Modifiers
-   */
-  void clear() noexcept { m_ht.clear(); }
-
-  std::pair<iterator, bool> insert(const value_type& value) {
-    return m_ht.insert(value);
-  }
-
-  template <class P, typename std::enable_if<std::is_constructible<
-                         value_type, P&&>::value>::type* = nullptr>
-  std::pair<iterator, bool> insert(P&& value) {
-    return m_ht.emplace(std::forward<P>(value));
-  }
-
-  std::pair<iterator, bool> insert(value_type&& value) {
-    return m_ht.insert(std::move(value));
-  }
-
-  iterator insert(const_iterator hint, const value_type& value) {
-    return m_ht.insert_hint(hint, value);
-  }
-
-  template <class P, typename std::enable_if<std::is_constructible<
-                         value_type, P&&>::value>::type* = nullptr>
-  iterator insert(const_iterator hint, P&& value) {
-    return m_ht.emplace_hint(hint, std::forward<P>(value));
-  }
-
-  iterator insert(const_iterator hint, value_type&& value) {
-    return m_ht.insert_hint(hint, std::move(value));
-  }
-
-  template <class InputIt>
-  void insert(InputIt first, InputIt last) {
-    m_ht.insert(first, last);
-  }
-
-  void insert(std::initializer_list<value_type> ilist) {
-    m_ht.insert(ilist.begin(), ilist.end());
-  }
-
-  template <class M>
-  std::pair<iterator, bool> insert_or_assign(const key_type& k, M&& obj) {
-    return m_ht.insert_or_assign(k, std::forward<M>(obj));
-  }
-
-  template <class M>
-  std::pair<iterator, bool> insert_or_assign(key_type&& k, M&& obj) {
-    return m_ht.insert_or_assign(std::move(k), std::forward<M>(obj));
-  }
-
-  template <class M>
-  iterator insert_or_assign(const_iterator hint, const key_type& k, M&& obj) {
-    return m_ht.insert_or_assign(hint, k, std::forward<M>(obj));
-  }
-
-  template <class M>
-  iterator insert_or_assign(const_iterator hint, key_type&& k, M&& obj) {
-    return m_ht.insert_or_assign(hint, std::move(k), std::forward<M>(obj));
-  }
-
-  /**
-   * Due to the way elements are stored, emplace will need to move or copy the
-   * key-value once. The method is equivalent to
-   * insert(value_type(std::forward<Args>(args)...));
-   *
-   * Mainly here for compatibility with the std::unordered_map interface.
-   */
-  template <class... Args>
-  std::pair<iterator, bool> emplace(Args&&... args) {
-    return m_ht.emplace(std::forward<Args>(args)...);
-  }
-
-  /**
-   * Due to the way elements are stored, emplace_hint will need to move or copy
-   * the key-value once. The method is equivalent to insert(hint,
-   * value_type(std::forward<Args>(args)...));
-   *
-   * Mainly here for compatibility with the std::unordered_map interface.
-   */
-  template <class... Args>
-  iterator emplace_hint(const_iterator hint, Args&&... args) {
-    return m_ht.emplace_hint(hint, std::forward<Args>(args)...);
-  }
-
-  template <class... Args>
-  std::pair<iterator, bool> try_emplace(const key_type& k, Args&&... args) {
-    return m_ht.try_emplace(k, std::forward<Args>(args)...);
-  }
-
-  template <class... Args>
-  std::pair<iterator, bool> try_emplace(key_type&& k, Args&&... args) {
-    return m_ht.try_emplace(std::move(k), std::forward<Args>(args)...);
-  }
-
-  template <class... Args>
-  iterator try_emplace(const_iterator hint, const key_type& k, Args&&... args) {
-    return m_ht.try_emplace_hint(hint, k, std::forward<Args>(args)...);
-  }
-
-  template <class... Args>
-  iterator try_emplace(const_iterator hint, key_type&& k, Args&&... args) {
-    return m_ht.try_emplace_hint(hint, std::move(k),
-                                 std::forward<Args>(args)...);
-  }
-
-  iterator erase(iterator pos) { return m_ht.erase(pos); }
-  iterator erase(const_iterator pos) { return m_ht.erase(pos); }
-  iterator erase(const_iterator first, const_iterator last) {
-    return m_ht.erase(first, last);
-  }
-  size_type erase(const key_type& key) { return m_ht.erase(key); }
-
-  /**
-   * Erase the element at position 'pos'. In contrast to the regular erase()
-   * function, erase_fast() does not return an iterator. This allows it to be
-   * faster especially in hash tables with a low load factor, where finding the
-   * next nonempty bucket would be costly.
-   */
-  void erase_fast(iterator pos) { return m_ht.erase_fast(pos); }
-
-  /**
-   * Use the hash value 'precalculated_hash' instead of hashing the key. The
-   * hash value should be the same as hash_function()(key). Useful to speed-up
-   * the lookup to the value if you already have the hash.
-   */
-  size_type erase(const key_type& key, std::size_t precalculated_hash) {
-    return m_ht.erase(key, precalculated_hash);
-  }
-
-  /**
-   * This overload only participates in the overload resolution if the typedef
-   * KeyEqual::is_transparent exists. If so, K must be hashable and comparable
-   * to Key.
-   */
-  template <
-      class K, class KE = KeyEqual,
-      typename std::enable_if<has_is_transparent<KE>::value>::type* = nullptr>
-  size_type erase(const K& key) {
-    return m_ht.erase(key);
-  }
-
-  /**
-   * @copydoc erase(const K& key)
-   *
-   * Use the hash value 'precalculated_hash' instead of hashing the key. The
-   * hash value should be the same as hash_function()(key). Useful to speed-up
-   * the lookup to the value if you already have the hash.
-   */
-  template <
-      class K, class KE = KeyEqual,
-      typename std::enable_if<has_is_transparent<KE>::value>::type* = nullptr>
-  size_type erase(const K& key, std::size_t precalculated_hash) {
-    return m_ht.erase(key, precalculated_hash);
-  }
-
-  void swap(robin_map& other) { other.m_ht.swap(m_ht); }
-
-  /*
-   * Lookup
-   */
-  T& at(const Key& key) { return m_ht.at(key); }
-
-  /**
-   * Use the hash value 'precalculated_hash' instead of hashing the key. The
-   * hash value should be the same as hash_function()(key). Useful to speed-up
-   * the lookup if you already have the hash.
-   */
-  T& at(const Key& key, std::size_t precalculated_hash) {
-    return m_ht.at(key, precalculated_hash);
-  }
-
-  const T& at(const Key& key) const { return m_ht.at(key); }
-
-  /**
-   * @copydoc at(const Key& key, std::size_t precalculated_hash)
-   */
-  const T& at(const Key& key, std::size_t precalculated_hash) const {
-    return m_ht.at(key, precalculated_hash);
-  }
-
-  /**
-   * This overload only participates in the overload resolution if the typedef
-   * KeyEqual::is_transparent exists. If so, K must be hashable and comparable
-   * to Key.
-   */
-  template <
-      class K, class KE = KeyEqual,
-      typename std::enable_if<has_is_transparent<KE>::value>::type* = nullptr>
-  T& at(const K& key) {
-    return m_ht.at(key);
-  }
-
-  /**
-   * @copydoc at(const K& key)
-   *
-   * Use the hash value 'precalculated_hash' instead of hashing the key. The
-   * hash value should be the same as hash_function()(key). Useful to speed-up
-   * the lookup if you already have the hash.
-   */
-  template <
-      class K, class KE = KeyEqual,
-      typename std::enable_if<has_is_transparent<KE>::value>::type* = nullptr>
-  T& at(const K& key, std::size_t precalculated_hash) {
-    return m_ht.at(key, precalculated_hash);
-  }
-
-  /**
-   * @copydoc at(const K& key)
-   */
-  template <
-      class K, class KE = KeyEqual,
-      typename std::enable_if<has_is_transparent<KE>::value>::type* = nullptr>
-  const T& at(const K& key) const {
-    return m_ht.at(key);
-  }
-
-  /**
-   * @copydoc at(const K& key, std::size_t precalculated_hash)
-   */
-  template <
-      class K, class KE = KeyEqual,
-      typename std::enable_if<has_is_transparent<KE>::value>::type* = nullptr>
-  const T& at(const K& key, std::size_t precalculated_hash) const {
-    return m_ht.at(key, precalculated_hash);
-  }
-
-  T& operator[](const Key& key) { return m_ht[key]; }
-  T& operator[](Key&& key) { return m_ht[std::move(key)]; }
-
-  size_type count(const Key& key) const { return m_ht.count(key); }
-
-  /**
-   * Use the hash value 'precalculated_hash' instead of hashing the key. The
-   * hash value should be the same as hash_function()(key). Useful to speed-up
-   * the lookup if you already have the hash.
-   */
-  size_type count(const Key& key, std::size_t precalculated_hash) const {
-    return m_ht.count(key, precalculated_hash);
-  }
-
-  /**
-   * This overload only participates in the overload resolution if the typedef
-   * KeyEqual::is_transparent exists. If so, K must be hashable and comparable
-   * to Key.
-   */
-  template <
-      class K, class KE = KeyEqual,
-      typename std::enable_if<has_is_transparent<KE>::value>::type* = nullptr>
-  size_type count(const K& key) const {
-    return m_ht.count(key);
-  }
-
-  /**
-   * @copydoc count(const K& key) const
-   *
-   * Use the hash value 'precalculated_hash' instead of hashing the key. The
-   * hash value should be the same as hash_function()(key). Useful to speed-up
-   * the lookup if you already have the hash.
-   */
-  template <
-      class K, class KE = KeyEqual,
-      typename std::enable_if<has_is_transparent<KE>::value>::type* = nullptr>
-  size_type count(const K& key, std::size_t precalculated_hash) const {
-    return m_ht.count(key, precalculated_hash);
-  }
-
-  iterator find(const Key& key) { return m_ht.find(key); }
-
-  /**
-   * Use the hash value 'precalculated_hash' instead of hashing the key. The
-   * hash value should be the same as hash_function()(key). Useful to speed-up
-   * the lookup if you already have the hash.
-   */
-  iterator find(const Key& key, std::size_t precalculated_hash) {
-    return m_ht.find(key, precalculated_hash);
-  }
-
-  const_iterator find(const Key& key) const { return m_ht.find(key); }
-
-  /**
-   * @copydoc find(const Key& key, std::size_t precalculated_hash)
-   */
-  const_iterator find(const Key& key, std::size_t precalculated_hash) const {
-    return m_ht.find(key, precalculated_hash);
-  }
-
-  /**
-   * This overload only participates in the overload resolution if the typedef
-   * KeyEqual::is_transparent exists. If so, K must be hashable and comparable
-   * to Key.
-   */
-  template <
-      class K, class KE = KeyEqual,
-      typename std::enable_if<has_is_transparent<KE>::value>::type* = nullptr>
-  iterator find(const K& key) {
-    return m_ht.find(key);
-  }
-
-  /**
-   * @copydoc find(const K& key)
-   *
-   * Use the hash value 'precalculated_hash' instead of hashing the key. The
-   * hash value should be the same as hash_function()(key). Useful to speed-up
-   * the lookup if you already have the hash.
-   */
-  template <
-      class K, class KE = KeyEqual,
-      typename std::enable_if<has_is_transparent<KE>::value>::type* = nullptr>
-  iterator find(const K& key, std::size_t precalculated_hash) {
-    return m_ht.find(key, precalculated_hash);
-  }
-
-  /**
-   * @copydoc find(const K& key)
-   */
-  template <
-      class K, class KE = KeyEqual,
-      typename std::enable_if<has_is_transparent<KE>::value>::type* = nullptr>
-  const_iterator find(const K& key) const {
-    return m_ht.find(key);
-  }
-
-  /**
-   * @copydoc find(const K& key)
-   *
-   * Use the hash value 'precalculated_hash' instead of hashing the key. The
-   * hash value should be the same as hash_function()(key). Useful to speed-up
-   * the lookup if you already have the hash.
-   */
-  template <
-      class K, class KE = KeyEqual,
-      typename std::enable_if<has_is_transparent<KE>::value>::type* = nullptr>
-  const_iterator find(const K& key, std::size_t precalculated_hash) const {
-    return m_ht.find(key, precalculated_hash);
-  }
-
-  bool contains(const Key& key) const { return m_ht.contains(key); }
-
-  /**
-   * Use the hash value 'precalculated_hash' instead of hashing the key. The
-   * hash value should be the same as hash_function()(key). Useful to speed-up
-   * the lookup if you already have the hash.
-   */
-  bool contains(const Key& key, std::size_t precalculated_hash) const {
-    return m_ht.contains(key, precalculated_hash);
-  }
-
-  /**
-   * This overload only participates in the overload resolution if the typedef
-   * KeyEqual::is_transparent exists. If so, K must be hashable and comparable
-   * to Key.
-   */
-  template <
-      class K, class KE = KeyEqual,
-      typename std::enable_if<has_is_transparent<KE>::value>::type* = nullptr>
-  bool contains(const K& key) const {
-    return m_ht.contains(key);
-  }
-
-  /**
-   * @copydoc contains(const K& key) const
-   *
-   * Use the hash value 'precalculated_hash' instead of hashing the key. The
-   * hash value should be the same as hash_function()(key). Useful to speed-up
-   * the lookup if you already have the hash.
-   */
-  template <
-      class K, class KE = KeyEqual,
-      typename std::enable_if<has_is_transparent<KE>::value>::type* = nullptr>
-  bool contains(const K& key, std::size_t precalculated_hash) const {
-    return m_ht.contains(key, precalculated_hash);
-  }
-
-  std::pair<iterator, iterator> equal_range(const Key& key) {
-    return m_ht.equal_range(key);
-  }
-
-  /**
-   * Use the hash value 'precalculated_hash' instead of hashing the key. The
-   * hash value should be the same as hash_function()(key). Useful to speed-up
-   * the lookup if you already have the hash.
-   */
-  std::pair<iterator, iterator> equal_range(const Key& key,
-                                            std::size_t precalculated_hash) {
-    return m_ht.equal_range(key, precalculated_hash);
-  }
-
-  std::pair<const_iterator, const_iterator> equal_range(const Key& key) const {
-    return m_ht.equal_range(key);
-  }
-
-  /**
-   * @copydoc equal_range(const Key& key, std::size_t precalculated_hash)
-   */
-  std::pair<const_iterator, const_iterator> equal_range(
-      const Key& key, std::size_t precalculated_hash) const {
-    return m_ht.equal_range(key, precalculated_hash);
-  }
-
-  /**
-   * This overload only participates in the overload resolution if the typedef
-   * KeyEqual::is_transparent exists. If so, K must be hashable and comparable
-   * to Key.
-   */
-  template <
-      class K, class KE = KeyEqual,
-      typename std::enable_if<has_is_transparent<KE>::value>::type* = nullptr>
-  std::pair<iterator, iterator> equal_range(const K& key) {
-    return m_ht.equal_range(key);
-  }
-
-  /**
-   * @copydoc equal_range(const K& key)
-   *
-   * Use the hash value 'precalculated_hash' instead of hashing the key. The
-   * hash value should be the same as hash_function()(key). Useful to speed-up
-   * the lookup if you already have the hash.
-   */
-  template <
-      class K, class KE = KeyEqual,
-      typename std::enable_if<has_is_transparent<KE>::value>::type* = nullptr>
-  std::pair<iterator, iterator> equal_range(const K& key,
-                                            std::size_t precalculated_hash) {
-    return m_ht.equal_range(key, precalculated_hash);
-  }
-
-  /**
-   * @copydoc equal_range(const K& key)
-   */
-  template <
-      class K, class KE = KeyEqual,
-      typename std::enable_if<has_is_transparent<KE>::value>::type* = nullptr>
-  std::pair<const_iterator, const_iterator> equal_range(const K& key) const {
-    return m_ht.equal_range(key);
-  }
-
-  /**
-   * @copydoc equal_range(const K& key, std::size_t precalculated_hash)
-   */
-  template <
-      class K, class KE = KeyEqual,
-      typename std::enable_if<has_is_transparent<KE>::value>::type* = nullptr>
-  std::pair<const_iterator, const_iterator> equal_range(
-      const K& key, std::size_t precalculated_hash) const {
-    return m_ht.equal_range(key, precalculated_hash);
-  }
-
-  /*
-   * Bucket interface
-   */
-  size_type bucket_count() const { return m_ht.bucket_count(); }
-  size_type max_bucket_count() const { return m_ht.max_bucket_count(); }
-
-  /*
-   *  Hash policy
-   */
-  float load_factor() const { return m_ht.load_factor(); }
-
-  float min_load_factor() const { return m_ht.min_load_factor(); }
-  float max_load_factor() const { return m_ht.max_load_factor(); }
-
-  /**
-   * Set the `min_load_factor` to `ml`. When the `load_factor` of the map goes
-   * below `min_load_factor` after some erase operations, the map will be
-   * shrunk when an insertion occurs. The erase method itself never shrinks
-   * the map.
-   *
-   * The default value of `min_load_factor` is 0.0f, the map never shrinks by
-   * default.
-   */
-  void min_load_factor(float ml) { m_ht.min_load_factor(ml); }
-  void max_load_factor(float ml) { m_ht.max_load_factor(ml); }
-
-  void rehash(size_type count_) { m_ht.rehash(count_); }
-  void reserve(size_type count_) { m_ht.reserve(count_); }
-
-  /*
-   * Observers
-   */
-  hasher hash_function() const { return m_ht.hash_function(); }
-  key_equal key_eq() const { return m_ht.key_eq(); }
-
-  /*
-   * Other
-   */
-
-  /**
-   * Convert a const_iterator to an iterator.
-   */
-  iterator mutable_iterator(const_iterator pos) {
-    return m_ht.mutable_iterator(pos);
-  }
-
-  /**
-   * Serialize the map through the `serializer` parameter.
-   *
-   * The `serializer` parameter must be a function object that supports the
-   * following call:
-   *  - `template<typename U> void operator()(const U& value);` where the types
-   * `std::int16_t`, `std::uint32_t`, `std::uint64_t`, `float` and
-   * `std::pair<Key, T>` must be supported for U.
-   *
-   * The implementation leaves binary compatibility (endianness, IEEE 754 for
-   * floats, ...) of the types it serializes in the hands of the `Serializer`
-   * function object if compatibility is required.
-   */
-  template <class Serializer>
-  void serialize(Serializer& serializer) const {
-    m_ht.serialize(serializer);
-  }
-
-  /**
-   * Deserialize a previously serialized map through the `deserializer`
-   * parameter.
-   *
-   * The `deserializer` parameter must be a function object that supports the
-   * following call:
-   *  - `template<typename U> U operator()();` where the types `std::int16_t`,
-   * `std::uint32_t`, `std::uint64_t`, `float` and `std::pair<Key, T>` must be
-   * supported for U.
-   *
-   * If the deserialized hash map type is hash compatible with the serialized
-   * map, the deserialization process can be sped up by setting
-   * `hash_compatible` to true. To be hash compatible, the Hash, KeyEqual and
-   * GrowthPolicy must behave the same way than the ones used on the serialized
-   * map and the StoreHash must have the same value. The `std::size_t` must also
-   * be of the same size as the one on the platform used to serialize the map.
-   * If these criteria are not met, the behaviour is undefined with
-   * `hash_compatible` sets to true.
-   *
-   * The behaviour is undefined if the type `Key` and `T` of the `robin_map` are
-   * not the same as the types used during serialization.
-   *
-   * The implementation leaves binary compatibility (endianness, IEEE 754 for
-   * floats, size of int, ...) of the types it deserializes in the hands of the
-   * `Deserializer` function object if compatibility is required.
-   */
-  template <class Deserializer>
-  static robin_map deserialize(Deserializer& deserializer,
-                               bool hash_compatible = false) {
-    robin_map map(0);
-    map.m_ht.deserialize(deserializer, hash_compatible);
-
-    return map;
-  }
-
-  friend bool operator==(const robin_map& lhs, const robin_map& rhs) {
-    if (lhs.size() != rhs.size()) {
-      return false;
-    }
-
-    for (const auto& element_lhs : lhs) {
-      const auto it_element_rhs = rhs.find(element_lhs.first);
-      if (it_element_rhs == rhs.cend() ||
-          element_lhs.second != it_element_rhs->second) {
-        return false;
-      }
-    }
-
-    return true;
-  }
-
-  friend bool operator!=(const robin_map& lhs, const robin_map& rhs) {
-    return !operator==(lhs, rhs);
-  }
-
-  friend void swap(robin_map& lhs, robin_map& rhs) { lhs.swap(rhs); }
-
- private:
-  ht m_ht;
-};
-
-/**
- * Same as `tsl::robin_map<Key, T, Hash, KeyEqual, Allocator, StoreHash,
- * tsl::rh::prime_growth_policy>`.
- */
-template <class Key, class T, class Hash = std::hash<Key>,
-          class KeyEqual = std::equal_to<Key>,
-          class Allocator = std::allocator<std::pair<Key, T>>,
-          bool StoreHash = false>
-using robin_pg_map = robin_map<Key, T, Hash, KeyEqual, Allocator, StoreHash,
-                               tsl::rh::prime_growth_policy>;
-
-}  // end namespace tsl
-
-#endif
diff --git a/src/nanobind/ext/robin_map/include/tsl/robin_set.h b/src/nanobind/ext/robin_map/include/tsl/robin_set.h
deleted file mode 100644
index e115007..0000000
--- a/src/nanobind/ext/robin_map/include/tsl/robin_set.h
+++ /dev/null
@@ -1,668 +0,0 @@
-/**
- * MIT License
- *
- * Copyright (c) 2017 Thibaut Goetghebuer-Planchon <tessil@gmx.com>
- *
- * 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.
- */
-#ifndef TSL_ROBIN_SET_H
-#define TSL_ROBIN_SET_H
-
-#include <cstddef>
-#include <functional>
-#include <initializer_list>
-#include <memory>
-#include <type_traits>
-#include <utility>
-
-#include "robin_hash.h"
-
-namespace tsl {
-
-/**
- * Implementation of a hash set using open-addressing and the robin hood hashing
- * algorithm with backward shift deletion.
- *
- * For operations modifying the hash set (insert, erase, rehash, ...), the
- * strong exception guarantee is only guaranteed when the expression
- * `std::is_nothrow_swappable<Key>::value &&
- * std::is_nothrow_move_constructible<Key>::value` is true, otherwise if an
- * exception is thrown during the swap or the move, the hash set may end up in a
- * undefined state. Per the standard a `Key` with a noexcept copy constructor
- * and no move constructor also satisfies the
- * `std::is_nothrow_move_constructible<Key>::value` criterion (and will thus
- * guarantee the strong exception for the set).
- *
- * When `StoreHash` is true, 32 bits of the hash are stored alongside the
- * values. It can improve the performance during lookups if the `KeyEqual`
- * function takes time (or engenders a cache-miss for example) as we then
- * compare the stored hashes before comparing the keys. When
- * `tsl::rh::power_of_two_growth_policy` is used as `GrowthPolicy`, it may also
- * speed-up the rehash process as we can avoid to recalculate the hash. When it
- * is detected that storing the hash will not incur any memory penalty due to
- * alignment (i.e. `sizeof(tsl::detail_robin_hash::bucket_entry<ValueType,
- * true>) == sizeof(tsl::detail_robin_hash::bucket_entry<ValueType, false>)`)
- * and `tsl::rh::power_of_two_growth_policy` is used, the hash will be stored
- * even if `StoreHash` is false so that we can speed-up the rehash (but it will
- * not be used on lookups unless `StoreHash` is true).
- *
- * `GrowthPolicy` defines how the set grows and consequently how a hash value is
- * mapped to a bucket. By default the set uses
- * `tsl::rh::power_of_two_growth_policy`. This policy keeps the number of
- * buckets to a power of two and uses a mask to set the hash to a bucket instead
- * of the slow modulo. Other growth policies are available and you may define
- * your own growth policy, check `tsl::rh::power_of_two_growth_policy` for the
- * interface.
- *
- * `Key` must be swappable.
- *
- * `Key` must be copy and/or move constructible.
- *
- * If the destructor of `Key` throws an exception, the behaviour of the class is
- * undefined.
- *
- * Iterators invalidation:
- *  - clear, operator=, reserve, rehash: always invalidate the iterators.
- *  - insert, emplace, emplace_hint, operator[]: if there is an effective
- * insert, invalidate the iterators.
- *  - erase: always invalidate the iterators.
- */
-template <class Key, class Hash = std::hash<Key>,
-          class KeyEqual = std::equal_to<Key>,
-          class Allocator = std::allocator<Key>, bool StoreHash = false,
-          class GrowthPolicy = tsl::rh::power_of_two_growth_policy<2>>
-class robin_set {
- private:
-  template <typename U>
-  using has_is_transparent = tsl::detail_robin_hash::has_is_transparent<U>;
-
-  class KeySelect {
-   public:
-    using key_type = Key;
-
-    const key_type& operator()(const Key& key) const noexcept { return key; }
-
-    key_type& operator()(Key& key) noexcept { return key; }
-  };
-
-  using ht = detail_robin_hash::robin_hash<Key, KeySelect, void, Hash, KeyEqual,
-                                           Allocator, StoreHash, GrowthPolicy>;
-
- public:
-  using key_type = typename ht::key_type;
-  using value_type = typename ht::value_type;
-  using size_type = typename ht::size_type;
-  using difference_type = typename ht::difference_type;
-  using hasher = typename ht::hasher;
-  using key_equal = typename ht::key_equal;
-  using allocator_type = typename ht::allocator_type;
-  using reference = typename ht::reference;
-  using const_reference = typename ht::const_reference;
-  using pointer = typename ht::pointer;
-  using const_pointer = typename ht::const_pointer;
-  using iterator = typename ht::iterator;
-  using const_iterator = typename ht::const_iterator;
-
-  /*
-   * Constructors
-   */
-  robin_set() : robin_set(ht::DEFAULT_INIT_BUCKETS_SIZE) {}
-
-  explicit robin_set(size_type bucket_count, const Hash& hash = Hash(),
-                     const KeyEqual& equal = KeyEqual(),
-                     const Allocator& alloc = Allocator())
-      : m_ht(bucket_count, hash, equal, alloc) {}
-
-  robin_set(size_type bucket_count, const Allocator& alloc)
-      : robin_set(bucket_count, Hash(), KeyEqual(), alloc) {}
-
-  robin_set(size_type bucket_count, const Hash& hash, const Allocator& alloc)
-      : robin_set(bucket_count, hash, KeyEqual(), alloc) {}
-
-  explicit robin_set(const Allocator& alloc)
-      : robin_set(ht::DEFAULT_INIT_BUCKETS_SIZE, alloc) {}
-
-  template <class InputIt>
-  robin_set(InputIt first, InputIt last,
-            size_type bucket_count = ht::DEFAULT_INIT_BUCKETS_SIZE,
-            const Hash& hash = Hash(), const KeyEqual& equal = KeyEqual(),
-            const Allocator& alloc = Allocator())
-      : robin_set(bucket_count, hash, equal, alloc) {
-    insert(first, last);
-  }
-
-  template <class InputIt>
-  robin_set(InputIt first, InputIt last, size_type bucket_count,
-            const Allocator& alloc)
-      : robin_set(first, last, bucket_count, Hash(), KeyEqual(), alloc) {}
-
-  template <class InputIt>
-  robin_set(InputIt first, InputIt last, size_type bucket_count,
-            const Hash& hash, const Allocator& alloc)
-      : robin_set(first, last, bucket_count, hash, KeyEqual(), alloc) {}
-
-  robin_set(std::initializer_list<value_type> init,
-            size_type bucket_count = ht::DEFAULT_INIT_BUCKETS_SIZE,
-            const Hash& hash = Hash(), const KeyEqual& equal = KeyEqual(),
-            const Allocator& alloc = Allocator())
-      : robin_set(init.begin(), init.end(), bucket_count, hash, equal, alloc) {}
-
-  robin_set(std::initializer_list<value_type> init, size_type bucket_count,
-            const Allocator& alloc)
-      : robin_set(init.begin(), init.end(), bucket_count, Hash(), KeyEqual(),
-                  alloc) {}
-
-  robin_set(std::initializer_list<value_type> init, size_type bucket_count,
-            const Hash& hash, const Allocator& alloc)
-      : robin_set(init.begin(), init.end(), bucket_count, hash, KeyEqual(),
-                  alloc) {}
-
-  robin_set& operator=(std::initializer_list<value_type> ilist) {
-    m_ht.clear();
-
-    m_ht.reserve(ilist.size());
-    m_ht.insert(ilist.begin(), ilist.end());
-
-    return *this;
-  }
-
-  allocator_type get_allocator() const { return m_ht.get_allocator(); }
-
-  /*
-   * Iterators
-   */
-  iterator begin() noexcept { return m_ht.begin(); }
-  const_iterator begin() const noexcept { return m_ht.begin(); }
-  const_iterator cbegin() const noexcept { return m_ht.cbegin(); }
-
-  iterator end() noexcept { return m_ht.end(); }
-  const_iterator end() const noexcept { return m_ht.end(); }
-  const_iterator cend() const noexcept { return m_ht.cend(); }
-
-  /*
-   * Capacity
-   */
-  bool empty() const noexcept { return m_ht.empty(); }
-  size_type size() const noexcept { return m_ht.size(); }
-  size_type max_size() const noexcept { return m_ht.max_size(); }
-
-  /*
-   * Modifiers
-   */
-  void clear() noexcept { m_ht.clear(); }
-
-  std::pair<iterator, bool> insert(const value_type& value) {
-    return m_ht.insert(value);
-  }
-
-  std::pair<iterator, bool> insert(value_type&& value) {
-    return m_ht.insert(std::move(value));
-  }
-
-  iterator insert(const_iterator hint, const value_type& value) {
-    return m_ht.insert_hint(hint, value);
-  }
-
-  iterator insert(const_iterator hint, value_type&& value) {
-    return m_ht.insert_hint(hint, std::move(value));
-  }
-
-  template <class InputIt>
-  void insert(InputIt first, InputIt last) {
-    m_ht.insert(first, last);
-  }
-
-  void insert(std::initializer_list<value_type> ilist) {
-    m_ht.insert(ilist.begin(), ilist.end());
-  }
-
-  /**
-   * Due to the way elements are stored, emplace will need to move or copy the
-   * key-value once. The method is equivalent to
-   * insert(value_type(std::forward<Args>(args)...));
-   *
-   * Mainly here for compatibility with the std::unordered_map interface.
-   */
-  template <class... Args>
-  std::pair<iterator, bool> emplace(Args&&... args) {
-    return m_ht.emplace(std::forward<Args>(args)...);
-  }
-
-  /**
-   * Due to the way elements are stored, emplace_hint will need to move or copy
-   * the key-value once. The method is equivalent to insert(hint,
-   * value_type(std::forward<Args>(args)...));
-   *
-   * Mainly here for compatibility with the std::unordered_map interface.
-   */
-  template <class... Args>
-  iterator emplace_hint(const_iterator hint, Args&&... args) {
-    return m_ht.emplace_hint(hint, std::forward<Args>(args)...);
-  }
-
-  iterator erase(iterator pos) { return m_ht.erase(pos); }
-  iterator erase(const_iterator pos) { return m_ht.erase(pos); }
-  iterator erase(const_iterator first, const_iterator last) {
-    return m_ht.erase(first, last);
-  }
-  size_type erase(const key_type& key) { return m_ht.erase(key); }
-
-  /**
-   * Erase the element at position 'pos'. In contrast to the regular erase()
-   * function, erase_fast() does not return an iterator. This allows it to be
-   * faster especially in hash sets with a low load factor, where finding the
-   * next nonempty bucket would be costly.
-   */
-  void erase_fast(iterator pos) { return m_ht.erase_fast(pos); }
-
-  /**
-   * Use the hash value 'precalculated_hash' instead of hashing the key. The
-   * hash value should be the same as hash_function()(key). Useful to speed-up
-   * the lookup to the value if you already have the hash.
-   */
-  size_type erase(const key_type& key, std::size_t precalculated_hash) {
-    return m_ht.erase(key, precalculated_hash);
-  }
-
-  /**
-   * This overload only participates in the overload resolution if the typedef
-   * KeyEqual::is_transparent exists. If so, K must be hashable and comparable
-   * to Key.
-   */
-  template <
-      class K, class KE = KeyEqual,
-      typename std::enable_if<has_is_transparent<KE>::value>::type* = nullptr>
-  size_type erase(const K& key) {
-    return m_ht.erase(key);
-  }
-
-  /**
-   * @copydoc erase(const K& key)
-   *
-   * Use the hash value 'precalculated_hash' instead of hashing the key. The
-   * hash value should be the same as hash_function()(key). Useful to speed-up
-   * the lookup to the value if you already have the hash.
-   */
-  template <
-      class K, class KE = KeyEqual,
-      typename std::enable_if<has_is_transparent<KE>::value>::type* = nullptr>
-  size_type erase(const K& key, std::size_t precalculated_hash) {
-    return m_ht.erase(key, precalculated_hash);
-  }
-
-  void swap(robin_set& other) { other.m_ht.swap(m_ht); }
-
-  /*
-   * Lookup
-   */
-  size_type count(const Key& key) const { return m_ht.count(key); }
-
-  /**
-   * Use the hash value 'precalculated_hash' instead of hashing the key. The
-   * hash value should be the same as hash_function()(key). Useful to speed-up
-   * the lookup if you already have the hash.
-   */
-  size_type count(const Key& key, std::size_t precalculated_hash) const {
-    return m_ht.count(key, precalculated_hash);
-  }
-
-  /**
-   * This overload only participates in the overload resolution if the typedef
-   * KeyEqual::is_transparent exists. If so, K must be hashable and comparable
-   * to Key.
-   */
-  template <
-      class K, class KE = KeyEqual,
-      typename std::enable_if<has_is_transparent<KE>::value>::type* = nullptr>
-  size_type count(const K& key) const {
-    return m_ht.count(key);
-  }
-
-  /**
-   * @copydoc count(const K& key) const
-   *
-   * Use the hash value 'precalculated_hash' instead of hashing the key. The
-   * hash value should be the same as hash_function()(key). Useful to speed-up
-   * the lookup if you already have the hash.
-   */
-  template <
-      class K, class KE = KeyEqual,
-      typename std::enable_if<has_is_transparent<KE>::value>::type* = nullptr>
-  size_type count(const K& key, std::size_t precalculated_hash) const {
-    return m_ht.count(key, precalculated_hash);
-  }
-
-  iterator find(const Key& key) { return m_ht.find(key); }
-
-  /**
-   * Use the hash value 'precalculated_hash' instead of hashing the key. The
-   * hash value should be the same as hash_function()(key). Useful to speed-up
-   * the lookup if you already have the hash.
-   */
-  iterator find(const Key& key, std::size_t precalculated_hash) {
-    return m_ht.find(key, precalculated_hash);
-  }
-
-  const_iterator find(const Key& key) const { return m_ht.find(key); }
-
-  /**
-   * @copydoc find(const Key& key, std::size_t precalculated_hash)
-   */
-  const_iterator find(const Key& key, std::size_t precalculated_hash) const {
-    return m_ht.find(key, precalculated_hash);
-  }
-
-  /**
-   * This overload only participates in the overload resolution if the typedef
-   * KeyEqual::is_transparent exists. If so, K must be hashable and comparable
-   * to Key.
-   */
-  template <
-      class K, class KE = KeyEqual,
-      typename std::enable_if<has_is_transparent<KE>::value>::type* = nullptr>
-  iterator find(const K& key) {
-    return m_ht.find(key);
-  }
-
-  /**
-   * @copydoc find(const K& key)
-   *
-   * Use the hash value 'precalculated_hash' instead of hashing the key. The
-   * hash value should be the same as hash_function()(key). Useful to speed-up
-   * the lookup if you already have the hash.
-   */
-  template <
-      class K, class KE = KeyEqual,
-      typename std::enable_if<has_is_transparent<KE>::value>::type* = nullptr>
-  iterator find(const K& key, std::size_t precalculated_hash) {
-    return m_ht.find(key, precalculated_hash);
-  }
-
-  /**
-   * @copydoc find(const K& key)
-   */
-  template <
-      class K, class KE = KeyEqual,
-      typename std::enable_if<has_is_transparent<KE>::value>::type* = nullptr>
-  const_iterator find(const K& key) const {
-    return m_ht.find(key);
-  }
-
-  /**
-   * @copydoc find(const K& key)
-   *
-   * Use the hash value 'precalculated_hash' instead of hashing the key. The
-   * hash value should be the same as hash_function()(key). Useful to speed-up
-   * the lookup if you already have the hash.
-   */
-  template <
-      class K, class KE = KeyEqual,
-      typename std::enable_if<has_is_transparent<KE>::value>::type* = nullptr>
-  const_iterator find(const K& key, std::size_t precalculated_hash) const {
-    return m_ht.find(key, precalculated_hash);
-  }
-
-  bool contains(const Key& key) const { return m_ht.contains(key); }
-
-  /**
-   * Use the hash value 'precalculated_hash' instead of hashing the key. The
-   * hash value should be the same as hash_function()(key). Useful to speed-up
-   * the lookup if you already have the hash.
-   */
-  bool contains(const Key& key, std::size_t precalculated_hash) const {
-    return m_ht.contains(key, precalculated_hash);
-  }
-
-  /**
-   * This overload only participates in the overload resolution if the typedef
-   * KeyEqual::is_transparent exists. If so, K must be hashable and comparable
-   * to Key.
-   */
-  template <
-      class K, class KE = KeyEqual,
-      typename std::enable_if<has_is_transparent<KE>::value>::type* = nullptr>
-  bool contains(const K& key) const {
-    return m_ht.contains(key);
-  }
-
-  /**
-   * @copydoc contains(const K& key) const
-   *
-   * Use the hash value 'precalculated_hash' instead of hashing the key. The
-   * hash value should be the same as hash_function()(key). Useful to speed-up
-   * the lookup if you already have the hash.
-   */
-  template <
-      class K, class KE = KeyEqual,
-      typename std::enable_if<has_is_transparent<KE>::value>::type* = nullptr>
-  bool contains(const K& key, std::size_t precalculated_hash) const {
-    return m_ht.contains(key, precalculated_hash);
-  }
-
-  std::pair<iterator, iterator> equal_range(const Key& key) {
-    return m_ht.equal_range(key);
-  }
-
-  /**
-   * Use the hash value 'precalculated_hash' instead of hashing the key. The
-   * hash value should be the same as hash_function()(key). Useful to speed-up
-   * the lookup if you already have the hash.
-   */
-  std::pair<iterator, iterator> equal_range(const Key& key,
-                                            std::size_t precalculated_hash) {
-    return m_ht.equal_range(key, precalculated_hash);
-  }
-
-  std::pair<const_iterator, const_iterator> equal_range(const Key& key) const {
-    return m_ht.equal_range(key);
-  }
-
-  /**
-   * @copydoc equal_range(const Key& key, std::size_t precalculated_hash)
-   */
-  std::pair<const_iterator, const_iterator> equal_range(
-      const Key& key, std::size_t precalculated_hash) const {
-    return m_ht.equal_range(key, precalculated_hash);
-  }
-
-  /**
-   * This overload only participates in the overload resolution if the typedef
-   * KeyEqual::is_transparent exists. If so, K must be hashable and comparable
-   * to Key.
-   */
-  template <
-      class K, class KE = KeyEqual,
-      typename std::enable_if<has_is_transparent<KE>::value>::type* = nullptr>
-  std::pair<iterator, iterator> equal_range(const K& key) {
-    return m_ht.equal_range(key);
-  }
-
-  /**
-   * @copydoc equal_range(const K& key)
-   *
-   * Use the hash value 'precalculated_hash' instead of hashing the key. The
-   * hash value should be the same as hash_function()(key). Useful to speed-up
-   * the lookup if you already have the hash.
-   */
-  template <
-      class K, class KE = KeyEqual,
-      typename std::enable_if<has_is_transparent<KE>::value>::type* = nullptr>
-  std::pair<iterator, iterator> equal_range(const K& key,
-                                            std::size_t precalculated_hash) {
-    return m_ht.equal_range(key, precalculated_hash);
-  }
-
-  /**
-   * @copydoc equal_range(const K& key)
-   */
-  template <
-      class K, class KE = KeyEqual,
-      typename std::enable_if<has_is_transparent<KE>::value>::type* = nullptr>
-  std::pair<const_iterator, const_iterator> equal_range(const K& key) const {
-    return m_ht.equal_range(key);
-  }
-
-  /**
-   * @copydoc equal_range(const K& key, std::size_t precalculated_hash)
-   */
-  template <
-      class K, class KE = KeyEqual,
-      typename std::enable_if<has_is_transparent<KE>::value>::type* = nullptr>
-  std::pair<const_iterator, const_iterator> equal_range(
-      const K& key, std::size_t precalculated_hash) const {
-    return m_ht.equal_range(key, precalculated_hash);
-  }
-
-  /*
-   * Bucket interface
-   */
-  size_type bucket_count() const { return m_ht.bucket_count(); }
-  size_type max_bucket_count() const { return m_ht.max_bucket_count(); }
-
-  /*
-   *  Hash policy
-   */
-  float load_factor() const { return m_ht.load_factor(); }
-
-  float min_load_factor() const { return m_ht.min_load_factor(); }
-  float max_load_factor() const { return m_ht.max_load_factor(); }
-
-  /**
-   * Set the `min_load_factor` to `ml`. When the `load_factor` of the set goes
-   * below `min_load_factor` after some erase operations, the set will be
-   * shrunk when an insertion occurs. The erase method itself never shrinks
-   * the set.
-   *
-   * The default value of `min_load_factor` is 0.0f, the set never shrinks by
-   * default.
-   */
-  void min_load_factor(float ml) { m_ht.min_load_factor(ml); }
-  void max_load_factor(float ml) { m_ht.max_load_factor(ml); }
-
-  void rehash(size_type count_) { m_ht.rehash(count_); }
-  void reserve(size_type count_) { m_ht.reserve(count_); }
-
-  /*
-   * Observers
-   */
-  hasher hash_function() const { return m_ht.hash_function(); }
-  key_equal key_eq() const { return m_ht.key_eq(); }
-
-  /*
-   * Other
-   */
-
-  /**
-   * Convert a const_iterator to an iterator.
-   */
-  iterator mutable_iterator(const_iterator pos) {
-    return m_ht.mutable_iterator(pos);
-  }
-
-  friend bool operator==(const robin_set& lhs, const robin_set& rhs) {
-    if (lhs.size() != rhs.size()) {
-      return false;
-    }
-
-    for (const auto& element_lhs : lhs) {
-      const auto it_element_rhs = rhs.find(element_lhs);
-      if (it_element_rhs == rhs.cend()) {
-        return false;
-      }
-    }
-
-    return true;
-  }
-
-  /**
-   * Serialize the set through the `serializer` parameter.
-   *
-   * The `serializer` parameter must be a function object that supports the
-   * following call:
-   *  - `template<typename U> void operator()(const U& value);` where the types
-   * `std::int16_t`, `std::uint32_t`, `std::uint64_t`, `float` and `Key` must be
-   * supported for U.
-   *
-   * The implementation leaves binary compatibility (endianness, IEEE 754 for
-   * floats, ...) of the types it serializes in the hands of the `Serializer`
-   * function object if compatibility is required.
-   */
-  template <class Serializer>
-  void serialize(Serializer& serializer) const {
-    m_ht.serialize(serializer);
-  }
-
-  /**
-   * Deserialize a previously serialized set through the `deserializer`
-   * parameter.
-   *
-   * The `deserializer` parameter must be a function object that supports the
-   * following call:
-   *  - `template<typename U> U operator()();` where the types `std::int16_t`,
-   * `std::uint32_t`, `std::uint64_t`, `float` and `Key` must be supported for
-   * U.
-   *
-   * If the deserialized hash set type is hash compatible with the serialized
-   * set, the deserialization process can be sped up by setting
-   * `hash_compatible` to true. To be hash compatible, the Hash, KeyEqual and
-   * GrowthPolicy must behave the same way than the ones used on the serialized
-   * set and the StoreHash must have the same value. The `std::size_t` must also
-   * be of the same size as the one on the platform used to serialize the set.
-   * If these criteria are not met, the behaviour is undefined with
-   * `hash_compatible` sets to true.
-   *
-   * The behaviour is undefined if the type `Key` of the `robin_set` is not the
-   * same as the type used during serialization.
-   *
-   * The implementation leaves binary compatibility (endianness, IEEE 754 for
-   * floats, size of int, ...) of the types it deserializes in the hands of the
-   * `Deserializer` function object if compatibility is required.
-   */
-  template <class Deserializer>
-  static robin_set deserialize(Deserializer& deserializer,
-                               bool hash_compatible = false) {
-    robin_set set(0);
-    set.m_ht.deserialize(deserializer, hash_compatible);
-
-    return set;
-  }
-
-  friend bool operator!=(const robin_set& lhs, const robin_set& rhs) {
-    return !operator==(lhs, rhs);
-  }
-
-  friend void swap(robin_set& lhs, robin_set& rhs) { lhs.swap(rhs); }
-
- private:
-  ht m_ht;
-};
-
-/**
- * Same as `tsl::robin_set<Key, Hash, KeyEqual, Allocator, StoreHash,
- * tsl::rh::prime_growth_policy>`.
- */
-template <class Key, class Hash = std::hash<Key>,
-          class KeyEqual = std::equal_to<Key>,
-          class Allocator = std::allocator<Key>, bool StoreHash = false>
-using robin_pg_set = robin_set<Key, Hash, KeyEqual, Allocator, StoreHash,
-                               tsl::rh::prime_growth_policy>;
-
-}  // end namespace tsl
-
-#endif
diff --git a/src/nanobind/ext/robin_map/tests/CMakeLists.txt b/src/nanobind/ext/robin_map/tests/CMakeLists.txt
deleted file mode 100644
index 6d3bbcd..0000000
--- a/src/nanobind/ext/robin_map/tests/CMakeLists.txt
+++ /dev/null
@@ -1,26 +0,0 @@
-cmake_minimum_required(VERSION 3.8)
-
-project(tsl_robin_map_tests)
-
-add_executable(tsl_robin_map_tests "main.cpp" 
-                                   "custom_allocator_tests.cpp"
-                                   "policy_tests.cpp"
-                                   "robin_map_tests.cpp" 
-                                   "robin_set_tests.cpp")
-
-target_compile_features(tsl_robin_map_tests PRIVATE cxx_std_17)
-                                    
-if(CMAKE_CXX_COMPILER_ID MATCHES "Clang" OR CMAKE_CXX_COMPILER_ID MATCHES "GNU")
-    target_compile_options(tsl_robin_map_tests PRIVATE -Werror -Wall -Wextra -Wold-style-cast -DTSL_DEBUG -UNDEBUG)
-elseif(CMAKE_CXX_COMPILER_ID MATCHES "MSVC")
-    target_compile_options(tsl_robin_map_tests PRIVATE /bigobj /WX /W3 /DTSL_DEBUG /UNDEBUG)
-endif()
-
-# Boost::unit_test_framework
-set(Boost_USE_STATIC_LIBS ON)
-find_package(Boost REQUIRED COMPONENTS unit_test_framework)
-target_link_libraries(tsl_robin_map_tests PRIVATE Boost::unit_test_framework)   
-
-# tsl::robin_map
-add_subdirectory(../ ${CMAKE_CURRENT_BINARY_DIR}/tsl)
-target_link_libraries(tsl_robin_map_tests PRIVATE tsl::robin_map)  
diff --git a/src/nanobind/ext/robin_map/tests/custom_allocator_tests.cpp b/src/nanobind/ext/robin_map/tests/custom_allocator_tests.cpp
deleted file mode 100644
index 4ee18ee..0000000
--- a/src/nanobind/ext/robin_map/tests/custom_allocator_tests.cpp
+++ /dev/null
@@ -1,138 +0,0 @@
-/**
- * MIT License
- *
- * Copyright (c) 2017 Thibaut Goetghebuer-Planchon <tessil@gmx.com>
- *
- * 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.
- */
-#include <tsl/robin_map.h>
-
-#include <boost/test/unit_test.hpp>
-#include <cstddef>
-#include <cstdlib>
-#include <functional>
-#include <limits>
-#include <stdexcept>
-#include <type_traits>
-#include <utility>
-
-#include "utils.h"
-
-static std::size_t nb_custom_allocs = 0;
-
-template <typename T>
-class custom_allocator {
- public:
-  using value_type = T;
-  using pointer = T*;
-  using const_pointer = const T*;
-  using reference = T&;
-  using const_reference = const T&;
-  using size_type = std::size_t;
-  using difference_type = std::ptrdiff_t;
-  using propagate_on_container_move_assignment = std::true_type;
-
-  template <typename U>
-  struct rebind {
-    using other = custom_allocator<U>;
-  };
-
-  custom_allocator() = default;
-  custom_allocator(const custom_allocator&) = default;
-
-  template <typename U>
-  custom_allocator(const custom_allocator<U>&) {}
-
-  pointer address(reference x) const noexcept { return &x; }
-
-  const_pointer address(const_reference x) const noexcept { return &x; }
-
-  pointer allocate(size_type n, const void* /*hint*/ = 0) {
-    nb_custom_allocs++;
-
-    pointer ptr = static_cast<pointer>(std::malloc(n * sizeof(T)));
-    if (ptr == nullptr) {
-#ifdef TSL_RH_NO_EXCEPTIONS
-      std::abort();
-#else
-      throw std::bad_alloc();
-#endif
-    }
-
-    return ptr;
-  }
-
-  void deallocate(T* p, size_type /*n*/) { std::free(p); }
-
-  size_type max_size() const noexcept {
-    return std::numeric_limits<size_type>::max() / sizeof(value_type);
-  }
-
-  template <typename U, typename... Args>
-  void construct(U* p, Args&&... args) {
-    ::new (static_cast<void*>(p)) U(std::forward<Args>(args)...);
-  }
-
-  template <typename U>
-  void destroy(U* p) {
-    p->~U();
-  }
-};
-
-template <class T, class U>
-bool operator==(const custom_allocator<T>&, const custom_allocator<U>&) {
-  return true;
-}
-
-template <class T, class U>
-bool operator!=(const custom_allocator<T>&, const custom_allocator<U>&) {
-  return false;
-}
-
-// TODO Avoid overloading new to check number of global new
-// static std::size_t nb_global_new = 0;
-// void* operator new(std::size_t sz) {
-//     nb_global_new++;
-//     return std::malloc(sz);
-// }
-//
-// void operator delete(void* ptr) noexcept {
-//     std::free(ptr);
-// }
-
-BOOST_AUTO_TEST_SUITE(test_custom_allocator)
-
-BOOST_AUTO_TEST_CASE(test_custom_allocator_1) {
-  //    nb_global_new = 0;
-  nb_custom_allocs = 0;
-
-  tsl::robin_map<int, int, std::hash<int>, std::equal_to<int>,
-                 custom_allocator<std::pair<int, int>>>
-      map;
-
-  const int nb_elements = 1000;
-  for (int i = 0; i < nb_elements; i++) {
-    map.insert({i, i * 2});
-  }
-
-  BOOST_CHECK_NE(nb_custom_allocs, 0);
-  //    BOOST_CHECK_EQUAL(nb_global_new, 0);
-}
-
-BOOST_AUTO_TEST_SUITE_END()
diff --git a/src/nanobind/ext/robin_map/tests/main.cpp b/src/nanobind/ext/robin_map/tests/main.cpp
deleted file mode 100644
index e33a020..0000000
--- a/src/nanobind/ext/robin_map/tests/main.cpp
+++ /dev/null
@@ -1,26 +0,0 @@
-/**
- * MIT License
- *
- * Copyright (c) 2017 Thibaut Goetghebuer-Planchon <tessil@gmx.com>
- *
- * 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.
- */
-#define BOOST_TEST_MODULE robin_map_tests
-
-#include <boost/test/unit_test.hpp>
\ No newline at end of file
diff --git a/src/nanobind/ext/robin_map/tests/policy_tests.cpp b/src/nanobind/ext/robin_map/tests/policy_tests.cpp
deleted file mode 100644
index 798a22d..0000000
--- a/src/nanobind/ext/robin_map/tests/policy_tests.cpp
+++ /dev/null
@@ -1,97 +0,0 @@
-/**
- * MIT License
- *
- * Copyright (c) 2017 Thibaut Goetghebuer-Planchon <tessil@gmx.com>
- *
- * 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.
- */
-#include <tsl/robin_growth_policy.h>
-
-#include <boost/mpl/list.hpp>
-#include <boost/test/unit_test.hpp>
-#include <cstddef>
-#include <limits>
-#include <ratio>
-#include <stdexcept>
-
-#include "utils.h"
-
-BOOST_AUTO_TEST_SUITE(test_policy)
-
-using test_types =
-    boost::mpl::list<tsl::rh::power_of_two_growth_policy<2>,
-                     tsl::rh::power_of_two_growth_policy<4>,
-                     tsl::rh::prime_growth_policy, tsl::rh::mod_growth_policy<>,
-                     tsl::rh::mod_growth_policy<std::ratio<7, 2>>>;
-
-BOOST_AUTO_TEST_CASE_TEMPLATE(test_policy, Policy, test_types) {
-  // Call next_bucket_count() on the policy until we reach its
-  // max_bucket_count()
-  std::size_t bucket_count = 0;
-  Policy policy(bucket_count);
-
-  BOOST_CHECK_EQUAL(policy.bucket_for_hash(0), 0);
-  BOOST_CHECK_EQUAL(bucket_count, 0);
-
-#ifndef TSL_RH_NO_EXCEPTIONS
-  bool exception_thrown = false;
-  try {
-    while (true) {
-      const std::size_t previous_bucket_count = bucket_count;
-
-      bucket_count = policy.next_bucket_count();
-      policy = Policy(bucket_count);
-
-      BOOST_CHECK_EQUAL(policy.bucket_for_hash(0), 0);
-      BOOST_CHECK(bucket_count > previous_bucket_count);
-    }
-  } catch (const std::length_error&) {
-    exception_thrown = true;
-  }
-
-  BOOST_CHECK(exception_thrown);
-#endif
-}
-
-BOOST_AUTO_TEST_CASE_TEMPLATE(test_policy_min_bucket_count, Policy,
-                              test_types) {
-  // Check policy when a bucket_count of 0 is asked.
-  std::size_t bucket_count = 0;
-  Policy policy(bucket_count);
-
-  BOOST_CHECK_EQUAL(policy.bucket_for_hash(0), 0);
-}
-
-BOOST_AUTO_TEST_CASE_TEMPLATE(test_policy_max_bucket_count, Policy,
-                              test_types) {
-  // Test a bucket_count equals to the max_bucket_count limit and above
-  std::size_t bucket_count = 0;
-  Policy policy(bucket_count);
-
-  bucket_count = policy.max_bucket_count();
-  Policy policy2(bucket_count);
-
-  bucket_count = std::numeric_limits<std::size_t>::max();
-  TSL_RH_CHECK_THROW((Policy(bucket_count)), std::length_error);
-
-  bucket_count = policy.max_bucket_count() + 1;
-  TSL_RH_CHECK_THROW((Policy(bucket_count)), std::length_error);
-}
-
-BOOST_AUTO_TEST_SUITE_END()
diff --git a/src/nanobind/ext/robin_map/tests/robin_map_tests.cpp b/src/nanobind/ext/robin_map/tests/robin_map_tests.cpp
deleted file mode 100644
index 68398e2..0000000
--- a/src/nanobind/ext/robin_map/tests/robin_map_tests.cpp
+++ /dev/null
@@ -1,1462 +0,0 @@
-/**
- * MIT License
- *
- * Copyright (c) 2017 Thibaut Goetghebuer-Planchon <tessil@gmx.com>
- *
- * 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.
- */
-#include <tsl/robin_map.h>
-
-#include <boost/mpl/list.hpp>
-#include <boost/test/unit_test.hpp>
-#include <cstddef>
-#include <cstdint>
-#include <functional>
-#include <iterator>
-#include <memory>
-#include <stdexcept>
-#include <string>
-#include <tuple>
-#include <type_traits>
-#include <utility>
-#include <vector>
-
-#include "utils.h"
-
-BOOST_AUTO_TEST_SUITE(test_robin_map)
-
-using test_types = boost::mpl::list<
-    tsl::robin_map<std::int64_t, std::int64_t>,
-    tsl::robin_map<std::string, std::string>,
-    // Test with hash having a lot of collisions
-    tsl::robin_map<std::int64_t, std::int64_t, mod_hash<9>>,
-    tsl::robin_map<std::string, std::string, mod_hash<9>>,
-    tsl::robin_map<move_only_test, move_only_test, mod_hash<9>>,
-    tsl::robin_map<copy_only_test, copy_only_test, mod_hash<9>>,
-    tsl::robin_map<self_reference_member_test, self_reference_member_test,
-                   mod_hash<9>>,
-
-    // other GrowthPolicy
-    tsl::robin_map<move_only_test, move_only_test, mod_hash<9>,
-                   std::equal_to<move_only_test>,
-                   std::allocator<std::pair<move_only_test, move_only_test>>,
-                   true, tsl::rh::power_of_two_growth_policy<4>>,
-    tsl::robin_pg_map<move_only_test, move_only_test, mod_hash<9>>,
-    tsl::robin_map<move_only_test, move_only_test, mod_hash<9>,
-                   std::equal_to<move_only_test>,
-                   std::allocator<std::pair<move_only_test, move_only_test>>,
-                   false, tsl::rh::mod_growth_policy<>>,
-
-    tsl::robin_map<copy_only_test, copy_only_test, mod_hash<9>,
-                   std::equal_to<copy_only_test>,
-                   std::allocator<std::pair<copy_only_test, copy_only_test>>,
-                   false, tsl::rh::power_of_two_growth_policy<4>>,
-    tsl::robin_pg_map<copy_only_test, copy_only_test, mod_hash<9>>,
-    tsl::robin_map<copy_only_test, copy_only_test, mod_hash<9>,
-                   std::equal_to<copy_only_test>,
-                   std::allocator<std::pair<copy_only_test, copy_only_test>>,
-                   true, tsl::rh::mod_growth_policy<>>>;
-
-/**
- * insert
- */
-BOOST_AUTO_TEST_CASE_TEMPLATE(test_insert, HMap, test_types) {
-  // insert x values, insert them again, check values
-  using key_t = typename HMap::key_type;
-  using value_t = typename HMap::mapped_type;
-
-  const std::size_t nb_values = 1000;
-  HMap map(0);
-  BOOST_CHECK_EQUAL(map.bucket_count(), 0);
-
-  typename HMap::iterator it;
-  bool inserted;
-
-  for (std::size_t i = 0; i < nb_values; i++) {
-    std::tie(it, inserted) =
-        map.insert({utils::get_key<key_t>(i), utils::get_value<value_t>(i)});
-
-    BOOST_CHECK_EQUAL(it->first, utils::get_key<key_t>(i));
-    BOOST_CHECK_EQUAL(it->second, utils::get_value<value_t>(i));
-    BOOST_CHECK(inserted);
-  }
-  BOOST_CHECK_EQUAL(map.size(), nb_values);
-
-  for (std::size_t i = 0; i < nb_values; i++) {
-    std::tie(it, inserted) = map.insert(
-        {utils::get_key<key_t>(i), utils::get_value<value_t>(i + 1)});
-
-    BOOST_CHECK_EQUAL(it->first, utils::get_key<key_t>(i));
-    BOOST_CHECK_EQUAL(it->second, utils::get_value<value_t>(i));
-    BOOST_CHECK(!inserted);
-  }
-
-  for (std::size_t i = 0; i < nb_values; i++) {
-    it = map.find(utils::get_key<key_t>(i));
-
-    BOOST_CHECK_EQUAL(it->first, utils::get_key<key_t>(i));
-    BOOST_CHECK_EQUAL(it->second, utils::get_value<value_t>(i));
-  }
-}
-
-BOOST_AUTO_TEST_CASE(test_range_insert) {
-  // create a vector<std::pair> of values to insert, insert part of them in the
-  // map, check values
-  const int nb_values = 1000;
-  std::vector<std::pair<int, int>> values_to_insert(nb_values);
-  for (int i = 0; i < nb_values; i++) {
-    values_to_insert[i] = std::make_pair(i, i + 1);
-  }
-
-  tsl::robin_map<int, int> map = {{-1, 1}, {-2, 2}};
-  map.insert(std::next(values_to_insert.begin(), 10),
-             values_to_insert.end() - 5);
-
-  BOOST_CHECK_EQUAL(map.size(), 987);
-
-  BOOST_CHECK_EQUAL(map.at(-1), 1);
-  BOOST_CHECK_EQUAL(map.at(-2), 2);
-
-  for (int i = 10; i < nb_values - 5; i++) {
-    BOOST_CHECK_EQUAL(map.at(i), i + 1);
-  }
-}
-
-BOOST_AUTO_TEST_CASE(test_rehash_0) {
-  tsl::robin_map<int, int, std::hash<int>, std::equal_to<int>,
-                 std::allocator<std::pair<int, int>>, true>
-      map;
-  map.rehash(0);
-}
-
-BOOST_AUTO_TEST_CASE(test_insert_with_hint) {
-  tsl::robin_map<int, int> map{{1, 0}, {2, 1}, {3, 2}};
-
-  // Wrong hint
-  BOOST_CHECK(map.insert(map.find(2), std::make_pair(3, 4)) == map.find(3));
-
-  // Good hint
-  BOOST_CHECK(map.insert(map.find(2), std::make_pair(2, 4)) == map.find(2));
-
-  // end() hint
-  BOOST_CHECK(map.insert(map.find(10), std::make_pair(2, 4)) == map.find(2));
-
-  BOOST_CHECK_EQUAL(map.size(), 3);
-
-  // end() hint, new value
-  BOOST_CHECK_EQUAL(map.insert(map.find(10), std::make_pair(4, 3))->first, 4);
-
-  // Wrong hint, new value
-  BOOST_CHECK_EQUAL(map.insert(map.find(2), std::make_pair(5, 4))->first, 5);
-
-  BOOST_CHECK_EQUAL(map.size(), 5);
-}
-
-/**
- * emplace_hint
- */
-BOOST_AUTO_TEST_CASE(test_emplace_hint) {
-  tsl::robin_map<int, int> map{{1, 0}, {2, 1}, {3, 2}};
-
-  // Wrong hint
-  BOOST_CHECK(map.emplace_hint(map.find(2), std::piecewise_construct,
-                               std::forward_as_tuple(3),
-                               std::forward_as_tuple(4)) == map.find(3));
-
-  // Good hint
-  BOOST_CHECK(map.emplace_hint(map.find(2), std::piecewise_construct,
-                               std::forward_as_tuple(2),
-                               std::forward_as_tuple(4)) == map.find(2));
-
-  // end() hint
-  BOOST_CHECK(map.emplace_hint(map.find(10), std::piecewise_construct,
-                               std::forward_as_tuple(2),
-                               std::forward_as_tuple(4)) == map.find(2));
-
-  BOOST_CHECK_EQUAL(map.size(), 3);
-
-  // end() hint, new value
-  BOOST_CHECK_EQUAL(
-      map.emplace_hint(map.find(10), std::piecewise_construct,
-                       std::forward_as_tuple(4), std::forward_as_tuple(3))
-          ->first,
-      4);
-
-  // Wrong hint, new value
-  BOOST_CHECK_EQUAL(
-      map.emplace_hint(map.find(2), std::piecewise_construct,
-                       std::forward_as_tuple(5), std::forward_as_tuple(4))
-          ->first,
-      5);
-
-  BOOST_CHECK_EQUAL(map.size(), 5);
-}
-
-/**
- * emplace
- */
-BOOST_AUTO_TEST_CASE(test_emplace) {
-  tsl::robin_map<std::int64_t, move_only_test> map;
-  tsl::robin_map<std::int64_t, move_only_test>::iterator it;
-  bool inserted;
-
-  std::tie(it, inserted) =
-      map.emplace(std::piecewise_construct, std::forward_as_tuple(10),
-                  std::forward_as_tuple(1));
-  BOOST_CHECK_EQUAL(it->first, 10);
-  BOOST_CHECK_EQUAL(it->second, move_only_test(1));
-  BOOST_CHECK(inserted);
-
-  std::tie(it, inserted) =
-      map.emplace(std::piecewise_construct, std::forward_as_tuple(10),
-                  std::forward_as_tuple(3));
-  BOOST_CHECK_EQUAL(it->first, 10);
-  BOOST_CHECK_EQUAL(it->second, move_only_test(1));
-  BOOST_CHECK(!inserted);
-}
-
-/**
- * try_emplace
- */
-BOOST_AUTO_TEST_CASE(test_try_emplace) {
-  tsl::robin_map<std::int64_t, move_only_test> map;
-  tsl::robin_map<std::int64_t, move_only_test>::iterator it;
-  bool inserted;
-
-  std::tie(it, inserted) = map.try_emplace(10, 1);
-  BOOST_CHECK_EQUAL(it->first, 10);
-  BOOST_CHECK_EQUAL(it->second, move_only_test(1));
-  BOOST_CHECK(inserted);
-
-  std::tie(it, inserted) = map.try_emplace(10, 3);
-  BOOST_CHECK_EQUAL(it->first, 10);
-  BOOST_CHECK_EQUAL(it->second, move_only_test(1));
-  BOOST_CHECK(!inserted);
-}
-
-BOOST_AUTO_TEST_CASE(test_try_emplace_2) {
-  // Insert x values with try_emplace, insert them again, check with find.
-  tsl::robin_map<std::string, move_only_test> map;
-  tsl::robin_map<std::string, move_only_test>::iterator it;
-  bool inserted;
-
-  const std::size_t nb_values = 1000;
-  for (std::size_t i = 0; i < nb_values; i++) {
-    std::tie(it, inserted) = map.try_emplace(utils::get_key<std::string>(i), i);
-
-    BOOST_CHECK_EQUAL(it->first, utils::get_key<std::string>(i));
-    BOOST_CHECK_EQUAL(it->second, move_only_test(i));
-    BOOST_CHECK(inserted);
-  }
-  BOOST_CHECK_EQUAL(map.size(), nb_values);
-
-  for (std::size_t i = 0; i < nb_values; i++) {
-    std::tie(it, inserted) =
-        map.try_emplace(utils::get_key<std::string>(i), i + 1);
-
-    BOOST_CHECK_EQUAL(it->first, utils::get_key<std::string>(i));
-    BOOST_CHECK_EQUAL(it->second, move_only_test(i));
-    BOOST_CHECK(!inserted);
-  }
-
-  for (std::size_t i = 0; i < nb_values; i++) {
-    it = map.find(utils::get_key<std::string>(i));
-
-    BOOST_CHECK_EQUAL(it->first, utils::get_key<std::string>(i));
-    BOOST_CHECK_EQUAL(it->second, move_only_test(i));
-  }
-}
-
-BOOST_AUTO_TEST_CASE(test_try_emplace_hint) {
-  tsl::robin_map<std::int64_t, move_only_test> map(0);
-
-  // end() hint, new value
-  auto it = map.try_emplace(map.find(10), 10, 1);
-  BOOST_CHECK_EQUAL(it->first, 10);
-  BOOST_CHECK_EQUAL(it->second, move_only_test(1));
-
-  // Good hint
-  it = map.try_emplace(map.find(10), 10, 3);
-  BOOST_CHECK_EQUAL(it->first, 10);
-  BOOST_CHECK_EQUAL(it->second, move_only_test(1));
-
-  // Wrong hint, new value
-  it = map.try_emplace(map.find(10), 1, 3);
-  BOOST_CHECK_EQUAL(it->first, 1);
-  BOOST_CHECK_EQUAL(it->second, move_only_test(3));
-}
-
-/**
- * insert_or_assign
- */
-BOOST_AUTO_TEST_CASE(test_insert_or_assign) {
-  tsl::robin_map<std::int64_t, move_only_test> map;
-  tsl::robin_map<std::int64_t, move_only_test>::iterator it;
-  bool inserted;
-
-  std::tie(it, inserted) = map.insert_or_assign(10, move_only_test(1));
-  BOOST_CHECK_EQUAL(it->first, 10);
-  BOOST_CHECK_EQUAL(it->second, move_only_test(1));
-  BOOST_CHECK(inserted);
-
-  std::tie(it, inserted) = map.insert_or_assign(10, move_only_test(3));
-  BOOST_CHECK_EQUAL(it->first, 10);
-  BOOST_CHECK_EQUAL(it->second, move_only_test(3));
-  BOOST_CHECK(!inserted);
-}
-
-BOOST_AUTO_TEST_CASE(test_insert_or_assign_hint) {
-  tsl::robin_map<std::int64_t, move_only_test> map(0);
-
-  // end() hint, new value
-  auto it = map.insert_or_assign(map.find(10), 10, move_only_test(1));
-  BOOST_CHECK_EQUAL(it->first, 10);
-  BOOST_CHECK_EQUAL(it->second, move_only_test(1));
-
-  // Good hint
-  it = map.insert_or_assign(map.find(10), 10, move_only_test(3));
-  BOOST_CHECK_EQUAL(it->first, 10);
-  BOOST_CHECK_EQUAL(it->second, move_only_test(3));
-
-  // Bad hint, new value
-  it = map.insert_or_assign(map.find(10), 1, move_only_test(3));
-  BOOST_CHECK_EQUAL(it->first, 1);
-  BOOST_CHECK_EQUAL(it->second, move_only_test(3));
-}
-
-/**
- * erase
- */
-BOOST_AUTO_TEST_CASE(test_range_erase_all) {
-  // insert x values, delete all with iterators
-  using HMap = tsl::robin_map<std::string, std::int64_t>;
-
-  const std::size_t nb_values = 1000;
-  HMap map = utils::get_filled_hash_map<HMap>(nb_values);
-
-  auto it = map.erase(map.begin(), map.end());
-  BOOST_CHECK(it == map.end());
-  BOOST_CHECK(map.empty());
-}
-
-BOOST_AUTO_TEST_CASE(test_range_erase) {
-  // insert x values, delete all with iterators except 10 first and 780 last
-  // values
-  using HMap = tsl::robin_map<std::string, std::int64_t>;
-
-  const std::size_t nb_values = 1000;
-  HMap map = utils::get_filled_hash_map<HMap>(nb_values);
-
-  auto it_first = std::next(map.begin(), 10);
-  auto it_last = std::next(map.begin(), 220);
-
-  auto it = map.erase(it_first, it_last);
-  BOOST_CHECK_EQUAL(std::distance(it, map.end()), 780);
-  BOOST_CHECK_EQUAL(map.size(), 790);
-  BOOST_CHECK_EQUAL(std::distance(map.begin(), map.end()), 790);
-
-  for (auto& val : map) {
-    BOOST_CHECK_EQUAL(map.count(val.first), 1);
-  }
-}
-
-BOOST_AUTO_TEST_CASE_TEMPLATE(test_erase_loop, HMap, test_types) {
-  // insert x values, delete all one by one with iterator
-  std::size_t nb_values = 1000;
-
-  HMap map = utils::get_filled_hash_map<HMap>(nb_values);
-  HMap map2 = utils::get_filled_hash_map<HMap>(nb_values);
-
-  auto it = map.begin();
-  // Use second map to check for key after delete as we may not copy the key
-  // with move-only types.
-  auto it2 = map2.begin();
-  while (it != map.end()) {
-    it = map.erase(it);
-    --nb_values;
-
-    BOOST_CHECK_EQUAL(map.count(it2->first), 0);
-    BOOST_CHECK_EQUAL(map.size(), nb_values);
-    ++it2;
-  }
-
-  BOOST_CHECK(map.empty());
-}
-
-BOOST_AUTO_TEST_CASE_TEMPLATE(test_erase_loop_range, HMap, test_types) {
-  // insert x values, delete all five by five with iterators
-  const std::size_t hop = 5;
-  std::size_t nb_values = 1000;
-
-  BOOST_REQUIRE_EQUAL(nb_values % hop, 0);
-
-  HMap map = utils::get_filled_hash_map<HMap>(nb_values);
-
-  auto it = map.begin();
-  while (it != map.end()) {
-    it = map.erase(it, std::next(it, hop));
-    nb_values -= hop;
-
-    BOOST_CHECK_EQUAL(map.size(), nb_values);
-  }
-
-  BOOST_CHECK(map.empty());
-}
-
-BOOST_AUTO_TEST_CASE_TEMPLATE(test_insert_erase_insert, HMap, test_types) {
-  // insert x/2 values, delete x/4 values, insert x/2 values, find each value
-  using key_t = typename HMap::key_type;
-  using value_t = typename HMap::mapped_type;
-
-  const std::size_t nb_values = 2000;
-  HMap map(10);
-  typename HMap::iterator it;
-  bool inserted;
-
-  // Insert nb_values/2
-  for (std::size_t i = 0; i < nb_values / 2; i++) {
-    std::tie(it, inserted) =
-        map.insert({utils::get_key<key_t>(i), utils::get_value<value_t>(i)});
-
-    BOOST_CHECK_EQUAL(it->first, utils::get_key<key_t>(i));
-    BOOST_CHECK_EQUAL(it->second, utils::get_value<value_t>(i));
-    BOOST_CHECK(inserted);
-  }
-  BOOST_CHECK_EQUAL(map.size(), nb_values / 2);
-
-  // Delete nb_values/4
-  for (std::size_t i = 0; i < nb_values / 2; i++) {
-    if (i % 2 == 0) {
-      BOOST_CHECK_EQUAL(map.erase(utils::get_key<key_t>(i)), 1);
-    }
-  }
-  BOOST_CHECK_EQUAL(map.size(), nb_values / 4);
-
-  // Insert nb_values/2
-  for (std::size_t i = nb_values / 2; i < nb_values; i++) {
-    std::tie(it, inserted) =
-        map.insert({utils::get_key<key_t>(i), utils::get_value<value_t>(i)});
-
-    BOOST_CHECK_EQUAL(it->first, utils::get_key<key_t>(i));
-    BOOST_CHECK_EQUAL(it->second, utils::get_value<value_t>(i));
-    BOOST_CHECK(inserted);
-  }
-  BOOST_CHECK_EQUAL(map.size(), nb_values - nb_values / 4);
-
-  // Find
-  for (std::size_t i = 0; i < nb_values; i++) {
-    if (i % 2 == 0 && i < nb_values / 2) {
-      it = map.find(utils::get_key<key_t>(i));
-
-      BOOST_CHECK(it == map.end());
-    } else {
-      it = map.find(utils::get_key<key_t>(i));
-
-      BOOST_REQUIRE(it != map.end());
-      BOOST_CHECK_EQUAL(it->first, utils::get_key<key_t>(i));
-      BOOST_CHECK_EQUAL(it->second, utils::get_value<value_t>(i));
-    }
-  }
-}
-
-BOOST_AUTO_TEST_CASE(test_range_erase_same_iterators) {
-  // insert x values, test erase with same iterator as each parameter, check if
-  // returned mutable iterator is valid.
-  const std::size_t nb_values = 100;
-  auto map =
-      utils::get_filled_hash_map<tsl::robin_map<std::int64_t, std::int64_t>>(
-          nb_values);
-
-  tsl::robin_map<std::int64_t, std::int64_t>::const_iterator it_const =
-      map.cbegin();
-  std::advance(it_const, 10);
-
-  tsl::robin_map<std::int64_t, std::int64_t>::iterator it_mutable =
-      map.erase(it_const, it_const);
-  BOOST_CHECK(it_const == it_mutable);
-  BOOST_CHECK(map.mutable_iterator(it_const) == it_mutable);
-  BOOST_CHECK_EQUAL(map.size(), 100);
-
-  it_mutable.value() = -100;
-  BOOST_CHECK_EQUAL(it_const.value(), -100);
-}
-
-/**
- * max_load_factor
- */
-BOOST_AUTO_TEST_CASE(test_max_load_factor_extreme_factors) {
-  tsl::robin_map<std::int64_t, std::int64_t> map;
-
-  map.max_load_factor(0.0f);
-  BOOST_CHECK_GT(map.max_load_factor(), 0.0f);
-
-  map.max_load_factor(10.0f);
-  BOOST_CHECK_LT(map.max_load_factor(), 1.0f);
-}
-
-/**
- * min_load_factor
- */
-BOOST_AUTO_TEST_CASE(test_min_load_factor_extreme_factors) {
-  tsl::robin_map<std::int64_t, std::int64_t> map;
-
-  BOOST_CHECK_EQUAL(map.min_load_factor(), 0.0f);
-  BOOST_CHECK_LT(map.min_load_factor(), map.max_load_factor());
-
-  map.min_load_factor(-10.0f);
-  BOOST_CHECK_EQUAL(map.min_load_factor(), 0.0f);
-
-  map.min_load_factor(0.9f);
-  map.max_load_factor(0.1f);
-
-  // max_load_factor should always be > min_load_factor.
-  // Factors should have been clamped.
-  BOOST_CHECK_LT(map.min_load_factor(), map.max_load_factor());
-}
-
-BOOST_AUTO_TEST_CASE(test_min_load_factor) {
-  // set min_load_factor to 0.15 and max_load_factor to 0.5.
-  // rehash to 100 buckets, insert 50 elements, erase until load_factor() <
-  // min_load_factor(), insert an element, check if map has shrinked.
-  const std::size_t nb_values = 50;
-  tsl::robin_map<std::int64_t, std::int64_t> map;
-
-  map.min_load_factor(0.15f);
-  BOOST_CHECK_EQUAL(map.min_load_factor(), 0.15f);
-
-  map.max_load_factor(0.5f);
-  BOOST_CHECK_EQUAL(map.max_load_factor(), 0.5f);
-
-  map.rehash(nb_values * 2);
-  for (std::size_t i = 0; i < nb_values; i++) {
-    map.insert(
-        {utils::get_key<std::int64_t>(i), utils::get_value<std::int64_t>(i)});
-  }
-  BOOST_CHECK_GT(map.load_factor(), map.min_load_factor());
-
-  while (map.load_factor() >= map.min_load_factor()) {
-    map.erase(map.begin());
-  }
-
-  // Shrink is done on insert.
-  map.insert({utils::get_key<std::int64_t>(map.bucket_count()),
-              utils::get_value<std::int64_t>(map.bucket_count())});
-  BOOST_CHECK_GT(map.load_factor(), map.min_load_factor());
-}
-
-BOOST_AUTO_TEST_CASE(test_min_load_factor_range_erase) {
-  // set min_load_factor to 0.15 and max_load_factor to 0.5.
-  // rehash to 100 buckets, insert 50 elements, erase 40 with range erase,
-  // insert an element, check if map has shrinked.
-  const std::size_t nb_values = 50;
-  const std::size_t nb_values_erase = 40;
-  tsl::robin_map<std::int64_t, std::int64_t> map;
-
-  map.min_load_factor(0.15f);
-  BOOST_CHECK_EQUAL(map.min_load_factor(), 0.15f);
-
-  map.max_load_factor(0.5f);
-  BOOST_CHECK_EQUAL(map.max_load_factor(), 0.5f);
-
-  map.rehash(nb_values * 2);
-  for (std::size_t i = 0; i < nb_values; i++) {
-    map.insert(
-        {utils::get_key<std::int64_t>(i), utils::get_value<std::int64_t>(i)});
-  }
-  BOOST_CHECK_GT(map.load_factor(), map.min_load_factor());
-
-  map.erase(std::next(map.begin(), nb_values - nb_values_erase), map.end());
-
-  // Shrink is done on insert.
-  map.insert({utils::get_key<std::int64_t>(map.bucket_count()),
-              utils::get_value<std::int64_t>(map.bucket_count())});
-  BOOST_CHECK_GT(map.load_factor(), map.min_load_factor());
-  BOOST_CHECK_LT(map.bucket_count(), nb_values * 2);
-}
-
-/**
- * rehash
- */
-BOOST_AUTO_TEST_CASE(test_rehash_empty) {
-  // test rehash(0), test find/erase/insert on map.
-  const std::size_t nb_values = 100;
-  auto map =
-      utils::get_filled_hash_map<tsl::robin_map<std::int64_t, std::int64_t>>(
-          nb_values);
-
-  const std::size_t bucket_count = map.bucket_count();
-  BOOST_CHECK(bucket_count >= nb_values);
-
-  map.clear();
-  BOOST_CHECK_EQUAL(map.bucket_count(), bucket_count);
-  BOOST_CHECK(map.empty());
-
-  map.rehash(0);
-  BOOST_CHECK_EQUAL(map.bucket_count(), 0);
-  BOOST_CHECK(map.empty());
-
-  BOOST_CHECK(map.find(1) == map.end());
-  BOOST_CHECK_EQUAL(map.erase(1), 0);
-  BOOST_CHECK(map.insert({1, 10}).second);
-  BOOST_CHECK_EQUAL(map.at(1), 10);
-}
-
-/**
- * operator== and operator!=
- */
-BOOST_AUTO_TEST_CASE(test_compare) {
-  const tsl::robin_map<std::string, std::int64_t> map1 = {
-      {"a", 1}, {"e", 5}, {"d", 4}, {"c", 3}, {"b", 2}};
-  const tsl::robin_map<std::string, std::int64_t> map1_copy = {
-      {"e", 5}, {"c", 3}, {"b", 2}, {"a", 1}, {"d", 4}};
-  const tsl::robin_map<std::string, std::int64_t> map2 = {
-      {"e", 5}, {"c", 3}, {"b", 2}, {"a", 1}, {"d", 4}, {"f", 6}};
-  const tsl::robin_map<std::string, std::int64_t> map3 = {
-      {"e", 5}, {"c", 3}, {"b", 2}, {"a", 1}};
-  const tsl::robin_map<std::string, std::int64_t> map4 = {
-      {"a", 1}, {"e", 5}, {"d", 4}, {"c", 3}, {"b", 26}};
-  const tsl::robin_map<std::string, std::int64_t> map5 = {
-      {"a", 1}, {"e", 5}, {"d", 4}, {"c", 3}, {"z", 2}};
-
-  BOOST_CHECK(map1 == map1_copy);
-  BOOST_CHECK(map1_copy == map1);
-
-  BOOST_CHECK(map1 != map2);
-  BOOST_CHECK(map2 != map1);
-
-  BOOST_CHECK(map1 != map3);
-  BOOST_CHECK(map3 != map1);
-
-  BOOST_CHECK(map1 != map4);
-  BOOST_CHECK(map4 != map1);
-
-  BOOST_CHECK(map1 != map5);
-  BOOST_CHECK(map5 != map1);
-
-  BOOST_CHECK(map2 != map3);
-  BOOST_CHECK(map3 != map2);
-
-  BOOST_CHECK(map2 != map4);
-  BOOST_CHECK(map4 != map2);
-
-  BOOST_CHECK(map2 != map5);
-  BOOST_CHECK(map5 != map2);
-
-  BOOST_CHECK(map3 != map4);
-  BOOST_CHECK(map4 != map3);
-
-  BOOST_CHECK(map3 != map5);
-  BOOST_CHECK(map5 != map3);
-
-  BOOST_CHECK(map4 != map5);
-  BOOST_CHECK(map5 != map4);
-}
-
-/**
- * clear
- */
-BOOST_AUTO_TEST_CASE(test_clear) {
-  // insert x values, clear map, test insert
-  using HMap = tsl::robin_map<std::int64_t, std::int64_t>;
-
-  const std::size_t nb_values = 1000;
-  auto map = utils::get_filled_hash_map<HMap>(nb_values);
-
-  map.clear();
-  BOOST_CHECK_EQUAL(map.size(), 0);
-  BOOST_CHECK_EQUAL(std::distance(map.begin(), map.end()), 0);
-
-  map.insert({5, -5});
-  map.insert({{1, -1}, {2, -1}, {4, -4}, {3, -3}});
-
-  BOOST_CHECK(map == (HMap({{5, -5}, {1, -1}, {2, -1}, {4, -4}, {3, -3}})));
-}
-
-BOOST_AUTO_TEST_CASE(test_clear_with_min_load_factor) {
-  // insert x values, clear map, test insert
-  using HMap = tsl::robin_map<std::int64_t, std::int64_t>;
-
-  const std::size_t nb_values = 1000;
-  auto map = utils::get_filled_hash_map<HMap>(nb_values);
-  map.min_load_factor(0.1f);
-
-  map.clear();
-  BOOST_CHECK_EQUAL(map.bucket_count(), 0);
-  BOOST_CHECK_EQUAL(map.size(), 0);
-  BOOST_CHECK_EQUAL(std::distance(map.begin(), map.end()), 0);
-
-  map.insert({5, -5});
-  map.insert({{1, -1}, {2, -1}, {4, -4}, {3, -3}});
-
-  BOOST_CHECK(map == (HMap({{5, -5}, {1, -1}, {2, -1}, {4, -4}, {3, -3}})));
-}
-
-/**
- * iterator.value()
- */
-BOOST_AUTO_TEST_CASE(test_modify_value_through_iterator) {
-  // insert x values, modify value of even keys with iterators, check values
-  const std::size_t nb_values = 100;
-  auto map =
-      utils::get_filled_hash_map<tsl::robin_map<std::int64_t, std::int64_t>>(
-          nb_values);
-
-  for (auto it = map.begin(); it != map.end(); it++) {
-    if (it.key() % 2 == 0) {
-      it.value() = -1;
-    }
-  }
-
-  for (auto& val : map) {
-    if (val.first % 2 == 0) {
-      BOOST_CHECK_EQUAL(val.second, -1);
-    } else {
-      BOOST_CHECK_NE(val.second, -1);
-    }
-  }
-}
-
-BOOST_AUTO_TEST_CASE(test_modify_value_through_iterator_with_const_qualifier) {
-  tsl::robin_map<int, int> map = {{0, 1}};
-  const auto it = map.begin();
-
-  BOOST_CHECK_EQUAL(it->second, 1);
-  it.value() += 10;
-  BOOST_CHECK_EQUAL(it->second, 11);
-}
-
-/**
- * constructor
- */
-
-BOOST_AUTO_TEST_CASE(test_extreme_bucket_count_value_construction) {
-  // std::bad_alloc or std::length_error will be thrown depending on the
-  // platform overcommit
-  TSL_RH_CHECK_THROW_EITHER(
-      (tsl::robin_map<int, int, std::hash<int>, std::equal_to<int>,
-                      std::allocator<std::pair<int, int>>, false,
-                      tsl::rh::power_of_two_growth_policy<2>>(
-          std::numeric_limits<std::size_t>::max())),
-      std::bad_alloc, std::length_error);
-
-  TSL_RH_CHECK_THROW_EITHER(
-      (tsl::robin_map<int, int, std::hash<int>, std::equal_to<int>,
-                      std::allocator<std::pair<int, int>>, false,
-                      tsl::rh::power_of_two_growth_policy<2>>(
-          std::numeric_limits<std::size_t>::max() / 2 + 1)),
-      std::bad_alloc, std::length_error);
-
-  TSL_RH_CHECK_THROW_EITHER(
-      (tsl::robin_map<int, int, std::hash<int>, std::equal_to<int>,
-                      std::allocator<std::pair<int, int>>, false,
-                      tsl::rh::prime_growth_policy>(
-          std::numeric_limits<std::size_t>::max())),
-      std::bad_alloc, std::length_error);
-
-  TSL_RH_CHECK_THROW_EITHER(
-      (tsl::robin_map<int, int, std::hash<int>, std::equal_to<int>,
-                      std::allocator<std::pair<int, int>>, false,
-                      tsl::rh::prime_growth_policy>(
-          std::numeric_limits<std::size_t>::max() / 2)),
-      std::bad_alloc, std::length_error);
-
-  TSL_RH_CHECK_THROW_EITHER(
-      (tsl::robin_map<int, int, std::hash<int>, std::equal_to<int>,
-                      std::allocator<std::pair<int, int>>, false,
-                      tsl::rh::mod_growth_policy<>>(
-          std::numeric_limits<std::size_t>::max())),
-      std::bad_alloc, std::length_error);
-}
-
-BOOST_AUTO_TEST_CASE(test_range_construct) {
-  tsl::robin_map<int, int> map = {{2, 1}, {1, 0}, {3, 2}};
-
-  tsl::robin_map<int, int> map2(map.begin(), map.end());
-  tsl::robin_map<int, int> map3(map.cbegin(), map.cend());
-}
-
-/**
- * operator=(std::initializer_list)
- */
-BOOST_AUTO_TEST_CASE(test_assign_operator) {
-  tsl::robin_map<std::int64_t, std::int64_t> map = {{0, 10}, {-2, 20}};
-  BOOST_CHECK_EQUAL(map.size(), 2);
-
-  map = {{1, 3}, {2, 4}};
-  BOOST_CHECK_EQUAL(map.size(), 2);
-  BOOST_CHECK_EQUAL(map.at(1), 3);
-  BOOST_CHECK_EQUAL(map.at(2), 4);
-  BOOST_CHECK(map.find(0) == map.end());
-
-  map = {};
-  BOOST_CHECK(map.empty());
-}
-
-/**
- * move/copy constructor/operator
- */
-BOOST_AUTO_TEST_CASE(test_move_constructor) {
-  // insert x values in map, move map into map_move with move constructor, check
-  // map and map_move, insert additional values in map_move, check map_move
-  using HMap = tsl::robin_map<std::string, move_only_test>;
-
-  const std::size_t nb_values = 100;
-  HMap map = utils::get_filled_hash_map<HMap>(nb_values);
-  HMap map_move(std::move(map));
-
-  BOOST_CHECK(map_move == utils::get_filled_hash_map<HMap>(nb_values));
-  BOOST_CHECK(map == (HMap()));
-
-  for (std::size_t i = nb_values; i < nb_values * 2; i++) {
-    map_move.insert(
-        {utils::get_key<std::string>(i), utils::get_value<move_only_test>(i)});
-  }
-
-  BOOST_CHECK_EQUAL(map_move.size(), nb_values * 2);
-  BOOST_CHECK(map_move == utils::get_filled_hash_map<HMap>(nb_values * 2));
-}
-
-BOOST_AUTO_TEST_CASE(test_move_constructor_empty) {
-  tsl::robin_map<std::string, move_only_test> map(0);
-  tsl::robin_map<std::string, move_only_test> map_move(std::move(map));
-
-  BOOST_CHECK(map.empty());
-  BOOST_CHECK(map_move.empty());
-
-  BOOST_CHECK(map.find("") == map.end());
-  BOOST_CHECK(map_move.find("") == map_move.end());
-}
-
-BOOST_AUTO_TEST_CASE(test_move_operator) {
-  // insert x values in map, move map into map_move with move operator, check
-  // map and map_move, insert additional values in map_move, check map_move
-  using HMap = tsl::robin_map<std::string, move_only_test>;
-
-  const std::size_t nb_values = 100;
-  HMap map = utils::get_filled_hash_map<HMap>(nb_values);
-  HMap map_move = utils::get_filled_hash_map<HMap>(1);
-  map_move = std::move(map);
-
-  BOOST_CHECK(map_move == utils::get_filled_hash_map<HMap>(nb_values));
-  BOOST_CHECK(map == (HMap()));
-
-  for (std::size_t i = nb_values; i < nb_values * 2; i++) {
-    map_move.insert(
-        {utils::get_key<std::string>(i), utils::get_value<move_only_test>(i)});
-  }
-
-  BOOST_CHECK_EQUAL(map_move.size(), nb_values * 2);
-  BOOST_CHECK(map_move == utils::get_filled_hash_map<HMap>(nb_values * 2));
-}
-
-BOOST_AUTO_TEST_CASE(test_move_operator_empty) {
-  tsl::robin_map<std::string, move_only_test> map(0);
-  tsl::robin_map<std::string, move_only_test> map_move;
-  map_move = (std::move(map));
-
-  BOOST_CHECK(map.empty());
-  BOOST_CHECK(map_move.empty());
-
-  BOOST_CHECK(map.find("") == map.end());
-  BOOST_CHECK(map_move.find("") == map_move.end());
-}
-
-BOOST_AUTO_TEST_CASE(test_reassign_moved_object_move_constructor) {
-  using HMap = tsl::robin_map<std::string, std::string>;
-
-  HMap map = {{"Key1", "Value1"}, {"Key2", "Value2"}, {"Key3", "Value3"}};
-  HMap map_move(std::move(map));
-
-  BOOST_CHECK_EQUAL(map_move.size(), 3);
-  BOOST_CHECK_EQUAL(map.size(), 0);
-
-  map = {{"Key4", "Value4"}, {"Key5", "Value5"}};
-  BOOST_CHECK(map == (HMap({{"Key4", "Value4"}, {"Key5", "Value5"}})));
-}
-
-BOOST_AUTO_TEST_CASE(test_reassign_moved_object_move_operator) {
-  using HMap = tsl::robin_map<std::string, std::string>;
-
-  HMap map = {{"Key1", "Value1"}, {"Key2", "Value2"}, {"Key3", "Value3"}};
-  HMap map_move = std::move(map);
-
-  BOOST_CHECK_EQUAL(map_move.size(), 3);
-  BOOST_CHECK_EQUAL(map.size(), 0);
-
-  map = {{"Key4", "Value4"}, {"Key5", "Value5"}};
-  BOOST_CHECK(map == (HMap({{"Key4", "Value4"}, {"Key5", "Value5"}})));
-}
-
-BOOST_AUTO_TEST_CASE(test_use_after_move_constructor) {
-  using HMap = tsl::robin_map<std::string, move_only_test>;
-
-  const std::size_t nb_values = 100;
-  HMap map = utils::get_filled_hash_map<HMap>(nb_values);
-  HMap map_move(std::move(map));
-
-  BOOST_CHECK(map == (HMap()));
-  BOOST_CHECK_EQUAL(map.size(), 0);
-  BOOST_CHECK_EQUAL(map.bucket_count(), 0);
-  BOOST_CHECK_EQUAL(map.erase("a"), 0);
-  BOOST_CHECK(map.find("a") == map.end());
-
-  for (std::size_t i = 0; i < nb_values; i++) {
-    map.insert(
-        {utils::get_key<std::string>(i), utils::get_value<move_only_test>(i)});
-  }
-
-  BOOST_CHECK_EQUAL(map.size(), nb_values);
-  BOOST_CHECK(map == map_move);
-}
-
-BOOST_AUTO_TEST_CASE(test_use_after_move_operator) {
-  using HMap = tsl::robin_map<std::string, move_only_test>;
-
-  const std::size_t nb_values = 100;
-  HMap map = utils::get_filled_hash_map<HMap>(nb_values);
-  HMap map_move(0);
-  map_move = std::move(map);
-
-  BOOST_CHECK(map == (HMap()));
-  BOOST_CHECK_EQUAL(map.size(), 0);
-  BOOST_CHECK_EQUAL(map.bucket_count(), 0);
-  BOOST_CHECK_EQUAL(map.erase("a"), 0);
-  BOOST_CHECK(map.find("a") == map.end());
-
-  for (std::size_t i = 0; i < nb_values; i++) {
-    map.insert(
-        {utils::get_key<std::string>(i), utils::get_value<move_only_test>(i)});
-  }
-
-  BOOST_CHECK_EQUAL(map.size(), nb_values);
-  BOOST_CHECK(map == map_move);
-}
-
-BOOST_AUTO_TEST_CASE(test_copy_constructor_and_operator) {
-  using HMap = tsl::robin_map<std::string, std::string, mod_hash<9>>;
-
-  const std::size_t nb_values = 100;
-  HMap map = utils::get_filled_hash_map<HMap>(nb_values);
-
-  HMap map_copy = map;
-  HMap map_copy2(map);
-  HMap map_copy3 = utils::get_filled_hash_map<HMap>(1);
-  map_copy3 = map;
-
-  BOOST_CHECK(map == map_copy);
-  map.clear();
-
-  BOOST_CHECK(map_copy == map_copy2);
-  BOOST_CHECK(map_copy == map_copy3);
-}
-
-BOOST_AUTO_TEST_CASE(test_copy_constructor_empty) {
-  tsl::robin_map<std::string, int> map(0);
-  tsl::robin_map<std::string, int> map_copy(map);
-
-  BOOST_CHECK(map.empty());
-  BOOST_CHECK(map_copy.empty());
-
-  BOOST_CHECK(map.find("") == map.end());
-  BOOST_CHECK(map_copy.find("") == map_copy.end());
-}
-
-BOOST_AUTO_TEST_CASE(test_copy_operator_empty) {
-  tsl::robin_map<std::string, int> map(0);
-  tsl::robin_map<std::string, int> map_copy(16);
-  map_copy = map;
-
-  BOOST_CHECK(map.empty());
-  BOOST_CHECK(map_copy.empty());
-
-  BOOST_CHECK(map.find("") == map.end());
-  BOOST_CHECK(map_copy.find("") == map_copy.end());
-}
-
-/**
- * at
- */
-BOOST_AUTO_TEST_CASE(test_at) {
-  // insert x values, use at for known and unknown values.
-  const tsl::robin_map<std::int64_t, std::int64_t> map = {{0, 10}, {-2, 20}};
-
-  BOOST_CHECK_EQUAL(map.at(0), 10);
-  BOOST_CHECK_EQUAL(map.at(-2), 20);
-  TSL_RH_CHECK_THROW(map.at(1), std::out_of_range);
-}
-
-/**
- * contains
- */
-BOOST_AUTO_TEST_CASE(test_contains) {
-  tsl::robin_map<std::int64_t, std::int64_t> map = {{0, 10}, {-2, 20}};
-
-  BOOST_CHECK(map.contains(0));
-  BOOST_CHECK(map.contains(-2));
-  BOOST_CHECK(!map.contains(-3));
-}
-
-/**
- * equal_range
- */
-BOOST_AUTO_TEST_CASE(test_equal_range) {
-  const tsl::robin_map<std::int64_t, std::int64_t> map = {{0, 10}, {-2, 20}};
-
-  auto it_pair = map.equal_range(0);
-  BOOST_REQUIRE_EQUAL(std::distance(it_pair.first, it_pair.second), 1);
-  BOOST_CHECK_EQUAL(it_pair.first->second, 10);
-
-  it_pair = map.equal_range(1);
-  BOOST_CHECK(it_pair.first == it_pair.second);
-  BOOST_CHECK(it_pair.first == map.end());
-}
-
-/**
- * operator[]
- */
-BOOST_AUTO_TEST_CASE(test_access_operator) {
-  // insert x values, use at for known and unknown values.
-  tsl::robin_map<std::int64_t, std::int64_t> map = {{0, 10}, {-2, 20}};
-
-  BOOST_CHECK_EQUAL(map[0], 10);
-  BOOST_CHECK_EQUAL(map[-2], 20);
-  BOOST_CHECK_EQUAL(map[2], std::int64_t());
-
-  BOOST_CHECK_EQUAL(map.size(), 3);
-}
-
-/**
- * swap
- */
-BOOST_AUTO_TEST_CASE(test_swap) {
-  tsl::robin_map<std::int64_t, std::int64_t> map = {{1, 10}, {8, 80}, {3, 30}};
-  tsl::robin_map<std::int64_t, std::int64_t> map2 = {{4, 40}, {5, 50}};
-
-  using std::swap;
-  swap(map, map2);
-
-  BOOST_CHECK(map ==
-              (tsl::robin_map<std::int64_t, std::int64_t>{{4, 40}, {5, 50}}));
-  BOOST_CHECK(map2 == (tsl::robin_map<std::int64_t, std::int64_t>{
-                          {1, 10}, {8, 80}, {3, 30}}));
-
-  map.insert({6, 60});
-  map2.insert({4, 40});
-
-  BOOST_CHECK(map == (tsl::robin_map<std::int64_t, std::int64_t>{
-                         {4, 40}, {5, 50}, {6, 60}}));
-  BOOST_CHECK(map2 == (tsl::robin_map<std::int64_t, std::int64_t>{
-                          {1, 10}, {8, 80}, {3, 30}, {4, 40}}));
-}
-
-BOOST_AUTO_TEST_CASE(test_swap_empty) {
-  tsl::robin_map<std::int64_t, std::int64_t> map = {{1, 10}, {8, 80}, {3, 30}};
-  tsl::robin_map<std::int64_t, std::int64_t> map2;
-
-  using std::swap;
-  swap(map, map2);
-
-  BOOST_CHECK(map == (tsl::robin_map<std::int64_t, std::int64_t>{}));
-  BOOST_CHECK(map2 == (tsl::robin_map<std::int64_t, std::int64_t>{
-                          {1, 10}, {8, 80}, {3, 30}}));
-
-  map.insert({6, 60});
-  map2.insert({4, 40});
-
-  BOOST_CHECK(map == (tsl::robin_map<std::int64_t, std::int64_t>{{6, 60}}));
-  BOOST_CHECK(map2 == (tsl::robin_map<std::int64_t, std::int64_t>{
-                          {1, 10}, {8, 80}, {3, 30}, {4, 40}}));
-}
-
-/**
- * serialize and deserialize
- */
-BOOST_AUTO_TEST_CASE(test_serialize_desearialize_empty) {
-  // serialize empty map; deserialize in new map; check equal.
-  // for deserialization, test it with and without hash compatibility.
-  const tsl::robin_map<std::string, move_only_test> empty_map(0);
-
-  serializer serial;
-  empty_map.serialize(serial);
-
-  deserializer dserial(serial.str());
-  auto empty_map_deserialized = decltype(empty_map)::deserialize(dserial, true);
-  BOOST_CHECK(empty_map_deserialized == empty_map);
-
-  deserializer dserial2(serial.str());
-  empty_map_deserialized = decltype(empty_map)::deserialize(dserial2, false);
-  BOOST_CHECK(empty_map_deserialized == empty_map);
-}
-
-BOOST_AUTO_TEST_CASE(test_serialize_desearialize) {
-  // insert x values; delete some values; serialize map; deserialize in new map;
-  // check equal. for deserialization, test it with and without hash
-  // compatibility.
-  const std::size_t nb_values = 1000;
-
-  tsl::robin_map<std::int32_t, move_only_test> map;
-  for (std::size_t i = 0; i < nb_values + 40; i++) {
-    map.insert(
-        {utils::get_key<std::int32_t>(i), utils::get_value<move_only_test>(i)});
-  }
-
-  for (std::size_t i = nb_values; i < nb_values + 40; i++) {
-    map.erase(utils::get_key<std::int32_t>(i));
-  }
-  BOOST_CHECK_EQUAL(map.size(), nb_values);
-
-  serializer serial;
-  map.serialize(serial);
-
-  deserializer dserial(serial.str());
-  auto map_deserialized = decltype(map)::deserialize(dserial, true);
-  BOOST_CHECK(map == map_deserialized);
-
-  deserializer dserial2(serial.str());
-  map_deserialized = decltype(map)::deserialize(dserial2, false);
-  BOOST_CHECK(map_deserialized == map);
-
-  // Deserializing a map with StoreHash=true from a map serialized with
-  // StoreHash=false with hash_compatible=true should throw an exception.
-  deserializer dserial3(serial.str());
-  TSL_RH_CHECK_THROW(
-      (tsl::robin_map<std::int32_t, move_only_test, std::hash<std::int32_t>,
-                      std::equal_to<std::int32_t>,
-                      std::allocator<std::pair<std::int32_t, move_only_test>>,
-                      true>::deserialize(dserial3, true)),
-      std::runtime_error);
-}
-
-BOOST_AUTO_TEST_CASE(test_serialize_desearialize_with_store_hash) {
-  // insert x values; delete some values; serialize map; deserialize in new map;
-  // check equal. for deserialization, test it with and without hash
-  // compatibility.
-  const std::size_t nb_values = 1000;
-
-  tsl::robin_map<std::int32_t, move_only_test, std::hash<std::int32_t>,
-                 std::equal_to<std::int32_t>,
-                 std::allocator<std::pair<std::int32_t, move_only_test>>, true>
-      map;
-  for (std::size_t i = 0; i < nb_values + 40; i++) {
-    map.insert(
-        {utils::get_key<std::int32_t>(i), utils::get_value<move_only_test>(i)});
-  }
-
-  for (std::size_t i = nb_values; i < nb_values + 40; i++) {
-    map.erase(utils::get_key<std::int32_t>(i));
-  }
-  BOOST_CHECK_EQUAL(map.size(), nb_values);
-
-  serializer serial;
-  map.serialize(serial);
-
-  deserializer dserial(serial.str());
-  auto map_deserialized = decltype(map)::deserialize(dserial, true);
-  BOOST_CHECK(map == map_deserialized);
-
-  deserializer dserial2(serial.str());
-  map_deserialized = decltype(map)::deserialize(dserial2, false);
-  BOOST_CHECK(map_deserialized == map);
-
-  // Deserializing a map with StoreHash=false from a map serialized with
-  // StoreHash=true with hash_compatible=true should throw an exception.
-  deserializer dserial3(serial.str());
-  TSL_RH_CHECK_THROW((tsl::robin_map<std::int32_t, move_only_test>::deserialize(
-                         dserial3, true)),
-                     std::runtime_error);
-}
-
-BOOST_AUTO_TEST_CASE(test_serialize_desearialize_with_different_hash) {
-  // insert x values; serialize map; deserialize in new map which has a
-  // different hash; check equal
-  struct hash_str_diff {
-    std::size_t operator()(const std::string& str) const {
-      return std::hash<std::string>()(str) + 123;
-    }
-  };
-
-  const std::size_t nb_values = 1000;
-
-  tsl::robin_map<std::string, move_only_test> map;
-  for (std::size_t i = 0; i < nb_values; i++) {
-    map.insert(
-        {utils::get_key<std::string>(i), utils::get_value<move_only_test>(i)});
-  }
-  BOOST_CHECK_EQUAL(map.size(), nb_values);
-
-  serializer serial;
-  map.serialize(serial);
-
-  deserializer dserial(serial.str());
-  auto map_deserialized =
-      tsl::robin_map<std::string, move_only_test, hash_str_diff>::deserialize(
-          dserial, false);
-
-  BOOST_CHECK_EQUAL(map_deserialized.size(), map.size());
-  for (const auto& val : map) {
-    BOOST_CHECK(map_deserialized.find(val.first) != map_deserialized.end());
-  }
-}
-
-/**
- * KeyEqual
- */
-BOOST_AUTO_TEST_CASE(test_key_equal) {
-  // Use a KeyEqual and Hash where any odd unsigned number 'x' is equal to
-  // 'x-1'. Make sure that KeyEqual is called (and not ==).
-  struct hash {
-    std::size_t operator()(std::uint64_t v) const {
-      if (v % 2u == 1u) {
-        return std::hash<std::uint64_t>()(v - 1);
-      } else {
-        return std::hash<std::uint64_t>()(v);
-      }
-    }
-  };
-
-  struct key_equal {
-    bool operator()(std::uint64_t lhs, std::uint64_t rhs) const {
-      if (lhs % 2u == 1u) {
-        lhs--;
-      }
-
-      if (rhs % 2u == 1u) {
-        rhs--;
-      }
-
-      return lhs == rhs;
-    }
-  };
-
-  tsl::robin_map<std::uint64_t, std::uint64_t, hash, key_equal> map;
-  BOOST_CHECK(map.insert({2, 10}).second);
-  BOOST_CHECK_EQUAL(map.at(2), 10);
-  BOOST_CHECK_EQUAL(map.at(3), 10);
-  BOOST_CHECK(!map.insert({3, 10}).second);
-
-  BOOST_CHECK_EQUAL(map.size(), 1);
-}
-
-/**
- * other
- */
-BOOST_AUTO_TEST_CASE(test_heterogeneous_lookups) {
-  struct hash_ptr {
-    std::size_t operator()(const std::unique_ptr<int>& p) const {
-      return std::hash<std::uintptr_t>()(
-          reinterpret_cast<std::uintptr_t>(p.get()));
-    }
-
-    std::size_t operator()(std::uintptr_t p) const {
-      return std::hash<std::uintptr_t>()(p);
-    }
-
-    std::size_t operator()(const int* const& p) const {
-      return std::hash<std::uintptr_t>()(reinterpret_cast<std::uintptr_t>(p));
-    }
-  };
-
-  struct equal_to_ptr {
-    using is_transparent = std::true_type;
-
-    bool operator()(const std::unique_ptr<int>& p1,
-                    const std::unique_ptr<int>& p2) const {
-      return p1 == p2;
-    }
-
-    bool operator()(const std::unique_ptr<int>& p1, std::uintptr_t p2) const {
-      return reinterpret_cast<std::uintptr_t>(p1.get()) == p2;
-    }
-
-    bool operator()(std::uintptr_t p1, const std::unique_ptr<int>& p2) const {
-      return p1 == reinterpret_cast<std::uintptr_t>(p2.get());
-    }
-
-    bool operator()(const std::unique_ptr<int>& p1,
-                    const int* const& p2) const {
-      return p1.get() == p2;
-    }
-
-    bool operator()(const int* const& p1,
-                    const std::unique_ptr<int>& p2) const {
-      return p1 == p2.get();
-    }
-  };
-
-  std::unique_ptr<int> ptr1(new int(1));
-  std::unique_ptr<int> ptr2(new int(2));
-  std::unique_ptr<int> ptr3(new int(3));
-  int other = -1;
-
-  const std::uintptr_t addr1 = reinterpret_cast<std::uintptr_t>(ptr1.get());
-  const int* const addr2 = ptr2.get();
-  const int* const addr_unknown = &other;
-
-  tsl::robin_map<std::unique_ptr<int>, int, hash_ptr, equal_to_ptr> map;
-  map.insert({std::move(ptr1), 4});
-  map.insert({std::move(ptr2), 5});
-  map.insert({std::move(ptr3), 6});
-
-  BOOST_CHECK_EQUAL(map.size(), 3);
-
-  BOOST_CHECK_EQUAL(map.at(addr1), 4);
-  BOOST_CHECK_EQUAL(map.at(addr2), 5);
-  TSL_RH_CHECK_THROW(map.at(addr_unknown), std::out_of_range);
-
-  BOOST_REQUIRE(map.find(addr1) != map.end());
-  BOOST_CHECK_EQUAL(*map.find(addr1)->first, 1);
-
-  BOOST_REQUIRE(map.find(addr2) != map.end());
-  BOOST_CHECK_EQUAL(*map.find(addr2)->first, 2);
-
-  BOOST_CHECK(map.find(addr_unknown) == map.end());
-
-  BOOST_CHECK_EQUAL(map.count(addr1), 1);
-  BOOST_CHECK_EQUAL(map.count(addr2), 1);
-  BOOST_CHECK_EQUAL(map.count(addr_unknown), 0);
-
-  BOOST_CHECK_EQUAL(map.erase(addr1), 1);
-  BOOST_CHECK_EQUAL(map.erase(addr2), 1);
-  BOOST_CHECK_EQUAL(map.erase(addr_unknown), 0);
-
-  BOOST_CHECK_EQUAL(map.size(), 1);
-}
-
-/**
- * Various operations on empty map
- */
-BOOST_AUTO_TEST_CASE(test_empty_map) {
-  tsl::robin_map<std::string, int> map(0);
-
-  BOOST_CHECK_EQUAL(map.bucket_count(), 0);
-  BOOST_CHECK_EQUAL(map.size(), 0);
-  BOOST_CHECK_EQUAL(map.load_factor(), 0);
-  BOOST_CHECK(map.empty());
-
-  BOOST_CHECK(map.begin() == map.end());
-  BOOST_CHECK(map.begin() == map.cend());
-  BOOST_CHECK(map.cbegin() == map.cend());
-
-  BOOST_CHECK(map.find("") == map.end());
-  BOOST_CHECK(map.find("test") == map.end());
-
-  BOOST_CHECK_EQUAL(map.count(""), 0);
-  BOOST_CHECK_EQUAL(map.count("test"), 0);
-
-  BOOST_CHECK(!map.contains(""));
-  BOOST_CHECK(!map.contains("test"));
-
-  TSL_RH_CHECK_THROW(map.at(""), std::out_of_range);
-  TSL_RH_CHECK_THROW(map.at("test"), std::out_of_range);
-
-  auto range = map.equal_range("test");
-  BOOST_CHECK(range.first == range.second);
-
-  BOOST_CHECK_EQUAL(map.erase("test"), 0);
-  BOOST_CHECK(map.erase(map.begin(), map.end()) == map.end());
-
-  BOOST_CHECK_EQUAL(map["new value"], int{});
-}
-
-/**
- * Test precalculated hash
- */
-BOOST_AUTO_TEST_CASE(test_precalculated_hash) {
-  tsl::robin_map<int, int, identity_hash<int>> map = {
-      {1, -1}, {2, -2}, {3, -3}, {4, -4}, {5, -5}, {6, -6}};
-  const tsl::robin_map<int, int, identity_hash<int>> map_const = map;
-
-  /**
-   * find
-   */
-  BOOST_REQUIRE(map.find(3, map.hash_function()(3)) != map.end());
-  BOOST_CHECK_EQUAL(map.find(3, map.hash_function()(3))->second, -3);
-
-  BOOST_REQUIRE(map_const.find(3, map_const.hash_function()(3)) !=
-                map_const.end());
-  BOOST_CHECK_EQUAL(map_const.find(3, map_const.hash_function()(3))->second,
-                    -3);
-
-  BOOST_REQUIRE_NE(map.hash_function()(2), map.hash_function()(3));
-  BOOST_CHECK(map.find(3, map.hash_function()(2)) == map.end());
-
-  /**
-   * at
-   */
-  BOOST_CHECK_EQUAL(map.at(3, map.hash_function()(3)), -3);
-  BOOST_CHECK_EQUAL(map_const.at(3, map_const.hash_function()(3)), -3);
-
-  BOOST_REQUIRE_NE(map.hash_function()(2), map.hash_function()(3));
-  TSL_RH_CHECK_THROW(map.at(3, map.hash_function()(2)), std::out_of_range);
-
-  /**
-   * contains
-   */
-  BOOST_CHECK(map.contains(3, map.hash_function()(3)));
-  BOOST_CHECK(map_const.contains(3, map_const.hash_function()(3)));
-
-  BOOST_REQUIRE_NE(map.hash_function()(2), map.hash_function()(3));
-  BOOST_CHECK(!map.contains(3, map.hash_function()(2)));
-
-  /**
-   * count
-   */
-  BOOST_CHECK_EQUAL(map.count(3, map.hash_function()(3)), 1);
-  BOOST_CHECK_EQUAL(map_const.count(3, map_const.hash_function()(3)), 1);
-
-  BOOST_REQUIRE_NE(map.hash_function()(2), map.hash_function()(3));
-  BOOST_CHECK_EQUAL(map.count(3, map.hash_function()(2)), 0);
-
-  /**
-   * equal_range
-   */
-  auto it_range = map.equal_range(3, map.hash_function()(3));
-  BOOST_REQUIRE_EQUAL(std::distance(it_range.first, it_range.second), 1);
-  BOOST_CHECK_EQUAL(it_range.first->second, -3);
-
-  auto it_range_const = map_const.equal_range(3, map_const.hash_function()(3));
-  BOOST_REQUIRE_EQUAL(
-      std::distance(it_range_const.first, it_range_const.second), 1);
-  BOOST_CHECK_EQUAL(it_range_const.first->second, -3);
-
-  it_range = map.equal_range(3, map.hash_function()(2));
-  BOOST_REQUIRE_NE(map.hash_function()(2), map.hash_function()(3));
-  BOOST_CHECK_EQUAL(std::distance(it_range.first, it_range.second), 0);
-
-  /**
-   * erase
-   */
-  BOOST_CHECK_EQUAL(map.erase(3, map.hash_function()(3)), 1);
-
-  BOOST_REQUIRE_NE(map.hash_function()(2), map.hash_function()(4));
-  BOOST_CHECK_EQUAL(map.erase(4, map.hash_function()(2)), 0);
-}
-
-BOOST_AUTO_TEST_CASE(test_erase_fast) {
-  using Map = tsl::robin_map<int, int>;
-  Map map;
-  map.emplace(4, 5);
-  auto it = map.find(4);
-  BOOST_CHECK(it != map.end());
-  map.erase_fast(it);
-  BOOST_CHECK(map.size() == 0);
-}
-
-
-BOOST_AUTO_TEST_SUITE_END()
diff --git a/src/nanobind/ext/robin_map/tests/robin_set_tests.cpp b/src/nanobind/ext/robin_map/tests/robin_set_tests.cpp
deleted file mode 100644
index e68b514..0000000
--- a/src/nanobind/ext/robin_map/tests/robin_set_tests.cpp
+++ /dev/null
@@ -1,174 +0,0 @@
-/**
- * MIT License
- *
- * Copyright (c) 2017 Thibaut Goetghebuer-Planchon <tessil@gmx.com>
- *
- * 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.
- */
-#include <tsl/robin_set.h>
-
-#include <boost/mpl/list.hpp>
-#include <boost/test/unit_test.hpp>
-#include <cstddef>
-#include <cstdint>
-#include <functional>
-#include <memory>
-#include <string>
-#include <tuple>
-#include <utility>
-
-#include "utils.h"
-
-BOOST_AUTO_TEST_SUITE(test_robin_set)
-
-using test_types =
-    boost::mpl::list<tsl::robin_set<std::int64_t>, tsl::robin_set<std::string>,
-                     tsl::robin_set<self_reference_member_test>,
-                     tsl::robin_set<move_only_test>,
-                     tsl::robin_pg_set<self_reference_member_test>,
-                     tsl::robin_set<move_only_test, std::hash<move_only_test>,
-                                    std::equal_to<move_only_test>,
-                                    std::allocator<move_only_test>, true,
-                                    tsl::rh::prime_growth_policy>,
-                     tsl::robin_set<self_reference_member_test,
-                                    std::hash<self_reference_member_test>,
-                                    std::equal_to<self_reference_member_test>,
-                                    std::allocator<self_reference_member_test>,
-                                    true, tsl::rh::mod_growth_policy<>>,
-                     tsl::robin_set<move_only_test, std::hash<move_only_test>,
-                                    std::equal_to<move_only_test>,
-                                    std::allocator<move_only_test>, false,
-                                    tsl::rh::mod_growth_policy<>>>;
-
-BOOST_AUTO_TEST_CASE_TEMPLATE(test_insert, HSet, test_types) {
-  // insert x values, insert them again, check values
-  using key_t = typename HSet::key_type;
-
-  const std::size_t nb_values = 1000;
-  HSet set;
-  typename HSet::iterator it;
-  bool inserted;
-
-  for (std::size_t i = 0; i < nb_values; i++) {
-    std::tie(it, inserted) = set.insert(utils::get_key<key_t>(i));
-
-    BOOST_CHECK_EQUAL(*it, utils::get_key<key_t>(i));
-    BOOST_CHECK(inserted);
-  }
-  BOOST_CHECK_EQUAL(set.size(), nb_values);
-
-  for (std::size_t i = 0; i < nb_values; i++) {
-    std::tie(it, inserted) = set.insert(utils::get_key<key_t>(i));
-
-    BOOST_CHECK_EQUAL(*it, utils::get_key<key_t>(i));
-    BOOST_CHECK(!inserted);
-  }
-
-  for (std::size_t i = 0; i < nb_values; i++) {
-    it = set.find(utils::get_key<key_t>(i));
-
-    BOOST_CHECK_EQUAL(*it, utils::get_key<key_t>(i));
-  }
-}
-
-BOOST_AUTO_TEST_CASE(test_compare) {
-  const tsl::robin_set<std::string> set1 = {"a", "e", "d", "c", "b"};
-  const tsl::robin_set<std::string> set1_copy = {"e", "c", "b", "a", "d"};
-  const tsl::robin_set<std::string> set2 = {"e", "c", "b", "a", "d", "f"};
-  const tsl::robin_set<std::string> set3 = {"e", "c", "b", "a"};
-  const tsl::robin_set<std::string> set4 = {"a", "e", "d", "c", "z"};
-
-  BOOST_CHECK(set1 == set1_copy);
-  BOOST_CHECK(set1_copy == set1);
-
-  BOOST_CHECK(set1 != set2);
-  BOOST_CHECK(set2 != set1);
-
-  BOOST_CHECK(set1 != set3);
-  BOOST_CHECK(set3 != set1);
-
-  BOOST_CHECK(set1 != set4);
-  BOOST_CHECK(set4 != set1);
-
-  BOOST_CHECK(set2 != set3);
-  BOOST_CHECK(set3 != set2);
-
-  BOOST_CHECK(set2 != set4);
-  BOOST_CHECK(set4 != set2);
-
-  BOOST_CHECK(set3 != set4);
-  BOOST_CHECK(set4 != set3);
-}
-
-BOOST_AUTO_TEST_CASE(test_insert_pointer) {
-  // Test added mainly to be sure that the code compiles with MSVC due to a bug
-  // in the compiler. See robin_hash::insert_value_impl for details.
-  std::string value;
-  std::string* value_ptr = &value;
-
-  tsl::robin_set<std::string*> set;
-  set.insert(value_ptr);
-  set.emplace(value_ptr);
-
-  BOOST_CHECK_EQUAL(set.size(), 1);
-  BOOST_CHECK_EQUAL(**set.begin(), value);
-}
-
-/**
- * serialize and deserialize
- */
-BOOST_AUTO_TEST_CASE(test_serialize_deserialize) {
-  // insert x values; delete some values; serialize set; deserialize in new set;
-  // check equal. for deserialization, test it with and without hash
-  // compatibility.
-  const std::size_t nb_values = 1000;
-
-  tsl::robin_set<move_only_test> set;
-  for (std::size_t i = 0; i < nb_values + 40; i++) {
-    set.insert(utils::get_key<move_only_test>(i));
-  }
-
-  for (std::size_t i = nb_values; i < nb_values + 40; i++) {
-    set.erase(utils::get_key<move_only_test>(i));
-  }
-  BOOST_CHECK_EQUAL(set.size(), nb_values);
-
-  serializer serial;
-  set.serialize(serial);
-
-  deserializer dserial(serial.str());
-  auto set_deserialized = decltype(set)::deserialize(dserial, true);
-  BOOST_CHECK(set == set_deserialized);
-
-  deserializer dserial2(serial.str());
-  set_deserialized = decltype(set)::deserialize(dserial2, false);
-  BOOST_CHECK(set_deserialized == set);
-}
-
-BOOST_AUTO_TEST_CASE(test_erase_fast) {
-  using Set = tsl::robin_set<int>;
-  Set set;
-  set.emplace(4);
-  auto it = set.find(4);
-  BOOST_CHECK(it != set.end());
-  set.erase_fast(it);
-  BOOST_CHECK(set.size() == 0);
-}
-
-BOOST_AUTO_TEST_SUITE_END()
diff --git a/src/nanobind/ext/robin_map/tests/utils.h b/src/nanobind/ext/robin_map/tests/utils.h
deleted file mode 100644
index 74433a3..0000000
--- a/src/nanobind/ext/robin_map/tests/utils.h
+++ /dev/null
@@ -1,443 +0,0 @@
-/**
- * MIT License
- *
- * Copyright (c) 2017 Thibaut Goetghebuer-Planchon <tessil@gmx.com>
- *
- * 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.
- */
-#ifndef TSL_UTILS_H
-#define TSL_UTILS_H
-
-#include <tsl/robin_hash.h>
-
-#include <cstddef>
-#include <cstdint>
-#include <functional>
-#include <memory>
-#include <ostream>
-#include <string>
-#include <utility>
-
-#ifdef TSL_RH_NO_EXCEPTIONS
-#define TSL_RH_CHECK_THROW(S, E)
-#define TSL_RH_CHECK_THROW_EITHER(S, E1, E2)
-#else
-#define TSL_RH_CHECK_THROW(S, E) BOOST_CHECK_THROW(S, E)
-#define TSL_RH_CHECK_THROW_EITHER(S, E1, E2) \
-  do {                                       \
-    try {                                    \
-      S;                                     \
-      BOOST_CHECK(false);                    \
-    } catch (const E1&) {                    \
-    } catch (const E2&) {                    \
-    }                                        \
-  } while (0)
-#endif
-
-template <typename T>
-class identity_hash {
- public:
-  std::size_t operator()(const T& value) const {
-    return static_cast<std::size_t>(value);
-  }
-};
-
-template <unsigned int MOD>
-class mod_hash {
- public:
-  template <typename T>
-  std::size_t operator()(const T& value) const {
-    return std::hash<T>()(value) % MOD;
-  }
-};
-
-class self_reference_member_test {
- public:
-  self_reference_member_test()
-      : m_value(std::to_string(-1)), m_value_ptr(&m_value) {}
-
-  explicit self_reference_member_test(std::int64_t value)
-      : m_value(std::to_string(value)), m_value_ptr(&m_value) {}
-
-  self_reference_member_test(const self_reference_member_test& other)
-      : m_value(*other.m_value_ptr), m_value_ptr(&m_value) {}
-
-  self_reference_member_test(self_reference_member_test&& other)
-      : m_value(*other.m_value_ptr), m_value_ptr(&m_value) {}
-
-  self_reference_member_test& operator=(
-      const self_reference_member_test& other) {
-    m_value = *other.m_value_ptr;
-    m_value_ptr = &m_value;
-
-    return *this;
-  }
-
-  self_reference_member_test& operator=(self_reference_member_test&& other) {
-    m_value = *other.m_value_ptr;
-    m_value_ptr = &m_value;
-
-    return *this;
-  }
-
-  std::string value() const { return *m_value_ptr; }
-
-  friend std::ostream& operator<<(std::ostream& stream,
-                                  const self_reference_member_test& value) {
-    stream << *value.m_value_ptr;
-
-    return stream;
-  }
-
-  friend bool operator==(const self_reference_member_test& lhs,
-                         const self_reference_member_test& rhs) {
-    return *lhs.m_value_ptr == *rhs.m_value_ptr;
-  }
-
-  friend bool operator!=(const self_reference_member_test& lhs,
-                         const self_reference_member_test& rhs) {
-    return !(lhs == rhs);
-  }
-
-  friend bool operator<(const self_reference_member_test& lhs,
-                        const self_reference_member_test& rhs) {
-    return *lhs.m_value_ptr < *rhs.m_value_ptr;
-  }
-
- private:
-  std::string m_value;
-  std::string* m_value_ptr;
-};
-
-class move_only_test {
- public:
-  explicit move_only_test(std::int64_t value)
-      : m_value(new std::string(std::to_string(value))) {}
-
-  explicit move_only_test(std::string value)
-      : m_value(new std::string(std::move(value))) {}
-
-  move_only_test(const move_only_test&) = delete;
-  move_only_test(move_only_test&&) = default;
-  move_only_test& operator=(const move_only_test&) = delete;
-  move_only_test& operator=(move_only_test&&) = default;
-
-  friend std::ostream& operator<<(std::ostream& stream,
-                                  const move_only_test& value) {
-    if (value.m_value == nullptr) {
-      stream << "null";
-    } else {
-      stream << *value.m_value;
-    }
-
-    return stream;
-  }
-
-  friend bool operator==(const move_only_test& lhs, const move_only_test& rhs) {
-    if (lhs.m_value == nullptr || rhs.m_value == nullptr) {
-      return lhs.m_value == nullptr && rhs.m_value == nullptr;
-    } else {
-      return *lhs.m_value == *rhs.m_value;
-    }
-  }
-
-  friend bool operator!=(const move_only_test& lhs, const move_only_test& rhs) {
-    return !(lhs == rhs);
-  }
-
-  friend bool operator<(const move_only_test& lhs, const move_only_test& rhs) {
-    if (lhs.m_value == nullptr && rhs.m_value == nullptr) {
-      return false;
-    } else if (lhs.m_value == nullptr) {
-      return true;
-    } else if (rhs.m_value == nullptr) {
-      return false;
-    } else {
-      return *lhs.m_value < *rhs.m_value;
-    }
-  }
-
-  const std::string& value() const { return *m_value; }
-
- private:
-  std::unique_ptr<std::string> m_value;
-};
-
-class copy_only_test {
- public:
-  explicit copy_only_test(std::int64_t value)
-      : m_value(std::to_string(value)) {}
-
-  copy_only_test(const copy_only_test& other) : m_value(other.m_value) {}
-
-  copy_only_test& operator=(const copy_only_test& other) {
-    m_value = other.m_value;
-
-    return *this;
-  }
-
-  ~copy_only_test() {}
-
-  friend std::ostream& operator<<(std::ostream& stream,
-                                  const copy_only_test& value) {
-    stream << value.m_value;
-
-    return stream;
-  }
-
-  friend bool operator==(const copy_only_test& lhs, const copy_only_test& rhs) {
-    return lhs.m_value == rhs.m_value;
-  }
-
-  friend bool operator!=(const copy_only_test& lhs, const copy_only_test& rhs) {
-    return !(lhs == rhs);
-  }
-
-  friend bool operator<(const copy_only_test& lhs, const copy_only_test& rhs) {
-    return lhs.m_value < rhs.m_value;
-  }
-
-  std::string value() const { return m_value; }
-
- private:
-  std::string m_value;
-};
-
-namespace std {
-template <>
-struct hash<self_reference_member_test> {
-  std::size_t operator()(const self_reference_member_test& val) const {
-    return std::hash<std::string>()(val.value());
-  }
-};
-
-template <>
-struct hash<move_only_test> {
-  std::size_t operator()(const move_only_test& val) const {
-    return std::hash<std::string>()(val.value());
-  }
-};
-
-template <>
-struct hash<copy_only_test> {
-  std::size_t operator()(const copy_only_test& val) const {
-    return std::hash<std::string>()(val.value());
-  }
-};
-}  // namespace std
-
-class utils {
- public:
-  template <typename T>
-  static T get_key(std::size_t counter);
-
-  template <typename T>
-  static T get_value(std::size_t counter);
-
-  template <typename HMap>
-  static HMap get_filled_hash_map(std::size_t nb_elements);
-};
-
-template <>
-inline std::int32_t utils::get_key<std::int32_t>(std::size_t counter) {
-  return tsl::detail_robin_hash::numeric_cast<std::int32_t>(counter);
-}
-
-template <>
-inline std::int64_t utils::get_key<std::int64_t>(std::size_t counter) {
-  return tsl::detail_robin_hash::numeric_cast<std::int64_t>(counter);
-}
-
-template <>
-inline self_reference_member_test utils::get_key<self_reference_member_test>(
-    std::size_t counter) {
-  return self_reference_member_test(
-      tsl::detail_robin_hash::numeric_cast<std::int64_t>(counter));
-}
-
-template <>
-inline std::string utils::get_key<std::string>(std::size_t counter) {
-  return "Key " + std::to_string(counter);
-}
-
-template <>
-inline move_only_test utils::get_key<move_only_test>(std::size_t counter) {
-  return move_only_test(
-      tsl::detail_robin_hash::numeric_cast<std::int64_t>(counter));
-}
-
-template <>
-inline copy_only_test utils::get_key<copy_only_test>(std::size_t counter) {
-  return copy_only_test(
-      tsl::detail_robin_hash::numeric_cast<std::int64_t>(counter));
-}
-
-template <>
-inline std::int32_t utils::get_value<std::int32_t>(std::size_t counter) {
-  return tsl::detail_robin_hash::numeric_cast<std::int32_t>(counter * 2);
-}
-
-template <>
-inline std::int64_t utils::get_value<std::int64_t>(std::size_t counter) {
-  return tsl::detail_robin_hash::numeric_cast<std::int64_t>(counter * 2);
-}
-
-template <>
-inline self_reference_member_test utils::get_value<self_reference_member_test>(
-    std::size_t counter) {
-  return self_reference_member_test(
-      tsl::detail_robin_hash::numeric_cast<std::int64_t>(counter * 2));
-}
-
-template <>
-inline std::string utils::get_value<std::string>(std::size_t counter) {
-  return "Value " + std::to_string(counter);
-}
-
-template <>
-inline move_only_test utils::get_value<move_only_test>(std::size_t counter) {
-  return move_only_test(
-      tsl::detail_robin_hash::numeric_cast<std::int64_t>(counter * 2));
-}
-
-template <>
-inline copy_only_test utils::get_value<copy_only_test>(std::size_t counter) {
-  return copy_only_test(
-      tsl::detail_robin_hash::numeric_cast<std::int64_t>(counter * 2));
-}
-
-template <typename HMap>
-inline HMap utils::get_filled_hash_map(std::size_t nb_elements) {
-  using key_t = typename HMap::key_type;
-  using value_t = typename HMap::mapped_type;
-
-  HMap map;
-  map.reserve(nb_elements);
-
-  for (std::size_t i = 0; i < nb_elements; i++) {
-    map.insert({utils::get_key<key_t>(i), utils::get_value<value_t>(i)});
-  }
-
-  return map;
-}
-
-template <class T>
-struct is_pair : std::false_type {};
-
-template <class T1, class T2>
-struct is_pair<std::pair<T1, T2>> : std::true_type {};
-
-/**
- * serializer helper to test serialize(...) and deserialize(...) functions
- */
-class serializer {
- public:
-  serializer() { m_ostream.exceptions(m_ostream.badbit | m_ostream.failbit); }
-
-  template <class T>
-  void operator()(const T& val) {
-    serialize_impl(val);
-  }
-
-  std::string str() const { return m_ostream.str(); }
-
- private:
-  template <typename T, typename U>
-  void serialize_impl(const std::pair<T, U>& val) {
-    serialize_impl(val.first);
-    serialize_impl(val.second);
-  }
-
-  void serialize_impl(const std::string& val) {
-    serialize_impl(
-        tsl::detail_robin_hash::numeric_cast<std::uint64_t>(val.size()));
-    m_ostream.write(val.data(), val.size());
-  }
-
-  void serialize_impl(const move_only_test& val) {
-    serialize_impl(val.value());
-  }
-
-  template <class T, typename std::enable_if<
-                         std::is_arithmetic<T>::value>::type* = nullptr>
-  void serialize_impl(const T& val) {
-    m_ostream.write(reinterpret_cast<const char*>(&val), sizeof(val));
-  }
-
- private:
-  std::stringstream m_ostream;
-};
-
-class deserializer {
- public:
-  explicit deserializer(const std::string& init_str = "")
-      : m_istream(init_str) {
-    m_istream.exceptions(m_istream.badbit | m_istream.failbit |
-                         m_istream.eofbit);
-  }
-
-  template <class T>
-  T operator()() {
-    return deserialize_impl<T>();
-  }
-
- private:
-  template <class T,
-            typename std::enable_if<is_pair<T>::value>::type* = nullptr>
-  T deserialize_impl() {
-    auto first = deserialize_impl<typename T::first_type>();
-    return std::make_pair(std::move(first),
-                          deserialize_impl<typename T::second_type>());
-  }
-
-  template <class T, typename std::enable_if<
-                         std::is_same<std::string, T>::value>::type* = nullptr>
-  T deserialize_impl() {
-    const std::size_t str_size =
-        tsl::detail_robin_hash::numeric_cast<std::size_t>(
-            deserialize_impl<std::uint64_t>());
-
-    // TODO std::string::data() return a const pointer pre-C++17. Avoid the
-    // inefficient double allocation.
-    std::vector<char> chars(str_size);
-    m_istream.read(chars.data(), str_size);
-
-    return std::string(chars.data(), chars.size());
-  }
-
-  template <class T, typename std::enable_if<std::is_same<
-                         move_only_test, T>::value>::type* = nullptr>
-  move_only_test deserialize_impl() {
-    return move_only_test(deserialize_impl<std::string>());
-  }
-
-  template <class T, typename std::enable_if<
-                         std::is_arithmetic<T>::value>::type* = nullptr>
-  T deserialize_impl() {
-    T val;
-    m_istream.read(reinterpret_cast<char*>(&val), sizeof(val));
-
-    return val;
-  }
-
- private:
-  std::stringstream m_istream;
-};
-
-#endif
diff --git a/src/nanobind/ext/robin_map/tsl-robin-map.natvis b/src/nanobind/ext/robin_map/tsl-robin-map.natvis
deleted file mode 100644
index f6eb842..0000000
--- a/src/nanobind/ext/robin_map/tsl-robin-map.natvis
+++ /dev/null
@@ -1,78 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<AutoVisualizer xmlns="http://schemas.microsoft.com/vstudio/debugger/natvis/2010">
-    <!-- Written in VC 2017 15.7 but is expected to be compatible with VC 2015 -->
-
-    <!-- Visualization that shows the index in the name column and the key-value pair in the value column -->
-    <Type Name="tsl::robin_map&lt;*&gt;" Priority="Medium">
-        <AlternativeType Name="tsl::robin_set&lt;*&gt;"/>
-        <DisplayString>{{ size={m_ht.m_nb_elements} }}</DisplayString>
-        <Expand>
-            <Item Name="[bucket_count]" IncludeView="detailed">m_ht.m_buckets_data._Mypair._Myval2._Mylast - m_ht.m_buckets_data._Mypair._Myval2._Myfirst</Item>
-            <Item Name="[load_factor]" Condition="m_ht.m_buckets_data._Mypair._Myval2._Myfirst != m_ht.m_buckets_data._Mypair._Myval2._Mylast" IncludeView="detailed">
-                ((float)m_ht.m_nb_elements) / ((float)(m_ht.m_buckets_data._Mypair._Myval2._Mylast - m_ht.m_buckets_data._Mypair._Myval2._Myfirst))
-            </Item>
-            <Item Name="[load_factor]" Condition="m_ht.m_buckets_data._Mypair._Myval2._Myfirst == m_ht.m_buckets_data._Mypair._Myval2._Mylast" IncludeView="detailed">
-                0
-            </Item>
-            <Item Name="[max_load_factor]" IncludeView="detailed">m_ht.m_max_load_factor</Item>
-            <CustomListItems>
-                <Variable Name="bucket" InitialValue="m_ht.m_buckets"/>
-
-                <Size>m_ht.m_nb_elements</Size>
-                <Loop>
-                    <Item Condition="bucket-&gt;m_dist_from_ideal_bucket != -1">*bucket</Item>
-                    <Break Condition="bucket-&gt;m_last_bucket"/>
-                    <Exec>++bucket</Exec>
-                </Loop>
-            </CustomListItems>
-        </Expand>
-    </Type>
-
-    <!-- Visualization that shows the key in the name column and the key-value pair in the value column -->
-    <Type Name="tsl::robin_map&lt;*&gt;" ExcludeView="ShowElementsByIndex" Priority="MediumHigh">
-        <DisplayString>{{ size={m_ht.m_nb_elements} }}</DisplayString>
-        <Expand>
-            <Item Name="[bucket_count]" IncludeView="detailed">m_ht.m_buckets_data._Mypair._Myval2._Mylast - m_ht.m_buckets_data._Mypair._Myval2._Myfirst</Item>
-            <Item Name="[load_factor]" Condition="m_ht.m_buckets_data._Mypair._Myval2._Myfirst != m_ht.m_buckets_data._Mypair._Myval2._Mylast" IncludeView="detailed">
-                ((float)m_ht.m_nb_elements) / ((float)(m_ht.m_buckets_data._Mypair._Myval2._Mylast - m_ht.m_buckets_data._Mypair._Myval2._Myfirst))
-            </Item>
-            <Item Name="[load_factor]" Condition="m_ht.m_buckets_data._Mypair._Myval2._Myfirst == m_ht.m_buckets_data._Mypair._Myval2._Mylast" IncludeView="detailed">
-                0
-            </Item>
-            <Item Name="[max_load_factor]" IncludeView="detailed">m_ht.m_max_load_factor</Item>
-            <CustomListItems>
-                <Variable Name="bucket" InitialValue="m_ht.m_buckets"/>
-
-                <Size>m_ht.m_nb_elements</Size>
-                <Loop>
-                    <Item Condition="bucket-&gt;m_dist_from_ideal_bucket != -1" Name="[{reinterpret_cast&lt;std::pair&lt;$T1,$T2&gt;*&gt;(&amp;bucket->m_value)->first}]">*bucket</Item>
-                    <Break Condition="bucket-&gt;m_last_bucket"/>
-                    <Exec>++bucket</Exec>
-                </Loop>
-            </CustomListItems>
-        </Expand>
-    </Type>
-
-    <Type Name="tsl::detail_robin_hash::robin_hash&lt;*&gt;::robin_iterator&lt;*&gt;">
-        <DisplayString>{*m_bucket}</DisplayString>
-        <Expand>
-            <ExpandedItem>*m_bucket</ExpandedItem>
-        </Expand>
-    </Type>
-
-    <Type Name="tsl::detail_robin_hash::bucket_entry&lt;*&gt;">
-        <DisplayString Condition="m_dist_from_ideal_bucket == -1">empty</DisplayString>
-        <DisplayString Condition="m_dist_from_ideal_bucket != -1">{*reinterpret_cast&lt;$T1*&gt;(&amp;m_value)}</DisplayString>
-        <Expand>
-            <ExpandedItem Condition="m_dist_from_ideal_bucket != -1">*reinterpret_cast&lt;$T1*&gt;(&amp;m_value)</ExpandedItem>
-        </Expand>
-    </Type>
-
-    <Type Name="tsl::detail_robin_hash::bucket_entry&lt;*&gt;" IncludeView="MapHelper">
-        <DisplayString Condition="m_dist_from_ideal_bucket == -1">empty</DisplayString>
-        <DisplayString Condition="m_dist_from_ideal_bucket != -1">{reinterpret_cast&lt;$T1*&gt;(&amp;m_value)->second}</DisplayString>
-        <Expand>
-            <ExpandedItem Condition="m_dist_from_ideal_bucket != -1">*reinterpret_cast&lt;$T1*&gt;(&amp;m_value)</ExpandedItem>
-        </Expand>
-    </Type>
-</AutoVisualizer>
diff --git a/src/nanobind/include/nanobind/eigen/dense.h b/src/nanobind/include/nanobind/eigen/dense.h
deleted file mode 100644
index b8224cb..0000000
--- a/src/nanobind/include/nanobind/eigen/dense.h
+++ /dev/null
@@ -1,474 +0,0 @@
-/*
-    nanobind/eigen/dense.h: type casters for dense Eigen
-    vectors and matrices
-
-    Copyright (c) 2023 Wenzel Jakob
-
-    All rights reserved. Use of this source code is governed by a
-    BSD-style license that can be found in the LICENSE file.
-*/
-
-#pragma once
-
-#include <nanobind/ndarray.h>
-#include <Eigen/Core>
-
-static_assert(EIGEN_VERSION_AT_LEAST(3, 3, 1),
-              "Eigen matrix support in nanobind requires Eigen >= 3.3.1");
-
-NAMESPACE_BEGIN(NB_NAMESPACE)
-
-/// Function argument types that are compatible with various array flavors
-using DStride = Eigen::Stride<Eigen::Dynamic, Eigen::Dynamic>;
-template <typename T> using DRef = Eigen::Ref<T, 0, DStride>;
-template <typename T> using DMap = Eigen::Map<T, 0, DStride>;
-
-NAMESPACE_BEGIN(detail)
-
-/// Determine the number of dimensions of the given Eigen type
-template <typename T>
-constexpr int ndim_v = bool(T::IsVectorAtCompileTime) ? 1 : 2;
-
-/// Extract the compile-time strides of the given Eigen type
-template <typename T> struct stride {
-    using type = Eigen::Stride<0, 0>;
-};
-
-template <typename T, int Options, typename StrideType> struct stride<Eigen::Map<T, Options, StrideType>> {
-    using type = StrideType;
-};
-
-template <typename T, int Options, typename StrideType> struct stride<Eigen::Ref<T, Options, StrideType>> {
-    using type = StrideType;
-};
-
-template <typename T> using stride_t = typename stride<T>::type;
-
-/** \brief Identify types with a contiguous memory representation.
- *
- * This includes all specializations of ``Eigen::Matrix``/``Eigen::Array`` and
- * certain specializations of ``Eigen::Map`` and ``Eigen::Ref``. Note: Eigen
- * interprets a compile-time stride of 0 as contiguous.
- */
-template <typename T>
-constexpr bool is_contiguous_v =
-    (stride_t<T>::InnerStrideAtCompileTime == 0 ||
-     stride_t<T>::InnerStrideAtCompileTime == 1) &&
-    (ndim_v<T> == 1 || stride_t<T>::OuterStrideAtCompileTime == 0 ||
-     (stride_t<T>::OuterStrideAtCompileTime != Eigen::Dynamic &&
-      int(stride_t<T>::OuterStrideAtCompileTime) == int(T::InnerSizeAtCompileTime)));
-
-/// Identify types with a static or dynamic layout that support contiguous storage
-template <typename T>
-constexpr bool can_map_contiguous_memory_v =
-    (stride_t<T>::InnerStrideAtCompileTime == 0 ||
-     stride_t<T>::InnerStrideAtCompileTime == 1 ||
-     stride_t<T>::InnerStrideAtCompileTime == Eigen::Dynamic) &&
-    (ndim_v<T> == 1 || stride_t<T>::OuterStrideAtCompileTime == 0 ||
-     stride_t<T>::OuterStrideAtCompileTime == Eigen::Dynamic ||
-     int(stride_t<T>::OuterStrideAtCompileTime) == int(T::InnerSizeAtCompileTime));
-
-/* This type alias builds the most suitable 'ndarray' for the given Eigen type.
-   In particular, it
-
-  - matches the underlying scalar type
-  - matches the number of dimensions (i.e. whether the type is a vector/matrix)
-  - matches the shape (if the row/column count is known at compile time)
-  - matches the in-memory ordering when the Eigen type is contiguous.
-
-  This is helpful because type_caster<ndarray<..>> will then perform the
-  necessary conversion steps (if given incompatible input) to enable data
-  exchange with Eigen.
-
-  A limitation of this approach is that ndarray does not support compile-time
-  strides besides c_contig and f_contig. If an Eigen type requires
-  non-contiguous strides (at compile-time) and we are given an ndarray with
-  unsuitable strides (at run-time), type casting will fail. Note, however, that
-  this is rather unusual, since the default stride type of Eigen::Map requires
-  contiguous memory, and the one of Eigen::Ref requires a contiguous inner
-  stride, while handling any outer stride.
-*/
-
-template <typename T, typename Scalar = typename T::Scalar>
-using array_for_eigen_t = ndarray<
-    Scalar,
-    numpy,
-    std::conditional_t<
-        ndim_v<T> == 1,
-        shape<T::SizeAtCompileTime>,
-        shape<T::RowsAtCompileTime,
-              T::ColsAtCompileTime>>,
-    std::conditional_t<
-        is_contiguous_v<T>,
-        std::conditional_t<
-            ndim_v<T> == 1 || T::IsRowMajor,
-            c_contig,
-            f_contig>,
-        unused>>;
-
-/// Any kind of Eigen class
-template <typename T> constexpr bool is_eigen_v = is_base_of_template_v<T, Eigen::EigenBase>;
-
-/// Detects Eigen::Array, Eigen::Matrix, etc.
-template <typename T> constexpr bool is_eigen_plain_v = is_base_of_template_v<T, Eigen::PlainObjectBase>;
-
-/// Detect Eigen::SparseMatrix
-template <typename T> constexpr bool is_eigen_sparse_v = is_base_of_template_v<T, Eigen::SparseMatrixBase>;
-
-/// Detects expression templates
-template <typename T> constexpr bool is_eigen_xpr_v =
-    is_eigen_v<T> && !is_eigen_plain_v<T> && !is_eigen_sparse_v<T> &&
-    !std::is_base_of_v<Eigen::MapBase<T, Eigen::ReadOnlyAccessors>, T>;
-
-template <typename T>
-struct type_caster<T, enable_if_t<is_eigen_plain_v<T> &&
-                                  is_ndarray_scalar_v<typename T::Scalar>>> {
-    using Scalar = typename T::Scalar;
-    using NDArray = array_for_eigen_t<T>;
-    using NDArrayCaster = make_caster<NDArray>;
-
-    NB_TYPE_CASTER(T, NDArrayCaster::Name)
-
-    bool from_python(handle src, uint8_t flags, cleanup_list *cleanup) noexcept {
-        // We're in any case making a copy, so non-writable inputs area also okay
-        using NDArrayConst = array_for_eigen_t<T, const typename T::Scalar>;
-        make_caster<NDArrayConst> caster;
-        if (!caster.from_python(src, flags & ~(uint8_t)cast_flags::accepts_none, cleanup))
-            return false;
-
-        const NDArrayConst &array = caster.value;
-        if constexpr (ndim_v<T> == 1)
-            value.resize(array.shape(0));
-        else
-            value.resize(array.shape(0), array.shape(1));
-
-        // The layout is contiguous & compatible thanks to array_for_eigen_t<T>
-        memcpy(value.data(), array.data(), array.size() * sizeof(Scalar));
-
-        return true;
-    }
-
-    template <typename T2>
-    static handle from_cpp(T2 &&v, rv_policy policy, cleanup_list *cleanup) noexcept {
-        policy = infer_policy<T2>(policy);
-        if constexpr (std::is_pointer_v<T2>)
-            return from_cpp_internal((const T &) *v, policy, cleanup);
-        else
-            return from_cpp_internal((const T &) v, policy, cleanup);
-    }
-
-    static handle from_cpp_internal(const T &v, rv_policy policy, cleanup_list *cleanup) noexcept {
-        size_t shape[ndim_v<T>];
-        int64_t strides[ndim_v<T>];
-
-        if constexpr (ndim_v<T> == 1) {
-            shape[0] = v.size();
-            strides[0] = v.innerStride();
-        } else {
-            shape[0] = v.rows();
-            shape[1] = v.cols();
-            strides[0] = v.rowStride();
-            strides[1] = v.colStride();
-        }
-
-        void *ptr = (void *) v.data();
-
-        if (policy == rv_policy::move) {
-            // Don't bother moving when the data is static or occupies <1KB
-            if ((T::SizeAtCompileTime != Eigen::Dynamic ||
-                 (size_t) v.size() < (1024 / sizeof(Scalar))))
-                policy = rv_policy::copy;
-        }
-
-        object owner;
-        if (policy == rv_policy::move) {
-            T *temp = new T(std::move(v));
-            owner = capsule(temp, [](void *p) noexcept { delete (T *) p; });
-            ptr = temp->data();
-            policy = rv_policy::reference;
-        } else if (policy == rv_policy::reference_internal && cleanup->self()) {
-            owner = borrow(cleanup->self());
-            policy = rv_policy::reference;
-        }
-
-        object o = steal(NDArrayCaster::from_cpp(
-            NDArray(ptr, ndim_v<T>, shape, owner, strides),
-            policy, cleanup));
-
-        return o.release();
-    }
-};
-
-/// Caster for Eigen expression templates
-template <typename T>
-struct type_caster<T, enable_if_t<is_eigen_xpr_v<T> &&
-                                  is_ndarray_scalar_v<typename T::Scalar>>> {
-    using Array = Eigen::Array<typename T::Scalar, T::RowsAtCompileTime,
-                               T::ColsAtCompileTime>;
-    using Caster = make_caster<Array>;
-    static constexpr auto Name = Caster::Name;
-    template <typename T_> using Cast = T;
-    template <typename T_> static constexpr bool can_cast() { return true; }
-
-    /// Generating an expression template from a Python object is, of course, not possible
-    bool from_python(handle src, uint8_t flags, cleanup_list *cleanup) noexcept = delete;
-
-    template <typename T2>
-    static handle from_cpp(T2 &&v, rv_policy policy, cleanup_list *cleanup) noexcept {
-        return Caster::from_cpp(std::forward<T2>(v), policy, cleanup);
-    }
-};
-
-/** \brief Type caster for ``Eigen::Map<T>``
-
-  The ``Eigen::Map<..>`` type exists to efficiently access memory provided by a
-  caller. Given that, the nanobind type caster refuses to turn incompatible
-  inputs into a ``Eigen::Map<T>`` when this would require an implicit
-  conversion.
-*/
-
-template <typename T, int Options, typename StrideType>
-struct type_caster<Eigen::Map<T, Options, StrideType>,
-                   enable_if_t<is_eigen_plain_v<T> &&
-                               is_ndarray_scalar_v<typename T::Scalar>>> {
-    using Map = Eigen::Map<T, Options, StrideType>;
-    using NDArray =
-        array_for_eigen_t<Map, std::conditional_t<std::is_const_v<T>,
-                                                  const typename Map::Scalar,
-                                                  typename Map::Scalar>>;
-    using NDArrayCaster = type_caster<NDArray>;
-    static constexpr auto Name = NDArrayCaster::Name;
-    template <typename T_> using Cast = Map;
-    template <typename T_> static constexpr bool can_cast() { return true; }
-
-    NDArrayCaster caster;
-
-    bool from_python(handle src, uint8_t flags, cleanup_list *cleanup) noexcept {
-        // Disable implicit conversions
-        return from_python_(src, flags & ~(uint8_t)cast_flags::convert, cleanup);
-    }
-
-    bool from_python_(handle src, uint8_t flags, cleanup_list* cleanup) noexcept {
-        if (!caster.from_python(src, flags & ~(uint8_t)cast_flags::accepts_none, cleanup))
-            return false;
-
-        // Check for memory layout compatibility of non-contiguous 'Map' types
-        if constexpr (!is_contiguous_v<Map>)  {
-            // Dynamic inner strides support any input, check the fixed case
-            if constexpr (StrideType::InnerStrideAtCompileTime != Eigen::Dynamic) {
-                // A compile-time stride of 0 implies "contiguous" ..
-                int64_t is_expected = StrideType::InnerStrideAtCompileTime == 0
-                                      ? 1 /*  .. and equals 1 for the inner stride */
-                                      : StrideType::InnerStrideAtCompileTime,
-                        is_actual = caster.value.stride(
-                            (ndim_v<T> != 1 && T::IsRowMajor) ? 1 : 0);
-
-                if (is_expected != is_actual)
-                    return false;
-            }
-
-            // Analogous check for the outer strides
-            if constexpr (ndim_v<T> == 2 && StrideType::OuterStrideAtCompileTime != Eigen::Dynamic) {
-                int64_t os_expected = StrideType::OuterStrideAtCompileTime == 0
-                                        ? caster.value.shape(T::IsRowMajor ? 1 : 0)
-                                        : StrideType::OuterStrideAtCompileTime,
-                        os_actual   = caster.value.stride(T::IsRowMajor ? 0 : 1);
-
-                if (os_expected != os_actual)
-                    return false;
-            }
-        }
-        return true;
-    }
-
-    static handle from_cpp(const Map &v, rv_policy policy, cleanup_list *cleanup) noexcept {
-        size_t shape[ndim_v<T>];
-        int64_t strides[ndim_v<T>];
-
-        if constexpr (ndim_v<T> == 1) {
-            shape[0] = v.size();
-            strides[0] = v.innerStride();
-        } else {
-            shape[0] = v.rows();
-            shape[1] = v.cols();
-            strides[0] = v.rowStride();
-            strides[1] = v.colStride();
-        }
-
-        return NDArrayCaster::from_cpp(
-            NDArray((void *) v.data(), ndim_v<T>, shape, handle(), strides),
-            (policy == rv_policy::automatic ||
-             policy == rv_policy::automatic_reference)
-                ? rv_policy::reference
-                : policy,
-            cleanup);
-    }
-
-    StrideType strides() const {
-        constexpr int IS = StrideType::InnerStrideAtCompileTime,
-                      OS = StrideType::OuterStrideAtCompileTime;
-
-        int64_t inner = caster.value.stride(0),
-                outer;
-
-        if constexpr (ndim_v<T> == 1)
-            outer = caster.value.shape(0);
-        else
-            outer = caster.value.stride(1);
-
-        (void) inner; (void) outer;
-        if constexpr (ndim_v<T> == 2 && T::IsRowMajor)
-            std::swap(inner, outer);
-
-        // Eigen may expect a stride of 0 to avoid an assertion failure
-        if constexpr (IS == 0)
-            inner = 0;
-
-        if constexpr (OS == 0)
-            outer = 0;
-
-        if constexpr (std::is_same_v<StrideType, Eigen::InnerStride<IS>>)
-            return StrideType(inner);
-        else if constexpr (std::is_same_v<StrideType, Eigen::OuterStride<OS>>)
-            return StrideType(outer);
-        else
-            return StrideType(outer, inner);
-    }
-
-    operator Map() {
-        NDArray &t = caster.value;
-        if constexpr (ndim_v<T> == 1)
-            return Map(t.data(), t.shape(0), strides());
-        else
-            return Map(t.data(), t.shape(0), t.shape(1), strides());
-    }
-};
-
-/** \brief Caster for Eigen::Ref<T>
-
-  Compared to the ``Eigen::Map<T>`` type caster above, the reference caster
-  accepts a wider set of inputs when it is used in *constant reference* mode
-  (i.e., ``Eigen::Ref<const T>``). In this case, it performs stride conversions
-  (except for unusual non-contiguous strides) as well as conversions of the
-  underlying scalar type (if implicit conversions are enabled).
-
-  For non-constant references, the caster matches that of ``Eigen::Map<T>`` and
-  requires an input with the expected layout (so that changes can propagate to
-  the caller).
-*/
-template <typename T, int Options, typename StrideType>
-struct type_caster<Eigen::Ref<T, Options, StrideType>,
-                   enable_if_t<is_eigen_plain_v<T> &&
-                               is_ndarray_scalar_v<typename T::Scalar>>> {
-    using Ref = Eigen::Ref<T, Options, StrideType>;
-
-    /// Potentially convert strides/dtype when casting constant references
-    static constexpr bool MaybeConvert =
-        std::is_const_v<T> &&
-        // Restrict to contiguous 'T' (limitation in Eigen, see PR #215)
-        can_map_contiguous_memory_v<Ref>;
-
-    using NDArray =
-        array_for_eigen_t<Ref, std::conditional_t<std::is_const_v<T>,
-                                                  const typename Ref::Scalar,
-                                                  typename Ref::Scalar>>;
-    using NDArrayCaster = type_caster<NDArray>;
-
-    /// Eigen::Map<T> caster with fixed strides
-    using Map = Eigen::Map<T, Options, StrideType>;
-    using MapCaster = make_caster<Map>;
-
-    // Extended version taking arbitrary strides
-    using DMap = Eigen::Map<const T, Options, DStride>;
-    using DMapCaster = make_caster<DMap>;
-
-    /**
-     * The constructor of ``Ref<const T>`` uses one of two strategies
-     * depending on the input. It may either
-     *
-     * 1. Create a copy ``Ref<const T>::m_object`` (owned by Ref), or
-     * 2. Reference the existing input (non-owned).
-     *
-     * When the value below is ``true``, then it is guaranteed that
-     * ``Ref(<DMap instance>)`` owns the underlying data.
-     */
-    static constexpr bool DMapConstructorOwnsData =
-        !Eigen::internal::traits<Ref>::template match<DMap>::type::value;
-
-    static constexpr auto Name =
-        const_name<MaybeConvert>(DMapCaster::Name, MapCaster::Name);
-
-    template <typename T_> using Cast = Ref;
-    template <typename T_> static constexpr bool can_cast() { return true; }
-
-    MapCaster caster;
-    struct Empty { };
-    std::conditional_t<MaybeConvert, DMapCaster, Empty> dcaster;
-
-    bool from_python(handle src, uint8_t flags, cleanup_list *cleanup) noexcept {
-        // Try a direct cast without implicit conversion first
-        if (caster.from_python(src, flags, cleanup))
-            return true;
-
-        // Potentially convert strides/dtype when casting constant references
-        if constexpr (MaybeConvert) {
-            /* Generating an implicit copy requires some object to assume
-               ownership. During a function call, ``dcaster`` can serve that
-               role (this case is detected by checking whether ``flags`` has
-               the ``manual`` flag set). When used in other situations (e.g.
-               ``nb::cast()``), the created ``Eigen::Ref<..>`` must take
-               ownership of the copy. This is only guranteed to work if
-               DMapConstructorOwnsData.
-
-               If neither of these is possible, we disable implicit
-               conversions. */
-
-            if ((flags & (uint8_t) cast_flags::manual) &&
-                !DMapConstructorOwnsData)
-                flags &= ~(uint8_t) cast_flags::convert;
-
-            if (dcaster.from_python_(src, flags, cleanup))
-                return true;
-        }
-
-        return false;
-    }
-
-    static handle from_cpp(const Ref &v, rv_policy policy, cleanup_list *cleanup) noexcept {
-        // Copied from the Eigen::Map caster
-
-        size_t shape[ndim_v<T>];
-        int64_t strides[ndim_v<T>];
-
-        if constexpr (ndim_v<T> == 1) {
-            shape[0] = v.size();
-            strides[0] = v.innerStride();
-        } else {
-            shape[0] = v.rows();
-            shape[1] = v.cols();
-            strides[0] = v.rowStride();
-            strides[1] = v.colStride();
-        }
-
-        return NDArrayCaster::from_cpp(
-            NDArray((void *) v.data(), ndim_v<T>, shape, handle(), strides),
-            (policy == rv_policy::automatic ||
-             policy == rv_policy::automatic_reference)
-                ? rv_policy::reference
-                : policy,
-            cleanup);
-    }
-
-    operator Ref() {
-        if constexpr (MaybeConvert) {
-            if (dcaster.caster.value.is_valid())
-                return Ref(dcaster.operator DMap());
-        }
-
-        return Ref(caster.operator Map());
-    }
-};
-
-NAMESPACE_END(detail)
-
-NAMESPACE_END(NB_NAMESPACE)
diff --git a/src/nanobind/include/nanobind/eigen/sparse.h b/src/nanobind/include/nanobind/eigen/sparse.h
deleted file mode 100644
index 7a137de..0000000
--- a/src/nanobind/include/nanobind/eigen/sparse.h
+++ /dev/null
@@ -1,290 +0,0 @@
-/*
-    nanobind/eigen/sparse.h: type casters for sparse Eigen matrices
-
-    Copyright (c) 2023 Henri Menke and Wenzel Jakob
-
-    All rights reserved. Use of this source code is governed by a
-    BSD-style license that can be found in the LICENSE file.
-*/
-
-#pragma once
-
-#include <nanobind/ndarray.h>
-#include <nanobind/eigen/dense.h>
-#include <Eigen/SparseCore>
-
-#include <memory>
-#include <type_traits>
-#include <utility>
-
-NAMESPACE_BEGIN(NB_NAMESPACE)
-
-NAMESPACE_BEGIN(detail)
-
-/// Detect Eigen::SparseMatrix
-template <typename T> constexpr bool is_eigen_sparse_matrix_v =
-    is_eigen_sparse_v<T> &&
-    !std::is_base_of_v<Eigen::SparseMapBase<T, Eigen::ReadOnlyAccessors>, T>;
-
-
-/// Caster for Eigen::SparseMatrix
-template <typename T> struct type_caster<T, enable_if_t<is_eigen_sparse_matrix_v<T>>> {
-    using Scalar = typename T::Scalar;
-    using StorageIndex = typename T::StorageIndex;
-    using Index = typename T::Index;
-    using SparseMap = Eigen::Map<T>;
-
-    static_assert(std::is_same_v<T, Eigen::SparseMatrix<Scalar, T::Options, StorageIndex>>,
-                  "nanobind: Eigen sparse caster only implemented for matrices");
-
-    static constexpr bool RowMajor = T::IsRowMajor;
-
-    using ScalarNDArray = ndarray<numpy, Scalar, shape<-1>>;
-    using StorageIndexNDArray = ndarray<numpy, StorageIndex, shape<-1>>;
-
-    using ScalarCaster = make_caster<ScalarNDArray>;
-    using StorageIndexCaster = make_caster<StorageIndexNDArray>;
-
-    NB_TYPE_CASTER(T, const_name<RowMajor>("scipy.sparse.csr_matrix[",
-                                           "scipy.sparse.csc_matrix[")
-                   + make_caster<Scalar>::Name + const_name("]"))
-
-    ScalarCaster data_caster;
-    StorageIndexCaster indices_caster, indptr_caster;
-
-    bool from_python(handle src, uint8_t flags, cleanup_list *cleanup) noexcept {
-        object obj = borrow(src);
-
-        try {
-            object matrix_type =
-                module_::import_("scipy.sparse")
-                    .attr(RowMajor ? "csr_matrix" : "csc_matrix");
-            if (!obj.type().is(matrix_type))
-                obj = matrix_type(obj);
-
-            if (!cast<bool>(obj.attr("has_sorted_indices")))
-                obj.attr("sort_indices")();
-
-            if (object data_o = obj.attr("data");
-                !data_caster.from_python(data_o, flags, cleanup))
-                return false;
-
-            if (object indices_o = obj.attr("indices");
-                !indices_caster.from_python(indices_o, flags, cleanup))
-                return false;
-
-            if (object indptr_o = obj.attr("indptr");
-                !indptr_caster.from_python(indptr_o, flags, cleanup))
-                return false;
-
-            object shape_o = obj.attr("shape");
-            if (len(shape_o) != 2)
-                return false;
-
-            Index rows = cast<Index>(shape_o[0]),
-                  cols = cast<Index>(shape_o[1]),
-                  nnz = cast<Index>(obj.attr("nnz"));
-
-            value = SparseMap(rows, cols, nnz,
-                              indptr_caster.value.data(),
-                              indices_caster.value.data(),
-                              data_caster.value.data());
-            return true;
-        } catch (const python_error &) {
-            return false;
-        }
-    }
-
-    static handle from_cpp(T &&v, rv_policy policy, cleanup_list *cleanup) noexcept {
-        if (policy == rv_policy::automatic ||
-            policy == rv_policy::automatic_reference)
-            policy = rv_policy::move;
-
-        return from_cpp((const T &) v, policy, cleanup);
-    }
-
-    template <typename T2>
-    static handle from_cpp(T2 &&v, rv_policy policy, cleanup_list *cleanup) noexcept {
-        policy = infer_policy<T2>(policy);
-        if constexpr (std::is_pointer_v<T2>)
-            return from_cpp_internal((const T &) *v, policy, cleanup);
-        else
-            return from_cpp_internal((const T &) v, policy, cleanup);
-    }
-
-    static handle from_cpp_internal(const T &v, rv_policy policy, cleanup_list *) noexcept {
-        if (!v.isCompressed()) {
-            PyErr_SetString(PyExc_ValueError,
-                            "nanobind: unable to return an Eigen sparse matrix that is not in a compressed format. "
-                            "Please call `.makeCompressed()` before returning the value on the C++ end.");
-            return handle();
-        }
-
-        object matrix_type;
-        try {
-            matrix_type = module_::import_("scipy.sparse").attr(RowMajor ? "csr_matrix" : "csc_matrix");
-        } catch (python_error &e) {
-            e.restore();
-            return handle();
-        }
-
-        const Index rows = v.rows(), cols = v.cols();
-        const size_t data_shape[] = { (size_t) v.nonZeros() };
-        const size_t outer_indices_shape[] = { (size_t) ((RowMajor ? rows : cols) + 1) };
-
-        T *src = std::addressof(const_cast<T &>(v));
-        object owner;
-        if (policy == rv_policy::move) {
-            src = new T(std::move(v));
-            owner = capsule(src, [](void *p) noexcept { delete (T *) p; });
-        }
-
-        ScalarNDArray data(src->valuePtr(), 1, data_shape, owner);
-        StorageIndexNDArray outer_indices(src->outerIndexPtr(), 1, outer_indices_shape, owner);
-        StorageIndexNDArray inner_indices(src->innerIndexPtr(), 1, data_shape, owner);
-
-        try {
-            return matrix_type(nanobind::make_tuple(
-                                   std::move(data), std::move(inner_indices), std::move(outer_indices)),
-                               nanobind::make_tuple(rows, cols))
-                .release();
-        } catch (python_error &e) {
-            e.restore();
-            return handle();
-        }
-    }
-};
-
-
-/// Caster for Eigen::Map<Eigen::SparseMatrix>, still needs to be implemented.
-template <typename T>
-struct type_caster<Eigen::Map<T>, enable_if_t<is_eigen_sparse_matrix_v<T>>> {
-    using Scalar = typename T::Scalar;
-    using StorageIndex = typename T::StorageIndex;
-    using Index = typename T::Index;
-    using SparseMap = Eigen::Map<T>;
-    using Map = Eigen::Map<T>;
-    using SparseMatrixCaster = type_caster<T>;
-    static constexpr bool RowMajor = T::IsRowMajor;
-
-    using ScalarNDArray = ndarray<numpy, Scalar, shape<-1>>;
-    using StorageIndexNDArray = ndarray<numpy, StorageIndex, shape<-1>>;
-
-    using ScalarCaster = make_caster<ScalarNDArray>;
-    using StorageIndexCaster = make_caster<StorageIndexNDArray>;
-
-    static constexpr auto Name = const_name<RowMajor>("scipy.sparse.csr_matrix[",
-                                           "scipy.sparse.csc_matrix[")
-                   + make_caster<Scalar>::Name + const_name("]");
-
-    template <typename T_> using Cast = Map;
-    template <typename T_> static constexpr bool can_cast() { return true; }
-
-    ScalarCaster data_caster;
-    StorageIndexCaster indices_caster, indptr_caster;
-    Index rows, cols, nnz;
-
-    bool from_python(handle src, uint8_t flags, cleanup_list *cleanup) noexcept {
-        flags = ~(uint8_t) cast_flags::convert;
-
-        try {
-            object matrix_type =
-                module_::import_("scipy.sparse")
-                    .attr(RowMajor ? "csr_matrix" : "csc_matrix");
-            if (!src.type().is(matrix_type))
-                return false;
-
-            if (!cast<bool>(src.attr("has_sorted_indices")))
-                src.attr("sort_indices")();
-
-            if (object data_o = src.attr("data");
-                !data_caster.from_python(data_o, flags, cleanup))
-                return false;
-
-            if (object indices_o = src.attr("indices");
-                !indices_caster.from_python(indices_o, flags, cleanup))
-                return false;
-
-            if (object indptr_o = src.attr("indptr");
-                !indptr_caster.from_python(indptr_o, flags, cleanup))
-                return false;
-
-            object shape_o = src.attr("shape");
-            if (len(shape_o) != 2)
-                return false;
-
-            rows = cast<Index>(shape_o[0]);
-            cols = cast<Index>(shape_o[1]);
-            nnz = cast<Index>(src.attr("nnz"));
-        } catch (const python_error &) {
-            return false;
-        }
-
-        return true;
-    }
-
-    static handle from_cpp(const Map &v, rv_policy, cleanup_list *) noexcept {
-        if (!v.isCompressed()) {
-            PyErr_SetString(
-                PyExc_ValueError,
-                "nanobind: unable to return an Eigen sparse matrix that is not "
-                "in a compressed format. Please call `.makeCompressed()` "
-                "before returning the value on the C++ end.");
-            return handle();
-        }
-
-        object matrix_type;
-        try {
-            matrix_type = module_::import_("scipy.sparse")
-                              .attr(RowMajor ? "csr_matrix" : "csc_matrix");
-
-            const Index rows = v.rows(), cols = v.cols();
-            const size_t data_shape[] = { (size_t) v.nonZeros() };
-            const size_t outer_indices_shape[] = {
-                (size_t) ((RowMajor ? rows : cols) + 1)
-            };
-
-            ScalarNDArray data((void *) v.valuePtr(), 1, data_shape);
-            StorageIndexNDArray
-                outer_indices((void *) v.outerIndexPtr(), 1, outer_indices_shape),
-                inner_indices((void *) v.innerIndexPtr(), 1, data_shape);
-
-            return matrix_type(nanobind::make_tuple(
-                                   cast(data, rv_policy::reference),
-                                   cast(inner_indices, rv_policy::reference),
-                                   cast(outer_indices, rv_policy::reference)),
-                               nanobind::make_tuple(rows, cols))
-                .release();
-        } catch (python_error &e) {
-            e.restore();
-            return handle();
-        }
-    };
-
-    operator Map() {
-        return SparseMap(rows, cols, nnz,
-                         indptr_caster.value.data(),
-                         indices_caster.value.data(),
-                         data_caster.value.data());
-    }
-};
-
-
-/// Caster for Eigen::Ref<Eigen::SparseMatrix>, still needs to be implemented
-template <typename T, int Options>
-struct type_caster<Eigen::Ref<T, Options>, enable_if_t<is_eigen_sparse_matrix_v<T>>> {
-    using Ref = Eigen::Ref<T, Options>;
-    using Map = Eigen::Map<T, Options>;
-    using MapCaster = make_caster<Map>;
-    static constexpr auto Name = MapCaster::Name;
-    template <typename T_> using Cast = Ref;
-    template <typename T_> static constexpr bool can_cast() { return true; }
-
-    bool from_python(handle src, uint8_t flags, cleanup_list *cleanup) noexcept = delete;
-
-    static handle from_cpp(const Ref &v, rv_policy policy, cleanup_list *cleanup) noexcept = delete;
-};
-
-NAMESPACE_END(detail)
-
-NAMESPACE_END(NB_NAMESPACE)
diff --git a/src/nanobind/include/nanobind/eval.h b/src/nanobind/include/nanobind/eval.h
deleted file mode 100644
index eb18f8e..0000000
--- a/src/nanobind/include/nanobind/eval.h
+++ /dev/null
@@ -1,61 +0,0 @@
-/*
-    nanobind/eval.h: Support for evaluating Python expressions and
-                     statements from strings
-
-    Adapted by Nico Schlömer from pybind11's eval.h.
-
-    All rights reserved. Use of this source code is governed by a
-    BSD-style license that can be found in the LICENSE file.
-*/
-
-#pragma once
-
-#include <nanobind/nanobind.h>
-
-NAMESPACE_BEGIN(NB_NAMESPACE)
-
-enum eval_mode {
-    // Evaluate a string containing an isolated expression
-    eval_expr = Py_eval_input,
-
-    // Evaluate a string containing a single statement. Returns \c none
-    eval_single_statement = Py_single_input,
-
-    // Evaluate a string containing a sequence of statement. Returns \c none
-    eval_statements = Py_file_input
-};
-
-template <eval_mode start = eval_expr>
-object eval(const str &expr, handle global = handle(), handle local = handle()) {
-    if (!local.is_valid())
-        local = global;
-
-    // This used to be PyRun_String, but that function isn't in the stable ABI.
-    object codeobj = steal(Py_CompileString(expr.c_str(), "<string>", start));
-    if (!codeobj.is_valid())
-        raise_python_error();
-
-    PyObject *result = PyEval_EvalCode(codeobj.ptr(), global.ptr(), local.ptr());
-    if (!result)
-        raise_python_error();
-
-    return steal(result);
-}
-
-template <eval_mode start = eval_expr, size_t N>
-object eval(const char (&s)[N], handle global = handle(), handle local = handle()) {
-    // Support raw string literals by removing common leading whitespace
-    str expr = (s[0] == '\n') ? str(module_::import_("textwrap").attr("dedent")(s)) : str(s);
-    return eval<start>(expr, global, local);
-}
-
-inline void exec(const str &expr, handle global = handle(), handle local = handle()) {
-    eval<eval_statements>(expr, global, local);
-}
-
-template <size_t N>
-void exec(const char (&s)[N], handle global = handle(), handle local = handle()) {
-    eval<eval_statements>(s, global, local);
-}
-
-NAMESPACE_END(NB_NAMESPACE)
diff --git a/src/nanobind/include/nanobind/intrusive/counter.h b/src/nanobind/include/nanobind/intrusive/counter.h
deleted file mode 100644
index cb15464..0000000
--- a/src/nanobind/include/nanobind/intrusive/counter.h
+++ /dev/null
@@ -1,261 +0,0 @@
-/*
-    nanobind/intrusive/counter.h: Intrusive reference counting sample
-    implementation.
-
-    Intrusive reference counting is a simple solution for various lifetime and
-    ownership-related issues that can arise in Python bindings of C++ code. The
-    implementation here represents one of many ways in which intrusive
-    reference counting can be realized and is included for convenience.
-
-    The code in this file is designed to be truly minimal: it depends neither
-    on Python, nanobind, nor the STL. This enables its use in small projects
-    with a 100% optional Python interface.
-
-    Two section of nanobind's documentation discuss intrusive reference
-    counting in general:
-
-     - https://nanobind.readthedocs.io/en/latest/ownership.html
-     - https://nanobind.readthedocs.io/en/latest/ownership_adv.html
-
-    Comments below are specific to this sample implementation.
-
-    Copyright (c) 2023 Wenzel Jakob
-
-    All rights reserved. Use of this source code is governed by a
-    BSD-style license that can be found in the LICENSE file.
-*/
-
-#pragma once
-
-#include <cstdint>
-
-// Override this definition to specify DLL export/import declarations
-#if !defined(NB_INTRUSIVE_EXPORT)
-#  define NB_INTRUSIVE_EXPORT
-#endif
-
-#if !defined(Py_PYTHON_H)
-/* While the implementation below does not directly depend on Python, the
-   PyObject type occurs in a few function interfaces (in a fully opaque
-   manner). The lines below forward-declare it. */
-extern "C" {
-    struct _object;
-    typedef _object PyObject;
-};
-#endif
-
-#if !defined(NAMESPACE_BEGIN)
-#  define NAMESPACE_BEGIN(name) namespace name {
-#endif
-
-#if !defined(NAMESPACE_END)
-#  define NAMESPACE_END(name) }
-#endif
-
-NAMESPACE_BEGIN(nanobind)
-
-/** \brief Simple intrusive reference counter.
- *
- * Intrusive reference counting is a simple solution for various lifetime and
- * ownership-related issues that can arise in Python bindings of C++ code. The
- * implementation here represents one of many ways in which intrusive reference
- * counting can be realized and is included for convenience.
- *
- * The ``intrusive_counter`` class represents an atomic counter that can be
- * increased (via ``inc_ref()``) or decreased (via ``dec_ref()``). When the
- * counter reaches zero, the object should be deleted, which ``dec_ref()``
- * indicates by returning ``true``.
- *
- * In addition to this simple counting mechanism, ownership of the object can
- * also be transferred to Python (via ``set_self_py()``). In this case,
- * subsequent calls to ``inc_ref()`` and ``dec_ref()`` modify the reference
- * count of the underlying Python object. The ``intrusive_counter`` class
- * supports both cases using only ``sizeof(void*)`` bytes of storage.
- *
- * To incorporate intrusive reference counting into your own project, you would
- * usually add an ``intrusive_counter``-typed member to the base class of an
- * object hierarchy and expose it as follows:
- *
- * ```cpp
- * #include <nanobind/intrusive/counter.h>
- *
- * class Object {
- * public:
- *     void inc_ref() noexcept { m_ref_count.inc_ref(); }
- *     bool dec_ref() noexcept { return m_ref_count.dec_ref(); }
- *
- *     // Important: must declare virtual destructor
- *     virtual ~Object() = default;
- *
- *     void set_self_py(PyObject *self) noexcept {
- *         m_ref_count.set_self_py(self);
- *     }
- *
- * private:
- *     nb::intrusive_counter m_ref_count;
- * };
- *
- * // Convenience function for increasing the reference count of an instance
- * inline void inc_ref(Object *o) noexcept {
- *     if (o)
- *        o->inc_ref();
- * }
- *
- * // Convenience function for decreasing the reference count of an instance
- * // and potentially deleting it when the count reaches zero
- * inline void dec_ref(Object *o) noexcept {
- *     if (o && o->dec_ref())
- *         delete o;
- * }
- * ```
- *
- * Alternatively, you could also inherit from ``intrusive_base``, which obviates
- * the need for all of the above declarations:
- *
- * ```cpp
- * class Object : public intrusive_base {
- * public:
- *     // ...
- * };
- * ```
- *
- * When binding the base class in Python, you must indicate to nanobind that
- * this type uses intrusive reference counting and expose the ``set_self_py``
- * member. This must only be done once, as the attribute is automatically
- * inherited by subclasses.
- *
- * ```cpp
- * nb::class_<Object>(
- *   m, "Object",
- *   nb::intrusive_ptr<Object>(
- *       [](Object *o, PyObject *po) noexcept { o->set_self_py(po); }));
- * ```
- *
- * Also, somewhere in your binding initialization code, you must call
- *
- * ```cpp
- * nb::intrusive_init(
- *     [](PyObject *o) noexcept {
- *         nb::gil_scoped_acquire guard;
- *         Py_INCREF(o);
- *     },
- *     [](PyObject *o) noexcept {
- *         nb::gil_scoped_acquire guard;
- *         Py_DECREF(o);
- *     });
- * ```
- *
- * For this all to compile, a single one of your .cpp files must include this
- * header file from somewhere as follows:
- *
- * ```cpp
- * #include <nanobind/intrusive/counter.inl>
- * ```
- *
- * Calling the ``inc_ref()`` and ``dec_ref()`` members many times throughout
- * the code can quickly become tedious. Nanobind also ships with a ``ref<T>``
- * RAII helper class to help with this.
- *
- * ```cpp
- * #include <nanobind/intrusive/ref.h>
- *
- * {
- *     ref<MyObject> x = new MyObject(); // <-- assigment to ref<..> automatically calls inc_ref()
- *     x->func(); // ref<..> can be used like a normal pointer
- * } // <-- Destruction of ref<..> calls dec_ref(), deleting the instance in this example.
- * ```
- *
- * When the file ``nanobind/intrusive/ref.h`` is included following
- * ``nanobind/nanobind.h``, it also exposes a custom type caster to bind
- * functions taking or returning ``ref<T>``-typed values.
- */
-struct NB_INTRUSIVE_EXPORT intrusive_counter {
-public:
-    intrusive_counter() noexcept = default;
-
-    // The counter value is not affected by copy/move assignment/construction
-    intrusive_counter(const intrusive_counter &) noexcept { }
-    intrusive_counter(intrusive_counter &&) noexcept { }
-    intrusive_counter &operator=(const intrusive_counter &) noexcept { return *this; }
-    intrusive_counter &operator=(intrusive_counter &&) noexcept { return *this; }
-
-    /// Increase the object's reference count
-    void inc_ref() const noexcept;
-
-    /// Decrease the object's reference count, return ``true`` if it should be deallocated
-    bool dec_ref() const noexcept;
-
-    /// Return the Python object associated with this instance (or NULL)
-    PyObject *self_py() const noexcept;
-
-    /// Set the Python object associated with this instance
-    void set_self_py(PyObject *self) noexcept;
-
-protected:
-    /**
-     * \brief Mutable counter. Note that the value ``1`` actually encodes
-     * a zero reference count (see the file ``counter.inl`` for details).
-     */
-    mutable uintptr_t m_state = 1;
-};
-
-static_assert(
-    sizeof(intrusive_counter) == sizeof(void *),
-    "The intrusive_counter class should always have the same size as a pointer.");
-
-/// Reference-counted base type of an object hierarchy
-class NB_INTRUSIVE_EXPORT intrusive_base {
-public:
-    /// Increase the object's reference count
-    void inc_ref() const noexcept { m_ref_count.inc_ref(); }
-
-    /// Decrease the object's reference count, return ``true`` if it should be deallocated
-    bool dec_ref() const noexcept { return m_ref_count.dec_ref(); }
-
-    /// Set the Python object associated with this instance
-    void set_self_py(PyObject *self) noexcept { m_ref_count.set_self_py(self); }
-
-    /// Return the Python object associated with this instance (or NULL)
-    PyObject *self_py() const noexcept { return m_ref_count.self_py(); }
-
-    /// Virtual destructor
-    virtual ~intrusive_base() = default;
-
-private:
-    mutable intrusive_counter m_ref_count;
-};
-
-/**
- * \brief Increase the reference count of an intrusively reference-counted
- * object ``o`` if ``o`` is non-NULL.
- */
-inline void inc_ref(const intrusive_base *o) noexcept {
-    if (o)
-        o->inc_ref();
-}
-
-/**
- * \brief Decrease the reference count and potentially delete an intrusively
- * reference-counted object ``o`` if ``o`` is non-NULL.
- */
-inline void dec_ref(const intrusive_base *o) noexcept {
-    if (o && o->dec_ref())
-        delete o;
-}
-
-/**
- * \brief Install Python reference counting handlers
- *
- * The ``intrusive_counter`` class is designed so that the dependency on Python is
- * *optional*: the code compiles in ordinary C++ projects, in which case the
- * Python reference counting functionality will simply not be used.
- *
- * Python binding code must invoke ``intrusive_init`` once to supply two
- * functions that increase and decrease the reference count of a Python object,
- * while ensuring that the GIL is held.
- */
-extern NB_INTRUSIVE_EXPORT
-void intrusive_init(void (*intrusive_inc_ref_py)(PyObject *) noexcept,
-                    void (*intrusive_dec_ref_py)(PyObject *) noexcept);
-
-NAMESPACE_END(nanobind)
diff --git a/src/nanobind/include/nanobind/intrusive/counter.inl b/src/nanobind/include/nanobind/intrusive/counter.inl
deleted file mode 100644
index faf6a27..0000000
--- a/src/nanobind/include/nanobind/intrusive/counter.inl
+++ /dev/null
@@ -1,148 +0,0 @@
-/*
-    nanobind/intrusive/counter.inl: Intrusive reference counting sample
-    implementation; see 'counter.h' for an explanation of the interface.
-
-    Copyright (c) 2023 Wenzel Jakob
-
-    All rights reserved. Use of this source code is governed by a
-    BSD-style license that can be found in the LICENSE file.
-*/
-
-#include "counter.h"
-#include <cstdio>
-#include <cstdlib>
-
-NAMESPACE_BEGIN(nanobind)
-
-// The code below uses intrinsics for atomic operations. This is not as nice
-// and portable as ``std::atomic<T>`` but avoids pulling in large amounts of
-// STL header code
-
-#if !defined(_MSC_VER)
-#define NB_ATOMIC_LOAD(ptr) __atomic_load_n(ptr, 0)
-#define NB_ATOMIC_STORE(ptr, v) __atomic_store_n(ptr, v, 0)
-#define NB_ATOMIC_CMPXCHG(ptr, cmp, xchg)                                      \
-    __atomic_compare_exchange_n(ptr, cmp, xchg, true, 0, 0)
-#else
-extern "C" void *_InterlockedCompareExchangePointer(
-    void *volatile *Destination,
-    void *Exchange, void *Comparand);
-#pragma intrinsic(_InterlockedCompareExchangePointer)
-
-#define NB_ATOMIC_LOAD(ptr) *((volatile const uintptr_t *) ptr)
-#define NB_ATOMIC_STORE(ptr, v) *((volatile uintptr_t *) ptr) = v;
-#define NB_ATOMIC_CMPXCHG(ptr, cmp, xchg) nb_cmpxchg(ptr, cmp, xchg)
-
-static bool nb_cmpxchg(uintptr_t *ptr, uintptr_t *cmp, uintptr_t xchg) {
-    uintptr_t cmpv = *cmp;
-    uintptr_t prev = (uintptr_t) _InterlockedCompareExchangePointer(
-        (void * volatile *) ptr, (void *) xchg, (void *) cmpv);
-    if (prev == cmpv) {
-        return true;
-    } else {
-        *cmp = prev;
-        return false;
-    }
-}
-#endif
-
-static void (*intrusive_inc_ref_py)(PyObject *) noexcept = nullptr,
-            (*intrusive_dec_ref_py)(PyObject *) noexcept = nullptr;
-
-void intrusive_init(void (*intrusive_inc_ref_py_)(PyObject *) noexcept,
-                    void (*intrusive_dec_ref_py_)(PyObject *) noexcept) {
-    intrusive_inc_ref_py = intrusive_inc_ref_py_;
-    intrusive_dec_ref_py = intrusive_dec_ref_py_;
-}
-
-/** A few implementation details:
- *
- * The ``intrusive_counter`` constructor sets the ``m_state`` field to ``1``,
- * which indicates that the instance is owned by C++. Bits 2..63 of this
- * field are used to store the actual reference count value. The
- * ``inc_ref()`` and ``dec_ref()`` functions increment or decrement this
- * number. When ``dec_ref()`` removes the last reference, the instance
- * returns ``true`` to indicate that it should be deallocated using a
- * *delete expression* that would typically be handled using a polymorphic
- * destructor.
- *
- * When an class with intrusive reference counting is returned from C++ to
- * Python, nanobind will invoke ``set_self_py()``, which hands ownership
- * over to Python/nanobind. Any remaining references will be moved from the
- * ``m_state`` field to the Python reference count. In this mode,
- * ``inc_ref()`` and ``dec_ref()`` wrap Python reference counting
- * primitives (``Py_INCREF()`` / ``Py_DECREF()``) which must be made
- * available by calling the function ``intrusive_init`` once during module
- * initialization. Note that the `m_state` field is also used to store a
- * pointer to the `PyObject *`. Python instance pointers are always aligned
- * (i.e. bit 1 is zero), which disambiguates between the two possible
- * configurations.
- */
-
-void intrusive_counter::inc_ref() const noexcept {
-    uintptr_t v = NB_ATOMIC_LOAD(&m_state);
-
-    while (true) {
-        if (v & 1) {
-            if (!NB_ATOMIC_CMPXCHG(&m_state, &v, v + 2))
-                continue;
-        } else {
-            intrusive_inc_ref_py((PyObject *) v);
-        }
-
-        break;
-    }
-}
-
-bool intrusive_counter::dec_ref() const noexcept {
-    uintptr_t v = NB_ATOMIC_LOAD(&m_state);
-
-    while (true) {
-        if (v & 1) {
-            if (v == 1) {
-                fprintf(stderr,
-                        "intrusive_counter::dec_ref(%p): reference count "
-                        "underflow!", (void *) this);
-                abort();
-            }
-
-            if (!NB_ATOMIC_CMPXCHG(&m_state, &v, v - 2))
-                continue;
-
-            if (v == 3)
-                return true;
-        } else {
-            intrusive_dec_ref_py((PyObject *) v);
-        }
-
-        return false;
-    }
-}
-
-void intrusive_counter::set_self_py(PyObject *o) noexcept {
-    uintptr_t v = NB_ATOMIC_LOAD(&m_state);
-
-    if (v & 1) {
-        v >>= 1;
-        for (uintptr_t i = 0; i < v; ++i)
-            intrusive_inc_ref_py(o);
-
-        NB_ATOMIC_STORE(&m_state, (uintptr_t) o);
-    } else {
-        fprintf(stderr,
-                "intrusive_counter::set_self_py(%p): a Python object was "
-                "already present!", (void *) this);
-        abort();
-    }
-}
-
-PyObject *intrusive_counter::self_py() const noexcept {
-    uintptr_t v = NB_ATOMIC_LOAD(&m_state);
-
-    if (v & 1)
-        return nullptr;
-    else
-        return (PyObject *) v;
-}
-
-NAMESPACE_END(nanobind)
diff --git a/src/nanobind/include/nanobind/intrusive/ref.h b/src/nanobind/include/nanobind/intrusive/ref.h
deleted file mode 100644
index a6f78b8..0000000
--- a/src/nanobind/include/nanobind/intrusive/ref.h
+++ /dev/null
@@ -1,153 +0,0 @@
-/*
-    nanobind/intrusive/ref.h: This file defines the ``ref<T>`` RAII scoped
-    reference counting helper class.
-
-    When included following ``nanobind/nanobind.h``, the code below also
-    exposes a custom type caster to bind functions taking or returning
-    ``ref<T>``-typed values.
-
-    Copyright (c) 2023 Wenzel Jakob
-
-    All rights reserved. Use of this source code is governed by a
-    BSD-style license that can be found in the LICENSE file.
-*/
-
-#pragma once
-
-#include "counter.h"
-
-NAMESPACE_BEGIN(nanobind)
-
-/**
- * \brief RAII scoped reference counting helper class
- *
- * ``ref`` is a simple RAII wrapper class that encapsulates a pointer to an
- * instance with intrusive reference counting.
- *
- * It takes care of increasing and decreasing the reference count as needed and
- * deleting the instance when the count reaches zero.
- *
- * For this to work, compatible functions ``inc_ref()`` and ``dec_ref()`` must
- * be defined before including this file. Default implementations for
- * subclasses of the type ``intrusive_base`` are already provided as part of the
- * file ``counter.h``.
- */
-template <typename T> class ref {
-public:
-    /// Create a null reference
-    ref() = default;
-
-    /// Construct a reference from a pointer
-    ref(T *ptr) : m_ptr(ptr) { inc_ref((intrusive_base *) m_ptr); }
-
-    /// Copy a reference, increases the reference count
-    ref(const ref &r) : m_ptr(r.m_ptr) { inc_ref((intrusive_base *) m_ptr); }
-
-    /// Move a reference without changing the reference count
-    ref(ref &&r) noexcept : m_ptr(r.m_ptr) { r.m_ptr = nullptr; }
-
-    /// Destroy this reference
-    ~ref() { dec_ref((intrusive_base *) m_ptr); }
-
-    /// Move-assign another reference into this one
-    ref &operator=(ref &&r) noexcept {
-        dec_ref((intrusive_base *) m_ptr);
-        m_ptr = r.m_ptr;
-        r.m_ptr = nullptr;
-        return *this;
-    }
-
-    /// Copy-assign another reference into this one
-    ref &operator=(const ref &r) {
-        inc_ref((intrusive_base *) r.m_ptr);
-        dec_ref((intrusive_base *) m_ptr);
-        m_ptr = r.m_ptr;
-        return *this;
-    }
-
-    /// Overwrite this reference with a pointer to another object
-    ref &operator=(T *ptr) {
-        inc_ref((intrusive_base *) ptr);
-        dec_ref((intrusive_base *) m_ptr);
-        m_ptr = ptr;
-        return *this;
-    }
-
-    /// Clear the currently stored reference
-    void reset() {
-        dec_ref((intrusive_base *) m_ptr);
-        m_ptr = nullptr;
-    }
-
-    /// Compare this reference with another reference
-    bool operator==(const ref &r) const { return m_ptr == r.m_ptr; }
-
-    /// Compare this reference with another reference
-    bool operator!=(const ref &r) const { return m_ptr != r.m_ptr; }
-
-    /// Compare this reference with a pointer
-    bool operator==(const T *ptr) const { return m_ptr == ptr; }
-
-    /// Compare this reference with a pointer
-    bool operator!=(const T *ptr) const { return m_ptr != ptr; }
-
-    /// Access the object referenced by this reference
-    T *operator->() { return m_ptr; }
-
-    /// Access the object referenced by this reference
-    const T *operator->() const { return m_ptr; }
-
-    /// Return a C++ reference to the referenced object
-    T &operator*() { return *m_ptr; }
-
-    /// Return a const C++ reference to the referenced object
-    const T &operator*() const { return *m_ptr; }
-
-    /// Return a pointer to the referenced object
-    operator T *() { return m_ptr; }
-
-    /// Return a const pointer to the referenced object
-    operator const T *() const { return m_ptr; }
-
-    /// Return a pointer to the referenced object
-    T *get() { return m_ptr; }
-
-    /// Return a const pointer to the referenced object
-    const T *get() const { return m_ptr; }
-
-private:
-    T *m_ptr = nullptr;
-};
-
-// Registar a type caster for ``ref<T>`` if nanobind was previously #included
-#if defined(NB_VERSION_MAJOR)
-NAMESPACE_BEGIN(detail)
-template <typename T> struct type_caster<nanobind::ref<T>> {
-    using Caster = make_caster<T>;
-    static constexpr bool IsClass = true;
-    NB_TYPE_CASTER(ref<T>, Caster::Name)
-
-    bool from_python(handle src, uint8_t flags,
-                     cleanup_list *cleanup) noexcept {
-        Caster caster;
-        if (!caster.from_python(src, flags, cleanup))
-            return false;
-
-        value = Value(caster.operator T *());
-        return true;
-    }
-
-    static handle from_cpp(const ref<T> &value, rv_policy policy,
-                           cleanup_list *cleanup) noexcept {
-        if constexpr (std::is_base_of_v<intrusive_base, T>)
-            if (policy != rv_policy::copy && policy != rv_policy::move && value.get())
-                if (PyObject* obj = value->self_py())
-                    return handle(obj).inc_ref();
-
-        return Caster::from_cpp(value.get(), policy, cleanup);
-    }
-};
-NAMESPACE_END(detail)
-#endif
-
-NAMESPACE_END(nanobind)
diff --git a/src/nanobind/include/nanobind/make_iterator.h b/src/nanobind/include/nanobind/make_iterator.h
deleted file mode 100644
index db63a91..0000000
--- a/src/nanobind/include/nanobind/make_iterator.h
+++ /dev/null
@@ -1,160 +0,0 @@
-/*
-    nanobind/make_iterator.h: nb::make_[key,value_]iterator()
-
-    This implementation is a port from pybind11 with minimal adjustments.
-
-    All rights reserved. Use of this source code is governed by a
-    BSD-style license that can be found in the LICENSE file.
-*/
-
-#pragma once
-
-#include <nanobind/nanobind.h>
-#include <nanobind/stl/pair.h>
-
-NAMESPACE_BEGIN(NB_NAMESPACE)
-NAMESPACE_BEGIN(detail)
-
-/* There are a large number of apparently unused template arguments because
-   each combination requires a separate nb::class_ registration. */
-template <typename Access, rv_policy Policy, typename Iterator,
-          typename Sentinel, typename ValueType, typename... Extra>
-struct iterator_state {
-    Iterator it;
-    Sentinel end;
-    bool first_or_done;
-};
-
-template <typename T>
-struct remove_rvalue_ref { using type = T; };
-template <typename T>
-struct remove_rvalue_ref<T&&> { using type = T; };
-
-// Note: these helpers take the iterator by non-const reference because some
-// iterators in the wild can't be dereferenced when const.
-template <typename Iterator> struct iterator_access {
-    using result_type = decltype(*std::declval<Iterator &>());
-    result_type operator()(Iterator &it) const { return *it; }
-};
-
-template <typename Iterator> struct iterator_key_access {
-    // Note double parens in decltype((...)) to capture the value category
-    // as well. This will be lvalue if the iterator's operator* returned an
-    // lvalue reference, and xvalue if the iterator's operator* returned an
-    // object (or rvalue reference but that's unlikely). decltype of an xvalue
-    // produces T&&, but we want to return a value T from operator() in that
-    // case, in order to avoid creating a Python object that references a
-    // C++ temporary. Thus, pass the result through remove_rvalue_ref.
-    using result_type = typename remove_rvalue_ref<
-        decltype(((*std::declval<Iterator &>()).first))>::type;
-    result_type operator()(Iterator &it) const { return (*it).first; }
-};
-
-template <typename Iterator> struct iterator_value_access {
-    using result_type = typename remove_rvalue_ref<
-        decltype(((*std::declval<Iterator &>()).second))>::type;
-    result_type operator()(Iterator &it) const { return (*it).second; }
-};
-
-template <typename Access, rv_policy Policy, typename Iterator,
-          typename Sentinel, typename ValueType, typename... Extra>
-typed<iterator, ValueType> make_iterator_impl(handle scope, const char *name,
-                                              Iterator first, Sentinel last,
-                                              Extra &&...extra) {
-    using State = iterator_state<Access, Policy, Iterator, Sentinel, ValueType, Extra...>;
-
-    static_assert(
-        !detail::is_base_caster_v<detail::make_caster<ValueType>> ||
-        detail::is_copy_constructible_v<ValueType> ||
-        (Policy != rv_policy::automatic_reference &&
-         Policy != rv_policy::copy),
-        "make_iterator_impl(): the generated __next__ would copy elements, so the "
-        "element type must be copy-constructible");
-
-    {
-        static ft_mutex mu;
-        ft_lock_guard lock(mu);
-        if (!type<State>().is_valid()) {
-            class_<State>(scope, name)
-                .def("__iter__", [](handle h) { return h; })
-                .def("__next__",
-                    [](State &s) -> ValueType {
-                        if (!s.first_or_done)
-                            ++s.it;
-                        else
-                            s.first_or_done = false;
-
-                        if (s.it == s.end) {
-                            s.first_or_done = true;
-                            throw stop_iteration();
-                        }
-
-                        return Access()(s.it);
-                    },
-                    std::forward<Extra>(extra)...,
-                    Policy);
-        }
-    }
-    return borrow<typed<iterator, ValueType>>(cast(State{
-        std::forward<Iterator>(first), std::forward<Sentinel>(last), true }));
-}
-
-NAMESPACE_END(detail)
-
-/// Makes a python iterator from a first and past-the-end C++ InputIterator.
-template <rv_policy Policy = rv_policy::automatic_reference,
-          typename Iterator,
-          typename Sentinel,
-          typename ValueType = typename detail::iterator_access<Iterator>::result_type,
-          typename... Extra,
-          typename = decltype(std::declval<Iterator>() == std::declval<Sentinel>())>
-auto make_iterator(handle scope, const char *name, Iterator first, Sentinel last, Extra &&...extra) {
-    return detail::make_iterator_impl<detail::iterator_access<Iterator>, Policy,
-                                      Iterator, Sentinel, ValueType, Extra...>(
-        scope, name, std::forward<Iterator>(first),
-        std::forward<Sentinel>(last), std::forward<Extra>(extra)...);
-}
-
-/// Makes an iterator over the keys (`.first`) of a iterator over pairs from a
-/// first and past-the-end InputIterator.
-template <rv_policy Policy = rv_policy::automatic_reference, typename Iterator,
-          typename Sentinel,
-          typename KeyType =
-              typename detail::iterator_key_access<Iterator>::result_type,
-          typename... Extra>
-auto make_key_iterator(handle scope, const char *name, Iterator first,
-                       Sentinel last, Extra &&...extra) {
-    return detail::make_iterator_impl<detail::iterator_key_access<Iterator>,
-                                      Policy, Iterator, Sentinel, KeyType,
-                                      Extra...>(
-        scope, name, std::forward<Iterator>(first),
-        std::forward<Sentinel>(last), std::forward<Extra>(extra)...);
-}
-
-/// Makes an iterator over the values (`.second`) of a iterator over pairs from a
-/// first and past-the-end InputIterator.
-template <rv_policy Policy = rv_policy::automatic_reference,
-          typename Iterator,
-          typename Sentinel,
-          typename ValueType = typename detail::iterator_value_access<Iterator>::result_type,
-          typename... Extra>
-auto make_value_iterator(handle scope, const char *name, Iterator first, Sentinel last, Extra &&...extra) {
-    return detail::make_iterator_impl<detail::iterator_value_access<Iterator>,
-                                      Policy, Iterator, Sentinel, ValueType,
-                                      Extra...>(
-        scope, name, std::forward<Iterator>(first),
-        std::forward<Sentinel>(last), std::forward<Extra>(extra)...);
-}
-
-/// Makes an iterator over values of a container supporting `std::begin()`/`std::end()`
-template <rv_policy Policy = rv_policy::automatic_reference,
-          typename Type,
-          typename... Extra,
-          typename = decltype(std::begin(std::declval<Type&>()))>
-auto make_iterator(handle scope, const char *name, Type &value, Extra &&...extra) {
-    return make_iterator<Policy>(scope, name, std::begin(value),
-                                 std::end(value),
-                                 std::forward<Extra>(extra)...);
-}
-
-NAMESPACE_END(NB_NAMESPACE)
diff --git a/src/nanobind/include/nanobind/nanobind.h b/src/nanobind/include/nanobind/nanobind.h
deleted file mode 100644
index bf0b768..0000000
--- a/src/nanobind/include/nanobind/nanobind.h
+++ /dev/null
@@ -1,61 +0,0 @@
-/*
-    nanobind/nanobind.h: Main include file for core nanobind components
-
-    Copyright (c) 2022 Wenzel Jakob
-
-    All rights reserved. Use of this source code is governed by a
-    BSD-style license that can be found in the LICENSE file.
-*/
-
-#pragma once
-
-#if __cplusplus < 201703L && (!defined(_MSVC_LANG) || _MSVC_LANG < 201703L)
-#  error The nanobind library requires C++17!
-#endif
-
-#if defined(_MSC_VER)
-#  pragma warning(push)
-#  pragma warning(disable: 4702) // unreachable code (e.g. when binding a noreturn function)
-   // The next two lines disable warnings that are "just noise" according to Stephan T. Lavavej (a MSFT STL maintainer)
-#  pragma warning(disable: 4275) // non dll-interface class 'std::exception' used as base for dll-interface class [..]
-#  pragma warning(disable: 4251) // [..] needs to have a dll-interface to be used by clients of class [..]
-#endif
-
-#define NB_VERSION_MAJOR 2
-#define NB_VERSION_MINOR 7
-#define NB_VERSION_PATCH 1
-#define NB_VERSION_DEV   1 // A value > 0 indicates a development release
-
-// Core C++ headers that nanobind depends on
-#include <cstddef>
-#include <cstdint>
-#include <exception>
-#include <stdexcept>
-#include <type_traits>
-#include <typeinfo>
-#include <utility>
-#include <new>
-
-// Implementation. The nb_*.h files should only be included through nanobind.h
-// IWYU pragma: begin_exports
-#include "nb_python.h"
-#include "nb_defs.h"
-#include "nb_enums.h"
-#include "nb_traits.h"
-#include "nb_tuple.h"
-#include "nb_lib.h"
-#include "nb_descr.h"
-#include "nb_types.h"
-#include "nb_accessor.h"
-#include "nb_error.h"
-#include "nb_attr.h"
-#include "nb_cast.h"
-#include "nb_misc.h"
-#include "nb_call.h"
-#include "nb_func.h"
-#include "nb_class.h"
-// IWYU pragma: end_exports
-
-#if defined(_MSC_VER)
-#  pragma warning(pop)
-#endif
diff --git a/src/nanobind/include/nanobind/nb_accessor.h b/src/nanobind/include/nanobind/nb_accessor.h
deleted file mode 100644
index f690360..0000000
--- a/src/nanobind/include/nanobind/nb_accessor.h
+++ /dev/null
@@ -1,225 +0,0 @@
-/*
-    nanobind/nb_accessor.h: Accessor helper class for .attr(), operator[]
-
-    Copyright (c) 2022 Wenzel Jakob
-
-    All rights reserved. Use of this source code is governed by a
-    BSD-style license that can be found in the LICENSE file.
-*/
-
-NAMESPACE_BEGIN(NB_NAMESPACE)
-NAMESPACE_BEGIN(detail)
-
-template <typename Impl> class accessor : public api<accessor<Impl>> {
-    template <typename T> friend void nanobind::del(accessor<T> &);
-    template <typename T> friend void nanobind::del(accessor<T> &&);
-public:
-    static constexpr auto Name = const_name("object");
-
-    template <typename Key>
-    accessor(handle obj, Key &&key)
-        : m_base(obj.ptr()), m_key(std::move(key)) { }
-    accessor(const accessor &) = delete;
-    accessor(accessor &&) = delete;
-    ~accessor() {
-        if constexpr (Impl::cache_dec_ref)
-            Py_XDECREF(m_cache);
-    }
-
-    template <typename T> accessor& operator=(T &&value);
-
-    template <typename T, enable_if_t<std::is_base_of_v<object, T>> = 0>
-    operator T() const { return borrow<T>(ptr()); }
-    NB_INLINE PyObject *ptr() const {
-        Impl::get(m_base, m_key, &m_cache);
-        return m_cache;
-    }
-    NB_INLINE handle base() const { return m_base; }
-    NB_INLINE object key() const { return steal(Impl::key(m_key)); }
-
-private:
-    NB_INLINE void del () { Impl::del(m_base, m_key); }
-
-private:
-    PyObject *m_base;
-    mutable PyObject *m_cache{nullptr};
-    typename Impl::key_type m_key;
-};
-
-struct str_attr {
-    static constexpr bool cache_dec_ref = true;
-    using key_type = const char *;
-
-    NB_INLINE static void get(PyObject *obj, const char *key, PyObject **cache) {
-        detail::getattr_or_raise(obj, key, cache);
-    }
-
-    NB_INLINE static void set(PyObject *obj, const char *key, PyObject *v) {
-        setattr(obj, key, v);
-    }
-
-    NB_INLINE static PyObject *key(const char *key) {
-        return PyUnicode_InternFromString(key);
-    }
-};
-
-struct obj_attr {
-    static constexpr bool cache_dec_ref = true;
-    using key_type = handle;
-
-    NB_INLINE static void get(PyObject *obj, handle key, PyObject **cache) {
-        detail::getattr_or_raise(obj, key.ptr(), cache);
-    }
-
-    NB_INLINE static void set(PyObject *obj, handle key, PyObject *v) {
-        setattr(obj, key.ptr(), v);
-    }
-
-    NB_INLINE static PyObject *key(handle key) {
-        Py_INCREF(key.ptr());
-        return key.ptr();
-    }
-};
-
-struct str_item {
-    static constexpr bool cache_dec_ref = true;
-    using key_type = const char *;
-
-    NB_INLINE static void get(PyObject *obj, const char *key, PyObject **cache) {
-        detail::getitem_or_raise(obj, key, cache);
-    }
-
-    NB_INLINE static void set(PyObject *obj, const char *key, PyObject *v) {
-        setitem(obj, key, v);
-    }
-
-    NB_INLINE static void del(PyObject *obj, const char *key) {
-        delitem(obj, key);
-    }
-};
-
-struct obj_item {
-    static constexpr bool cache_dec_ref = true;
-    using key_type = handle;
-
-    NB_INLINE static void get(PyObject *obj, handle key, PyObject **cache) {
-        detail::getitem_or_raise(obj, key.ptr(), cache);
-    }
-
-    NB_INLINE static void set(PyObject *obj, handle key, PyObject *v) {
-        setitem(obj, key.ptr(), v);
-    }
-
-    NB_INLINE static void del(PyObject *obj, handle key) {
-        delitem(obj, key.ptr());
-    }
-};
-
-struct num_item {
-    static constexpr bool cache_dec_ref = true;
-    using key_type = Py_ssize_t;
-
-    NB_INLINE static void get(PyObject *obj, Py_ssize_t index, PyObject **cache) {
-        detail::getitem_or_raise(obj, index, cache);
-    }
-
-    NB_INLINE static void set(PyObject *obj, Py_ssize_t index, PyObject *v) {
-        setitem(obj, index, v);
-    }
-
-    NB_INLINE static void del(PyObject *obj, Py_ssize_t index) {
-        delitem(obj, index);
-    }
-};
-
-struct num_item_list {
-    #if defined(Py_GIL_DISABLED)
-          static constexpr bool cache_dec_ref = true;
-    #else
-          static constexpr bool cache_dec_ref = false;
-    #endif
-
-    using key_type = Py_ssize_t;
-
-    NB_INLINE static void get(PyObject *obj, Py_ssize_t index, PyObject **cache) {
-        #if defined(Py_GIL_DISABLED)
-            *cache = PyList_GetItemRef(obj, index);
-        #else
-            *cache = NB_LIST_GET_ITEM(obj, index);
-        #endif
-    }
-
-    NB_INLINE static void set(PyObject *obj, Py_ssize_t index, PyObject *v) {
-#if defined(Py_LIMITED_API) || defined(NB_FREE_THREADED)
-        Py_INCREF(v);
-        PyList_SetItem(obj, index, v);
-#else
-        PyObject *old = NB_LIST_GET_ITEM(obj, index);
-        Py_INCREF(v);
-        NB_LIST_SET_ITEM(obj, index, v);
-        Py_DECREF(old);
-#endif
-    }
-
-    NB_INLINE static void del(PyObject *obj, Py_ssize_t index) {
-        delitem(obj, index);
-    }
-};
-
-struct num_item_tuple {
-    static constexpr bool cache_dec_ref = false;
-    using key_type = Py_ssize_t;
-
-    NB_INLINE static void get(PyObject *obj, Py_ssize_t index, PyObject **cache) {
-        *cache = NB_TUPLE_GET_ITEM(obj, index);
-    }
-
-    template <typename...Ts> static void set(Ts...) {
-        static_assert(false_v<Ts...>, "tuples are immutable!");
-    }
-};
-
-template <typename D> accessor<obj_attr> api<D>::attr(handle key) const {
-    return { derived(), borrow(key) };
-}
-
-template <typename D> accessor<str_attr> api<D>::attr(const char *key) const {
-    return { derived(), key };
-}
-
-template <typename D> accessor<str_attr> api<D>::doc() const {
-    return { derived(), "__doc__" };
-}
-
-template <typename D> accessor<obj_item> api<D>::operator[](handle key) const {
-    return { derived(), borrow(key) };
-}
-
-template <typename D> accessor<str_item> api<D>::operator[](const char *key) const {
-    return { derived(), key };
-}
-
-template <typename D>
-template <typename T, enable_if_t<std::is_arithmetic_v<T>>>
-accessor<num_item> api<D>::operator[](T index) const {
-    return { derived(), (Py_ssize_t) index };
-}
-
-NAMESPACE_END(detail)
-
-template <typename T, detail::enable_if_t<std::is_arithmetic_v<T>>>
-detail::accessor<detail::num_item_list> list::operator[](T index) const {
-    return { derived(), (Py_ssize_t) index };
-}
-
-template <typename T, detail::enable_if_t<std::is_arithmetic_v<T>>>
-detail::accessor<detail::num_item_tuple> tuple::operator[](T index) const {
-    return { derived(), (Py_ssize_t) index };
-}
-
-template <typename... Args> str str::format(Args&&... args) {
-    return steal<str>(
-        derived().attr("format")((detail::forward_t<Args>) args...).release());
-}
-
-NAMESPACE_END(NB_NAMESPACE)
diff --git a/src/nanobind/include/nanobind/nb_attr.h b/src/nanobind/include/nanobind/nb_attr.h
deleted file mode 100644
index a69df86..0000000
--- a/src/nanobind/include/nanobind/nb_attr.h
+++ /dev/null
@@ -1,471 +0,0 @@
-/*
-    nanobind/nb_attr.h: Annotations for function and class declarations
-
-    Copyright (c) 2022 Wenzel Jakob
-
-    All rights reserved. Use of this source code is governed by a
-    BSD-style license that can be found in the LICENSE file.
-*/
-
-NAMESPACE_BEGIN(NB_NAMESPACE)
-
-struct scope {
-    PyObject *value;
-    NB_INLINE scope(handle value) : value(value.ptr()) {}
-};
-
-struct name {
-    const char *value;
-    NB_INLINE name(const char *value) : value(value) {}
-};
-
-struct arg_v;
-struct arg_locked;
-struct arg_locked_v;
-
-// Basic function argument descriptor (no default value, not locked)
-struct arg {
-    NB_INLINE constexpr explicit arg(const char *name = nullptr) : name_(name), signature_(nullptr) { }
-
-    // operator= can be used to provide a default value
-    template <typename T> NB_INLINE arg_v operator=(T &&value) const;
-
-    // Mutators that don't change default value or locked state
-    NB_INLINE arg &noconvert(bool value = true) {
-        convert_ = !value;
-        return *this;
-    }
-    NB_INLINE arg &none(bool value = true) {
-        none_ = value;
-        return *this;
-    }
-    NB_INLINE arg &sig(const char *value) {
-        signature_ = value;
-        return *this;
-    }
-
-    // After lock(), this argument is locked
-    NB_INLINE arg_locked lock();
-
-    const char *name_, *signature_;
-    uint8_t convert_{ true };
-    bool none_{ false };
-};
-
-// Function argument descriptor with default value (not locked)
-struct arg_v : arg {
-    object value;
-    NB_INLINE arg_v(const arg &base, object &&value)
-        : arg(base), value(std::move(value)) {}
-
-  private:
-    // Inherited mutators would slice off the default, and are not generally needed
-    using arg::noconvert;
-    using arg::none;
-    using arg::sig;
-    using arg::lock;
-};
-
-// Function argument descriptor that is locked (no default value)
-struct arg_locked : arg {
-    NB_INLINE constexpr explicit arg_locked(const char *name = nullptr) : arg(name) { }
-    NB_INLINE constexpr explicit arg_locked(const arg &base) : arg(base) { }
-
-    // operator= can be used to provide a default value
-    template <typename T> NB_INLINE arg_locked_v operator=(T &&value) const;
-
-    // Mutators must be respecified in order to not slice off the locked status
-    NB_INLINE arg_locked &noconvert(bool value = true) {
-        convert_ = !value;
-        return *this;
-    }
-    NB_INLINE arg_locked &none(bool value = true) {
-        none_ = value;
-        return *this;
-    }
-    NB_INLINE arg_locked &sig(const char *value) {
-        signature_ = value;
-        return *this;
-    }
-
-    // Redundant extra lock() is allowed
-    NB_INLINE arg_locked &lock() { return *this; }
-};
-
-// Function argument descriptor that is potentially locked and has a default value
-struct arg_locked_v : arg_locked {
-    object value;
-    NB_INLINE arg_locked_v(const arg_locked &base, object &&value)
-        : arg_locked(base), value(std::move(value)) {}
-
-  private:
-    // Inherited mutators would slice off the default, and are not generally needed
-    using arg_locked::noconvert;
-    using arg_locked::none;
-    using arg_locked::sig;
-    using arg_locked::lock;
-};
-
-NB_INLINE arg_locked arg::lock() { return arg_locked{*this}; }
-
-template <typename... Ts> struct call_guard {
-    using type = detail::tuple<Ts...>;
-};
-
-struct dynamic_attr {};
-struct is_weak_referenceable {};
-struct is_method {};
-struct is_implicit {};
-struct is_operator {};
-struct is_arithmetic {};
-struct is_flag {};
-struct is_final {};
-struct is_generic {};
-struct kw_only {};
-struct lock_self {};
-
-template <size_t /* Nurse */, size_t /* Patient */> struct keep_alive {};
-template <typename T> struct supplement {};
-template <typename T> struct intrusive_ptr {
-    intrusive_ptr(void (*set_self_py)(T *, PyObject *) noexcept)
-        : set_self_py(set_self_py) { }
-    void (*set_self_py)(T *, PyObject *) noexcept;
-};
-
-struct type_slots {
-    type_slots (const PyType_Slot *value) : value(value) { }
-    const PyType_Slot *value;
-};
-
-struct type_slots_callback {
-    using cb_t = void (*)(const detail::type_init_data *t,
-                          PyType_Slot *&slots, size_t max_slots) noexcept;
-    type_slots_callback(cb_t callback) : callback(callback) { }
-    cb_t callback;
-};
-
-struct sig {
-    const char *value;
-    sig(const char *value) : value(value) { }
-};
-
-struct is_getter { };
-
-template <typename Policy> struct call_policy final {};
-
-NAMESPACE_BEGIN(literals)
-constexpr arg operator""_a(const char *name, size_t) { return arg(name); }
-NAMESPACE_END(literals)
-
-NAMESPACE_BEGIN(detail)
-
-enum class func_flags : uint32_t {
-    /* Low 3 bits reserved for return value policy */
-
-    /// Did the user specify a name for this function, or is it anonymous?
-    has_name = (1 << 4),
-    /// Did the user specify a scope in which this function should be installed?
-    has_scope = (1 << 5),
-    /// Did the user specify a docstring?
-    has_doc = (1 << 6),
-    /// Did the user specify nb::arg/arg_v annotations for all arguments?
-    has_args = (1 << 7),
-    /// Does the function signature contain an *args-style argument?
-    has_var_args = (1 << 8),
-    /// Does the function signature contain an *kwargs-style argument?
-    has_var_kwargs = (1 << 9),
-    /// Is this function a method of a class?
-    is_method = (1 << 10),
-    /// Is this function a method called __init__? (automatically generated)
-    is_constructor = (1 << 11),
-    /// Can this constructor be used to perform an implicit conversion?
-    is_implicit = (1 << 12),
-    /// Is this function an arithmetic operator?
-    is_operator = (1 << 13),
-    /// When the function is GCed, do we need to call func_data_prelim::free_capture?
-    has_free = (1 << 14),
-    /// Should the func_new() call return a new reference?
-    return_ref = (1 << 15),
-    /// Does this overload specify a custom function signature (for docstrings, typing)
-    has_signature = (1 << 16),
-    /// Does this function potentially modify the elements of the PyObject*[] array
-    /// representing its arguments? (nb::keep_alive() or call_policy annotations)
-    can_mutate_args = (1 << 17)
-};
-
-enum cast_flags : uint8_t {
-    // Enable implicit conversions (code assumes this has value 1, don't reorder..)
-    convert = (1 << 0),
-
-    // Passed to the 'self' argument in a constructor call (__init__)
-    construct = (1 << 1),
-
-    // Indicates that the function dispatcher should accept 'None' arguments
-    accepts_none = (1 << 2),
-
-    // Indicates that this cast is performed by nb::cast or nb::try_cast.
-    // This implies that objects added to the cleanup list may be
-    // released immediately after the caster's final output value is
-    // obtained, i.e., before it is used.
-    manual = (1 << 3)
-};
-
-
-struct arg_data {
-    const char *name;
-    const char *signature;
-    PyObject *name_py;
-    PyObject *value;
-    uint8_t flag;
-};
-
-template <size_t Size> struct func_data_prelim {
-    // A small amount of space to capture data used by the function/closure
-    void *capture[3];
-
-    // Callback to clean up the 'capture' field
-    void (*free_capture)(void *);
-
-    /// Implementation of the function call
-    PyObject *(*impl)(void *, PyObject **, uint8_t *, rv_policy,
-                      cleanup_list *);
-
-    /// Function signature description
-    const char *descr;
-
-    /// C++ types referenced by 'descr'
-    const std::type_info **descr_types;
-
-    /// Supplementary flags
-    uint32_t flags;
-
-    /// Total number of parameters accepted by the C++ function; nb::args
-    /// and nb::kwargs parameters are counted as one each. If the
-    /// 'has_args' flag is set, then there is one arg_data structure
-    /// for each of these.
-    uint16_t nargs;
-
-    /// Number of paramters to the C++ function that may be filled from
-    /// Python positional arguments without additional ceremony. nb::args and
-    /// nb::kwargs parameters are not counted in this total, nor are any
-    /// parameters after nb::args or after a nb::kw_only annotation.
-    /// The parameters counted here may be either named (nb::arg("name"))
-    /// or unnamed (nb::arg()). If unnamed, they are effectively positional-only.
-    /// nargs_pos is always <= nargs.
-    uint16_t nargs_pos;
-
-    // ------- Extra fields -------
-
-    const char *name;
-    const char *doc;
-    PyObject *scope;
-
-    // *WARNING*: nanobind regularly receives requests from users who run it
-    // through Clang-Tidy, or who compile with increased warnings levels, like
-    //
-    //   -Wpedantic, -Wcast-qual, -Wsign-conversion, etc.
-    //
-    // (i.e., beyond -Wall -Wextra and /W4 that are currently already used)
-    //
-    // Their next step is to open a big pull request needed to silence all of
-    // the resulting messages. This comment is strategically placed here
-    // because the zero-length array construction below will almost certainly
-    // be flagged in this process.
-    //
-    // My policy on this is as follows: I am always happy to fix issues in the
-    // codebase. However, many of the resulting change requests are in the
-    // "ritual purification" category: things that cause churn, decrease
-    // readability, and which don't fix actual problems. It's a never-ending
-    // cycle because each new revision of such tooling adds further warnings
-    // and purification rites.
-    //
-    // So just to be clear: I do not wish to pepper this codebase with
-    // "const_cast" and #pragmas/comments to avoid warnings in external
-    // tooling just so those users can have a "silent" build. I don't think it
-    // is reasonable for them to impose their own style on this project.
-    //
-    // As a workaround it is likely possible to restrict the scope of style
-    // checks to particular C++ namespaces or source code locations.
-#if defined(_MSC_VER)
-    // MSVC doesn't support zero-length arrays
-    arg_data args[Size == 0 ? 1 : Size];
-#else
-    // GCC and Clang do.
-    arg_data args[Size];
-#endif
-};
-
-template <typename F>
-NB_INLINE void func_extra_apply(F &f, const name &name, size_t &) {
-    f.name = name.value;
-    f.flags |= (uint32_t) func_flags::has_name;
-}
-
-template <typename F>
-NB_INLINE void func_extra_apply(F &f, const scope &scope, size_t &) {
-    f.scope = scope.value;
-    f.flags |= (uint32_t) func_flags::has_scope;
-}
-
-template <typename F>
-NB_INLINE void func_extra_apply(F &f, const sig &s, size_t &) {
-    f.flags |= (uint32_t) func_flags::has_signature;
-    f.name = s.value;
-}
-
-template <typename F>
-NB_INLINE void func_extra_apply(F &f, const char *doc, size_t &) {
-    f.doc = doc;
-    f.flags |= (uint32_t) func_flags::has_doc;
-}
-
-template <typename F>
-NB_INLINE void func_extra_apply(F &f, is_method, size_t &) {
-    f.flags |= (uint32_t) func_flags::is_method;
-}
-
-template <typename F>
-NB_INLINE void func_extra_apply(F &, is_getter, size_t &) { }
-
-template <typename F>
-NB_INLINE void func_extra_apply(F &f, is_implicit, size_t &) {
-    f.flags |= (uint32_t) func_flags::is_implicit;
-}
-
-template <typename F>
-NB_INLINE void func_extra_apply(F &f, is_operator, size_t &) {
-    f.flags |= (uint32_t) func_flags::is_operator;
-}
-
-template <typename F>
-NB_INLINE void func_extra_apply(F &f, rv_policy pol, size_t &) {
-    f.flags = (f.flags & ~0b111) | (uint16_t) pol;
-}
-
-template <typename F>
-NB_INLINE void func_extra_apply(F &, std::nullptr_t, size_t &) { }
-
-template <typename F>
-NB_INLINE void func_extra_apply(F &f, const arg &a, size_t &index) {
-    uint8_t flag = 0;
-    if (a.none_)
-        flag |= (uint8_t) cast_flags::accepts_none;
-    if (a.convert_)
-        flag |= (uint8_t) cast_flags::convert;
-
-    arg_data &arg = f.args[index];
-    arg.flag = flag;
-    arg.name = a.name_;
-    arg.signature = a.signature_;
-    arg.value = nullptr;
-    index++;
-}
-// arg_locked will select the arg overload; the locking is added statically
-// in nb_func.h
-
-template <typename F>
-NB_INLINE void func_extra_apply(F &f, const arg_v &a, size_t &index) {
-    arg_data &ad = f.args[index];
-    func_extra_apply(f, (const arg &) a, index);
-    ad.value = a.value.ptr();
-}
-template <typename F>
-NB_INLINE void func_extra_apply(F &f, const arg_locked_v &a, size_t &index) {
-    arg_data &ad = f.args[index];
-    func_extra_apply(f, (const arg_locked &) a, index);
-    ad.value = a.value.ptr();
-}
-
-template <typename F>
-NB_INLINE void func_extra_apply(F &, kw_only, size_t &) {}
-
-template <typename F>
-NB_INLINE void func_extra_apply(F &, lock_self, size_t &) {}
-
-template <typename F, typename... Ts>
-NB_INLINE void func_extra_apply(F &, call_guard<Ts...>, size_t &) {}
-
-template <typename F, size_t Nurse, size_t Patient>
-NB_INLINE void func_extra_apply(F &f, nanobind::keep_alive<Nurse, Patient>, size_t &) {
-    f.flags |= (uint32_t) func_flags::can_mutate_args;
-}
-
-template <typename F, typename Policy>
-NB_INLINE void func_extra_apply(F &f, call_policy<Policy>, size_t &) {
-    f.flags |= (uint32_t) func_flags::can_mutate_args;
-}
-
-template <typename... Ts> struct func_extra_info {
-    using call_guard = void;
-    static constexpr bool pre_post_hooks = false;
-    static constexpr size_t nargs_locked = 0;
-};
-
-template <typename T, typename... Ts> struct func_extra_info<T, Ts...>
-    : func_extra_info<Ts...> { };
-
-template <typename... Cs, typename... Ts>
-struct func_extra_info<call_guard<Cs...>, Ts...> : func_extra_info<Ts...> {
-    static_assert(std::is_same_v<typename func_extra_info<Ts...>::call_guard, void>,
-                  "call_guard<> can only be specified once!");
-    using call_guard = nanobind::call_guard<Cs...>;
-};
-
-template <size_t Nurse, size_t Patient, typename... Ts>
-struct func_extra_info<nanobind::keep_alive<Nurse, Patient>, Ts...> : func_extra_info<Ts...> {
-    static constexpr bool pre_post_hooks = true;
-};
-
-template <typename Policy, typename... Ts>
-struct func_extra_info<call_policy<Policy>, Ts...> : func_extra_info<Ts...> {
-    static constexpr bool pre_post_hooks = true;
-};
-
-template <typename... Ts>
-struct func_extra_info<arg_locked, Ts...> : func_extra_info<Ts...> {
-    static constexpr size_t nargs_locked = 1 + func_extra_info<Ts...>::nargs_locked;
-};
-
-template <typename... Ts>
-struct func_extra_info<lock_self, Ts...> : func_extra_info<Ts...> {
-    static constexpr size_t nargs_locked = 1 + func_extra_info<Ts...>::nargs_locked;
-};
-
-NB_INLINE void process_precall(PyObject **, size_t, detail::cleanup_list *, void *) { }
-
-template <size_t NArgs, typename Policy>
-NB_INLINE void
-process_precall(PyObject **args, std::integral_constant<size_t, NArgs> nargs,
-                detail::cleanup_list *cleanup, call_policy<Policy> *) {
-    Policy::precall(args, nargs, cleanup);
-}
-
-NB_INLINE void process_postcall(PyObject **, size_t, PyObject *, void *) { }
-
-template <size_t NArgs, size_t Nurse, size_t Patient>
-NB_INLINE void
-process_postcall(PyObject **args, std::integral_constant<size_t, NArgs>,
-                 PyObject *result, nanobind::keep_alive<Nurse, Patient> *) {
-    static_assert(Nurse != Patient,
-                  "keep_alive with the same argument as both nurse and patient "
-                  "doesn't make sense");
-    static_assert(Nurse <= NArgs && Patient <= NArgs,
-                  "keep_alive template parameters must be in the range "
-                  "[0, number of C++ function arguments]");
-    keep_alive(Nurse   == 0 ? result : args[Nurse - 1],
-               Patient == 0 ? result : args[Patient - 1]);
-}
-
-template <size_t NArgs, typename Policy>
-NB_INLINE void
-process_postcall(PyObject **args, std::integral_constant<size_t, NArgs> nargs,
-                 PyObject *&result, call_policy<Policy> *) {
-    // result_guard avoids leaking a reference to the return object
-    // if postcall throws an exception
-    object result_guard = steal(result);
-    Policy::postcall(args, nargs, result);
-    result_guard.release();
-}
-
-NAMESPACE_END(detail)
-NAMESPACE_END(NB_NAMESPACE)
diff --git a/src/nanobind/include/nanobind/nb_call.h b/src/nanobind/include/nanobind/nb_call.h
deleted file mode 100644
index 64206f3..0000000
--- a/src/nanobind/include/nanobind/nb_call.h
+++ /dev/null
@@ -1,152 +0,0 @@
-/*
-    nanobind/nb_call.h: Functionality for calling Python functions from C++
-
-    Copyright (c) 2022 Wenzel Jakob
-
-    All rights reserved. Use of this source code is governed by a
-    BSD-style license that can be found in the LICENSE file.
-*/
-
-NAMESPACE_BEGIN(NB_NAMESPACE)
-NAMESPACE_BEGIN(detail)
-
-#if defined(_MSC_VER)
-#  pragma warning(push)
-#  pragma warning(disable: 6255) // _alloca indicates failure by raising a stack overflow exception
-#endif
-
-class kwargs_proxy : public handle {
-public:
-    explicit kwargs_proxy(handle h) : handle(h) { }
-};
-
-class args_proxy : public handle {
-public:
-    explicit args_proxy(handle h) : handle(h) { }
-    kwargs_proxy operator*() const { return kwargs_proxy(*this); }
-};
-
-template <typename Derived>
-args_proxy api<Derived>::operator*() const {
-    return args_proxy(derived().ptr());
-}
-
-/// Implementation detail of api<T>::operator() (call operator)
-template <typename T>
-NB_INLINE void call_analyze(size_t &nargs, size_t &nkwargs, const T &value) {
-    using D = std::decay_t<T>;
-    static_assert(!std::is_base_of_v<arg_locked, D>,
-                  "nb::arg().lock() may be used only when defining functions, "
-                  "not when calling them");
-
-    if constexpr (std::is_same_v<D, arg_v>)
-        nkwargs++;
-    else if constexpr (std::is_same_v<D, args_proxy>)
-        nargs += len(value);
-    else if constexpr (std::is_same_v<D, kwargs_proxy>)
-        nkwargs += len(value);
-    else
-        nargs += 1;
-
-    (void) nargs; (void) nkwargs; (void) value;
-}
-
-/// Implementation detail of api<T>::operator() (call operator)
-template <rv_policy policy, typename T>
-NB_INLINE void call_init(PyObject **args, PyObject *kwnames, size_t &nargs,
-                         size_t &nkwargs, const size_t kwargs_offset,
-                         T &&value) {
-    using D = std::decay_t<T>;
-
-    if constexpr (std::is_same_v<D, arg_v>) {
-        args[kwargs_offset + nkwargs] = value.value.release().ptr();
-        NB_TUPLE_SET_ITEM(kwnames, nkwargs++,
-                         PyUnicode_InternFromString(value.name_));
-    } else if constexpr (std::is_same_v<D, args_proxy>) {
-        for (size_t i = 0, l = len(value); i < l; ++i)
-            args[nargs++] = borrow(value[i]).release().ptr();
-    } else if constexpr (std::is_same_v<D, kwargs_proxy>) {
-        PyObject *key, *entry;
-        Py_ssize_t pos = 0;
-#if defined(NB_FREE_THREADED)
-        ft_object_guard guard(value);
-#endif
-        while (PyDict_Next(value.ptr(), &pos, &key, &entry)) {
-            Py_INCREF(key); Py_INCREF(entry);
-            args[kwargs_offset + nkwargs] = entry;
-            NB_TUPLE_SET_ITEM(kwnames, nkwargs++, key);
-        }
-    } else {
-        args[nargs++] =
-            make_caster<T>::from_cpp((forward_t<T>) value, policy, nullptr).ptr();
-    }
-    (void) args; (void) kwnames; (void) nargs;
-    (void) nkwargs; (void) kwargs_offset;
-}
-
-#define NB_DO_VECTORCALL()                                                     \
-    PyObject *base, **args_p;                                                  \
-    if constexpr (method_call) {                                               \
-        base = derived().key().release().ptr();                                \
-        args[0] = derived().base().inc_ref().ptr();                            \
-        args_p = args;                                                         \
-        nargs++;                                                               \
-    } else {                                                                   \
-        base = derived().inc_ref().ptr();                                      \
-        args[0] = nullptr;                                                     \
-        args_p = args + 1;                                                     \
-    }                                                                          \
-    nargs |= NB_VECTORCALL_ARGUMENTS_OFFSET;                                   \
-    return steal(obj_vectorcall(base, args_p, nargs, kwnames, method_call))
-
-template <typename Derived>
-template <rv_policy policy, typename... Args>
-object api<Derived>::operator()(Args &&...args_) const {
-    static constexpr bool method_call =
-        std::is_same_v<Derived, accessor<obj_attr>> ||
-        std::is_same_v<Derived, accessor<str_attr>>;
-
-    if constexpr (((std::is_same_v<Args, arg_v> ||
-                    std::is_same_v<Args, args_proxy> ||
-                    std::is_same_v<Args, kwargs_proxy>) || ...)) {
-        // Complex call with keyword arguments, *args/**kwargs expansion, etc.
-        size_t nargs = 0, nkwargs = 0, nargs2 = 0, nkwargs2 = 0;
-
-        // Determine storage requirements for positional and keyword args
-        (call_analyze(nargs, nkwargs, (const Args &) args_), ...);
-
-        // Allocate memory on the stack
-        PyObject **args =
-            (PyObject **) alloca((nargs + nkwargs + 1) * sizeof(PyObject *));
-
-        PyObject *kwnames =
-            nkwargs ? PyTuple_New((Py_ssize_t) nkwargs) : nullptr;
-
-        // Fill 'args' and 'kwnames' variables
-        (call_init<policy>(args + 1, kwnames, nargs2, nkwargs2, nargs,
-                           (forward_t<Args>) args_), ...);
-
-        NB_DO_VECTORCALL();
-    } else {
-        // Simple version with only positional arguments
-        PyObject *args[sizeof...(Args) + 1], *kwnames = nullptr;
-        size_t nargs = 0;
-
-        ((args[1 + nargs++] =
-              detail::make_caster<Args>::from_cpp(
-                  (detail::forward_t<Args>) args_, policy, nullptr)
-                  .ptr()),
-         ...);
-
-        NB_DO_VECTORCALL();
-    }
-}
-
-#undef NB_DO_VECTORCALL
-
-#if defined(_MSC_VER)
-#  pragma warning(pop)
-#endif
-
-NAMESPACE_END(detail)
-NAMESPACE_END(NB_NAMESPACE)
diff --git a/src/nanobind/include/nanobind/nb_cast.h b/src/nanobind/include/nanobind/nb_cast.h
deleted file mode 100644
index a0781df..0000000
--- a/src/nanobind/include/nanobind/nb_cast.h
+++ /dev/null
@@ -1,764 +0,0 @@
-/*
-    nanobind/nb_cast.h: Type caster interface and essential type casters
-
-    Copyright (c) 2022 Wenzel Jakob
-
-    All rights reserved. Use of this source code is governed by a
-    BSD-style license that can be found in the LICENSE file.
-*/
-
-#define NB_TYPE_CASTER(Value_, descr)                                          \
-    using Value = Value_;                                                      \
-    static constexpr auto Name = descr;                                        \
-    template <typename T_> using Cast = movable_cast_t<T_>;                    \
-    template <typename T_> static constexpr bool can_cast() { return true; }   \
-    template <typename T_,                                                     \
-              enable_if_t<std::is_same_v<std::remove_cv_t<T_>, Value>> = 0>    \
-    static handle from_cpp(T_ *p, rv_policy policy, cleanup_list *list) {      \
-        if (!p)                                                                \
-            return none().release();                                           \
-        return from_cpp(*p, policy, list);                                     \
-    }                                                                          \
-    explicit operator Value*() { return &value; }                              \
-    explicit operator Value&() { return (Value &) value; }                     \
-    explicit operator Value&&() { return (Value &&) value; }                   \
-    Value value;
-
-#define NB_MAKE_OPAQUE(...)                                                    \
-    namespace nanobind::detail {                                               \
-    template <> class type_caster<__VA_ARGS__>                                 \
-        : public type_caster_base<__VA_ARGS__> { }; }
-
-NAMESPACE_BEGIN(NB_NAMESPACE)
-NAMESPACE_BEGIN(detail)
-
-/**
- * Type casters expose a member 'Cast<T>' which users of a type caster must
- * query to determine what the caster actually can (and prefers) to produce.
- * The convenience alias ``cast_t<T>`` defined below performs this query for a
- * given type ``T``.
- *
- * Often ``cast_t<T>`` is simply equal to ``T`` or ``T&``. More significant
- * deviations are also possible, which could be due to one of the following
- * two reasons:
- *
- * 1. Efficiency: most STL type casters create a local copy (``value`` member)
- *    of the value being cast. The caller should move this value to its
- *    intended destination instead of making further copies along the way.
- *    Consequently, ``cast_t<std::vector<T>>`` yields ``cast_t<std::vector<T>>
- *    &&`` to enable such behavior.
- *
- * 2. STL pairs may contain references, and such pairs aren't
- *    default-constructible. The STL pair caster therefore cannot create a local
- *    copy and must construct the pair on the fly, which in turns means that it
- *    cannot return references. Therefore, ``cast_t<const std::pair<T1, T2>&>``
- *    yields ``std::pair<T1, T2>``.
- */
-
-/// Ask a type caster what flavors of a type it can actually produce -- may be different from 'T'
-template <typename T> using cast_t = typename make_caster<T>::template Cast<T>;
-
-/// This is a default choice for the 'Cast' type alias described above. It
-/// prefers to return rvalue references to allow the caller to move the object.
-template <typename T>
-using movable_cast_t =
-    std::conditional_t<is_pointer_v<T>, intrinsic_t<T> *,
-                       std::conditional_t<std::is_lvalue_reference_v<T>,
-                                          intrinsic_t<T> &, intrinsic_t<T> &&>>;
-
-/// This version is more careful about what the caller actually requested and
-/// only moves when this was explicitly requested. It is the default for the
-/// base type caster (i.e., types bound via ``nanobind::class_<..>``)
-template <typename T>
-using precise_cast_t =
-    std::conditional_t<is_pointer_v<T>, intrinsic_t<T> *,
-                       std::conditional_t<std::is_rvalue_reference_v<T>,
-                                          intrinsic_t<T> &&, intrinsic_t<T> &>>;
-
-/// Many type casters delegate to another caster using the pattern:
-/// ~~~ .cc
-/// bool from_python(handle src, uint8_t flags, cleanup_list *cl) noexcept {
-///     SomeCaster c;
-///     if (!c.from_python(src, flags, cl)) return false;
-///     /* do something with */ c.operator T();
-///     return true;
-/// }
-/// ~~~
-/// This function adjusts the flags to avoid issues where the resulting T object
-/// refers into storage that will dangle after SomeCaster is destroyed, and
-/// causes a static assertion failure if that's not sufficient. Use it like:
-/// ~~~ .cc
-///     if (!c.from_python(src, flags_for_local_caster<T>(flags), cl))
-///         return false;
-/// ~~~
-/// where the template argument T is the type you plan to extract.
-template <typename T>
-NB_INLINE uint8_t flags_for_local_caster(uint8_t flags) noexcept {
-    using Caster = make_caster<T>;
-    constexpr bool is_ref = std::is_pointer_v<T> || std::is_reference_v<T>;
-    if constexpr (is_base_caster_v<Caster>) {
-        if constexpr (is_ref) {
-            /* References/pointers to a type produced by implicit conversions
-               refer to storage owned by the cleanup_list. In a nb::cast() call,
-               that storage will be released before the reference can be used;
-               to prevent dangling, don't allow implicit conversions there. */
-            if (flags & ((uint8_t) cast_flags::manual))
-                flags &= ~((uint8_t) cast_flags::convert);
-        }
-    } else {
-        /* Any pointer produced by a non-base caster will generally point
-           into storage owned by the caster, which won't live long enough.
-           Exception: the 'char' caster produces a result that points to
-           storage owned by the incoming Python 'str' object, so it's OK. */
-        static_assert(!is_ref || std::is_same_v<T, const char*> ||
-                      (std::is_pointer_v<T> && std::is_constructible_v<T*, Caster>),
-                      "nanobind generally cannot produce objects that "
-                      "contain interior pointers T* (or references T&) if "
-                      "the pointee T is not handled by nanobind's regular "
-                      "class binding mechanism. For example, you can write "
-                      "a function that accepts int*, or std::vector<int>, "
-                      "but not std::vector<int*>.");
-    }
-    return flags;
-}
-
-template <typename T>
-struct type_caster<T, enable_if_t<std::is_arithmetic_v<T> && !is_std_char_v<T>>> {
-    NB_INLINE bool from_python(handle src, uint8_t flags, cleanup_list *) noexcept {
-        if constexpr (std::is_floating_point_v<T>) {
-            if constexpr (std::is_same_v<T, double>) {
-                return detail::load_f64(src.ptr(), flags, &value);
-            } else if constexpr (std::is_same_v<T, float>) {
-                return detail::load_f32(src.ptr(), flags, &value);
-            } else {
-                double d;
-                if (!detail::load_f64(src.ptr(), flags, &d))
-                    return false;
-                T result = (T) d;
-                if ((flags & (uint8_t) cast_flags::convert)
-                        || (double) result == d
-                        || (result != result && d != d)) {
-                    value = result;
-                    return true;
-                }
-                return false;
-            }
-        } else {
-            if constexpr (std::is_signed_v<T>) {
-                if constexpr (sizeof(T) == 8)
-                    return detail::load_i64(src.ptr(), flags, (int64_t *) &value);
-                else if constexpr (sizeof(T) == 4)
-                    return detail::load_i32(src.ptr(), flags, (int32_t *) &value);
-                else if constexpr (sizeof(T) == 2)
-                    return detail::load_i16(src.ptr(), flags, (int16_t *) &value);
-                else
-                    return detail::load_i8(src.ptr(), flags, (int8_t *) &value);
-            } else {
-                if constexpr (sizeof(T) == 8)
-                    return detail::load_u64(src.ptr(), flags, (uint64_t *) &value);
-                else if constexpr (sizeof(T) == 4)
-                    return detail::load_u32(src.ptr(), flags, (uint32_t *) &value);
-                else if constexpr (sizeof(T) == 2)
-                    return detail::load_u16(src.ptr(), flags, (uint16_t *) &value);
-                else
-                    return detail::load_u8(src.ptr(), flags, (uint8_t *) &value);
-            }
-        }
-    }
-
-    NB_INLINE static handle from_cpp(T src, rv_policy, cleanup_list *) noexcept {
-        if constexpr (std::is_floating_point_v<T>) {
-            return PyFloat_FromDouble((double) src);
-        } else {
-            if constexpr (std::is_signed_v<T>) {
-                if constexpr (sizeof(T) <= sizeof(long))
-                    return PyLong_FromLong((long) src);
-                else
-                    return PyLong_FromLongLong((long long) src);
-            } else {
-                if constexpr (sizeof(T) <= sizeof(unsigned long))
-                    return PyLong_FromUnsignedLong((unsigned long) src);
-                else
-                    return PyLong_FromUnsignedLongLong((unsigned long long) src);
-            }
-        }
-    }
-
-    NB_TYPE_CASTER(T, const_name<std::is_integral_v<T>>("int", "float"))
-};
-
-template <typename T>
-struct type_caster<T, enable_if_t<std::is_enum_v<T>>> {
-    NB_INLINE bool from_python(handle src, uint8_t flags, cleanup_list *) noexcept {
-        int64_t result;
-        bool rv = enum_from_python(&typeid(T), src.ptr(), &result, flags);
-        value = (T) result;
-        return rv;
-    }
-
-    NB_INLINE static handle from_cpp(T src, rv_policy, cleanup_list *) noexcept {
-        return enum_from_cpp(&typeid(T), (int64_t) src);
-    }
-
-    NB_TYPE_CASTER(T, const_name<T>())
-};
-
-template <> struct type_caster<void_type> {
-    static constexpr auto Name = const_name("None");
-};
-
-template <> struct type_caster<void> {
-    template <typename T_> using Cast = void *;
-    template <typename T_> static constexpr bool can_cast() { return true; }
-    using Value = void*;
-    static constexpr auto Name = const_name(NB_TYPING_CAPSULE);
-    explicit operator void *() { return value; }
-    Value value;
-
-    bool from_python(handle src, uint8_t, cleanup_list *) noexcept {
-        if (src.is_none()) {
-            value = nullptr;
-            return true;
-        } else {
-            value = PyCapsule_GetPointer(src.ptr(), "nb_handle");
-            if (!value) {
-                PyErr_Clear();
-                return false;
-            }
-            return true;
-        }
-    }
-
-    static handle from_cpp(void *ptr, rv_policy, cleanup_list *) noexcept {
-        if (ptr)
-            return PyCapsule_New(ptr, "nb_handle", nullptr);
-        else
-            return none().release();
-    }
-};
-
-template <typename T> struct none_caster {
-    bool from_python(handle src, uint8_t, cleanup_list *) noexcept {
-        if (src.is_none())
-            return true;
-        return false;
-    }
-
-    static handle from_cpp(T, rv_policy, cleanup_list *) noexcept {
-        return none().release();
-    }
-
-    NB_TYPE_CASTER(T, const_name("None"))
-};
-
-template <> struct type_caster<std::nullptr_t> : none_caster<std::nullptr_t> { };
-
-template <> struct type_caster<bool> {
-    bool from_python(handle src, uint8_t, cleanup_list *) noexcept {
-        if (src.ptr() == Py_True) {
-            value = true;
-            return true;
-        } else if (src.ptr() == Py_False) {
-            value = false;
-            return true;
-        } else {
-            return false;
-        }
-    }
-
-    static handle from_cpp(bool src, rv_policy, cleanup_list *) noexcept {
-        return handle(src ? Py_True : Py_False).inc_ref();
-    }
-
-    NB_TYPE_CASTER(bool, const_name("bool"))
-};
-
-template <> struct type_caster<char> {
-    using Value = const char *;
-    Value value;
-    Py_ssize_t size;
-    static constexpr auto Name = const_name("str");
-    template <typename T_>
-    using Cast = std::conditional_t<is_pointer_v<T_>, const char *, char>;
-
-    bool from_python(handle src, uint8_t, cleanup_list *) noexcept {
-        value = PyUnicode_AsUTF8AndSize(src.ptr(), &size);
-        if (!value) {
-            PyErr_Clear();
-            return false;
-        }
-        return true;
-    }
-
-    static handle from_cpp(const char *value, rv_policy,
-                           cleanup_list *) noexcept {
-        if (value == nullptr) {
-            PyObject* result = Py_None;
-            Py_INCREF(result);
-            return result;
-        }
-        return PyUnicode_FromString(value);
-    }
-
-    static handle from_cpp(char value, rv_policy, cleanup_list *) noexcept {
-        return PyUnicode_FromStringAndSize(&value, 1);
-    }
-
-    template <typename T_>
-    NB_INLINE bool can_cast() const noexcept {
-        return std::is_pointer_v<T_> || (value && size == 1);
-    }
-
-    explicit operator const char *() { return value; }
-
-    explicit operator char() {
-        if (can_cast<char>())
-            return value[0];
-        else
-            throw next_overload();
-    }
-};
-
-template <typename T> struct type_caster<pointer_and_handle<T>> {
-    using Caster = make_caster<T>;
-    using T2 = pointer_and_handle<T>;
-    NB_TYPE_CASTER(T2, Caster::Name)
-
-    bool from_python(handle src, uint8_t flags, cleanup_list *cleanup) noexcept {
-        Caster c;
-        if (!c.from_python(src, flags_for_local_caster<T*>(flags), cleanup) ||
-            !c.template can_cast<T*>())
-            return false;
-        value.h = src;
-        value.p = c.operator T*();
-        return true;
-    }
-};
-
-template <> struct type_caster<fallback> {
-    NB_TYPE_CASTER(fallback, const_name("object"))
-    bool from_python(handle src, uint8_t flags, cleanup_list *) noexcept {
-        if (!(flags & (uint8_t) cast_flags::convert))
-            return false;
-        value = src;
-        return true;
-    }
-};
-
-template <typename T> struct typed_base_name {
-      static constexpr auto Name = type_caster<T>::Name;
-};
-
-#if PY_VERSION_HEX < 0x03090000
-#define NB_TYPED_NAME_PYTHON38(type, name)                     \
-    template <> struct typed_base_name<type> {                 \
-        static constexpr auto Name = detail::const_name(name); \
-    };
-
-NB_TYPED_NAME_PYTHON38(nanobind::tuple, NB_TYPING_TUPLE)
-NB_TYPED_NAME_PYTHON38(list, NB_TYPING_LIST)
-NB_TYPED_NAME_PYTHON38(set, NB_TYPING_SET)
-NB_TYPED_NAME_PYTHON38(dict, NB_TYPING_DICT)
-NB_TYPED_NAME_PYTHON38(type_object, NB_TYPING_TYPE)
-#endif
-
-// Base case: typed<T, Ts...> renders as T[Ts...], with some adjustments to
-// T for older versions of Python (typing.List instead of list, for example)
-template <typename T, typename... Ts> struct typed_name {
-    static constexpr auto Name =
-            typed_base_name<intrinsic_t<T>>::Name + const_name("[") +
-            concat(const_name<std::is_same_v<Ts, ellipsis>>(const_name("..."),
-                    make_caster<Ts>::Name)...) + const_name("]");
-};
-
-// typed<object, T> or typed<handle, T> renders as T, rather than as
-// the nonsensical object[T]
-template <typename T> struct typed_name<object, T> {
-    static constexpr auto Name = make_caster<T>::Name;
-};
-template <typename T> struct typed_name<handle, T> {
-    static constexpr auto Name = make_caster<T>::Name;
-};
-
-// typed<callable, R(Args...)> renders as Callable[[Args...], R]
-template <typename R, typename... Args>
-struct typed_name<callable, R(Args...)> {
-    using Ret = std::conditional_t<std::is_void_v<R>, void_type, R>;
-    static constexpr auto Name =
-            const_name(NB_TYPING_CALLABLE "[[") +
-            concat(make_caster<Args>::Name...) + const_name("], ") +
-            make_caster<Ret>::Name + const_name("]");
-};
-// typed<callable, R(...)> renders as Callable[..., R]
-template <typename R>
-struct typed_name<callable, R(...)> {
-    using Ret = std::conditional_t<std::is_void_v<R>, void_type, R>;
-    static constexpr auto Name =
-            const_name(NB_TYPING_CALLABLE "[..., ") +
-            make_caster<Ret>::Name + const_name("]");
-};
-
-template <typename T, typename... Ts> struct type_caster<typed<T, Ts...>> {
-    using Caster = make_caster<T>;
-    using Typed = typed<T, Ts...>;
-
-    NB_TYPE_CASTER(Typed, (typed_name<T, Ts...>::Name))
-
-    bool from_python(handle src, uint8_t flags, cleanup_list *cleanup) noexcept {
-        Caster caster;
-        if (!caster.from_python(src, flags_for_local_caster<T>(flags), cleanup) ||
-            !caster.template can_cast<T>())
-            return false;
-        value = caster.operator cast_t<T>();
-        return true;
-    }
-
-    static handle from_cpp(const Value &src, rv_policy policy, cleanup_list *cleanup) noexcept {
-        return Caster::from_cpp(src, policy, cleanup);
-    }
-};
-
-template <typename T>
-struct type_caster<T, enable_if_t<std::is_base_of_v<detail::api_tag, T> && !T::nb_typed>> {
-public:
-    NB_TYPE_CASTER(T, T::Name)
-
-    type_caster() : value(nullptr, ::nanobind::detail::steal_t()) { }
-
-    bool from_python(handle src, uint8_t, cleanup_list *) noexcept {
-        if (!isinstance<T>(src))
-            return false;
-
-        if constexpr (std::is_base_of_v<object, T>)
-            value = borrow<T>(src);
-        else
-            value = src;
-
-        return true;
-    }
-
-    static handle from_cpp(T&& src, rv_policy, cleanup_list *) noexcept {
-        if constexpr (std::is_base_of_v<object, T>)
-            return src.release();
-        else
-            return src.inc_ref();
-    }
-
-    static handle from_cpp(const T &src, rv_policy, cleanup_list *) noexcept {
-        return src.inc_ref();
-    }
-};
-
-template <typename T> NB_INLINE rv_policy infer_policy(rv_policy policy) {
-    if constexpr (is_pointer_v<T>) {
-        if (policy == rv_policy::automatic)
-            policy = rv_policy::take_ownership;
-        else if (policy == rv_policy::automatic_reference)
-            policy = rv_policy::reference;
-    } else if constexpr (std::is_lvalue_reference_v<T>) {
-        if (policy == rv_policy::automatic ||
-            policy == rv_policy::automatic_reference)
-            policy = rv_policy::copy;
-    } else {
-        if (policy == rv_policy::automatic ||
-            policy == rv_policy::automatic_reference ||
-            policy == rv_policy::reference ||
-            policy == rv_policy::reference_internal)
-            policy = rv_policy::move;
-    }
-    return policy;
-}
-
-template <typename T, typename SFINAE = int> struct type_hook : std::false_type { };
-
-template <typename Type_> struct type_caster_base : type_caster_base_tag {
-    using Type = Type_;
-    static constexpr auto Name = const_name<Type>();
-    template <typename T> using Cast = precise_cast_t<T>;
-
-    NB_INLINE bool from_python(handle src, uint8_t flags,
-                               cleanup_list *cleanup) noexcept {
-        return nb_type_get(&typeid(Type), src.ptr(), flags, cleanup,
-                           (void **) &value);
-    }
-
-    template <typename T>
-    NB_INLINE static handle from_cpp(T &&value, rv_policy policy,
-                                     cleanup_list *cleanup) noexcept {
-        Type *ptr;
-        if constexpr (is_pointer_v<T>)
-            ptr = (Type *) value;
-        else
-            ptr = (Type *) &value;
-
-        policy = infer_policy<T>(policy);
-        const std::type_info *type = &typeid(Type);
-
-        constexpr bool has_type_hook =
-            !std::is_base_of_v<std::false_type, type_hook<Type>>;
-        if constexpr (has_type_hook)
-            type = type_hook<Type>::get(ptr);
-
-        if constexpr (!std::is_polymorphic_v<Type>) {
-            return nb_type_put(type, ptr, policy, cleanup);
-        } else {
-            const std::type_info *type_p =
-                (!has_type_hook && ptr) ? &typeid(*ptr) : nullptr;
-            return nb_type_put_p(type, type_p, ptr, policy, cleanup);
-        }
-    }
-
-    template <typename T_>
-    bool can_cast() const noexcept {
-        return std::is_pointer_v<T_> || (value != nullptr);
-    }
-
-    operator Type*() { return value; }
-
-    operator Type&() {
-        raise_next_overload_if_null(value);
-        return *value;
-    }
-
-    operator Type&&() {
-        raise_next_overload_if_null(value);
-        return (Type &&) *value;
-    }
-
-private:
-    Type *value;
-};
-
-template <typename Type, typename SFINAE>
-struct type_caster : type_caster_base<Type> { };
-
-template <bool Convert, typename T>
-T cast_impl(handle h) {
-    using Caster = detail::make_caster<T>;
-
-    // A returned reference/pointer would usually refer into the type_caster
-    // object, which will be destroyed before the returned value can be used,
-    // so we prohibit it by default, with two exceptions that we know are safe:
-    //
-    // - If we're casting to a bound object type, the returned pointer points
-    //   into storage owned by that object, not the type caster. Note this is
-    //   only safe if we don't allow implicit conversions, because the pointer
-    //   produced after an implicit conversion points into storage owned by
-    //   a temporary object in the cleanup list, and we have to release those
-    //   temporaries before we return.
-    //
-    // - If we're casting to const char*, the caster was provided by nanobind,
-    //   and we know it will only accept Python 'str' objects, producing
-    //   a pointer to storage owned by that object.
-
-    constexpr bool is_ref = std::is_reference_v<T> || std::is_pointer_v<T>;
-    static_assert(
-        !is_ref ||
-            is_base_caster_v<Caster> ||
-            std::is_same_v<const char *, T>,
-        "nanobind::cast(): cannot return a reference to a temporary.");
-
-    Caster caster;
-    bool rv;
-    if constexpr (Convert && !is_ref) {
-        // Release the values in the cleanup list only after we
-        // initialize the return object, since the initialization
-        // might access those temporaries.
-        struct raii_cleanup {
-            cleanup_list list{nullptr};
-            ~raii_cleanup() { list.release(); }
-        } cleanup;
-        rv = caster.from_python(h.ptr(),
-                                ((uint8_t) cast_flags::convert) |
-                                ((uint8_t) cast_flags::manual),
-                                &cleanup.list);
-        if (!rv)
-            detail::raise_cast_error();
-        return caster.operator cast_t<T>();
-    } else {
-        rv = caster.from_python(h.ptr(), (uint8_t) cast_flags::manual, nullptr);
-        if (!rv)
-            detail::raise_cast_error();
-        return caster.operator cast_t<T>();
-    }
-}
-
-template <bool Convert, typename T>
-bool try_cast_impl(handle h, T &out) noexcept {
-    using Caster = detail::make_caster<T>;
-
-    // See comments in cast_impl above
-    constexpr bool is_ref = std::is_reference_v<T> || std::is_pointer_v<T>;
-    static_assert(
-        !is_ref ||
-            is_base_caster_v<Caster> ||
-            std::is_same_v<const char *, T>,
-        "nanobind::try_cast(): cannot return a reference to a temporary.");
-
-    Caster caster;
-    bool rv;
-    if constexpr (Convert && !is_ref) {
-        cleanup_list cleanup(nullptr);
-        rv = caster.from_python(h.ptr(),
-                                ((uint8_t) cast_flags::convert) |
-                                ((uint8_t) cast_flags::manual),
-                                &cleanup) &&
-             caster.template can_cast<T>();
-        if (rv) {
-            out = caster.operator cast_t<T>();
-        }
-        cleanup.release(); // 'from_python' is 'noexcept', so this always runs
-    } else {
-        rv = caster.from_python(h.ptr(), (uint8_t) cast_flags::manual, nullptr) &&
-             caster.template can_cast<T>();
-        if (rv) {
-            out = caster.operator cast_t<T>();
-        }
-    }
-
-    return rv;
-}
-
-NAMESPACE_END(detail)
-
-template <typename T, typename Derived>
-NB_INLINE T cast(const detail::api<Derived> &value, bool convert = true) {
-    if constexpr (std::is_same_v<T, void>) {
-        (void) value; (void) convert;
-        return;
-    } else {
-        if (convert)
-            return detail::cast_impl<true, T>(value);
-        else
-            return detail::cast_impl<false, T>(value);
-    }
-}
-
-template <typename T, typename Derived>
-NB_INLINE bool try_cast(const detail::api<Derived> &value, T &out, bool convert = true) noexcept {
-    if (convert)
-        return detail::try_cast_impl<true, T>(value, out);
-    else
-        return detail::try_cast_impl<false, T>(value, out);
-}
-
-template <typename T>
-object cast(T &&value, rv_policy policy = rv_policy::automatic_reference) {
-    handle h = detail::make_caster<T>::from_cpp((detail::forward_t<T>) value,
-                                                policy, nullptr);
-    if (!h.is_valid())
-        detail::raise_cast_error();
-
-    return steal(h);
-}
-
-template <typename T>
-object cast(T &&value, rv_policy policy, handle parent) {
-    detail::cleanup_list cleanup(parent.ptr());
-    handle h = detail::make_caster<T>::from_cpp((detail::forward_t<T>) value,
-                                                policy, &cleanup);
-
-    cleanup.release();
-
-    if (!h.is_valid())
-        detail::raise_cast_error();
-
-    return steal(h);
-}
-
-template <typename T> object find(const T &value) noexcept {
-    return steal(detail::make_caster<T>::from_cpp(value, rv_policy::none, nullptr));
-}
-
-template <rv_policy policy = rv_policy::automatic, typename... Args>
-tuple make_tuple(Args &&...args) {
-    tuple result = steal<tuple>(PyTuple_New((Py_ssize_t) sizeof...(Args)));
-
-    size_t nargs = 0;
-    PyObject *o = result.ptr();
-
-    (NB_TUPLE_SET_ITEM(o, nargs++,
-                       detail::make_caster<Args>::from_cpp(
-                           (detail::forward_t<Args>) args, policy, nullptr)
-                           .ptr()),
-     ...);
-
-    detail::tuple_check(o, sizeof...(Args));
-
-    return result;
-}
-
-template <typename T> arg_v arg::operator=(T &&value) const {
-    return arg_v(*this, cast((detail::forward_t<T>) value));
-}
-template <typename T> arg_locked_v arg_locked::operator=(T &&value) const {
-    return arg_locked_v(*this, cast((detail::forward_t<T>) value));
-}
-
-template <typename Impl> template <typename T>
-detail::accessor<Impl>& detail::accessor<Impl>::operator=(T &&value) {
-    object result = cast((detail::forward_t<T>) value);
-    Impl::set(m_base, m_key, result.ptr());
-    return *this;
-}
-
-template <typename T> void list::append(T &&value) {
-    object o = nanobind::cast((detail::forward_t<T>) value);
-    if (PyList_Append(m_ptr, o.ptr()))
-        raise_python_error();
-}
-
-template <typename T> void list::insert(Py_ssize_t index, T &&value) {
-    object o = nanobind::cast((detail::forward_t<T>) value);
-    if (PyList_Insert(m_ptr, index, o.ptr()))
-        raise_python_error();
-}
-
-template <typename T> bool dict::contains(T&& key) const {
-    object o = nanobind::cast((detail::forward_t<T>) key);
-    int rv = PyDict_Contains(m_ptr, o.ptr());
-    if (rv == -1)
-        raise_python_error();
-    return rv == 1;
-}
-
-template <typename T> bool set::contains(T&& key) const {
-    object o = nanobind::cast((detail::forward_t<T>) key);
-    int rv = PySet_Contains(m_ptr, o.ptr());
-    if (rv == -1)
-        raise_python_error();
-    return rv == 1;
-}
-
-template <typename T> void set::add(T&& key) {
-    object o = nanobind::cast((detail::forward_t<T>) key);
-    int rv = PySet_Add(m_ptr, o.ptr());
-    if (rv == -1)
-        raise_python_error();
-}
-
-template <typename T> bool set::discard(T &&value) {
-    object o = nanobind::cast((detail::forward_t<T>) value);
-    int rv = PySet_Discard(m_ptr, o.ptr());
-    if (rv < 0)
-        raise_python_error();
-    return rv == 1;
-}
-
-template <typename T> bool frozenset::contains(T&& key) const {
-    object o = nanobind::cast((detail::forward_t<T>) key);
-    int rv = PySet_Contains(m_ptr, o.ptr());
-    if (rv == -1)
-        raise_python_error();
-    return rv == 1;
-}
-
-template <typename T> bool mapping::contains(T&& key) const {
-    object o = nanobind::cast((detail::forward_t<T>) key);
-    int rv = PyMapping_HasKey(m_ptr, o.ptr());
-    if (rv == -1)
-        raise_python_error();
-    return rv == 1;
-}
-
-NAMESPACE_END(NB_NAMESPACE)
diff --git a/src/nanobind/include/nanobind/nb_class.h b/src/nanobind/include/nanobind/nb_class.h
deleted file mode 100644
index ef18f24..0000000
--- a/src/nanobind/include/nanobind/nb_class.h
+++ /dev/null
@@ -1,855 +0,0 @@
-/*
-    nanobind/nb_class.h: Functionality for binding C++ classes/structs
-
-    Copyright (c) 2022 Wenzel Jakob
-
-    All rights reserved. Use of this source code is governed by a
-    BSD-style license that can be found in the LICENSE file.
-*/
-
-NAMESPACE_BEGIN(NB_NAMESPACE)
-NAMESPACE_BEGIN(detail)
-
-/// Flags about a type that persist throughout its lifetime
-enum class type_flags : uint32_t {
-    /// Does the type provide a C++ destructor?
-    is_destructible          = (1 << 0),
-
-    /// Does the type provide a C++ copy constructor?
-    is_copy_constructible    = (1 << 1),
-
-    /// Does the type provide a C++ move constructor?
-    is_move_constructible    = (1 << 2),
-
-    /// Is the 'destruct' field of the type_data structure set?
-    has_destruct             = (1 << 4),
-
-    /// Is the 'copy' field of the type_data structure set?
-    has_copy                 = (1 << 5),
-
-    /// Is the 'move' field of the type_data structure set?
-    has_move                 = (1 << 6),
-
-    /// Internal: does the type maintain a list of implicit conversions?
-    has_implicit_conversions = (1 << 7),
-
-    /// Is this a python type that extends a bound C++ type?
-    is_python_type           = (1 << 8),
-
-    /// This type does not permit subclassing from Python
-    is_final                 = (1 << 9),
-
-    /// Instances of this type support dynamic attribute assignment
-    has_dynamic_attr         = (1 << 10),
-
-    /// The class uses an intrusive reference counting approach
-    intrusive_ptr            = (1 << 11),
-
-    /// Is this a class that inherits from enable_shared_from_this?
-    /// If so, type_data::keep_shared_from_this_alive is also set.
-    has_shared_from_this     = (1 << 12),
-
-    /// Instances of this type can be referenced by 'weakref'
-    is_weak_referenceable    = (1 << 13),
-
-    /// A custom signature override was specified
-    has_signature            = (1 << 14),
-
-    /// The class implements __class_getitem__ similar to typing.Generic
-    is_generic               = (1 << 15),
-
-    /// Does the type implement a custom __new__ operator?
-    has_new                  = (1 << 16),
-
-    /// Does the type implement a custom __new__ operator that can take no args
-    /// (except the type object)?
-    has_nullary_new          = (1 << 17)
-
-    // One more bit available without needing a larger reorganization
-};
-
-/// Flags about a type that are only relevant when it is being created.
-/// These are currently stored in type_data::flags alongside the type_flags
-/// for more efficient memory layout, but could move elsewhere if we run
-/// out of flags.
-enum class type_init_flags : uint32_t {
-    /// Is the 'supplement' field of the type_init_data structure set?
-    has_supplement           = (1 << 19),
-
-    /// Is the 'doc' field of the type_init_data structure set?
-    has_doc                  = (1 << 20),
-
-    /// Is the 'base' field of the type_init_data structure set?
-    has_base                 = (1 << 21),
-
-    /// Is the 'base_py' field of the type_init_data structure set?
-    has_base_py              = (1 << 22),
-
-    /// This type provides extra PyType_Slot fields
-    has_type_slots           = (1 << 23),
-
-    all_init_flags           = (0x1f << 19)
-};
-
-// See internals.h
-struct nb_alias_chain;
-
-// Implicit conversions for C++ type bindings, used in type_data below
-struct implicit_t {
-    const std::type_info **cpp;
-    bool (**py)(PyTypeObject *, PyObject *, cleanup_list *) noexcept;
-};
-
-// Forward and reverse mappings for enumerations, used in type_data below
-struct enum_tbl_t {
-    void *fwd;
-    void *rev;
-};
-
-/// Information about a type that persists throughout its lifetime
-struct type_data {
-    uint32_t size;
-    uint32_t align : 8;
-    uint32_t flags : 24;
-    const char *name;
-    const std::type_info *type;
-    PyTypeObject *type_py;
-    nb_alias_chain *alias_chain;
-#if defined(Py_LIMITED_API)
-    PyObject* (*vectorcall)(PyObject *, PyObject * const*, size_t, PyObject *);
-#endif
-    void *init; // Constructor nb_func
-    void (*destruct)(void *);
-    void (*copy)(void *, const void *);
-    void (*move)(void *, void *) noexcept;
-    union {
-        implicit_t implicit;  // for C++ type bindings
-        enum_tbl_t enum_tbl;  // for enumerations
-    };
-    void (*set_self_py)(void *, PyObject *) noexcept;
-    bool (*keep_shared_from_this_alive)(PyObject *) noexcept;
-#if defined(Py_LIMITED_API)
-    uint32_t dictoffset;
-    uint32_t weaklistoffset;
-#endif
-};
-
-/// Information about a type that is only relevant when it is being created
-struct type_init_data : type_data {
-    PyObject *scope;
-    const std::type_info *base;
-    PyTypeObject *base_py;
-    const char *doc;
-    const PyType_Slot *type_slots;
-    size_t supplement;
-};
-
-NB_INLINE void type_extra_apply(type_init_data &t, const handle &h) {
-    t.flags |= (uint32_t) type_init_flags::has_base_py;
-    t.base_py = (PyTypeObject *) h.ptr();
-}
-
-NB_INLINE void type_extra_apply(type_init_data &t, const char *doc) {
-    t.flags |= (uint32_t) type_init_flags::has_doc;
-    t.doc = doc;
-}
-
-NB_INLINE void type_extra_apply(type_init_data &t, type_slots c) {
-    t.flags |= (uint32_t) type_init_flags::has_type_slots;
-    t.type_slots = c.value;
-}
-
-template <typename T>
-NB_INLINE void type_extra_apply(type_init_data &t, intrusive_ptr<T> ip) {
-    t.flags |= (uint32_t) type_flags::intrusive_ptr;
-    t.set_self_py = (void (*)(void *, PyObject *) noexcept) ip.set_self_py;
-}
-
-NB_INLINE void type_extra_apply(type_init_data &t, is_final) {
-    t.flags |= (uint32_t) type_flags::is_final;
-}
-
-NB_INLINE void type_extra_apply(type_init_data &t, dynamic_attr) {
-    t.flags |= (uint32_t) type_flags::has_dynamic_attr;
-}
-
-NB_INLINE void type_extra_apply(type_init_data & t, is_weak_referenceable) {
-    t.flags |= (uint32_t) type_flags::is_weak_referenceable;
-}
-
-NB_INLINE void type_extra_apply(type_init_data & t, is_generic) {
-    t.flags |= (uint32_t) type_flags::is_generic;
-}
-
-NB_INLINE void type_extra_apply(type_init_data & t, const sig &s) {
-    t.flags |= (uint32_t) type_flags::has_signature;
-    t.name = s.value;
-}
-
-template <typename T>
-NB_INLINE void type_extra_apply(type_init_data &t, supplement<T>) {
-    static_assert(std::is_trivially_default_constructible_v<T>,
-                  "The supplement must be a POD (plain old data) type");
-    static_assert(alignof(T) <= alignof(void *),
-                  "The alignment requirement of the supplement is too high.");
-    t.flags |= (uint32_t) type_init_flags::has_supplement | (uint32_t) type_flags::is_final;
-    t.supplement = sizeof(T);
-}
-
-enum class enum_flags : uint32_t {
-    /// Is this an arithmetic enumeration?
-    is_arithmetic            = (1 << 1),
-
-    /// Is the number type underlying the enumeration signed?
-    is_signed                = (1 << 2),
-
-    /// Is the underlying enumeration type Flag?
-    is_flag                = (1 << 3)
-};
-
-struct enum_init_data {
-    const std::type_info *type;
-    PyObject *scope;
-    const char *name;
-    const char *docstr;
-    uint32_t flags;
-};
-
-NB_INLINE void enum_extra_apply(enum_init_data &e, is_arithmetic) {
-    e.flags |= (uint32_t) enum_flags::is_arithmetic;
-}
-
-NB_INLINE void enum_extra_apply(enum_init_data &e, is_flag) {
-    e.flags |= (uint32_t) enum_flags::is_flag;
-}
-
-NB_INLINE void enum_extra_apply(enum_init_data &e, const char *doc) {
-    e.docstr = doc;
-}
-
-template <typename T>
-NB_INLINE void enum_extra_apply(enum_init_data &, T) {
-    static_assert(
-        std::is_void_v<T>,
-        "Invalid enum binding annotation. The implementation of "
-        "enums changed nanobind 2.0.0: only nb::is_arithmetic and "
-        "docstrings can be passed since this change.");
-}
-
-template <typename T> void wrap_copy(void *dst, const void *src) {
-    new ((T *) dst) T(*(const T *) src);
-}
-
-template <typename T> void wrap_move(void *dst, void *src) noexcept {
-    new ((T *) dst) T(std::move(*(T *) src));
-}
-
-template <typename T> void wrap_destruct(void *value) noexcept {
-    ((T *) value)->~T();
-}
-
-template <typename, template <typename, typename> typename, typename...>
-struct extract;
-
-template <typename T, template <typename, typename> typename Pred>
-struct extract<T, Pred> {
-    using type = T;
-};
-
-template <typename T, template <typename, typename> typename Pred,
-          typename Tv, typename... Ts>
-struct extract<T, Pred, Tv, Ts...> {
-    using type = std::conditional_t<
-        Pred<T, Tv>::value,
-        Tv,
-        typename extract<T, Pred, Ts...>::type
-    >;
-};
-
-template <typename T, typename Arg> using is_alias = std::is_base_of<T, Arg>;
-template <typename T, typename Arg> using is_base = std::is_base_of<Arg, T>;
-
-enum op_id : int;
-enum op_type : int;
-struct undefined_t;
-template <op_id id, op_type ot, typename L = undefined_t, typename R = undefined_t> struct op_;
-
-// The header file include/nanobind/stl/detail/traits.h extends this type trait
-template <typename T, typename SFINAE = int>
-struct is_copy_constructible : std::is_copy_constructible<T> { };
-
-template <typename T>
-constexpr bool is_copy_constructible_v = is_copy_constructible<T>::value;
-
-NAMESPACE_END(detail)
-
-// Low level access to nanobind type objects
-inline bool type_check(handle h) { return detail::nb_type_check(h.ptr()); }
-inline size_t type_size(handle h) { return detail::nb_type_size(h.ptr()); }
-inline size_t type_align(handle h) { return detail::nb_type_align(h.ptr()); }
-inline const std::type_info& type_info(handle h) { return *detail::nb_type_info(h.ptr()); }
-template <typename T>
-inline T &type_supplement(handle h) { return *(T *) detail::nb_type_supplement(h.ptr()); }
-inline str type_name(handle h) { return steal<str>(detail::nb_type_name(h.ptr())); }
-
-// Low level access to nanobind instance objects
-inline bool inst_check(handle h) { return type_check(h.type()); }
-inline str inst_name(handle h) {
-    return steal<str>(detail::nb_inst_name(h.ptr()));
-}
-inline object inst_alloc(handle h) {
-    return steal(detail::nb_inst_alloc((PyTypeObject *) h.ptr()));
-}
-inline object inst_alloc_zero(handle h) {
-    return steal(detail::nb_inst_alloc_zero((PyTypeObject *) h.ptr()));
-}
-inline object inst_take_ownership(handle h, void *p) {
-    return steal(detail::nb_inst_take_ownership((PyTypeObject *) h.ptr(), p));
-}
-inline object inst_reference(handle h, void *p, handle parent = handle()) {
-    return steal(detail::nb_inst_reference((PyTypeObject *) h.ptr(), p, parent.ptr()));
-}
-inline void inst_zero(handle h) { detail::nb_inst_zero(h.ptr()); }
-inline void inst_set_state(handle h, bool ready, bool destruct) {
-    detail::nb_inst_set_state(h.ptr(), ready, destruct);
-}
-inline std::pair<bool, bool> inst_state(handle h) {
-    return detail::nb_inst_state(h.ptr());
-}
-inline void inst_mark_ready(handle h) { inst_set_state(h, true, true); }
-inline bool inst_ready(handle h) { return inst_state(h).first; }
-inline void inst_destruct(handle h) { detail::nb_inst_destruct(h.ptr()); }
-inline void inst_copy(handle dst, handle src) { detail::nb_inst_copy(dst.ptr(), src.ptr()); }
-inline void inst_move(handle dst, handle src) { detail::nb_inst_move(dst.ptr(), src.ptr()); }
-inline void inst_replace_copy(handle dst, handle src) { detail::nb_inst_replace_copy(dst.ptr(), src.ptr()); }
-inline void inst_replace_move(handle dst, handle src) { detail::nb_inst_replace_move(dst.ptr(), src.ptr()); }
-template <typename T> T *inst_ptr(handle h) { return (T *) detail::nb_inst_ptr(h.ptr()); }
-inline void *type_get_slot(handle h, int slot_id) {
-#if NB_TYPE_GET_SLOT_IMPL
-    return detail::type_get_slot((PyTypeObject *) h.ptr(), slot_id);
-#else
-    return PyType_GetSlot((PyTypeObject *) h.ptr(), slot_id);
-#endif
-}
-
-template <typename Visitor> struct def_visitor {
-  protected:
-    // Ensure def_visitor<T> can only be derived from, not constructed
-    // directly
-    def_visitor() {
-        static_assert(std::is_base_of_v<def_visitor, Visitor>,
-                      "def_visitor uses CRTP: def_visitor<T> should be "
-                      "a base of T");
-    }
-};
-
-template <typename... Args> struct init : def_visitor<init<Args...>> {
-    template <typename T, typename... Ts> friend class class_;
-    NB_INLINE init() {}
-
-private:
-    template <typename Class, typename... Extra>
-    NB_INLINE static void execute(Class &cl, const Extra&... extra) {
-        using Type = typename Class::Type;
-        using Alias = typename Class::Alias;
-        cl.def(
-            "__init__",
-            [](pointer_and_handle<Type> v, Args... args) {
-                if constexpr (!std::is_same_v<Type, Alias> &&
-                              std::is_constructible_v<Type, Args...>) {
-                    if (!detail::nb_inst_python_derived(v.h.ptr())) {
-                        new (v.p) Type{ (detail::forward_t<Args>) args... };
-                        return;
-                    }
-                }
-                new ((void *) v.p) Alias{ (detail::forward_t<Args>) args... };
-            },
-            extra...);
-    }
-};
-
-template <typename Arg> struct init_implicit : def_visitor<init_implicit<Arg>> {
-    template <typename T, typename... Ts> friend class class_;
-    NB_INLINE init_implicit() { }
-
-private:
-    template <typename Class, typename... Extra>
-    NB_INLINE static void execute(Class &cl, const Extra&... extra) {
-        using Type = typename Class::Type;
-        using Alias = typename Class::Alias;
-
-        cl.def(
-            "__init__",
-            [](pointer_and_handle<Type> v, Arg arg) {
-                if constexpr (!std::is_same_v<Type, Alias> &&
-                              std::is_constructible_v<Type, Arg>) {
-                    if (!detail::nb_inst_python_derived(v.h.ptr())) {
-                        new ((Type *) v.p) Type{ (detail::forward_t<Arg>) arg };
-                        return;
-                    }
-                }
-                new ((Alias *) v.p) Alias{ (detail::forward_t<Arg>) arg };
-            }, is_implicit(), extra...);
-
-        using Caster = detail::make_caster<Arg>;
-
-        if constexpr (!detail::is_class_caster_v<Caster>) {
-            detail::implicitly_convertible(
-                [](PyTypeObject *, PyObject *src,
-                   detail::cleanup_list *cleanup) noexcept -> bool {
-                    return Caster().from_python(
-                        src, detail::cast_flags::convert, cleanup);
-                },
-                &typeid(Type));
-        }
-    }
-};
-
-namespace detail {
-    // This is 'inline' so we can define it in a header and not pay
-    // for it if unused, and also 'noinline' so we don't generate
-    // multiple copies and produce code bloat.
-    NB_NOINLINE inline void wrap_base_new(handle cls, bool do_wrap) {
-        if (PyCFunction_Check(cls.attr("__new__").ptr())) {
-            if (do_wrap) {
-                cpp_function_def(
-                    [](handle type) {
-                        if (!type_check(type))
-                            detail::raise_cast_error();
-                        return inst_alloc(type);
-                    },
-                    scope(cls), name("__new__"));
-            }
-        } else {
-            if (!do_wrap) {
-                // We already defined the wrapper, so this zero-arg overload
-                // would be unreachable. Raise an error rather than hiding it.
-                raise("nanobind: %s must define its zero-argument __new__ "
-                      "before any other overloads", type_name(cls).c_str());
-            }
-        }
-    }
-
-    // Call policy that ensures __new__ returns an instance of the correct
-    // Python type, even when deriving from the C++ class in Python
-    struct new_returntype_fixup_policy {
-        static inline void precall(PyObject **, size_t,
-                                   detail::cleanup_list *) {}
-        NB_NOINLINE static inline void postcall(PyObject **args, size_t,
-                                                PyObject *&ret) {
-            handle type_requested = args[0];
-            if (ret == nullptr || !type_requested.is_type())
-                return; // somethign strange about this call; don't meddle
-            handle type_created = Py_TYPE(ret);
-            if (type_created.is(type_requested))
-                return; // already created the requested type so no fixup needed
-
-            if (type_check(type_created) &&
-                PyType_IsSubtype((PyTypeObject *) type_requested.ptr(),
-                                 (PyTypeObject *) type_created.ptr()) &&
-                type_info(type_created) == type_info(type_requested)) {
-                // The new_ constructor returned an instance of a bound type T.
-                // The user wanted an instance of some python subclass S of T.
-                // Since both wrap the same C++ type, we can satisfy the request
-                // by returning a pyobject of type S that wraps a C++ T*, and
-                // handling the lifetimes by having that pyobject keep the
-                // already-created T pyobject alive.
-                object wrapper = inst_reference(type_requested,
-                                                inst_ptr<void>(ret),
-                                                /* parent = */ ret);
-                handle(ret).dec_ref();
-                ret = wrapper.release().ptr();
-            }
-        }
-    };
-}
-
-template <typename Func, typename Sig = detail::function_signature_t<Func>>
-struct new_;
-
-template <typename Func, typename Return, typename... Args>
-struct new_<Func, Return(Args...)> : def_visitor<new_<Func, Return(Args...)>> {
-    std::remove_reference_t<Func> func;
-
-    new_(Func &&f) : func((detail::forward_t<Func>) f) {}
-
-    template <typename Class, typename... Extra>
-    NB_INLINE void execute(Class &cl, const Extra&... extra) {
-        // If this is the first __new__ overload we're defining, then wrap
-        // nanobind's built-in __new__ so we overload with it instead of
-        // replacing it; this is important for pickle support.
-        // We can't do this if the user-provided __new__ takes no
-        // arguments, because it would make an ambiguous overload set.
-        constexpr size_t num_defaults =
-            ((std::is_same_v<Extra, arg_v> ||
-              std::is_same_v<Extra, arg_locked_v>) + ... + 0);
-        constexpr size_t num_varargs =
-            ((std::is_same_v<detail::intrinsic_t<Args>, args> ||
-              std::is_same_v<detail::intrinsic_t<Args>, kwargs>) + ... + 0);
-        detail::wrap_base_new(cl, sizeof...(Args) > num_defaults + num_varargs);
-
-        auto wrapper = [func_ = (detail::forward_t<Func>) func](handle, Args... args) {
-            return func_((detail::forward_t<Args>) args...);
-        };
-
-        auto policy = call_policy<detail::new_returntype_fixup_policy>();
-        if constexpr ((std::is_base_of_v<arg, Extra> || ...)) {
-            // If any argument annotations are specified, add another for the
-            // extra class argument that we don't forward to Func, so visible
-            // arg() annotations stay aligned with visible function arguments.
-            cl.def_static("__new__", std::move(wrapper), arg("cls"), extra...,
-                          policy);
-        } else {
-            cl.def_static("__new__", std::move(wrapper), extra..., policy);
-        }
-        cl.def("__init__", [](handle, Args...) {}, extra...);
-    }
-};
-template <typename Func> new_(Func&& f) -> new_<Func>;
-
-template <typename T> struct for_setter {
-    T value;
-    for_setter(const T &value) : value(value) { }
-};
-
-template <typename T> struct for_getter {
-    T value;
-    for_getter(const T &value) : value(value) { }
-};
-
-template <typename T> for_getter(T) -> for_getter<std::decay_t<T>>;
-template <typename T> for_setter(T) -> for_setter<std::decay_t<T>>;
-
-namespace detail {
-    template <typename T> auto filter_getter(const T &v) { return v; }
-    template <typename T> auto filter_getter(const for_getter<T> &v) { return v.value; }
-    template <typename T> std::nullptr_t filter_getter(const for_setter<T> &) { return nullptr; }
-
-    template <typename T> auto filter_setter(const T &v) { return v; }
-    template <typename T> auto filter_setter(const for_setter<T> &v) { return v.value; }
-    template <typename T> std::nullptr_t filter_setter(const for_getter<T> &) { return nullptr; }
-}
-
-template <typename T, typename... Ts>
-class class_ : public object {
-public:
-    NB_OBJECT_DEFAULT(class_, object, "type", PyType_Check)
-    using Type = T;
-    using Base  = typename detail::extract<T, detail::is_base,  Ts...>::type;
-    using Alias = typename detail::extract<T, detail::is_alias, Ts...>::type;
-
-    static_assert(sizeof(Alias) < (((uint64_t) 1) << 32), "Instance size is too big!");
-    static_assert(alignof(Alias) < (1 << 8), "Instance alignment is too big!");
-    static_assert(
-        sizeof...(Ts) == !std::is_same_v<Base, T> + !std::is_same_v<Alias, T>,
-        "nanobind::class_<> was invoked with extra arguments that could not be handled");
-
-    static_assert(
-        detail::is_base_caster_v<detail::make_caster<Type>>,
-        "You attempted to bind a type that is already intercepted by a type "
-        "caster. Having both at the same time is not allowed. Are you perhaps "
-        "binding an STL type, while at the same time including a matching "
-        "type caster from <nanobind/stl/*>? Or did you perhaps forget to "
-        "declare NB_MAKE_OPAQUE(..) to specifically disable the type caster "
-        "catch-all for a specific type? Please review the documentation "
-        "to learn about the difference between bindings and type casters.");
-
-    template <typename... Extra>
-    NB_INLINE class_(handle scope, const char *name, const Extra &... extra) {
-        detail::type_init_data d;
-
-        d.flags = 0;
-        d.align = (uint8_t) alignof(Alias);
-        d.size = (uint32_t) sizeof(Alias);
-        d.name = name;
-        d.scope = scope.ptr();
-        d.type = &typeid(T);
-
-        if constexpr (!std::is_same_v<Base, T>) {
-            d.base = &typeid(Base);
-            d.flags |= (uint32_t) detail::type_init_flags::has_base;
-        }
-
-        if constexpr (detail::is_copy_constructible_v<T>) {
-            d.flags |= (uint32_t) detail::type_flags::is_copy_constructible;
-
-            if constexpr (!std::is_trivially_copy_constructible_v<T>) {
-                d.flags |= (uint32_t) detail::type_flags::has_copy;
-                d.copy = detail::wrap_copy<T>;
-            }
-        }
-
-        if constexpr (std::is_move_constructible<T>::value) {
-            d.flags |= (uint32_t) detail::type_flags::is_move_constructible;
-
-            if constexpr (!std::is_trivially_move_constructible_v<T>) {
-                d.flags |= (uint32_t) detail::type_flags::has_move;
-                d.move = detail::wrap_move<T>;
-            }
-        }
-
-        if constexpr (std::is_destructible_v<T>) {
-            d.flags |= (uint32_t) detail::type_flags::is_destructible;
-
-            if constexpr (!std::is_trivially_destructible_v<T>) {
-                d.flags |= (uint32_t) detail::type_flags::has_destruct;
-                d.destruct = detail::wrap_destruct<T>;
-            }
-        }
-
-        if constexpr (detail::has_shared_from_this_v<T>) {
-            d.flags |= (uint32_t) detail::type_flags::has_shared_from_this;
-            d.keep_shared_from_this_alive = [](PyObject *self) noexcept {
-                // weak_from_this().lock() is equivalent to shared_from_this(),
-                // except that it returns an empty shared_ptr instead of
-                // throwing an exception if there is no active shared_ptr
-                // for this object. (Added in C++17.)
-                if (auto sp = inst_ptr<T>(self)->weak_from_this().lock()) {
-                    detail::keep_alive(self, new auto(std::move(sp)),
-                                       [](void *p) noexcept {
-                                           delete (decltype(sp) *) p;
-                                       });
-                    return true;
-                }
-                return false;
-            };
-        }
-
-        (detail::type_extra_apply(d, extra), ...);
-
-        m_ptr = detail::nb_type_new(&d);
-    }
-
-    template <typename Func, typename... Extra>
-    NB_INLINE class_ &def(const char *name_, Func &&f, const Extra &... extra) {
-        cpp_function_def<T>((detail::forward_t<Func>) f, scope(*this),
-                            name(name_), is_method(), extra...);
-        return *this;
-    }
-
-    template <typename Visitor, typename... Extra>
-    NB_INLINE class_ &def(def_visitor<Visitor> &&arg, const Extra &... extra) {
-        static_cast<Visitor&&>(arg).execute(*this, extra...);
-        return *this;
-    }
-
-    template <typename Func, typename... Extra>
-    NB_INLINE class_ &def_static(const char *name_, Func &&f,
-                                 const Extra &... extra) {
-        static_assert(
-            !std::is_member_function_pointer_v<Func>,
-            "def_static(...) called with a non-static member function pointer");
-        cpp_function_def((detail::forward_t<Func>) f, scope(*this), name(name_),
-                         extra...);
-        return *this;
-    }
-
-    template <typename Getter, typename Setter, typename... Extra>
-    NB_INLINE class_ &def_prop_rw(const char *name_, Getter &&getter,
-                                  Setter &&setter, const Extra &...extra) {
-        object get_p, set_p;
-
-        if constexpr (!std::is_same_v<Getter, std::nullptr_t>)
-            get_p = cpp_function<T>((detail::forward_t<Getter>) getter,
-                                    is_method(), is_getter(),
-                                    rv_policy::reference_internal,
-                                    detail::filter_getter(extra)...);
-
-        if constexpr (!std::is_same_v<Setter, std::nullptr_t>)
-            set_p = cpp_function<T>((detail::forward_t<Setter>) setter,
-                                    is_method(), detail::filter_setter(extra)...);
-
-        detail::property_install(m_ptr, name_, get_p.ptr(), set_p.ptr());
-        return *this;
-    }
-
-    template <typename Getter, typename Setter, typename... Extra>
-    NB_INLINE class_ &def_prop_rw_static(const char *name_, Getter &&getter,
-                                         Setter &&setter,
-                                         const Extra &...extra) {
-        object get_p, set_p;
-
-        if constexpr (!std::is_same_v<Getter, std::nullptr_t>)
-            get_p = cpp_function((detail::forward_t<Getter>) getter, is_getter(),
-                                 rv_policy::reference,
-                                 detail::filter_getter(extra)...);
-
-        if constexpr (!std::is_same_v<Setter, std::nullptr_t>)
-            set_p = cpp_function((detail::forward_t<Setter>) setter,
-                                 detail::filter_setter(extra)...);
-
-        detail::property_install_static(m_ptr, name_, get_p.ptr(), set_p.ptr());
-        return *this;
-    }
-
-    template <typename Getter, typename... Extra>
-    NB_INLINE class_ &def_prop_ro(const char *name_, Getter &&getter,
-                                  const Extra &...extra) {
-        return def_prop_rw(name_, getter, nullptr, extra...);
-    }
-
-    template <typename Getter, typename... Extra>
-    NB_INLINE class_ &def_prop_ro_static(const char *name_,
-                                         Getter &&getter,
-                                         const Extra &...extra) {
-        return def_prop_rw_static(name_, getter, nullptr, extra...);
-    }
-
-    template <typename C, typename D, typename... Extra>
-    NB_INLINE class_ &def_rw(const char *name, D C::*p,
-                             const Extra &...extra) {
-        // Unions never satisfy is_base_of, thus the is_same alternative
-        static_assert(std::is_base_of_v<C, T> || std::is_same_v<C, T>,
-                      "def_rw() requires a (base) class member!");
-
-        using Q =
-            std::conditional_t<detail::is_base_caster_v<detail::make_caster<D>>,
-                               const D &, D &&>;
-
-        def_prop_rw(name,
-            [p](const T &c) -> const D & { return c.*p; },
-            [p](T &c, Q value) { c.*p = (Q) value; },
-            extra...);
-
-        return *this;
-    }
-
-    template <typename D, typename... Extra>
-    NB_INLINE class_ &def_rw_static(const char *name, D *p,
-                                    const Extra &...extra) {
-        using Q =
-            std::conditional_t<detail::is_base_caster_v<detail::make_caster<D>>,
-                               const D &, D &&>;
-
-        def_prop_rw_static(name,
-            [p](handle) -> const D & { return *p; },
-            [p](handle, Q value) { *p = (Q) value; }, extra...);
-
-        return *this;
-    }
-
-    template <typename C, typename D, typename... Extra>
-    NB_INLINE class_ &def_ro(const char *name, D C::*p,
-                             const Extra &...extra) {
-        // Unions never satisfy is_base_of, thus the is_same alternative
-        static_assert(std::is_base_of_v<C, T> || std::is_same_v<C, T>,
-                      "def_ro() requires a (base) class member!");
-
-        def_prop_ro(name,
-            [p](const T &c) -> const D & { return c.*p; }, extra...);
-
-        return *this;
-    }
-
-    template <typename D, typename... Extra>
-    NB_INLINE class_ &def_ro_static(const char *name, D *p,
-                                    const Extra &...extra) {
-        def_prop_ro_static(name,
-            [p](handle) -> const D & { return *p; }, extra...);
-
-        return *this;
-    }
-
-    template <detail::op_id id, detail::op_type ot, typename L, typename R, typename... Extra>
-    class_ &def(const detail::op_<id, ot, L, R> &op, const Extra&... extra) {
-        op.execute(*this, extra...);
-        return *this;
-    }
-
-    template <detail::op_id id, detail::op_type ot, typename L, typename R, typename... Extra>
-    class_ & def_cast(const detail::op_<id, ot, L, R> &op, const Extra&... extra) {
-        op.execute_cast(*this, extra...);
-        return *this;
-    }
-};
-
-template <typename T> class enum_ : public object {
-public:
-    static_assert(std::is_enum_v<T>, "nanobind::enum_<> requires an enumeration type!");
-
-    using Base = class_<T>;
-    using Underlying = std::underlying_type_t<T>;
-
-    template <typename... Extra>
-    NB_INLINE enum_(handle scope, const char *name, const Extra &... extra) {
-        detail::enum_init_data ed { };
-        ed.type = &typeid(T);
-        ed.scope = scope.ptr();
-        ed.name = name;
-        ed.flags = std::is_signed_v<Underlying>
-                       ? (uint32_t) detail::enum_flags::is_signed
-                       : 0;
-        (detail::enum_extra_apply(ed, extra), ...);
-        m_ptr = detail::enum_create(&ed);
-    }
-
-    NB_INLINE enum_ &value(const char *name, T value, const char *doc = nullptr) {
-        detail::enum_append(m_ptr, name, (int64_t) value, doc);
-        return *this;
-    }
-
-    NB_INLINE enum_ &export_values() { detail::enum_export(m_ptr); return *this; }
-
-    template <typename Func, typename... Extra>
-    NB_INLINE enum_ &def(const char *name_, Func &&f, const Extra &... extra) {
-        cpp_function_def<T>((detail::forward_t<Func>) f, scope(*this),
-                            name(name_), is_method(), extra...);
-        return *this;
-    }
-
-    template <typename Func, typename... Extra>
-    NB_INLINE enum_ &def_static(const char *name_, Func &&f,
-                                 const Extra &... extra) {
-        static_assert(
-            !std::is_member_function_pointer_v<Func>,
-            "def_static(...) called with a non-static member function pointer");
-        cpp_function_def((detail::forward_t<Func>) f, scope(*this), name(name_),
-                         extra...);
-        return *this;
-    }
-
-    template <typename Getter, typename Setter, typename... Extra>
-    NB_INLINE enum_ &def_prop_rw(const char *name_, Getter &&getter,
-                                 Setter &&setter, const Extra &...extra) {
-        object get_p, set_p;
-
-        if constexpr (!std::is_same_v<Getter, std::nullptr_t>)
-            get_p = cpp_function<T>((detail::forward_t<Getter>) getter,
-                                    is_method(), is_getter(),
-                                    rv_policy::reference_internal,
-                                    detail::filter_getter(extra)...);
-
-        if constexpr (!std::is_same_v<Setter, std::nullptr_t>)
-            set_p = cpp_function<T>((detail::forward_t<Setter>) setter,
-                                    is_method(), detail::filter_setter(extra)...);
-
-        detail::property_install(m_ptr, name_, get_p.ptr(), set_p.ptr());
-        return *this;
-    }
-
-
-    template <typename Getter, typename... Extra>
-    NB_INLINE enum_ &def_prop_ro(const char *name_, Getter &&getter,
-                                 const Extra &...extra) {
-        return def_prop_rw(name_, getter, nullptr, extra...);
-    }
-};
-
-template <typename Source, typename Target> void implicitly_convertible() {
-    using Caster = detail::make_caster<Source>;
-    static_assert(!std::is_enum_v<Target>, "implicitly_convertible(): 'Target' cannot be an enumeration.");
-
-    if constexpr (detail::is_base_caster_v<Caster>) {
-        detail::implicitly_convertible(&typeid(Source), &typeid(Target));
-    } else {
-        detail::implicitly_convertible(
-            [](PyTypeObject *, PyObject *src,
-               detail::cleanup_list *cleanup) noexcept -> bool {
-                return Caster().from_python(src, detail::cast_flags::convert,
-                                            cleanup);
-            },
-            &typeid(Target));
-    }
-}
-
-NAMESPACE_END(NB_NAMESPACE)
diff --git a/src/nanobind/include/nanobind/nb_defs.h b/src/nanobind/include/nanobind/nb_defs.h
deleted file mode 100644
index 5dc1361..0000000
--- a/src/nanobind/include/nanobind/nb_defs.h
+++ /dev/null
@@ -1,239 +0,0 @@
-/*
-    nanobind/nb_defs.h: Preprocessor definitions used by the project
-
-    Copyright (c) 2022 Wenzel Jakob
-
-    All rights reserved. Use of this source code is governed by a
-    BSD-style license that can be found in the LICENSE file.
-*/
-
-#pragma once
-
-#define NB_STRINGIFY(x) #x
-#define NB_TOSTRING(x) NB_STRINGIFY(x)
-#define NB_CONCAT(first, second) first##second
-#define NB_NEXT_OVERLOAD ((PyObject *) 1) // special failure return code
-
-#if !defined(NAMESPACE_BEGIN)
-#  define NAMESPACE_BEGIN(name) namespace name {
-#endif
-
-#if !defined(NAMESPACE_END)
-#  define NAMESPACE_END(name) }
-#endif
-
-#if defined(_WIN32)
-#  define NB_EXPORT          __declspec(dllexport)
-#  define NB_IMPORT          __declspec(dllimport)
-#  define NB_INLINE          __forceinline
-#  define NB_NOINLINE        __declspec(noinline)
-#  define NB_INLINE_LAMBDA
-#else
-#  define NB_EXPORT          __attribute__ ((visibility("default")))
-#  define NB_IMPORT          NB_EXPORT
-#  define NB_INLINE          inline __attribute__((always_inline))
-#  define NB_NOINLINE        __attribute__((noinline))
-#  if defined(__clang__)
-#    define NB_INLINE_LAMBDA __attribute__((always_inline))
-#  else
-#    define NB_INLINE_LAMBDA
-#  endif
-#endif
-
-#if defined(__GNUC__) && !defined(_WIN32)
-#  define NB_NAMESPACE nanobind __attribute__((visibility("hidden")))
-#else
-#  define NB_NAMESPACE nanobind
-#endif
-
-#if defined(__GNUC__)
-#  define NB_UNLIKELY(x) __builtin_expect(bool(x), 0)
-#  define NB_LIKELY(x)   __builtin_expect(bool(x), 1)
-#else
-#  define NB_LIKELY(x) x
-#  define NB_UNLIKELY(x) x
-#endif
-
-#if defined(NB_SHARED)
-#  if defined(NB_BUILD)
-#    define NB_CORE NB_EXPORT
-#  else
-#    define NB_CORE NB_IMPORT
-#  endif
-#else
-#  define NB_CORE
-#endif
-
-#if !defined(NB_SHARED) && defined(__GNUC__) && !defined(_WIN32)
-#  define NB_EXPORT_SHARED __attribute__ ((visibility("hidden")))
-#else
-#  define NB_EXPORT_SHARED
-#endif
-
-#if defined(__cpp_lib_char8_t) && __cpp_lib_char8_t >= 201811L
-#  define NB_HAS_U8STRING
-#endif
-
-#if defined(Py_TPFLAGS_HAVE_VECTORCALL)
-#  define NB_VECTORCALL PyObject_Vectorcall
-#  define NB_HAVE_VECTORCALL Py_TPFLAGS_HAVE_VECTORCALL
-#elif defined(_Py_TPFLAGS_HAVE_VECTORCALL)
-#  define NB_VECTORCALL _PyObject_Vectorcall
-#  define NB_HAVE_VECTORCALL _Py_TPFLAGS_HAVE_VECTORCALL
-#else
-#  define NB_HAVE_VECTORCALL (1UL << 11)
-#endif
-
-#if defined(PY_VECTORCALL_ARGUMENTS_OFFSET)
-#  define NB_VECTORCALL_ARGUMENTS_OFFSET PY_VECTORCALL_ARGUMENTS_OFFSET
-#  define NB_VECTORCALL_NARGS PyVectorcall_NARGS
-#else
-#  define NB_VECTORCALL_ARGUMENTS_OFFSET ((size_t) 1 << (8 * sizeof(size_t) - 1))
-#  define NB_VECTORCALL_NARGS(n) ((n) & ~NB_VECTORCALL_ARGUMENTS_OFFSET)
-#endif
-
-#if PY_VERSION_HEX < 0x03090000
-#  define NB_TYPING_ABC   "typing."
-#  define NB_TYPING_TUPLE "typing.Tuple"
-#  define NB_TYPING_LIST  "typing.List"
-#  define NB_TYPING_DICT  "typing.Dict"
-#  define NB_TYPING_SET   "typing.Set"
-#  define NB_TYPING_TYPE  "typing.Type"
-#else
-#  define NB_TYPING_ABC   "collections.abc."
-#  define NB_TYPING_TUPLE "tuple"
-#  define NB_TYPING_LIST  "list"
-#  define NB_TYPING_DICT  "dict"
-#  define NB_TYPING_SET   "set"
-#  define NB_TYPING_TYPE  "type"
-#endif
-
-#if PY_VERSION_HEX < 0x030D0000
-#  define NB_TYPING_CAPSULE "typing_extensions.CapsuleType"
-#else
-#  define NB_TYPING_CAPSULE "types.CapsuleType"
-#endif
-
-#define NB_TYPING_SEQUENCE     NB_TYPING_ABC "Sequence"
-#define NB_TYPING_MAPPING      NB_TYPING_ABC "Mapping"
-#define NB_TYPING_CALLABLE     NB_TYPING_ABC "Callable"
-#define NB_TYPING_ITERATOR     NB_TYPING_ABC "Iterator"
-#define NB_TYPING_ITERABLE     NB_TYPING_ABC "Iterable"
-
-#if PY_VERSION_HEX < 0x03090000
-#  define NB_TYPING_ABSTRACT_SET "typing.AbstractSet"
-#else
-#  define NB_TYPING_ABSTRACT_SET "collections.abc.Set"
-#endif
-
-#if defined(Py_LIMITED_API)
-#  if PY_VERSION_HEX < 0x030C0000 || defined(PYPY_VERSION)
-#    error "nanobind can target Python's limited API, but this requires CPython >= 3.12"
-#  endif
-#  define NB_TUPLE_GET_SIZE PyTuple_Size
-#  define NB_TUPLE_GET_ITEM PyTuple_GetItem
-#  define NB_TUPLE_SET_ITEM PyTuple_SetItem
-#  define NB_LIST_GET_SIZE PyList_Size
-#  define NB_LIST_GET_ITEM PyList_GetItem
-#  define NB_LIST_SET_ITEM PyList_SetItem
-#  define NB_DICT_GET_SIZE PyDict_Size
-#  define NB_SET_GET_SIZE PySet_Size
-#else
-#  define NB_TUPLE_GET_SIZE PyTuple_GET_SIZE
-#  define NB_TUPLE_GET_ITEM PyTuple_GET_ITEM
-#  define NB_TUPLE_SET_ITEM PyTuple_SET_ITEM
-#  define NB_LIST_GET_SIZE PyList_GET_SIZE
-#  define NB_LIST_GET_ITEM PyList_GET_ITEM
-#  define NB_LIST_SET_ITEM PyList_SET_ITEM
-#  define NB_DICT_GET_SIZE PyDict_GET_SIZE
-#  define NB_SET_GET_SIZE PySet_GET_SIZE
-#endif
-
-#if defined(PYPY_VERSION_NUM) && PYPY_VERSION_NUM < 0x07030a00
-#    error "nanobind requires a newer PyPy version (>= 7.3.10)"
-#endif
-
-#if defined(NB_FREE_THREADED) && !defined(Py_GIL_DISABLED)
-#    error "Free-threaded extensions require a free-threaded version of Python"
-#endif
-
-#if defined(NB_DOMAIN)
-#  define NB_DOMAIN_STR NB_TOSTRING(NB_DOMAIN)
-#else
-#  define NB_DOMAIN_STR nullptr
-#endif
-
-#if !defined(PYPY_VERSION)
-#  if PY_VERSION_HEX < 0x030A0000
-#    define NB_TYPE_GET_SLOT_IMPL 1 // Custom implementation of nb::type_get_slot
-#  else
-#    define NB_TYPE_GET_SLOT_IMPL 0
-#  endif
-#  if PY_VERSION_HEX < 0x030C0000
-#    define NB_TYPE_FROM_METACLASS_IMPL 1 // Custom implementation of PyType_FromMetaclass
-#  else
-#    define NB_TYPE_FROM_METACLASS_IMPL 0
-#  endif
-#else
-#  define NB_TYPE_FROM_METACLASS_IMPL 1
-#  define NB_TYPE_GET_SLOT_IMPL 1
-#endif
-
-#define NB_MODULE_SLOTS_0 { 0, nullptr }
-
-#if PY_VERSION_HEX < 0x030C0000
-#  define NB_MODULE_SLOTS_1 NB_MODULE_SLOTS_0
-#else
-#  define NB_MODULE_SLOTS_1                                                    \
-    { Py_mod_multiple_interpreters,                                            \
-      Py_MOD_MULTIPLE_INTERPRETERS_NOT_SUPPORTED },                            \
-    NB_MODULE_SLOTS_0
-#endif
-
-#if !defined(NB_FREE_THREADED)
-#  define NB_MODULE_SLOTS_2 NB_MODULE_SLOTS_1
-#else
-#  define NB_MODULE_SLOTS_2                                                    \
-   { Py_mod_gil, Py_MOD_GIL_NOT_USED },                                        \
-   NB_MODULE_SLOTS_1
-#endif
-
-#define NB_NONCOPYABLE(X)                                                      \
-    X(const X &) = delete;                                                     \
-    X &operator=(const X &) = delete;
-
-// Helper macros to ensure macro arguments are expanded before token pasting/stringification
-#define NB_MODULE_IMPL(name, variable) NB_MODULE_IMPL2(name, variable)
-#define NB_MODULE_IMPL2(name, variable)                                        \
-    static void nanobind_##name##_exec_impl(nanobind::module_);                \
-    static int nanobind_##name##_exec(PyObject *m) {                           \
-        nanobind::detail::init(NB_DOMAIN_STR);                                 \
-        try {                                                                  \
-            nanobind_##name##_exec_impl(                                       \
-                nanobind::borrow<nanobind::module_>(m));                       \
-            return 0;                                                          \
-        } catch (nanobind::python_error &e) {                                  \
-            e.restore();                                                       \
-            nanobind::chain_error(                                             \
-                PyExc_ImportError,                                             \
-                "Encountered an error while initializing the extension.");     \
-        } catch (const std::exception &e) {                                    \
-            PyErr_SetString(PyExc_ImportError, e.what());                      \
-        }                                                                      \
-        return -1;                                                             \
-    }                                                                          \
-    static PyModuleDef_Slot nanobind_##name##_slots[] = {                      \
-        { Py_mod_exec, (void *) nanobind_##name##_exec },                      \
-        NB_MODULE_SLOTS_2                                                      \
-    };                                                                         \
-    static struct PyModuleDef nanobind_##name##_module = {                     \
-        PyModuleDef_HEAD_INIT, #name, nullptr, 0, nullptr,                     \
-        nanobind_##name##_slots, nullptr, nullptr, nullptr                     \
-    };                                                                         \
-    extern "C" [[maybe_unused]] NB_EXPORT PyObject *PyInit_##name(void);       \
-    extern "C" PyObject *PyInit_##name(void) {                                 \
-        return PyModuleDef_Init(&nanobind_##name##_module);                    \
-    }                                                                          \
-    void nanobind_##name##_exec_impl(nanobind::module_ variable)
-
-#define NB_MODULE(name, variable) NB_MODULE_IMPL(name, variable)
diff --git a/src/nanobind/include/nanobind/nb_descr.h b/src/nanobind/include/nanobind/nb_descr.h
deleted file mode 100644
index 4975e13..0000000
--- a/src/nanobind/include/nanobind/nb_descr.h
+++ /dev/null
@@ -1,155 +0,0 @@
-/*
-    nanobind/nb_descr.h: Constexpr string class for function signatures
-
-    Copyright (c) 2022 Wenzel Jakob
-
-    All rights reserved. Use of this source code is governed by a
-    BSD-style license that can be found in the LICENSE file.
-*/
-
-NAMESPACE_BEGIN(NB_NAMESPACE)
-NAMESPACE_BEGIN(detail)
-
-/// Helper type for concatenating type signatures at compile time
-template <size_t N, typename... Ts>
-struct descr {
-    char text[N + 1]{'\0'};
-
-    constexpr descr() = default;
-    constexpr descr(char const (&s)[N+1]) : descr(s, std::make_index_sequence<N>()) { }
-
-    template <size_t... Is>
-    constexpr descr(char const (&s)[N+1], std::index_sequence<Is...>) : text{s[Is]..., '\0'} { }
-
-    template <typename... Cs>
-    constexpr descr(char c, Cs... cs) : text{c, static_cast<char>(cs)..., '\0'} { }
-
-    constexpr size_t type_count() const { return sizeof...(Ts); }
-    constexpr size_t size() const { return N; }
-
-    NB_INLINE void put_types(const std::type_info **out) const {
-        size_t ctr = 0;
-        ((out[ctr++] = &typeid(Ts)), ...);
-        out[ctr++] = nullptr;
-    }
-};
-
-template <size_t N1, size_t N2, typename... Ts1, typename... Ts2, size_t... Is1, size_t... Is2>
-constexpr descr<N1 + N2, Ts1..., Ts2...> plus_impl(const descr<N1, Ts1...> &a, const descr<N2, Ts2...> &b,
-                                                   std::index_sequence<Is1...>, std::index_sequence<Is2...>) {
-    return {a.text[Is1]..., b.text[Is2]...};
-}
-
-template <size_t N1, size_t N2, typename... Ts1, typename... Ts2>
-constexpr descr<N1 + N2, Ts1..., Ts2...> operator+(const descr<N1, Ts1...> &a, const descr<N2, Ts2...> &b) {
-    return plus_impl(a, b, std::make_index_sequence<N1>(), std::make_index_sequence<N2>());
-}
-
-template <size_t N>
-constexpr descr<N - 1> const_name(char const(&text)[N]) { return descr<N - 1>(text); }
-constexpr descr<0> const_name(char const(&)[1]) { return {}; }
-
-template <size_t Rem, size_t... Digits>
-struct int_to_str : int_to_str<Rem / 10, Rem % 10, Digits...> {};
-template <size_t... Digits> struct int_to_str<0, Digits...> {
-    static constexpr auto digits = descr<sizeof...(Digits)>(('0' + Digits)...);
-};
-
-constexpr auto const_name(char c) { return descr<1>(c); }
-
-// Ternary description (like std::conditional)
-template <bool B, size_t N1, size_t N2>
-constexpr auto const_name(char const(&text1)[N1], char const(&text2)[N2]) {
-    (void) text1; (void) text2;
-
-    if constexpr(B)
-        return const_name(text1);
-    else
-        return const_name(text2);
-}
-
-template <bool B, typename T1, typename T2>
-constexpr auto const_name(const T1 &d1, const T2 &d2) {
-    (void) d1; (void) d2;
-
-    if constexpr (B)
-        return d1;
-    else
-        return d2;
-}
-
-// Use a different name based on whether the parameter is used as input or output
-template <size_t N1, size_t N2>
-constexpr auto io_name(char const (&text1)[N1], char const (&text2)[N2]) {
-    return const_name('@') + const_name(text1) + const_name('@') +
-           const_name(text2) + const_name('@');
-}
-
-#if PY_VERSION_HEX < 0x030A0000
-template <typename T> constexpr auto optional_name(const T &v) {
-    return const_name("typing.Optional[") + v + const_name("]");
-}
-template <typename... Ts> constexpr auto union_name(const Ts&... vs) {
-    return const_name("typing.Union[") + concat(vs...) + const_name("]");
-}
-#else
-template <typename T> constexpr auto optional_name(const T &v) {
-    return v + const_name(" | None");
-}
-template <typename T> constexpr auto union_name(const T &v) {
-    return v;
-}
-template <typename T1, typename T2, typename... Ts>
-constexpr auto union_name(const T1 &v1, const T2 &v2, const Ts &...vs) {
-    return v1 + const_name(" | ") + union_name(v2, vs...);
-}
-#endif
-
-template <size_t Size>
-auto constexpr const_name() -> std::remove_cv_t<decltype(int_to_str<Size / 10, Size % 10>::digits)> {
-    return int_to_str<Size / 10, Size % 10>::digits;
-}
-
-template <typename Type> constexpr descr<1, Type> const_name() { return {'%'}; }
-
-constexpr descr<0> concat() { return {}; }
-constexpr descr<0> concat_maybe() { return {}; }
-
-template <size_t N, typename... Ts>
-constexpr descr<N, Ts...> concat(const descr<N, Ts...> &descr) { return descr; }
-
-template <size_t N, typename... Ts>
-constexpr descr<N, Ts...> concat_maybe(const descr<N, Ts...> &descr) { return descr; }
-
-template <size_t N, typename... Ts, typename... Args>
-constexpr auto concat(const descr<N, Ts...> &d, const Args &...args)
-    -> decltype(std::declval<descr<N + 2, Ts...>>() + concat(args...)) {
-    return d + const_name(", ") + concat(args...);
-}
-
-template <typename... Args>
-constexpr auto concat_maybe(const descr<0> &, const descr<0> &, const Args &...args)
-    -> decltype(concat_maybe(args...)) { return concat_maybe(args...); }
-
-template <size_t N, typename... Ts, typename... Args>
-constexpr auto concat_maybe(const descr<0> &, const descr<N, Ts...> &arg, const Args &...args)
-    -> decltype(concat_maybe(arg, args...)) { return concat_maybe(arg, args...); }
-
-template <size_t N, typename... Ts, typename... Args>
-constexpr auto concat_maybe(const descr<N, Ts...> &arg, const descr<0> &, const Args &...args)
-    -> decltype(concat_maybe(arg, args...)) { return concat_maybe(arg, args...); }
-
-template <size_t N, size_t N2, typename... Ts, typename... Ts2, typename... Args,
-          enable_if_t<N != 0 && N2 != 0> = 0>
-constexpr auto concat_maybe(const descr<N, Ts...> &arg0, const descr<N2, Ts2...> &arg1, const Args &...args)
-    -> decltype(concat(arg0, concat_maybe(arg1, args...))) {
-    return concat(arg0, concat_maybe(arg1, args...));
-}
-
-template <size_t N, typename... Ts>
-constexpr descr<N + 2, Ts...> type_descr(const descr<N, Ts...> &descr) {
-    return const_name("{") + descr + const_name("}");
-}
-
-NAMESPACE_END(detail)
-NAMESPACE_END(NB_NAMESPACE)
diff --git a/src/nanobind/include/nanobind/nb_enums.h b/src/nanobind/include/nanobind/nb_enums.h
deleted file mode 100644
index cae5dcb..0000000
--- a/src/nanobind/include/nanobind/nb_enums.h
+++ /dev/null
@@ -1,26 +0,0 @@
-/*
-    nanobind/nb_enums.h: enumerations used in nanobind (just rv_policy atm.)
-
-    Copyright (c) 2022 Wenzel Jakob
-
-    All rights reserved. Use of this source code is governed by a
-    BSD-style license that can be found in the LICENSE file.
-*/
-
-NAMESPACE_BEGIN(NB_NAMESPACE)
-
-// Approach used to cast a previously unknown C++ instance into a Python object
-enum class rv_policy {
-    automatic,
-    automatic_reference,
-    take_ownership,
-    copy,
-    move,
-    reference,
-    reference_internal,
-    none
-    /* Note to self: nb_func.h assumes that this value fits into 3 bits,
-       hence no further policies can be added. */
-};
-
-NAMESPACE_END(NB_NAMESPACE)
diff --git a/src/nanobind/include/nanobind/nb_error.h b/src/nanobind/include/nanobind/nb_error.h
deleted file mode 100644
index 3abc960..0000000
--- a/src/nanobind/include/nanobind/nb_error.h
+++ /dev/null
@@ -1,152 +0,0 @@
-/*
-    nanobind/nb_error.h: Python exception handling, binding of exceptions
-
-    Copyright (c) 2022 Wenzel Jakob
-
-    All rights reserved. Use of this source code is governed by a
-    BSD-style license that can be found in the LICENSE file.
-*/
-
-NAMESPACE_BEGIN(NB_NAMESPACE)
-
-/// RAII wrapper that temporarily clears any Python error state
-#if PY_VERSION_HEX >= 0x030C0000
-struct error_scope {
-    error_scope() { value = PyErr_GetRaisedException(); }
-    ~error_scope() { PyErr_SetRaisedException(value); }
-private:
-    PyObject *value;
-};
-#else
-struct error_scope {
-    error_scope() { PyErr_Fetch(&type, &value, &trace); }
-    ~error_scope() { PyErr_Restore(type, value, trace); }
-private:
-    PyObject *type, *value, *trace;
-};
-#endif
-
-/// Wraps a Python error state as a C++ exception
-class NB_EXPORT python_error : public std::exception {
-public:
-    NB_EXPORT_SHARED python_error();
-    NB_EXPORT_SHARED python_error(const python_error &);
-    NB_EXPORT_SHARED python_error(python_error &&) noexcept;
-    NB_EXPORT_SHARED ~python_error() override;
-
-    bool matches(handle exc) const noexcept {
-#if PY_VERSION_HEX < 0x030C0000
-        return PyErr_GivenExceptionMatches(m_type, exc.ptr()) != 0;
-#else
-        return PyErr_GivenExceptionMatches(m_value, exc.ptr()) != 0;
-#endif
-    }
-
-    /// Move the error back into the Python domain. This may only be called
-    /// once, and you should not reraise the exception in C++ afterward.
-    NB_EXPORT_SHARED void restore() noexcept;
-
-    /// Pass the error to Python's `sys.unraisablehook`, which prints
-    /// a traceback to `sys.stderr` by default but may be overridden.
-    /// The *context* should be some object whose repr() helps clarify where
-    /// the error occurred. Like `.restore()`, this consumes the error and
-    /// you should not reraise the exception in C++ afterward.
-    void discard_as_unraisable(handle context) noexcept {
-        restore();
-        PyErr_WriteUnraisable(context.ptr());
-    }
-
-    void discard_as_unraisable(const char *context) noexcept {
-        object context_s = steal(PyUnicode_FromString(context));
-        discard_as_unraisable(context_s);
-    }
-
-    handle value() const { return m_value; }
-
-#if PY_VERSION_HEX < 0x030C0000
-    handle type() const { return m_type; }
-    object traceback() const { return borrow(m_traceback); }
-#else
-    handle type() const { return value().type(); }
-    object traceback() const { return steal(PyException_GetTraceback(m_value)); }
-#endif
-    [[deprecated]]
-    object trace() const { return traceback(); }
-
-    NB_EXPORT_SHARED const char *what() const noexcept override;
-
-private:
-#if PY_VERSION_HEX < 0x030C0000
-    mutable PyObject *m_type = nullptr;
-    mutable PyObject *m_value = nullptr;
-    mutable PyObject *m_traceback = nullptr;
-#else
-    mutable PyObject *m_value = nullptr;
-#endif
-    mutable char *m_what = nullptr;
-};
-
-/// Thrown by nanobind::cast when casting fails
-using cast_error = std::bad_cast;
-
-enum class exception_type {
-    runtime_error, stop_iteration, index_error, key_error, value_error,
-    type_error, buffer_error, import_error, attribute_error, next_overload
-};
-
-// Base interface used to expose common Python exceptions in C++
-class NB_EXPORT builtin_exception : public std::runtime_error {
-public:
-    NB_EXPORT_SHARED builtin_exception(exception_type type, const char *what);
-    NB_EXPORT_SHARED builtin_exception(builtin_exception &&) = default;
-    NB_EXPORT_SHARED builtin_exception(const builtin_exception &) = default;
-    NB_EXPORT_SHARED ~builtin_exception();
-    NB_EXPORT_SHARED exception_type type() const { return m_type; }
-private:
-    exception_type m_type;
-};
-
-#define NB_EXCEPTION(name)                                                     \
-    inline builtin_exception name(const char *what = nullptr) {                \
-        return builtin_exception(exception_type::name, what);                  \
-    }
-
-NB_EXCEPTION(stop_iteration)
-NB_EXCEPTION(index_error)
-NB_EXCEPTION(key_error)
-NB_EXCEPTION(value_error)
-NB_EXCEPTION(type_error)
-NB_EXCEPTION(buffer_error)
-NB_EXCEPTION(import_error)
-NB_EXCEPTION(attribute_error)
-NB_EXCEPTION(next_overload)
-
-#undef NB_EXCEPTION
-
-inline void register_exception_translator(detail::exception_translator t,
-                                          void *payload = nullptr) {
-    detail::register_exception_translator(t, payload);
-}
-
-template <typename T>
-class exception : public object {
-    NB_OBJECT_DEFAULT(exception, object, "Exception", PyExceptionClass_Check)
-
-    exception(handle scope, const char *name, handle base = PyExc_Exception)
-        : object(detail::exception_new(scope.ptr(), name, base.ptr()),
-                 detail::steal_t()) {
-        detail::register_exception_translator(
-            [](const std::exception_ptr &p, void *payload) {
-                try {
-                    std::rethrow_exception(p);
-                } catch (T &e) {
-                    PyErr_SetString((PyObject *) payload, e.what());
-                }
-            }, m_ptr);
-    }
-};
-
-NB_CORE void chain_error(handle type, const char *fmt, ...) noexcept;
-[[noreturn]] NB_CORE void raise_from(python_error &e, handle type, const char *fmt, ...);
-
-NAMESPACE_END(NB_NAMESPACE)
diff --git a/src/nanobind/include/nanobind/nb_func.h b/src/nanobind/include/nanobind/nb_func.h
deleted file mode 100644
index 10eb399..0000000
--- a/src/nanobind/include/nanobind/nb_func.h
+++ /dev/null
@@ -1,414 +0,0 @@
-/*
-    nanobind/nb_func.h: Functionality for binding C++ functions/methods
-
-    Copyright (c) 2022 Wenzel Jakob
-
-    All rights reserved. Use of this source code is governed by a
-    BSD-style license that can be found in the LICENSE file.
-*/
-
-NAMESPACE_BEGIN(NB_NAMESPACE)
-NAMESPACE_BEGIN(detail)
-
-template <typename Caster>
-bool from_python_remember_conv(Caster &c, PyObject **args, uint8_t *args_flags,
-                               cleanup_list *cleanup, size_t index) {
-    size_t size_before = cleanup->size();
-    if (!c.from_python(args[index], args_flags[index], cleanup))
-        return false;
-
-    // If an implicit conversion took place, update the 'args' array so that
-    // any keep_alive annotation or postcall hook can be aware of this change
-    size_t size_after = cleanup->size();
-    if (size_after != size_before)
-        args[index] = (*cleanup)[size_after - 1];
-
-    return true;
-}
-
-// Return the number of nb::arg and nb::arg_v types in the first I types Ts.
-// Invoke with std::make_index_sequence<sizeof...(Ts)>() to provide
-// an index pack 'Is' that parallels the types pack Ts.
-template <size_t I, typename... Ts, size_t... Is>
-constexpr size_t count_args_before_index(std::index_sequence<Is...>) {
-    static_assert(sizeof...(Is) == sizeof...(Ts));
-    return ((Is < I && std::is_base_of_v<arg, Ts>) + ... + 0);
-}
-
-#if defined(NB_FREE_THREADED)
-struct ft_args_collector {
-    PyObject **args;
-    handle h1;
-    handle h2;
-    size_t index = 0;
-
-    NB_INLINE explicit ft_args_collector(PyObject **a) : args(a) {}
-    NB_INLINE void apply(arg_locked *) {
-        if (h1.ptr() == nullptr)
-            h1 = args[index];
-        h2 = args[index];
-        ++index;
-    }
-    NB_INLINE void apply(arg *) { ++index; }
-    NB_INLINE void apply(...) {}
-};
-
-struct ft_args_guard {
-    NB_INLINE void lock(const ft_args_collector& info) {
-        PyCriticalSection2_Begin(&cs, info.h1.ptr(), info.h2.ptr());
-    }
-    ~ft_args_guard() {
-        PyCriticalSection2_End(&cs);
-    }
-    PyCriticalSection2 cs;
-};
-#endif
-
-struct no_guard {};
-
-template <bool ReturnRef, bool CheckGuard, typename Func, typename Return,
-          typename... Args, size_t... Is, typename... Extra>
-NB_INLINE PyObject *func_create(Func &&func, Return (*)(Args...),
-                                std::index_sequence<Is...> is,
-                                const Extra &...extra) {
-    using Info = func_extra_info<Extra...>;
-
-    if constexpr (CheckGuard && !std::is_same_v<typename Info::call_guard, void>) {
-        return func_create<ReturnRef, false>(
-            [func = (forward_t<Func>) func](Args... args) NB_INLINE_LAMBDA {
-                typename Info::call_guard::type g;
-                (void) g;
-                return func((forward_t<Args>) args...);
-            },
-            (Return(*)(Args...)) nullptr, is, extra...);
-    }
-
-    (void) is;
-
-    // Detect locations of nb::args / nb::kwargs (if they exist).
-    // Find the first and last occurrence of each; we'll later make sure these
-    // match, in order to guarantee there's only one instance.
-    static constexpr size_t
-        args_pos_1 = index_1_v<std::is_same_v<intrinsic_t<Args>, args>...>,
-        args_pos_n = index_n_v<std::is_same_v<intrinsic_t<Args>, args>...>,
-        kwargs_pos_1 = index_1_v<std::is_same_v<intrinsic_t<Args>, kwargs>...>,
-        kwargs_pos_n = index_n_v<std::is_same_v<intrinsic_t<Args>, kwargs>...>,
-        nargs = sizeof...(Args);
-
-    // Determine the number of nb::arg/nb::arg_v annotations
-    constexpr size_t nargs_provided =
-        (std::is_base_of_v<arg, Extra> + ... + 0);
-    constexpr bool is_method_det =
-        (std::is_same_v<is_method, Extra> + ... + 0) != 0;
-    constexpr bool is_getter_det =
-        (std::is_same_v<is_getter, Extra> + ... + 0) != 0;
-    constexpr bool has_arg_annotations = nargs_provided > 0 && !is_getter_det;
-
-    // Determine the number of potentially-locked function arguments
-    constexpr bool lock_self_det =
-        (std::is_same_v<lock_self, Extra> + ... + 0) != 0;
-    static_assert(Info::nargs_locked <= 2,
-        "At most two function arguments can be locked");
-    static_assert(!(lock_self_det && !is_method_det),
-        "The nb::lock_self() annotation only applies to methods");
-
-    // Detect location of nb::kw_only annotation, if supplied. As with args/kwargs
-    // we find the first and last location and later verify they match each other.
-    // Note this is an index in Extra... while args/kwargs_pos_* are indices in
-    // Args... .
-    constexpr size_t
-        kwonly_pos_1 = index_1_v<std::is_same_v<kw_only, Extra>...>,
-        kwonly_pos_n = index_n_v<std::is_same_v<kw_only, Extra>...>;
-
-    // Arguments after nb::args are implicitly keyword-only even if there is no
-    // nb::kw_only annotation
-    constexpr bool explicit_kw_only = kwonly_pos_1 != sizeof...(Extra);
-    constexpr bool implicit_kw_only = args_pos_1 + 1 < kwargs_pos_1;
-
-    // A few compile-time consistency checks
-    static_assert(args_pos_1 == args_pos_n && kwargs_pos_1 == kwargs_pos_n,
-        "Repeated use of nb::kwargs or nb::args in the function signature!");
-    static_assert(!has_arg_annotations || nargs_provided + is_method_det == nargs,
-        "The number of nb::arg annotations must match the argument count!");
-    static_assert(kwargs_pos_1 == nargs || kwargs_pos_1 + 1 == nargs,
-        "nb::kwargs must be the last element of the function signature!");
-    static_assert(args_pos_1 == nargs || args_pos_1 < kwargs_pos_1,
-        "nb::args must precede nb::kwargs if both are present!");
-    static_assert(has_arg_annotations || (!implicit_kw_only && !explicit_kw_only),
-        "Keyword-only arguments must have names!");
-
-    // Find the index in Args... of the first keyword-only parameter. Since
-    // the 'self' parameter doesn't get a nb::arg annotation, we must adjust
-    // by 1 for methods. Note that nargs_before_kw_only is only used if
-    // a kw_only annotation exists (i.e., if explicit_kw_only is true);
-    // the conditional is just to save the compiler some effort otherwise.
-    constexpr size_t nargs_before_kw_only =
-        explicit_kw_only
-            ? is_method_det + count_args_before_index<kwonly_pos_1, Extra...>(
-                  std::make_index_sequence<sizeof...(Extra)>())
-            : nargs;
-
-    (void) kwonly_pos_n;
-
-    if constexpr (explicit_kw_only) {
-        static_assert(kwonly_pos_1 == kwonly_pos_n,
-            "Repeated use of nb::kw_only annotation!");
-
-        // If both kw_only and *args are specified, kw_only must be
-        // immediately after the nb::arg for *args.
-        static_assert(args_pos_1 == nargs || nargs_before_kw_only == args_pos_1 + 1,
-            "Arguments after nb::args are implicitly keyword-only; any "
-            "nb::kw_only() annotation must be positioned to reflect that!");
-
-        // If both kw_only and **kwargs are specified, kw_only must be
-        // before the nb::arg for **kwargs.
-        static_assert(nargs_before_kw_only < kwargs_pos_1,
-            "Variadic nb::kwargs are implicitly keyword-only; any "
-            "nb::kw_only() annotation must be positioned to reflect that!");
-    }
-
-    // Collect function signature information for the docstring
-    using cast_out = make_caster<
-        std::conditional_t<std::is_void_v<Return>, void_type, Return>>;
-
-    // Compile-time function signature
-    static constexpr auto descr =
-        const_name("(") +
-        concat(type_descr(
-            make_caster<remove_opt_mono_t<intrinsic_t<Args>>>::Name)...) +
-        const_name(") -> ") + cast_out::Name;
-
-    // std::type_info for all function arguments
-    const std::type_info* descr_types[descr.type_count() + 1];
-    descr.put_types(descr_types);
-
-    // Auxiliary data structure to capture the provided function/closure
-    struct capture {
-        std::remove_reference_t<Func> func;
-    };
-
-    // The following temporary record will describe the function in detail
-    func_data_prelim<nargs_provided> f;
-    f.flags = (args_pos_1   < nargs ? (uint32_t) func_flags::has_var_args   : 0) |
-              (kwargs_pos_1 < nargs ? (uint32_t) func_flags::has_var_kwargs : 0) |
-              (ReturnRef            ? (uint32_t) func_flags::return_ref     : 0) |
-              (has_arg_annotations  ? (uint32_t) func_flags::has_args       : 0);
-
-    /* Store captured function inside 'func_data_prelim' if there is space. Issues
-       with aliasing are resolved via separate compilation of libnanobind. */
-    if constexpr (sizeof(capture) <= sizeof(f.capture)) {
-        capture *cap = (capture *) f.capture;
-        new (cap) capture{ (forward_t<Func>) func };
-
-        if constexpr (!std::is_trivially_destructible_v<capture>) {
-            f.flags |= (uint32_t) func_flags::has_free;
-            f.free_capture = [](void *p) {
-                ((capture *) p)->~capture();
-            };
-        }
-    } else {
-        void **cap = (void **) f.capture;
-        cap[0] = new capture{ (forward_t<Func>) func };
-
-        f.flags |= (uint32_t) func_flags::has_free;
-        f.free_capture = [](void *p) {
-            delete (capture *) ((void **) p)[0];
-        };
-    }
-
-    f.impl = [](void *p, PyObject **args, uint8_t *args_flags, rv_policy policy,
-                cleanup_list *cleanup) NB_INLINE_LAMBDA -> PyObject * {
-        (void) p; (void) args; (void) args_flags; (void) policy; (void) cleanup;
-
-        const capture *cap;
-        if constexpr (sizeof(capture) <= sizeof(f.capture))
-            cap = (capture *) p;
-        else
-            cap = (capture *) ((void **) p)[0];
-
-        tuple<make_caster<Args>...> in;
-        (void) in;
-
-#if defined(NB_FREE_THREADED)
-        std::conditional_t<Info::nargs_locked != 0, ft_args_guard, no_guard> guard;
-        if constexpr (Info::nargs_locked) {
-            ft_args_collector collector{args};
-            if constexpr (is_method_det) {
-                if constexpr (lock_self_det)
-                    collector.apply((arg_locked *) nullptr);
-                else
-                    collector.apply((arg *) nullptr);
-            }
-            (collector.apply((Extra *) nullptr), ...);
-            guard.lock(collector);
-        }
-#endif
-
-        if constexpr (Info::pre_post_hooks) {
-            std::integral_constant<size_t, nargs> nargs_c;
-            (process_precall(args, nargs_c, cleanup, (Extra *) nullptr), ...);
-            if ((!from_python_remember_conv(in.template get<Is>(), args,
-                                            args_flags, cleanup, Is) || ...))
-                return NB_NEXT_OVERLOAD;
-        } else {
-            if ((!in.template get<Is>().from_python(args[Is], args_flags[Is],
-                                                    cleanup) || ...))
-                return NB_NEXT_OVERLOAD;
-        }
-
-        PyObject *result;
-        if constexpr (std::is_void_v<Return>) {
-#if defined(_WIN32) && !defined(__CUDACC__) // temporary workaround for an internal compiler error in MSVC
-            cap->func(static_cast<cast_t<Args>>(in.template get<Is>())...);
-#else
-            cap->func(in.template get<Is>().operator cast_t<Args>()...);
-#endif
-            result = Py_None;
-            Py_INCREF(result);
-        } else {
-#if defined(_WIN32) && !defined(__CUDACC__) // temporary workaround for an internal compiler error in MSVC
-            result = cast_out::from_cpp(
-                       cap->func(static_cast<cast_t<Args>>(in.template get<Is>())...),
-                       policy, cleanup).ptr();
-#else
-            result = cast_out::from_cpp(
-                       cap->func((in.template get<Is>())
-                                     .operator cast_t<Args>()...),
-                       policy, cleanup).ptr();
-#endif
-        }
-
-        if constexpr (Info::pre_post_hooks) {
-            std::integral_constant<size_t, nargs> nargs_c;
-            (process_postcall(args, nargs_c, result, (Extra *) nullptr), ...);
-        }
-
-        return result;
-    };
-
-    f.descr = descr.text;
-    f.descr_types = descr_types;
-    f.nargs = nargs;
-
-    // Set nargs_pos to the number of C++ function parameters (Args...) that
-    // can be filled from Python positional arguments in a one-to-one fashion.
-    // This ends at:
-    // - the location of the variadic *args parameter, if present; otherwise
-    // - the location of the first keyword-only parameter, if any; otherwise
-    // - the location of the variadic **kwargs parameter, if present; otherwise
-    // - the end of the parameter list
-    // It's correct to give *args priority over kw_only because we verified
-    // above that kw_only comes afterward if both are present. It's correct
-    // to give kw_only priority over **kwargs because we verified above that
-    // kw_only comes before if both are present.
-    f.nargs_pos =   args_pos_1 < nargs ? args_pos_1 :
-                      explicit_kw_only ? nargs_before_kw_only :
-                  kwargs_pos_1 < nargs ? kwargs_pos_1 : nargs;
-
-    // Fill remaining fields of 'f'
-    size_t arg_index = 0;
-    (func_extra_apply(f, extra, arg_index), ...);
-
-    (void) arg_index;
-
-    return nb_func_new((const void *) &f);
-}
-
-NAMESPACE_END(detail)
-
-// The initial template parameter to cpp_function/cpp_function_def is
-// used by class_ to ensure that member pointers are treated as members
-// of the class being defined; other users can safely leave it at its
-// default of void.
-
-template <typename = void, typename Return, typename... Args, typename... Extra>
-NB_INLINE object cpp_function(Return (*f)(Args...), const Extra&... extra) {
-    return steal(detail::func_create<true, true>(
-        f, f, std::make_index_sequence<sizeof...(Args)>(), extra...));
-}
-
-template <typename = void, typename Return, typename... Args, typename... Extra>
-NB_INLINE void cpp_function_def(Return (*f)(Args...), const Extra&... extra) {
-    detail::func_create<false, true>(
-        f, f, std::make_index_sequence<sizeof...(Args)>(), extra...);
-}
-
-/// Construct a cpp_function from a lambda function (pot. with internal state)
-template <
-    typename = void, typename Func, typename... Extra,
-    detail::enable_if_t<detail::is_lambda_v<std::remove_reference_t<Func>>> = 0>
-NB_INLINE object cpp_function(Func &&f, const Extra &...extra) {
-    using am = detail::analyze_method<decltype(&std::remove_reference_t<Func>::operator())>;
-    return steal(detail::func_create<true, true>(
-        (detail::forward_t<Func>) f, (typename am::func *) nullptr,
-        std::make_index_sequence<am::argc>(), extra...));
-}
-
-template <
-    typename = void, typename Func, typename... Extra,
-    detail::enable_if_t<detail::is_lambda_v<std::remove_reference_t<Func>>> = 0>
-NB_INLINE void cpp_function_def(Func &&f, const Extra &...extra) {
-    using am = detail::analyze_method<decltype(&std::remove_reference_t<Func>::operator())>;
-    detail::func_create<false, true>(
-        (detail::forward_t<Func>) f, (typename am::func *) nullptr,
-        std::make_index_sequence<am::argc>(), extra...);
-}
-
-/// Construct a cpp_function from a class method (non-const)
-template <typename Target = void,
-          typename Return, typename Class, typename... Args, typename... Extra>
-NB_INLINE object cpp_function(Return (Class::*f)(Args...), const Extra &...extra) {
-    using T = std::conditional_t<std::is_void_v<Target>, Class, Target>;
-    return steal(detail::func_create<true, true>(
-        [f](T *c, Args... args) NB_INLINE_LAMBDA -> Return {
-            return (c->*f)((detail::forward_t<Args>) args...);
-        },
-        (Return(*)(T *, Args...)) nullptr,
-        std::make_index_sequence<sizeof...(Args) + 1>(), extra...));
-}
-
-template <typename Target = void,
-          typename Return, typename Class, typename... Args, typename... Extra>
-NB_INLINE void cpp_function_def(Return (Class::*f)(Args...), const Extra &...extra) {
-    using T = std::conditional_t<std::is_void_v<Target>, Class, Target>;
-    detail::func_create<false, true>(
-        [f](T *c, Args... args) NB_INLINE_LAMBDA -> Return {
-            return (c->*f)((detail::forward_t<Args>) args...);
-        },
-        (Return(*)(T *, Args...)) nullptr,
-        std::make_index_sequence<sizeof...(Args) + 1>(), extra...);
-}
-
-/// Construct a cpp_function from a class method (const)
-template <typename Target = void,
-          typename Return, typename Class, typename... Args, typename... Extra>
-NB_INLINE object cpp_function(Return (Class::*f)(Args...) const, const Extra &...extra) {
-    using T = std::conditional_t<std::is_void_v<Target>, Class, Target>;
-    return steal(detail::func_create<true, true>(
-        [f](const T *c, Args... args) NB_INLINE_LAMBDA -> Return {
-            return (c->*f)((detail::forward_t<Args>) args...);
-        },
-        (Return(*)(const T *, Args...)) nullptr,
-        std::make_index_sequence<sizeof...(Args) + 1>(), extra...));
-}
-
-template <typename Target = void,
-          typename Return, typename Class, typename... Args, typename... Extra>
-NB_INLINE void cpp_function_def(Return (Class::*f)(Args...) const, const Extra &...extra) {
-    using T = std::conditional_t<std::is_void_v<Target>, Class, Target>;
-    detail::func_create<false, true>(
-        [f](const T *c, Args... args) NB_INLINE_LAMBDA -> Return {
-            return (c->*f)((detail::forward_t<Args>) args...);
-        },
-        (Return(*)(const T *, Args...)) nullptr,
-        std::make_index_sequence<sizeof...(Args) + 1>(), extra...);
-}
-
-template <typename Func, typename... Extra>
-module_ &module_::def(const char *name_, Func &&f, const Extra &...extra) {
-    cpp_function_def((detail::forward_t<Func>) f, scope(*this),
-                     name(name_), extra...);
-    return *this;
-}
-
-NAMESPACE_END(NB_NAMESPACE)
diff --git a/src/nanobind/include/nanobind/nb_lib.h b/src/nanobind/include/nanobind/nb_lib.h
deleted file mode 100644
index 356a7ca..0000000
--- a/src/nanobind/include/nanobind/nb_lib.h
+++ /dev/null
@@ -1,571 +0,0 @@
-/*
-    nanobind/nb_lib.h: Interface to libnanobind.so
-
-    Copyright (c) 2022 Wenzel Jakob
-
-    All rights reserved. Use of this source code is governed by a
-    BSD-style license that can be found in the LICENSE file.
-*/
-
-NAMESPACE_BEGIN(NB_NAMESPACE)
-
-// Forward declarations for types in ndarray.h (1)
-namespace dlpack { struct dltensor; struct dtype; }
-
-NAMESPACE_BEGIN(detail)
-
-// Forward declarations for types in ndarray.h (2)
-struct ndarray_handle;
-struct ndarray_config;
-
-/**
- * Helper class to clean temporaries created by function dispatch.
- * The first element serves a special role: it stores the 'self'
- * object of method calls (for rv_policy::reference_internal).
- */
-struct NB_CORE cleanup_list {
-public:
-    static constexpr uint32_t Small = 6;
-
-    cleanup_list(PyObject *self) :
-        m_size{1},
-        m_capacity{Small},
-        m_data{m_local} {
-        m_local[0] = self;
-    }
-
-    ~cleanup_list() = default;
-
-    /// Append a single PyObject to the cleanup stack
-    NB_INLINE void append(PyObject *value) noexcept {
-        if (m_size >= m_capacity)
-            expand();
-        m_data[m_size++] = value;
-    }
-
-    NB_INLINE PyObject *self() const {
-        return m_local[0];
-    }
-
-    /// Decrease the reference count of all appended objects
-    void release() noexcept;
-
-    /// Does the list contain any entries? (besides the 'self' argument)
-    bool used() { return m_size != 1; }
-
-    /// Return the size of the cleanup stack
-    size_t size() const { return m_size; }
-
-    /// Subscript operator
-    PyObject *operator[](size_t index) const { return m_data[index]; }
-
-protected:
-    /// Out of memory, expand..
-    void expand() noexcept;
-
-protected:
-    uint32_t m_size;
-    uint32_t m_capacity;
-    PyObject **m_data;
-    PyObject *m_local[Small];
-};
-
-// ========================================================================
-
-/// Raise a runtime error with the given message
-#if defined(__GNUC__)
-    __attribute__((noreturn, __format__ (__printf__, 1, 2)))
-#else
-    [[noreturn]]
-#endif
-NB_CORE void raise(const char *fmt, ...);
-
-/// Raise a type error with the given message
-#if defined(__GNUC__)
-    __attribute__((noreturn, __format__ (__printf__, 1, 2)))
-#else
-    [[noreturn]]
-#endif
-NB_CORE void raise_type_error(const char *fmt, ...);
-
-/// Abort the process with a fatal error
-#if defined(__GNUC__)
-    __attribute__((noreturn, __format__ (__printf__, 1, 2)))
-#else
-    [[noreturn]]
-#endif
-NB_CORE void fail(const char *fmt, ...) noexcept;
-
-/// Raise nanobind::python_error after an error condition was found
-[[noreturn]] NB_CORE void raise_python_error();
-
-/// Raise nanobind::next_overload
-NB_CORE void raise_next_overload_if_null(void *p);
-
-/// Raise nanobind::cast_error
-[[noreturn]] NB_CORE void raise_cast_error();
-
-// ========================================================================
-
-NB_CORE void init(const char *domain);
-
-// ========================================================================
-
-/// Convert a Python object into a Python unicode string
-NB_CORE PyObject *str_from_obj(PyObject *o);
-
-/// Convert an UTF8 null-terminated C string into a Python unicode string
-NB_CORE PyObject *str_from_cstr(const char *c);
-
-/// Convert an UTF8 C string + size into a Python unicode string
-NB_CORE PyObject *str_from_cstr_and_size(const char *c, size_t n);
-
-// ========================================================================
-
-/// Convert a Python object into a Python byte string
-NB_CORE PyObject *bytes_from_obj(PyObject *o);
-
-/// Convert an UTF8 null-terminated C string into a Python byte string
-NB_CORE PyObject *bytes_from_cstr(const char *c);
-
-/// Convert a memory region into a Python byte string
-NB_CORE PyObject *bytes_from_cstr_and_size(const void *c, size_t n);
-
-// ========================================================================
-
-/// Convert a Python object into a Python byte array
-NB_CORE PyObject *bytearray_from_obj(PyObject *o);
-
-/// Convert a memory region into a Python byte array
-NB_CORE PyObject *bytearray_from_cstr_and_size(const void *c, size_t n);
-
-// ========================================================================
-
-/// Convert a Python object into a Python boolean object
-NB_CORE PyObject *bool_from_obj(PyObject *o);
-
-/// Convert a Python object into a Python integer object
-NB_CORE PyObject *int_from_obj(PyObject *o);
-
-/// Convert a Python object into a Python floating point object
-NB_CORE PyObject *float_from_obj(PyObject *o);
-
-// ========================================================================
-
-/// Convert a Python object into a Python list
-NB_CORE PyObject *list_from_obj(PyObject *o);
-
-/// Convert a Python object into a Python tuple
-NB_CORE PyObject *tuple_from_obj(PyObject *o);
-
-/// Convert a Python object into a Python set
-NB_CORE PyObject *set_from_obj(PyObject *o);
-
-/// Convert a Python object into a Python frozenset
-NB_CORE PyObject *frozenset_from_obj(PyObject *o);
-
-// ========================================================================
-
-/// Get an object attribute or raise an exception
-NB_CORE PyObject *getattr(PyObject *obj, const char *key);
-NB_CORE PyObject *getattr(PyObject *obj, PyObject *key);
-
-/// Get an object attribute or return a default value (never raises)
-NB_CORE PyObject *getattr(PyObject *obj, const char *key, PyObject *def) noexcept;
-NB_CORE PyObject *getattr(PyObject *obj, PyObject *key, PyObject *def) noexcept;
-
-/// Get an object attribute or raise an exception. Skip if 'out' is non-null
-NB_CORE void getattr_or_raise(PyObject *obj, const char *key, PyObject **out);
-NB_CORE void getattr_or_raise(PyObject *obj, PyObject *key, PyObject **out);
-
-/// Set an object attribute or raise an exception
-NB_CORE void setattr(PyObject *obj, const char *key, PyObject *value);
-NB_CORE void setattr(PyObject *obj, PyObject *key, PyObject *value);
-
-/// Delete an object attribute or raise an exception
-NB_CORE void delattr(PyObject *obj, const char *key);
-NB_CORE void delattr(PyObject *obj, PyObject *key);
-
-// ========================================================================
-
-/// Index into an object or raise an exception. Skip if 'out' is non-null
-NB_CORE void getitem_or_raise(PyObject *obj, Py_ssize_t, PyObject **out);
-NB_CORE void getitem_or_raise(PyObject *obj, const char *key, PyObject **out);
-NB_CORE void getitem_or_raise(PyObject *obj, PyObject *key, PyObject **out);
-
-/// Set an item or raise an exception
-NB_CORE void setitem(PyObject *obj, Py_ssize_t, PyObject *value);
-NB_CORE void setitem(PyObject *obj, const char *key, PyObject *value);
-NB_CORE void setitem(PyObject *obj, PyObject *key, PyObject *value);
-
-/// Delete an item or raise an exception
-NB_CORE void delitem(PyObject *obj, Py_ssize_t);
-NB_CORE void delitem(PyObject *obj, const char *key);
-NB_CORE void delitem(PyObject *obj, PyObject *key);
-
-// ========================================================================
-
-/// Determine the length of a Python object
-NB_CORE size_t obj_len(PyObject *o);
-
-/// Try to roughly determine the length of a Python object
-NB_CORE size_t obj_len_hint(PyObject *o) noexcept;
-
-/// Obtain a string representation of a Python object
-NB_CORE PyObject* obj_repr(PyObject *o);
-
-/// Perform a comparison between Python objects and handle errors
-NB_CORE bool obj_comp(PyObject *a, PyObject *b, int value);
-
-/// Perform an unary operation on a Python object with error handling
-NB_CORE PyObject *obj_op_1(PyObject *a, PyObject* (*op)(PyObject*));
-
-/// Perform an unary operation on a Python object with error handling
-NB_CORE PyObject *obj_op_2(PyObject *a, PyObject *b,
-                           PyObject *(*op)(PyObject *, PyObject *));
-
-// Perform a vector function call
-NB_CORE PyObject *obj_vectorcall(PyObject *base, PyObject *const *args,
-                                 size_t nargsf, PyObject *kwnames,
-                                 bool method_call);
-
-/// Create an iterator from 'o', raise an exception in case of errors
-NB_CORE PyObject *obj_iter(PyObject *o);
-
-/// Advance the iterator 'o', raise an exception in case of errors
-NB_CORE PyObject *obj_iter_next(PyObject *o);
-
-// ========================================================================
-
-// Conversion validity check done by nb::make_tuple
-NB_CORE void tuple_check(PyObject *tuple, size_t nargs);
-
-// ========================================================================
-
-// Append a single argument to a function call
-NB_CORE void call_append_arg(PyObject *args, size_t &nargs, PyObject *value);
-
-// Append a variable-length sequence of arguments to a function call
-NB_CORE void call_append_args(PyObject *args, size_t &nargs, PyObject *value);
-
-// Append a single keyword argument to a function call
-NB_CORE void call_append_kwarg(PyObject *kwargs, const char *name, PyObject *value);
-
-// Append a variable-length dictionary of keyword arguments to a function call
-NB_CORE void call_append_kwargs(PyObject *kwargs, PyObject *value);
-
-// ========================================================================
-
-// If the given sequence has the size 'size', return a pointer to its contents.
-// May produce a temporary.
-NB_CORE PyObject **seq_get_with_size(PyObject *seq, size_t size,
-                                     PyObject **temp) noexcept;
-
-// Like the above, but return the size instead of checking it.
-NB_CORE PyObject **seq_get(PyObject *seq, size_t *size,
-                           PyObject **temp) noexcept;
-
-// ========================================================================
-
-/// Create a new capsule object with a name
-NB_CORE PyObject *capsule_new(const void *ptr, const char *name,
-                              void (*cleanup)(void *) noexcept) noexcept;
-
-// ========================================================================
-
-/// Create a Python function object for the given function record
-NB_CORE PyObject *nb_func_new(const void *data) noexcept;
-
-// ========================================================================
-
-/// Create a Python type object for the given type record
-struct type_init_data;
-NB_CORE PyObject *nb_type_new(const type_init_data *c) noexcept;
-
-/// Extract a pointer to a C++ type underlying a Python object, if possible
-NB_CORE bool nb_type_get(const std::type_info *t, PyObject *o, uint8_t flags,
-                         cleanup_list *cleanup, void **out) noexcept;
-
-/// Cast a C++ type instance into a Python object
-NB_CORE PyObject *nb_type_put(const std::type_info *cpp_type, void *value,
-                              rv_policy rvp, cleanup_list *cleanup,
-                              bool *is_new = nullptr) noexcept;
-
-// Special version of nb_type_put for polymorphic classes
-NB_CORE PyObject *nb_type_put_p(const std::type_info *cpp_type,
-                                const std::type_info *cpp_type_p, void *value,
-                                rv_policy rvp, cleanup_list *cleanup,
-                                bool *is_new = nullptr) noexcept;
-
-// Special version of 'nb_type_put' for unique pointers and ownership transfer
-NB_CORE PyObject *nb_type_put_unique(const std::type_info *cpp_type,
-                                     void *value, cleanup_list *cleanup,
-                                     bool cpp_delete) noexcept;
-
-// Special version of 'nb_type_put_unique' for polymorphic classes
-NB_CORE PyObject *nb_type_put_unique_p(const std::type_info *cpp_type,
-                                       const std::type_info *cpp_type_p,
-                                       void *value, cleanup_list *cleanup,
-                                       bool cpp_delete) noexcept;
-
-/// Try to relinquish ownership from Python object to a unique_ptr;
-/// return true if successful, false if not. (Failure is only
-/// possible if `cpp_delete` is true.)
-NB_CORE bool nb_type_relinquish_ownership(PyObject *o, bool cpp_delete) noexcept;
-
-/// Reverse the effects of nb_type_relinquish_ownership().
-NB_CORE void nb_type_restore_ownership(PyObject *o, bool cpp_delete) noexcept;
-
-/// Get a pointer to a user-defined 'extra' value associated with the nb_type t.
-NB_CORE void *nb_type_supplement(PyObject *t) noexcept;
-
-/// Check if the given python object represents a nanobind type
-NB_CORE bool nb_type_check(PyObject *t) noexcept;
-
-/// Return the size of the type wrapped by the given nanobind type object
-NB_CORE size_t nb_type_size(PyObject *t) noexcept;
-
-/// Return the alignment of the type wrapped by the given nanobind type object
-NB_CORE size_t nb_type_align(PyObject *t) noexcept;
-
-/// Return a unicode string representing the long-form name of the given type
-NB_CORE PyObject *nb_type_name(PyObject *t) noexcept;
-
-/// Return a unicode string representing the long-form name of object's type
-NB_CORE PyObject *nb_inst_name(PyObject *o) noexcept;
-
-/// Return the C++ type_info wrapped by the given nanobind type object
-NB_CORE const std::type_info *nb_type_info(PyObject *t) noexcept;
-
-/// Get a pointer to the instance data of a nanobind instance (nb_inst)
-NB_CORE void *nb_inst_ptr(PyObject *o) noexcept;
-
-/// Check if a Python type object wraps an instance of a specific C++ type
-NB_CORE bool nb_type_isinstance(PyObject *obj, const std::type_info *t) noexcept;
-
-/// Search for the Python type object associated with a C++ type
-NB_CORE PyObject *nb_type_lookup(const std::type_info *t) noexcept;
-
-/// Allocate an instance of type 't'
-NB_CORE PyObject *nb_inst_alloc(PyTypeObject *t);
-
-/// Allocate an zero-initialized instance of type 't'
-NB_CORE PyObject *nb_inst_alloc_zero(PyTypeObject *t);
-
-/// Allocate an instance of type 't' referencing the existing 'ptr'
-NB_CORE PyObject *nb_inst_reference(PyTypeObject *t, void *ptr,
-                                    PyObject *parent);
-
-/// Allocate an instance of type 't' taking ownership of the existing 'ptr'
-NB_CORE PyObject *nb_inst_take_ownership(PyTypeObject *t, void *ptr);
-
-/// Call the destructor of the given python object
-NB_CORE void nb_inst_destruct(PyObject *o) noexcept;
-
-/// Zero-initialize a POD type and mark it as ready + to be destructed upon GC
-NB_CORE void nb_inst_zero(PyObject *o) noexcept;
-
-/// Copy-construct 'dst' from 'src', mark it as ready and to be destructed (must have the same nb_type)
-NB_CORE void nb_inst_copy(PyObject *dst, const PyObject *src) noexcept;
-
-/// Move-construct 'dst' from 'src', mark it as ready and to be destructed (must have the same nb_type)
-NB_CORE void nb_inst_move(PyObject *dst, const PyObject *src) noexcept;
-
-/// Destruct 'dst', copy-construct 'dst' from 'src', mark ready and retain 'destruct' status (must have the same nb_type)
-NB_CORE void nb_inst_replace_copy(PyObject *dst, const PyObject *src) noexcept;
-
-/// Destruct 'dst', move-construct 'dst' from 'src', mark ready and retain 'destruct' status (must have the same nb_type)
-NB_CORE void nb_inst_replace_move(PyObject *dst, const PyObject *src) noexcept;
-
-/// Check if a particular instance uses a Python-derived type
-NB_CORE bool nb_inst_python_derived(PyObject *o) noexcept;
-
-/// Overwrite the instance's ready/destruct flags
-NB_CORE void nb_inst_set_state(PyObject *o, bool ready, bool destruct) noexcept;
-
-/// Query the 'ready' and 'destruct' flags of an instance
-NB_CORE std::pair<bool, bool> nb_inst_state(PyObject *o) noexcept;
-
-// ========================================================================
-
-// Create and install a Python property object
-NB_CORE void property_install(PyObject *scope, const char *name,
-                              PyObject *getter, PyObject *setter) noexcept;
-
-NB_CORE void property_install_static(PyObject *scope, const char *name,
-                                     PyObject *getter,
-                                     PyObject *setter) noexcept;
-
-// ========================================================================
-
-NB_CORE PyObject *get_override(void *ptr, const std::type_info *type,
-                               const char *name, bool pure);
-
-// ========================================================================
-
-// Ensure that 'patient' cannot be GCed while 'nurse' is alive
-NB_CORE void keep_alive(PyObject *nurse, PyObject *patient);
-
-// Keep 'payload' alive until 'nurse' is GCed
-NB_CORE void keep_alive(PyObject *nurse, void *payload,
-                        void (*deleter)(void *) noexcept) noexcept;
-
-
-// ========================================================================
-
-/// Indicate to nanobind that an implicit constructor can convert 'src' -> 'dst'
-NB_CORE void implicitly_convertible(const std::type_info *src,
-                                    const std::type_info *dst) noexcept;
-
-/// Register a callback to check if implicit conversion to 'dst' is possible
-NB_CORE void implicitly_convertible(bool (*predicate)(PyTypeObject *,
-                                                      PyObject *,
-                                                      cleanup_list *),
-                                    const std::type_info *dst) noexcept;
-
-// ========================================================================
-
-struct enum_init_data;
-
-/// Create a new enumeration type
-NB_CORE PyObject *enum_create(enum_init_data *) noexcept;
-
-/// Append an entry to an enumeration
-NB_CORE void enum_append(PyObject *tp, const char *name,
-                         int64_t value, const char *doc) noexcept;
-
-// Query an enumeration's Python object -> integer value map
-NB_CORE bool enum_from_python(const std::type_info *, PyObject *, int64_t *,
-                              uint8_t flags) noexcept;
-
-// Query an enumeration's integer value -> Python object map
-NB_CORE PyObject *enum_from_cpp(const std::type_info *, int64_t) noexcept;
-
-/// Export enum entries to the parent scope
-NB_CORE void enum_export(PyObject *tp);
-
-// ========================================================================
-
-/// Try to import a Python extension module, raises an exception upon failure
-NB_CORE PyObject *module_import(const char *name);
-
-/// Try to import a Python extension module, raises an exception upon failure
-NB_CORE PyObject *module_import(PyObject *name);
-
-/// Create a new extension module with the given name
-NB_CORE PyObject *module_new(const char *name, PyModuleDef *def) noexcept;
-
-/// Create a submodule of an existing module
-NB_CORE PyObject *module_new_submodule(PyObject *base, const char *name,
-                                       const char *doc) noexcept;
-
-
-// ========================================================================
-
-// Try to import a reference-counted ndarray object via DLPack
-NB_CORE ndarray_handle *ndarray_import(PyObject *o,
-                                       const ndarray_config *c,
-                                       bool convert,
-                                       cleanup_list *cleanup) noexcept;
-
-// Describe a local ndarray object using a DLPack capsule
-NB_CORE ndarray_handle *ndarray_create(void *value, size_t ndim,
-                                       const size_t *shape, PyObject *owner,
-                                       const int64_t *strides,
-                                       dlpack::dtype dtype, bool ro,
-                                       int device, int device_id,
-                                       char order);
-
-/// Increase the reference count of the given ndarray object; returns a pointer
-/// to the underlying DLTensor
-NB_CORE dlpack::dltensor *ndarray_inc_ref(ndarray_handle *) noexcept;
-
-/// Decrease the reference count of the given ndarray object
-NB_CORE void ndarray_dec_ref(ndarray_handle *) noexcept;
-
-/// Wrap a ndarray_handle* into a PyCapsule
-NB_CORE PyObject *ndarray_export(ndarray_handle *, int framework,
-                                 rv_policy policy, cleanup_list *cleanup) noexcept;
-
-/// Check if an object represents an ndarray
-NB_CORE bool ndarray_check(PyObject *o) noexcept;
-
-// ========================================================================
-
-/// Print to stdout using Python
-NB_CORE void print(PyObject *file, PyObject *str, PyObject *end);
-
-// ========================================================================
-
-typedef void (*exception_translator)(const std::exception_ptr &, void *);
-
-NB_CORE void register_exception_translator(exception_translator translator,
-                                           void *payload);
-
-NB_CORE PyObject *exception_new(PyObject *mod, const char *name,
-                                PyObject *base);
-
-// ========================================================================
-
-NB_CORE bool load_i8 (PyObject *o, uint8_t flags, int8_t *out) noexcept;
-NB_CORE bool load_u8 (PyObject *o, uint8_t flags, uint8_t *out) noexcept;
-NB_CORE bool load_i16(PyObject *o, uint8_t flags, int16_t *out) noexcept;
-NB_CORE bool load_u16(PyObject *o, uint8_t flags, uint16_t *out) noexcept;
-NB_CORE bool load_i32(PyObject *o, uint8_t flags, int32_t *out) noexcept;
-NB_CORE bool load_u32(PyObject *o, uint8_t flags, uint32_t *out) noexcept;
-NB_CORE bool load_i64(PyObject *o, uint8_t flags, int64_t *out) noexcept;
-NB_CORE bool load_u64(PyObject *o, uint8_t flags, uint64_t *out) noexcept;
-NB_CORE bool load_f32(PyObject *o, uint8_t flags, float *out) noexcept;
-NB_CORE bool load_f64(PyObject *o, uint8_t flags, double *out) noexcept;
-
-// ========================================================================
-
-/// Increase the reference count of 'o', and check that the GIL is held
-NB_CORE void incref_checked(PyObject *o) noexcept;
-
-/// Decrease the reference count of 'o', and check that the GIL is held
-NB_CORE void decref_checked(PyObject *o) noexcept;
-
-// ========================================================================
-
-NB_CORE bool leak_warnings() noexcept;
-NB_CORE bool implicit_cast_warnings() noexcept;
-NB_CORE void set_leak_warnings(bool value) noexcept;
-NB_CORE void set_implicit_cast_warnings(bool value) noexcept;
-
-// ========================================================================
-
-NB_CORE bool iterable_check(PyObject *o) noexcept;
-
-// ========================================================================
-
-NB_CORE void slice_compute(PyObject *slice, Py_ssize_t size,
-                           Py_ssize_t &start, Py_ssize_t &stop,
-                           Py_ssize_t &step, size_t &slice_length);
-
-// ========================================================================
-
-NB_CORE bool issubclass(PyObject *a, PyObject *b);
-
-// ========================================================================
-
-NB_CORE PyObject *repr_list(PyObject *o);
-NB_CORE PyObject *repr_map(PyObject *o);
-
-NB_CORE bool is_alive() noexcept;
-
-#if NB_TYPE_GET_SLOT_IMPL
-NB_CORE void *type_get_slot(PyTypeObject *t, int slot_id);
-#endif
-
-NB_CORE PyObject *dict_get_item_ref_or_fail(PyObject *d, PyObject *k);
-
-NB_CORE const char *abi_tag();
-
-NAMESPACE_END(detail)
-
-using detail::raise;
-using detail::raise_type_error;
-using detail::raise_python_error;
-
-NAMESPACE_END(NB_NAMESPACE)
diff --git a/src/nanobind/include/nanobind/nb_misc.h b/src/nanobind/include/nanobind/nb_misc.h
deleted file mode 100644
index 57e6025..0000000
--- a/src/nanobind/include/nanobind/nb_misc.h
+++ /dev/null
@@ -1,125 +0,0 @@
-/*
-    nanobind/nb_misc.h: Miscellaneous bits (GIL, etc.)
-
-    Copyright (c) 2022 Wenzel Jakob
-
-    All rights reserved. Use of this source code is governed by a
-    BSD-style license that can be found in the LICENSE file.
-*/
-
-NAMESPACE_BEGIN(NB_NAMESPACE)
-
-struct gil_scoped_acquire {
-public:
-    NB_NONCOPYABLE(gil_scoped_acquire)
-    gil_scoped_acquire() noexcept : state(PyGILState_Ensure()) { }
-    ~gil_scoped_acquire() { PyGILState_Release(state); }
-
-private:
-    const PyGILState_STATE state;
-};
-
-struct gil_scoped_release {
-public:
-    NB_NONCOPYABLE(gil_scoped_release)
-    gil_scoped_release() noexcept : state(PyEval_SaveThread()) { }
-    ~gil_scoped_release() { PyEval_RestoreThread(state); }
-
-private:
-    PyThreadState *state;
-};
-
-struct ft_mutex {
-public:
-    NB_NONCOPYABLE(ft_mutex)
-    ft_mutex() = default;
-
-#if !defined(NB_FREE_THREADED)
-    void lock() { }
-    void unlock() { }
-#else
-    void lock() { PyMutex_Lock(&mutex); }
-    void unlock() { PyMutex_Unlock(&mutex); }
-private:
-    PyMutex mutex { 0 };
-#endif
-};
-
-struct ft_lock_guard {
-public:
-    NB_NONCOPYABLE(ft_lock_guard)
-    ft_lock_guard(ft_mutex &m) : m(m) { m.lock(); }
-    ~ft_lock_guard() { m.unlock(); }
-private:
-    ft_mutex &m;
-};
-
-
-struct ft_object_guard {
-public:
-    NB_NONCOPYABLE(ft_object_guard)
-#if !defined(NB_FREE_THREADED)
-    ft_object_guard(handle) { }
-#else
-    ft_object_guard(handle h) { PyCriticalSection_Begin(&cs, h.ptr()); }
-    ~ft_object_guard() { PyCriticalSection_End(&cs); }
-private:
-    PyCriticalSection cs;
-#endif
-};
-
-struct ft_object2_guard {
-public:
-    NB_NONCOPYABLE(ft_object2_guard)
-#if !defined(NB_FREE_THREADED)
-    ft_object2_guard(handle, handle) { }
-#else
-    ft_object2_guard(handle h1, handle h2) { PyCriticalSection2_Begin(&cs, h1.ptr(), h2.ptr()); }
-    ~ft_object2_guard() { PyCriticalSection2_End(&cs); }
-private:
-    PyCriticalSection2 cs;
-#endif
-};
-
-inline bool leak_warnings() noexcept {
-    return detail::leak_warnings();
-}
-
-inline bool implicit_cast_warnings() noexcept {
-    return detail::implicit_cast_warnings();
-}
-
-inline void set_leak_warnings(bool value) noexcept {
-    detail::set_leak_warnings(value);
-}
-
-inline void set_implicit_cast_warnings(bool value) noexcept {
-    detail::set_implicit_cast_warnings(value);
-}
-
-inline dict globals() {
-    PyObject *p = PyEval_GetGlobals();
-    if (!p)
-        raise("nanobind::globals(): no frame is currently executing!");
-    return borrow<dict>(p);
-}
-
-inline Py_hash_t hash(handle h) {
-    Py_hash_t rv = PyObject_Hash(h.ptr());
-    if (rv == -1 && PyErr_Occurred())
-        nanobind::raise_python_error();
-    return rv;
-}
-
-inline bool isinstance(handle inst, handle cls) {
-    int ret = PyObject_IsInstance(inst.ptr(), cls.ptr());
-    if (ret == -1)
-      nanobind::raise_python_error();
-    return ret;
-}
-
-inline bool is_alive() noexcept {
-    return detail::is_alive();
-}
-
-NAMESPACE_END(NB_NAMESPACE)
diff --git a/src/nanobind/include/nanobind/nb_python.h b/src/nanobind/include/nanobind/nb_python.h
deleted file mode 100644
index 356500c..0000000
--- a/src/nanobind/include/nanobind/nb_python.h
+++ /dev/null
@@ -1,61 +0,0 @@
-/*
-    nanobind/nb_python.h: Include CPython headers while temporarily disabling
-    certain warnings. Also, disable dangerous preprocessor definitions.
-
-    Copyright (c) 2022 Wenzel Jakob
-
-    All rights reserved. Use of this source code is governed by a
-    BSD-style license that can be found in the LICENSE file.
-*/
-
-/// Include Python header, disable linking to pythonX_d.lib on Windows in debug mode
-
-#if defined(_MSC_VER)
-#  pragma warning(push)
-#  if defined(_DEBUG) && !defined(Py_DEBUG)
-#    define NB_DEBUG_MARKER
-#    undef _DEBUG
-#  endif
-#endif
-
-#include <Python.h>
-#include <frameobject.h>
-#include <pythread.h>
-#include <structmember.h>
-
-/* Python #defines overrides on all sorts of core functions, which
-   tends to weak havok in C++ codebases that expect these to work
-   like regular functions (potentially with several overloads) */
-#if defined(isalnum)
-#  undef isalnum
-#  undef isalpha
-#  undef islower
-#  undef isspace
-#  undef isupper
-#  undef tolower
-#  undef toupper
-#endif
-
-#if defined(copysign)
-#  undef copysign
-#endif
-
-#if defined(setter)
-#  undef setter
-#endif
-
-#if defined(getter)
-#  undef getter
-#endif
-
-#if defined(_MSC_VER)
-#  if defined(NB_DEBUG_MARKER)
-#    define _DEBUG
-#    undef NB_DEBUG_MARKER
-#  endif
-#  pragma warning(pop)
-#endif
-
-#if PY_VERSION_HEX < 0x03080000
-#  error The nanobind library requires Python 3.8 (or newer)
-#endif
diff --git a/src/nanobind/include/nanobind/nb_traits.h b/src/nanobind/include/nanobind/nb_traits.h
deleted file mode 100644
index 4480c86..0000000
--- a/src/nanobind/include/nanobind/nb_traits.h
+++ /dev/null
@@ -1,220 +0,0 @@
-/*
-    nanobind/nb_traits.h: type traits for metaprogramming in nanobind
-
-    Copyright (c) 2022 Wenzel Jakob
-
-    All rights reserved. Use of this source code is governed by a
-    BSD-style license that can be found in the LICENSE file.
-*/
-
-NAMESPACE_BEGIN(NB_NAMESPACE)
-using ssize_t = std::make_signed_t<size_t>;
-
-NAMESPACE_BEGIN(detail)
-
-struct void_type { };
-
-template <bool... Bs> struct index_1;
-template <bool... Bs> struct index_n;
-
-template <> struct index_1<> { constexpr static size_t value = 0; };
-template <> struct index_n<> { constexpr static size_t value = 0; };
-
-template <bool B, bool... Bs> struct index_1<B, Bs...> {
-    constexpr static size_t value_rec = index_1<Bs...>::value;
-    constexpr static size_t value = B ? 0 : (value_rec + 1);
-};
-
-template <bool B, bool... Bs> struct index_n<B, Bs...> {
-    constexpr static size_t value_rec = index_n<Bs...>::value;
-    constexpr static size_t value =
-        (value_rec < sizeof...(Bs) || !B) ? (value_rec + 1) : 0;
-};
-
-template <bool... Bs> constexpr size_t index_1_v = index_1<Bs...>::value;
-template <bool... Bs> constexpr size_t index_n_v = index_n<Bs...>::value;
-
-/// Helper template to strip away type modifiers
-template <typename T> struct intrinsic_type                       { using type = T; };
-template <typename T> struct intrinsic_type<const T>              { using type = typename intrinsic_type<T>::type; };
-template <typename T> struct intrinsic_type<T*>                   { using type = typename intrinsic_type<T>::type; };
-template <typename T> struct intrinsic_type<T&>                   { using type = typename intrinsic_type<T>::type; };
-template <typename T> struct intrinsic_type<T&&>                  { using type = typename intrinsic_type<T>::type; };
-template <typename T, size_t N> struct intrinsic_type<const T[N]> { using type = typename intrinsic_type<T>::type; };
-template <typename T, size_t N> struct intrinsic_type<T[N]>       { using type = typename intrinsic_type<T>::type; };
-template <typename T> using intrinsic_t = typename intrinsic_type<T>::type;
-
-// More relaxed pointer test
-template <typename T>
-constexpr bool is_pointer_v = std::is_pointer_v<std::remove_reference_t<T>>;
-
-template <typename T, typename U>
-using forwarded_type = std::conditional_t<std::is_lvalue_reference_v<T>,
-                                          std::remove_reference_t<U> &,
-                                          std::remove_reference_t<U> &&>;
-
-/// Forwards a value U as rvalue or lvalue according to whether T is rvalue or lvalue; typically
-/// used for forwarding a container's elements.
-template <typename T, typename U> NB_INLINE forwarded_type<T, U> forward_like_(U &&u) {
-    return (forwarded_type<T, U>) u;
-}
-
-template <typename T>
-constexpr bool is_std_char_v =
-    std::is_same_v<T, char>
-#if defined(NB_HAS_U8STRING)
-    || std::is_same_v<T, char8_t> /* std::u8string */
-#endif
-    || std::is_same_v<T, char16_t> ||
-    std::is_same_v<T, char32_t> || std::is_same_v<T, wchar_t>;
-
-template <bool V> using enable_if_t = std::enable_if_t<V, int>;
-
-/// Check if a function is a lambda function
-template <typename T>
-constexpr bool is_lambda_v = !std::is_function_v<T> && !std::is_pointer_v<T> &&
-                             !std::is_member_pointer_v<T>;
-
-/// Inspect the signature of a method call
-template <typename T> struct analyze_method { };
-template <typename Cls, typename Ret, typename... Args>
-struct analyze_method<Ret (Cls::*)(Args...)> {
-    using func = Ret(Args...);
-    static constexpr size_t argc = sizeof...(Args);
-};
-
-template <typename Cls, typename Ret, typename... Args>
-struct analyze_method<Ret (Cls::*)(Args...) noexcept> {
-    using func = Ret(Args...);
-    static constexpr size_t argc = sizeof...(Args);
-};
-
-template <typename Cls, typename Ret, typename... Args>
-struct analyze_method<Ret (Cls::*)(Args...) const> {
-    using func = Ret(Args...);
-    static constexpr size_t argc = sizeof...(Args);
-};
-
-template <typename Cls, typename Ret, typename... Args>
-struct analyze_method<Ret (Cls::*)(Args...) const noexcept> {
-    using func = Ret(Args...);
-    static constexpr size_t argc = sizeof...(Args);
-};
-
-template <typename F>
-struct strip_function_object {
-    using type = typename analyze_method<decltype(&F::operator())>::func;
-};
-
-// Extracts the function signature from a function, function pointer or lambda.
-template <typename Function, typename F = std::remove_reference_t<Function>>
-using function_signature_t = std::conditional_t<
-    std::is_function_v<F>, F,
-    typename std::conditional_t<
-        std::is_pointer_v<F> || std::is_member_pointer_v<F>,
-        std::remove_pointer<F>,
-        strip_function_object<F>>::type>;
-
-template <typename T>
-using forward_t = std::conditional_t<std::is_lvalue_reference_v<T>, T, T &&>;
-
-template <typename...> inline constexpr bool false_v = false;
-
-template <typename... Args> struct overload_cast_impl {
-    template <typename Return>
-    constexpr auto operator()(Return (*pf)(Args...)) const noexcept
-                              -> decltype(pf) { return pf; }
-
-    template <typename Return, typename Class>
-    constexpr auto operator()(Return (Class::*pmf)(Args...), std::false_type = {}) const noexcept
-                              -> decltype(pmf) { return pmf; }
-
-    template <typename Return, typename Class>
-    constexpr auto operator()(Return (Class::*pmf)(Args...) const, std::true_type) const noexcept
-                              -> decltype(pmf) { return pmf; }
-};
-
-/// Detector pattern
-template <typename SFINAE, template <typename> typename Op, typename Arg>
-struct detector : std::false_type { };
-
-template <template <typename> typename Op, typename Arg>
-struct detector<std::void_t<Op<Arg>>, Op, Arg>
-    : std::true_type { };
-
-/* This template is used for docstring generation and specialized in
-   ``stl/{variant,optional.h}`` to strip away std::optional and
-   ``std::variant<std::monostate>`` in top-level argument types and
-   avoid redundancy when combined with nb::arg(...).none(). */
-template <typename T> struct remove_opt_mono { using type = T; };
-
-// Detect std::enable_shared_from_this without including <memory>
-template <typename T>
-auto has_shared_from_this_impl(T *ptr) ->
-    decltype(ptr->weak_from_this().lock().get(), std::true_type{});
-std::false_type has_shared_from_this_impl(...);
-
-template <typename T>
-constexpr bool has_shared_from_this_v =
-    decltype(has_shared_from_this_impl((T *) nullptr))::value;
-
-/// Base of all type casters for traditional bindings created via nanobind::class_<>
-struct type_caster_base_tag {
-    static constexpr bool IsClass = true;
-};
-
-/// Check if a type caster represents traditional bindings created via nanobind::class_<>
-template <typename Caster>
-constexpr bool is_base_caster_v = std::is_base_of_v<type_caster_base_tag, Caster>;
-
-template <typename T> using is_class_caster_test = std::enable_if_t<T::IsClass>;
-
-/// Generalized version of the is_base_caster_v test that also accepts unique_ptr/shared_ptr
-template <typename Caster>
-constexpr bool is_class_caster_v = detail::detector<void, is_class_caster_test, Caster>::value;
-
-// Primary template
-template<typename T, typename = int>
-struct is_complex : std::false_type {};
-
-// Specialization if `T` is complex, i.e., `T` has a member type `value_type`,
-// member functions `real()` and `imag()` that return such, and the size of
-// `T` is twice that of `value_type`.
-template<typename T>
-struct is_complex<T, enable_if_t<std::is_same_v<
-                                     decltype(std::declval<T>().real()),
-                                     typename T::value_type>
-                              && std::is_same_v<
-                                     decltype(std::declval<T>().imag()),
-                                     typename T::value_type>
-                              && (sizeof(T) ==
-                                  2 * sizeof(typename T::value_type))>>
-    : std::true_type {};
-
-/// True if the type `T` is a complete type representing a complex number.
-template<typename T>
-inline constexpr bool is_complex_v = is_complex<T>::value;
-
-NAMESPACE_END(detail)
-
-template <typename... Args>
-static constexpr detail::overload_cast_impl<Args...> overload_cast = {};
-static constexpr auto const_ = std::true_type{};
-
-template <template<typename> class Op, typename Arg>
-constexpr bool is_detected_v = detail::detector<void, Op, Arg>::value;
-
-template <typename T>
-using remove_opt_mono_t = typename detail::remove_opt_mono<T>::type;
-
-template <template <typename> typename Base, typename T>
-std::true_type is_base_of_template(const Base<T>*);
-
-template <template <typename> typename Base>
-std::false_type is_base_of_template(...);
-
-template <typename T, template <typename> typename Base>
-constexpr bool is_base_of_template_v =
-    decltype(is_base_of_template<Base>(std::declval<T *>()))::value;
-
-NAMESPACE_END(NB_NAMESPACE)
diff --git a/src/nanobind/include/nanobind/nb_tuple.h b/src/nanobind/include/nanobind/nb_tuple.h
deleted file mode 100644
index ab2c292..0000000
--- a/src/nanobind/include/nanobind/nb_tuple.h
+++ /dev/null
@@ -1,78 +0,0 @@
-/*
-    nanobind/nb_tuple.h: tiny self-contained tuple class
-
-    Copyright (c) 2022 Wenzel Jakob
-
-    All rights reserved. Use of this source code is governed by a
-    BSD-style license that can be found in the LICENSE file.
-*/
-
-NAMESPACE_BEGIN(NB_NAMESPACE)
-NAMESPACE_BEGIN(detail)
-
-/**
- * \brief nanobind::tuple<...>: a tiny recursive tuple class
- *
- * std::tuple<...> is one of those STL types that just seems unnecessarily
- * complex for typical usage. It pulls in a large amount of headers (22K LOC,
- * 530 KiB with Clang/libc++) and goes through elaborate contortions to avoid a
- * recursive definition. This is helpful when dealing with very large tuples
- * (e.g. efficient compilation of std::get<1000>() in a tuple with 10K entries).
- * When working with small tuples used to pass around a few arguments, a simple
- * recursive definition compiles faster (generated code is identical).
- */
-
-template <typename... Ts> struct tuple;
-template <> struct tuple<> {
-    template <size_t> using type = void;
-};
-
-template <typename T, typename... Ts> struct tuple<T, Ts...> : tuple<Ts...> {
-    using Base = tuple<Ts...>;
-
-    tuple() = default;
-    tuple(const tuple &) = default;
-    tuple(tuple &&) = default;
-    tuple& operator=(tuple &&) = default;
-    tuple& operator=(const tuple &) = default;
-
-    template <typename A, typename... As>
-    NB_INLINE tuple(A &&a, As &&...as)
-        : Base((detail::forward_t<As>) as...), value((detail::forward_t<A>) a) {}
-
-    template <size_t I> NB_INLINE auto& get() {
-        if constexpr (I == 0)
-            return value;
-        else
-            return Base::template get<I - 1>();
-    }
-
-    template <size_t I> NB_INLINE const auto& get() const {
-        if constexpr (I == 0)
-            return value;
-        else
-            return Base::template get<I - 1>();
-    }
-
-    template <size_t I>
-    using type =
-        std::conditional_t<I == 0, T, typename Base::template type<I - 1>>;
-
-private:
-    T value;
-};
-
-template <typename... Ts> tuple(Ts &&...) -> tuple<std::decay_t<Ts>...>;
-
-NAMESPACE_END(detail)
-NAMESPACE_END(NB_NAMESPACE)
-
-// Support for C++17 structured bindings
-template <typename... Ts>
-struct std::tuple_size<nanobind::detail::tuple<Ts...>>
-    : std::integral_constant<size_t, sizeof...(Ts)> { };
-
-template <size_t I, typename... Ts>
-struct std::tuple_element<I, nanobind::detail::tuple<Ts...>> {
-    using type = typename nanobind::detail::tuple<Ts...>::template type<I>;
-};
diff --git a/src/nanobind/include/nanobind/nb_types.h b/src/nanobind/include/nanobind/nb_types.h
deleted file mode 100644
index c78c0d7..0000000
--- a/src/nanobind/include/nanobind/nb_types.h
+++ /dev/null
@@ -1,984 +0,0 @@
-/*
-    nanobind/nb_types.h: nb::dict/str/list/..: C++ wrappers for Python types
-
-    Copyright (c) 2022 Wenzel Jakob
-
-    All rights reserved. Use of this source code is governed by a
-    BSD-style license that can be found in the LICENSE file.
-*/
-
-NAMESPACE_BEGIN(NB_NAMESPACE)
-
-/// Macro defining functions/constructors for nanobind::handle subclasses
-#define NB_OBJECT(Type, Parent, Str, Check)                                    \
-public:                                                                        \
-    static constexpr auto Name = ::nanobind::detail::const_name(Str);          \
-    NB_INLINE Type(handle h, ::nanobind::detail::borrow_t)                     \
-        : Parent(h, ::nanobind::detail::borrow_t{}) { }                        \
-    NB_INLINE Type(handle h, ::nanobind::detail::steal_t)                      \
-        : Parent(h, ::nanobind::detail::steal_t{}) { }                         \
-    NB_INLINE static bool check_(handle h) {                                   \
-        return Check(h.ptr());                                                 \
-    }
-
-/// Like NB_OBJECT but allow null-initialization
-#define NB_OBJECT_DEFAULT(Type, Parent, Str, Check)                            \
-    NB_OBJECT(Type, Parent, Str, Check)                                        \
-    NB_INLINE Type() : Parent() {}
-
-/// Helper macro to create detail::api comparison functions
-#define NB_DECL_COMP(name)                                                     \
-    template <typename T2> NB_INLINE bool name(const api<T2> &o) const;
-
-#define NB_IMPL_COMP(name, op)                                                 \
-    template <typename T1> template <typename T2>                              \
-    NB_INLINE bool api<T1>::name(const api<T2> &o) const {                     \
-        return detail::obj_comp(derived().ptr(), o.derived().ptr(), op);       \
-    }
-
-/// Helper macros to create detail::api unary operators
-#define NB_DECL_OP_1(name)                                                     \
-    NB_INLINE object name() const;
-
-#define NB_IMPL_OP_1(name, op)                                                 \
-    template <typename T> NB_INLINE object api<T>::name() const {              \
-        return steal(detail::obj_op_1(derived().ptr(), op));                   \
-    }
-
-/// Helper macros to create detail::api binary operators
-#define NB_DECL_OP_2(name)                                                     \
-    template <typename T2> NB_INLINE object name(const api<T2> &o) const;
-
-#define NB_IMPL_OP_2(name, op)                                                 \
-    template <typename T1> template <typename T2>                              \
-    NB_INLINE object api<T1>::name(const api<T2> &o) const {                   \
-        return steal(                                                          \
-            detail::obj_op_2(derived().ptr(), o.derived().ptr(), op));         \
-    }
-
-#define NB_DECL_OP_2_I(name)                                                   \
-    template <typename T2> NB_INLINE object name(const api<T2> &o);
-
-#define NB_IMPL_OP_2_I(name, op)                                               \
-    template <typename T1> template <typename T2>                              \
-    NB_INLINE object api<T1>::name(const api<T2> &o) {                         \
-        return steal(                                                          \
-            detail::obj_op_2(derived().ptr(), o.derived().ptr(), op));         \
-    }
-
-#define NB_IMPL_OP_2_IO(name)                                                  \
-    template <typename T> NB_INLINE decltype(auto) name(const api<T> &o) {     \
-        return operator=(handle::name(o));                                     \
-    }
-
-// A few forward declarations
-class object;
-class handle;
-class iterator;
-
-template <typename T = object> NB_INLINE T borrow(handle h);
-template <typename T = object> NB_INLINE T steal(handle h);
-
-NAMESPACE_BEGIN(detail)
-
-template <typename T, typename SFINAE = int> struct type_caster;
-template <typename T> using make_caster = type_caster<intrinsic_t<T>>;
-
-template <typename Impl> class accessor;
-struct str_attr; struct obj_attr;
-struct str_item; struct obj_item; struct num_item;
-struct num_item_list; struct num_item_tuple;
-class args_proxy; class kwargs_proxy;
-struct borrow_t { };
-struct steal_t { };
-struct api_tag {
-    constexpr static bool nb_typed = false;
-};
-class dict_iterator;
-struct fast_iterator;
-
-// Standard operations provided by every nanobind object
-template <typename Derived> class api : public api_tag {
-public:
-    Derived &derived() { return static_cast<Derived &>(*this); }
-    const Derived &derived() const { return static_cast<const Derived &>(*this); }
-
-    NB_INLINE bool is(handle value) const;
-    NB_INLINE bool is_none() const { return derived().ptr() == Py_None; }
-    NB_INLINE bool is_type() const { return PyType_Check(derived().ptr()); }
-    NB_INLINE bool is_valid() const { return derived().ptr() != nullptr; }
-    NB_INLINE handle inc_ref() const &;
-    NB_INLINE handle dec_ref() const &;
-    iterator begin() const;
-    iterator end() const;
-
-    NB_INLINE handle type() const;
-    NB_INLINE operator handle() const;
-
-    accessor<obj_attr> attr(handle key) const;
-    accessor<str_attr> attr(const char *key) const;
-    accessor<str_attr> doc() const;
-
-    accessor<obj_item> operator[](handle key) const;
-    accessor<str_item> operator[](const char *key) const;
-    template <typename T, enable_if_t<std::is_arithmetic_v<T>> = 1>
-    accessor<num_item> operator[](T key) const;
-    args_proxy operator*() const;
-
-    template <rv_policy policy = rv_policy::automatic_reference,
-              typename... Args>
-    object operator()(Args &&...args) const;
-
-    NB_DECL_COMP(equal)
-    NB_DECL_COMP(not_equal)
-    NB_DECL_COMP(operator<)
-    NB_DECL_COMP(operator<=)
-    NB_DECL_COMP(operator>)
-    NB_DECL_COMP(operator>=)
-    NB_DECL_OP_1(operator-)
-    NB_DECL_OP_1(operator~)
-    NB_DECL_OP_2(operator+)
-    NB_DECL_OP_2(operator-)
-    NB_DECL_OP_2(operator*)
-    NB_DECL_OP_2(operator/)
-    NB_DECL_OP_2(operator%)
-    NB_DECL_OP_2(operator|)
-    NB_DECL_OP_2(operator&)
-    NB_DECL_OP_2(operator^)
-    NB_DECL_OP_2(operator<<)
-    NB_DECL_OP_2(operator>>)
-    NB_DECL_OP_2(floor_div)
-    NB_DECL_OP_2_I(operator+=)
-    NB_DECL_OP_2_I(operator-=)
-    NB_DECL_OP_2_I(operator*=)
-    NB_DECL_OP_2_I(operator/=)
-    NB_DECL_OP_2_I(operator%=)
-    NB_DECL_OP_2_I(operator|=)
-    NB_DECL_OP_2_I(operator&=)
-    NB_DECL_OP_2_I(operator^=)
-    NB_DECL_OP_2_I(operator<<=)
-    NB_DECL_OP_2_I(operator>>=)
-};
-
-NAMESPACE_END(detail)
-
-class handle : public detail::api<handle> {
-    friend class python_error;
-    friend struct detail::str_attr;
-    friend struct detail::obj_attr;
-    friend struct detail::str_item;
-    friend struct detail::obj_item;
-    friend struct detail::num_item;
-public:
-    static constexpr auto Name = detail::const_name("object");
-
-    handle() = default;
-    handle(const handle &) = default;
-    handle(handle &&) noexcept = default;
-    handle &operator=(const handle &) = default;
-    handle &operator=(handle &&) noexcept = default;
-    NB_INLINE handle(std::nullptr_t, detail::steal_t) : m_ptr(nullptr) { }
-    NB_INLINE handle(std::nullptr_t) : m_ptr(nullptr) { }
-    NB_INLINE handle(const PyObject *ptr) : m_ptr((PyObject *) ptr) { }
-    NB_INLINE handle(const PyTypeObject *ptr) : m_ptr((PyObject *) ptr) { }
-
-    const handle& inc_ref() const & noexcept {
-#if defined(NDEBUG)
-        Py_XINCREF(m_ptr);
-#else
-        detail::incref_checked(m_ptr);
-#endif
-        return *this;
-    }
-
-    const handle& dec_ref() const & noexcept {
-#if defined(NDEBUG)
-        Py_XDECREF(m_ptr);
-#else
-        detail::decref_checked(m_ptr);
-#endif
-        return *this;
-    }
-
-    NB_INLINE explicit operator bool() const { return m_ptr != nullptr; }
-    NB_INLINE PyObject *ptr() const { return m_ptr; }
-    NB_INLINE static bool check_(handle) { return true; }
-
-protected:
-    PyObject *m_ptr = nullptr;
-};
-
-class object : public handle {
-public:
-    static constexpr auto Name = detail::const_name("object");
-
-    object() = default;
-    object(const object &o) : handle(o) { inc_ref(); }
-    object(object &&o) noexcept : handle(o) { o.m_ptr = nullptr; }
-    ~object() { dec_ref(); }
-    object(handle h, detail::borrow_t) : handle(h) { inc_ref(); }
-    object(handle h, detail::steal_t) : handle(h) { }
-
-    handle release() {
-      handle temp(m_ptr);
-      m_ptr = nullptr;
-      return temp;
-    }
-
-    void reset() {
-        dec_ref();
-        m_ptr = nullptr;
-    }
-
-    object& operator=(const object &o) {
-        handle temp(m_ptr);
-        o.inc_ref();
-        m_ptr = o.m_ptr;
-        temp.dec_ref();
-        return *this;
-    }
-
-    object& operator=(object &&o) noexcept {
-        handle temp(m_ptr);
-        m_ptr = o.m_ptr;
-        o.m_ptr = nullptr;
-        temp.dec_ref();
-        return *this;
-    }
-
-    NB_IMPL_OP_2_IO(operator+=)
-    NB_IMPL_OP_2_IO(operator%=)
-    NB_IMPL_OP_2_IO(operator-=)
-    NB_IMPL_OP_2_IO(operator*=)
-    NB_IMPL_OP_2_IO(operator/=)
-    NB_IMPL_OP_2_IO(operator|=)
-    NB_IMPL_OP_2_IO(operator&=)
-    NB_IMPL_OP_2_IO(operator^=)
-    NB_IMPL_OP_2_IO(operator<<=)
-    NB_IMPL_OP_2_IO(operator>>=)
-};
-
-template <typename T> NB_INLINE T borrow(handle h) {
-    return { h, detail::borrow_t() };
-}
-
-template <typename T = object, typename T2,
-          std::enable_if_t<std::is_base_of_v<object, T2> && !std::is_lvalue_reference_v<T2>, int> = 0>
-NB_INLINE T borrow(T2 &&o) {
-    return { o.release(), detail::steal_t() };
-}
-
-template <typename T> NB_INLINE T steal(handle h) {
-    return { h, detail::steal_t() };
-}
-
-inline bool hasattr(handle h, const char *key) noexcept {
-    return PyObject_HasAttrString(h.ptr(), key);
-}
-
-inline bool hasattr(handle h, handle key) noexcept {
-    return PyObject_HasAttr(h.ptr(), key.ptr());
-}
-
-inline object getattr(handle h, const char *key) {
-    return steal(detail::getattr(h.ptr(), key));
-}
-
-inline object getattr(handle h, handle key) {
-    return steal(detail::getattr(h.ptr(), key.ptr()));
-}
-
-inline object getattr(handle h, const char *key, handle def) noexcept {
-    return steal(detail::getattr(h.ptr(), key, def.ptr()));
-}
-
-inline object getattr(handle h, handle key, handle value) noexcept {
-    return steal(detail::getattr(h.ptr(), key.ptr(), value.ptr()));
-}
-
-inline void setattr(handle h, const char *key, handle value) {
-    detail::setattr(h.ptr(), key, value.ptr());
-}
-
-inline void setattr(handle h, handle key, handle value) {
-    detail::setattr(h.ptr(), key.ptr(), value.ptr());
-}
-
-inline void delattr(handle h, const char *key) {
-    detail::delattr(h.ptr(), key);
-}
-
-inline void delattr(handle h, handle key) {
-    detail::delattr(h.ptr(), key.ptr());
-}
-
-class module_ : public object {
-public:
-    NB_OBJECT(module_, object, "types.ModuleType", PyModule_CheckExact)
-
-    template <typename Func, typename... Extra>
-    module_ &def(const char *name_, Func &&f, const Extra &...extra);
-
-    static NB_INLINE module_ import_(const char *name) {
-        return steal<module_>(detail::module_import(name));
-    }
-
-    static NB_INLINE module_ import_(handle name) {
-        return steal<module_>(detail::module_import(name.ptr()));
-    }
-
-    NB_INLINE module_ def_submodule(const char *name,
-                                    const char *doc = nullptr) {
-        return steal<module_>(detail::module_new_submodule(m_ptr, name, doc));
-    }
-};
-
-class capsule : public object {
-    NB_OBJECT_DEFAULT(capsule, object, NB_TYPING_CAPSULE, PyCapsule_CheckExact)
-
-    capsule(const void *ptr, void (*cleanup)(void *) noexcept = nullptr) {
-        m_ptr = detail::capsule_new(ptr, nullptr, cleanup);
-    }
-
-    capsule(const void *ptr, const char *name,
-            void (*cleanup)(void *) noexcept = nullptr) {
-        m_ptr = detail::capsule_new(ptr, name, cleanup);
-    }
-
-    const char *name() const { return PyCapsule_GetName(m_ptr); }
-
-    void *data() const { return PyCapsule_GetPointer(m_ptr, name()); }
-    void *data(const char *name) const {
-        void *p = PyCapsule_GetPointer(m_ptr, name);
-        if (!p && PyErr_Occurred())
-            raise_python_error();
-        return p;
-    }
-};
-
-class bool_ : public object {
-    NB_OBJECT_DEFAULT(bool_, object, "bool", PyBool_Check)
-
-    explicit bool_(handle h)
-        : object(detail::bool_from_obj(h.ptr()), detail::borrow_t{}) { }
-
-    explicit bool_(bool value)
-        : object(value ? Py_True : Py_False, detail::borrow_t{}) { }
-
-    explicit operator bool() const {
-        return m_ptr == Py_True;
-    }
-};
-
-class int_ : public object {
-    NB_OBJECT_DEFAULT(int_, object, "int", PyLong_Check)
-
-    explicit int_(handle h)
-        : object(detail::int_from_obj(h.ptr()), detail::steal_t{}) { }
-
-    template <typename T, detail::enable_if_t<std::is_arithmetic_v<T>> = 0>
-    explicit int_(T value) {
-        if constexpr (std::is_floating_point_v<T>)
-            m_ptr = PyLong_FromDouble((double) value);
-        else
-            m_ptr = detail::type_caster<T>::from_cpp(value, rv_policy::copy, nullptr).ptr();
-
-        if (!m_ptr)
-            raise_python_error();
-    }
-
-    template <typename T, detail::enable_if_t<std::is_arithmetic_v<T>> = 0>
-    explicit operator T() const {
-        detail::type_caster<T> tc;
-        if (!tc.from_python(m_ptr, 0, nullptr))
-            throw std::out_of_range("Conversion of nanobind::int_ failed");
-        return tc.value;
-    }
-};
-
-class float_ : public object {
-    NB_OBJECT_DEFAULT(float_, object, "float", PyFloat_Check)
-
-    explicit float_(handle h)
-        : object(detail::float_from_obj(h.ptr()), detail::steal_t{}) { }
-
-    explicit float_(double value)
-        : object(PyFloat_FromDouble(value), detail::steal_t{}) {
-        if (!m_ptr)
-            raise_python_error();
-    }
-
-#if !defined(Py_LIMITED_API)
-    explicit operator double() const { return PyFloat_AS_DOUBLE(m_ptr); }
-#else
-    explicit operator double() const { return PyFloat_AsDouble(m_ptr); }
-#endif
-};
-
-class str : public object {
-    NB_OBJECT_DEFAULT(str, object, "str", PyUnicode_Check)
-
-    explicit str(handle h)
-        : object(detail::str_from_obj(h.ptr()), detail::steal_t{}) { }
-
-    explicit str(const char *s)
-        : object(detail::str_from_cstr(s), detail::steal_t{}) { }
-
-    explicit str(const char *s, size_t n)
-        : object(detail::str_from_cstr_and_size(s, n), detail::steal_t{}) { }
-
-    template <typename... Args> str format(Args&&... args);
-
-    const char *c_str() const { return PyUnicode_AsUTF8AndSize(m_ptr, nullptr); }
-};
-
-class bytes : public object {
-    NB_OBJECT_DEFAULT(bytes, object, "bytes", PyBytes_Check)
-
-    explicit bytes(handle h)
-        : object(detail::bytes_from_obj(h.ptr()), detail::steal_t{}) { }
-
-    explicit bytes(const char *s)
-        : object(detail::bytes_from_cstr(s), detail::steal_t{}) { }
-
-    explicit bytes(const void *s, size_t n)
-        : object(detail::bytes_from_cstr_and_size(s, n), detail::steal_t{}) { }
-
-    const char *c_str() const { return PyBytes_AsString(m_ptr); }
-
-    const void *data() const { return (const void *) PyBytes_AsString(m_ptr); }
-
-    size_t size() const { return (size_t) PyBytes_Size(m_ptr); }
-};
-
-NAMESPACE_BEGIN(literals)
-inline str operator"" _s(const char *s, size_t n) {
-    return str(s, n);
-}
-NAMESPACE_END(literals)
-
-class bytearray : public object {
-    NB_OBJECT(bytearray, object, "bytearray", PyByteArray_Check)
-
-#if PY_VERSION_HEX >= 0x03090000
-    bytearray()
-        : object(PyObject_CallNoArgs((PyObject *)&PyByteArray_Type), detail::steal_t{}) { }
-#else
-    bytearray()
-        : object(PyObject_CallObject((PyObject *)&PyByteArray_Type, NULL), detail::steal_t{}) { }
-#endif
-
-    explicit bytearray(handle h)
-        : object(detail::bytearray_from_obj(h.ptr()), detail::steal_t{}) { }
-
-    explicit bytearray(const void *s, size_t n)
-        : object(detail::bytearray_from_cstr_and_size(s, n), detail::steal_t{}) { }
-
-    const char *c_str() const { return PyByteArray_AsString(m_ptr); }
-
-    const void *data() const { return PyByteArray_AsString(m_ptr); }
-    void *data() { return PyByteArray_AsString(m_ptr); }
-
-    size_t size() const { return (size_t) PyByteArray_Size(m_ptr); }
-
-    void resize(size_t n) {
-        if (PyByteArray_Resize(m_ptr, (Py_ssize_t) n) != 0)
-            detail::raise_python_error();
-    }
-};
-
-class tuple : public object {
-    NB_OBJECT(tuple, object, "tuple", PyTuple_Check)
-    tuple() : object(PyTuple_New(0), detail::steal_t()) { }
-    explicit tuple(handle h)
-        : object(detail::tuple_from_obj(h.ptr()), detail::steal_t{}) { }
-    size_t size() const { return (size_t) NB_TUPLE_GET_SIZE(m_ptr); }
-    template <typename T, detail::enable_if_t<std::is_arithmetic_v<T>> = 1>
-    detail::accessor<detail::num_item_tuple> operator[](T key) const;
-
-#if !defined(Py_LIMITED_API) && !defined(PYPY_VERSION)
-    detail::fast_iterator begin() const;
-    detail::fast_iterator end() const;
-#endif
-    bool empty() const { return size() == 0; }
-};
-
-class type_object : public object {
-    NB_OBJECT_DEFAULT(type_object, object, "type", PyType_Check)
-};
-
-class list : public object {
-    NB_OBJECT(list, object, "list", PyList_Check)
-    list() : object(PyList_New(0), detail::steal_t()) { }
-    explicit list(handle h)
-        : object(detail::list_from_obj(h.ptr()), detail::steal_t{}) { }
-    size_t size() const { return (size_t) NB_LIST_GET_SIZE(m_ptr); }
-
-    template <typename T> void append(T &&value);
-    template <typename T> void insert(Py_ssize_t index, T &&value);
-
-    template <typename T, detail::enable_if_t<std::is_arithmetic_v<T>> = 1>
-    detail::accessor<detail::num_item_list> operator[](T key) const;
-
-    void clear() {
-        if (PyList_SetSlice(m_ptr, 0, PY_SSIZE_T_MAX, nullptr))
-            raise_python_error();
-    }
-
-    void extend(handle h) {
-        if (PyList_SetSlice(m_ptr, PY_SSIZE_T_MAX, PY_SSIZE_T_MAX, h.ptr()))
-            raise_python_error();
-    }
-
-    void sort() {
-        if (PyList_Sort(m_ptr))
-            raise_python_error();
-    }
-
-    void reverse() {
-        if (PyList_Reverse(m_ptr))
-            raise_python_error();
-    }
-
-#if !defined(Py_LIMITED_API) && !defined(PYPY_VERSION)
-    detail::fast_iterator begin() const;
-    detail::fast_iterator end() const;
-#endif
-    bool empty() const { return size() == 0; }
-};
-
-class dict : public object {
-    NB_OBJECT(dict, object, "dict", PyDict_Check)
-    dict() : object(PyDict_New(), detail::steal_t()) { }
-    size_t size() const { return (size_t) NB_DICT_GET_SIZE(m_ptr); }
-    detail::dict_iterator begin() const;
-    detail::dict_iterator end() const;
-    list keys() const { return steal<list>(detail::obj_op_1(m_ptr, PyDict_Keys)); }
-    list values() const { return steal<list>(detail::obj_op_1(m_ptr, PyDict_Values)); }
-    list items() const { return steal<list>(detail::obj_op_1(m_ptr, PyDict_Items)); }
-    object get(handle key, handle def) const {
-        PyObject *o = PyDict_GetItem(m_ptr, key.ptr());
-        if (!o)
-            o = def.ptr();
-        return borrow(o);
-    }
-    object get(const char *key, handle def) const {
-        PyObject *o = PyDict_GetItemString(m_ptr, key);
-        if (!o)
-            o = def.ptr();
-        return borrow(o);
-    }
-    template <typename T> bool contains(T&& key) const;
-    void clear() { PyDict_Clear(m_ptr); }
-    void update(handle h) {
-        if (PyDict_Update(m_ptr, h.ptr()))
-            raise_python_error();
-    }
-    bool empty() const { return size() == 0; }
-};
-
-class set : public object {
-    NB_OBJECT(set, object, "set", PySet_Check)
-    set() : object(PySet_New(nullptr), detail::steal_t()) { }
-    explicit set(handle h)
-        : object(detail::set_from_obj(h.ptr()), detail::steal_t{}) { }
-    size_t size() const { return (size_t) NB_SET_GET_SIZE(m_ptr); }
-    template <typename T> bool contains(T&& key) const;
-    template <typename T> void add(T &&value);
-    void clear() {
-        if (PySet_Clear(m_ptr))
-            raise_python_error();
-    }
-    template <typename T> bool discard(T &&value);
-    bool empty() const { return size() == 0; }
-};
-
-class frozenset : public object {
-    NB_OBJECT(frozenset, object, "frozenset", PyFrozenSet_Check)
-    frozenset() : object(PyFrozenSet_New(nullptr), detail::steal_t()) { }
-    explicit frozenset(handle h)
-        : object(detail::frozenset_from_obj(h.ptr()), detail::steal_t{}) { }
-    size_t size() const { return (size_t) NB_SET_GET_SIZE(m_ptr); }
-    template <typename T> bool contains(T&& key) const;
-    bool empty() const { return size() == 0; }
-};
-
-class sequence : public object {
-    NB_OBJECT_DEFAULT(sequence, object, NB_TYPING_SEQUENCE, PySequence_Check)
-};
-
-class mapping : public object {
-    NB_OBJECT_DEFAULT(mapping, object, NB_TYPING_MAPPING, PyMapping_Check)
-    list keys() const { return steal<list>(detail::obj_op_1(m_ptr, PyMapping_Keys)); }
-    list values() const { return steal<list>(detail::obj_op_1(m_ptr, PyMapping_Values)); }
-    list items() const { return steal<list>(detail::obj_op_1(m_ptr, PyMapping_Items)); }
-    template <typename T> bool contains(T&& key) const;
-};
-
-class args : public tuple {
-    NB_OBJECT_DEFAULT(args, tuple, "tuple", PyTuple_Check)
-};
-
-class kwargs : public dict {
-    NB_OBJECT_DEFAULT(kwargs, dict, "dict", PyDict_Check)
-};
-
-class iterator : public object {
-public:
-    using difference_type = Py_ssize_t;
-    using value_type = handle;
-    using reference = const handle;
-    using pointer = const handle *;
-
-    NB_OBJECT_DEFAULT(iterator, object, NB_TYPING_ITERATOR, PyIter_Check)
-
-    iterator& operator++() {
-        m_value = steal(detail::obj_iter_next(m_ptr));
-        return *this;
-    }
-
-    iterator operator++(int) {
-        iterator rv = *this;
-        m_value = steal(detail::obj_iter_next(m_ptr));
-        return rv;
-    }
-
-    handle operator*() const {
-        if (is_valid() && !m_value.is_valid())
-            m_value = steal(detail::obj_iter_next(m_ptr));
-        return m_value;
-    }
-
-    pointer operator->() const { operator*(); return &m_value; }
-
-    static iterator sentinel() { return {}; }
-
-    friend bool operator==(const iterator &a, const iterator &b) { return a->ptr() == b->ptr(); }
-    friend bool operator!=(const iterator &a, const iterator &b) { return a->ptr() != b->ptr(); }
-
-private:
-    mutable object m_value;
-};
-
-class iterable : public object {
-public:
-    NB_OBJECT_DEFAULT(iterable, object, NB_TYPING_ITERABLE, detail::iterable_check)
-};
-
-/// Retrieve the Python type object associated with a C++ class
-template <typename T> handle type() noexcept {
-    return detail::nb_type_lookup(&typeid(detail::intrinsic_t<T>));
-}
-
-template <typename T>
-NB_INLINE bool isinstance(handle h) noexcept {
-    if constexpr (std::is_base_of_v<handle, T>)
-        return T::check_(h);
-    else if constexpr (detail::is_base_caster_v<detail::make_caster<T>>)
-        return detail::nb_type_isinstance(h.ptr(), &typeid(detail::intrinsic_t<T>));
-    else
-        return detail::make_caster<T>().from_python(h, 0, nullptr);
-}
-
-NB_INLINE bool issubclass(handle h1, handle h2) {
-    return detail::issubclass(h1.ptr(), h2.ptr());
-}
-
-NB_INLINE str repr(handle h) { return steal<str>(detail::obj_repr(h.ptr())); }
-NB_INLINE size_t len(handle h) { return detail::obj_len(h.ptr()); }
-NB_INLINE size_t len_hint(handle h) { return detail::obj_len_hint(h.ptr()); }
-NB_INLINE size_t len(const tuple &t) { return (size_t) NB_TUPLE_GET_SIZE(t.ptr()); }
-NB_INLINE size_t len(const list &l) { return (size_t) NB_LIST_GET_SIZE(l.ptr()); }
-NB_INLINE size_t len(const dict &d) { return (size_t) NB_DICT_GET_SIZE(d.ptr()); }
-NB_INLINE size_t len(const set &d) { return (size_t) NB_SET_GET_SIZE(d.ptr()); }
-
-inline void print(handle value, handle end = handle(), handle file = handle()) {
-    detail::print(value.ptr(), end.ptr(), file.ptr());
-}
-
-inline void print(const char *str, handle end = handle(), handle file = handle()) {
-    print(nanobind::str(str), end, file);
-}
-
-inline object none() { return borrow(Py_None); }
-inline dict builtins() { return borrow<dict>(PyEval_GetBuiltins()); }
-
-inline iterator iter(handle h) {
-    return steal<iterator>(detail::obj_iter(h.ptr()));
-}
-
-class slice : public object {
-public:
-    NB_OBJECT_DEFAULT(slice, object, "slice", PySlice_Check)
-    slice(handle start, handle stop, handle step) {
-        m_ptr = PySlice_New(start.ptr(), stop.ptr(), step.ptr());
-        if (!m_ptr)
-            raise_python_error();
-    }
-
-    template <typename T, detail::enable_if_t<std::is_arithmetic_v<T>> = 0>
-    explicit slice(T stop) : slice(Py_None, int_(stop), Py_None) {}
-    template <typename T, detail::enable_if_t<std::is_arithmetic_v<T>> = 0>
-    slice(T start, T stop) : slice(int_(start), int_(stop), Py_None) {}
-    template <typename T, detail::enable_if_t<std::is_arithmetic_v<T>> = 0>
-    slice(T start, T stop, T step) : slice(int_(start), int_(stop), int_(step)) {}
-
-    detail::tuple<Py_ssize_t, Py_ssize_t, Py_ssize_t, size_t> compute(size_t size) const {
-        Py_ssize_t start, stop, step;
-        size_t slice_length;
-        detail::slice_compute(m_ptr, (Py_ssize_t) size, start, stop, step, slice_length);
-        return detail::tuple(start, stop, step, slice_length);
-    }
-};
-
-class ellipsis : public object {
-    static bool is_ellipsis(PyObject *obj) { return obj == Py_Ellipsis; }
-
-public:
-    NB_OBJECT(ellipsis, object, "types.EllipsisType", is_ellipsis)
-    ellipsis() : object(Py_Ellipsis, detail::borrow_t()) {}
-};
-
-class not_implemented : public object {
-    static bool is_not_implemented(PyObject *obj) { return obj == Py_NotImplemented; }
-
-public:
-    NB_OBJECT(not_implemented, object, "types.NotImplementedType", is_not_implemented)
-    not_implemented() : object(Py_NotImplemented, detail::borrow_t()) {}
-};
-
-class callable : public object {
-public:
-    NB_OBJECT(callable, object, NB_TYPING_CALLABLE, PyCallable_Check)
-    using object::object;
-};
-
-class weakref : public object {
-public:
-    NB_OBJECT(weakref, object, "weakref.ReferenceType", PyWeakref_Check)
-
-    explicit weakref(handle obj, handle callback = {})
-        : object(PyWeakref_NewRef(obj.ptr(), callback.ptr()), detail::steal_t{}) {
-        if (!m_ptr)
-            raise_python_error();
-    }
-};
-
-class any : public object {
-public:
-    using object::object;
-    using object::operator=;
-    static constexpr auto Name = detail::const_name("typing.Any");
-};
-
-template <typename T> class handle_t : public handle {
-public:
-    static constexpr auto Name = detail::make_caster<T>::Name;
-
-    using handle::handle;
-    using handle::operator=;
-    handle_t(const handle &h) : handle(h) { }
-
-    static bool check_(handle h) { return isinstance<T>(h); }
-};
-
-struct fallback : public handle {
-public:
-    static constexpr auto Name = detail::const_name("object");
-
-    using handle::handle;
-    using handle::operator=;
-    fallback(const handle &h) : handle(h) { }
-};
-
-template <typename T> class type_object_t : public type_object {
-public:
-    static constexpr auto Name = detail::const_name(NB_TYPING_TYPE "[") +
-                                 detail::make_caster<T>::Name +
-                                 detail::const_name("]");
-
-    using type_object::type_object;
-    using type_object::operator=;
-
-    static bool check_(handle h) {
-        return PyType_Check(h.ptr()) &&
-               PyType_IsSubtype((PyTypeObject *) h.ptr(),
-                                (PyTypeObject *) nanobind::type<T>().ptr());
-    }
-};
-
-template <typename T, typename...> class typed : public T {
-public:
-    constexpr static bool nb_typed = true;
-    using T::T;
-    using T::operator=;
-    typed(const T& o) : T(o) {}
-    typed(T&& o) : T(std::move(o)) {}
-};
-
-template <typename T> struct pointer_and_handle {
-    T *p;
-    handle h;
-};
-
-NAMESPACE_BEGIN(detail)
-template <typename Derived> NB_INLINE api<Derived>::operator handle() const {
-    return derived().ptr();
-}
-
-template <typename Derived> NB_INLINE handle api<Derived>::type() const {
-    return (PyObject *) Py_TYPE(derived().ptr());
-}
-
-template <typename Derived> NB_INLINE handle api<Derived>::inc_ref() const & {
-    return operator handle().inc_ref();
-}
-
-template <typename Derived> NB_INLINE handle api<Derived>::dec_ref() const & {
-    return operator handle().dec_ref();
-}
-
-template <typename Derived>
-NB_INLINE bool api<Derived>::is(handle value) const {
-    return derived().ptr() == value.ptr();
-}
-
-template <typename Derived> iterator api<Derived>::begin() const {
-    return iter(*this);
-}
-
-template <typename Derived> iterator api<Derived>::end() const {
-    return iterator::sentinel();
-}
-
-struct fast_iterator {
-    using value_type = handle;
-    using reference = const value_type;
-    using difference_type = std::ptrdiff_t;
-
-    fast_iterator() = default;
-    fast_iterator(PyObject **value) : value(value) { }
-
-    fast_iterator& operator++() { value++; return *this; }
-    fast_iterator operator++(int) { fast_iterator rv = *this; value++; return rv; }
-    friend bool operator==(const fast_iterator &a, const fast_iterator &b) { return a.value == b.value; }
-    friend bool operator!=(const fast_iterator &a, const fast_iterator &b) { return a.value != b.value; }
-
-    handle operator*() const { return *value; }
-
-    PyObject **value;
-};
-
-class dict_iterator {
-public:
-    NB_NONCOPYABLE(dict_iterator)
-
-    using value_type = std::pair<handle, handle>;
-    using reference = const value_type;
-
-    dict_iterator() = default;
-    dict_iterator(handle h) : h(h), pos(0) {
-#if defined(NB_FREE_THREADED)
-        PyCriticalSection_Begin(&cs, h.ptr());
-#endif
-        increment();
-    }
-
-#if defined(NB_FREE_THREADED)
-    ~dict_iterator() {
-        if (h.ptr())
-            PyCriticalSection_End(&cs);
-    }
-#endif
-
-    dict_iterator& operator++() {
-        increment();
-        return *this;
-    }
-
-    void increment() {
-        if (PyDict_Next(h.ptr(), &pos, &key, &value) == 0)
-            pos = -1;
-    }
-
-    value_type operator*() const { return { key, value }; }
-
-    friend bool operator==(const dict_iterator &a, const dict_iterator &b) { return a.pos == b.pos; }
-    friend bool operator!=(const dict_iterator &a, const dict_iterator &b) { return a.pos != b.pos; }
-
-private:
-    handle h;
-    Py_ssize_t pos = -1;
-    PyObject *key = nullptr;
-    PyObject *value = nullptr;
-#if defined(NB_FREE_THREADED)
-    PyCriticalSection cs { };
-#endif
-};
-
-NB_IMPL_COMP(equal,      Py_EQ)
-NB_IMPL_COMP(not_equal,  Py_NE)
-NB_IMPL_COMP(operator<,  Py_LT)
-NB_IMPL_COMP(operator<=, Py_LE)
-NB_IMPL_COMP(operator>,  Py_GT)
-NB_IMPL_COMP(operator>=, Py_GE)
-NB_IMPL_OP_1(operator-,  PyNumber_Negative)
-NB_IMPL_OP_1(operator~,  PyNumber_Invert)
-NB_IMPL_OP_2(operator+,  PyNumber_Add)
-NB_IMPL_OP_2(operator-,  PyNumber_Subtract)
-NB_IMPL_OP_2(operator*,  PyNumber_Multiply)
-NB_IMPL_OP_2(operator/,  PyNumber_TrueDivide)
-NB_IMPL_OP_2(operator%,  PyNumber_Remainder)
-NB_IMPL_OP_2(operator|,  PyNumber_Or)
-NB_IMPL_OP_2(operator&,  PyNumber_And)
-NB_IMPL_OP_2(operator^,  PyNumber_Xor)
-NB_IMPL_OP_2(operator<<, PyNumber_Lshift)
-NB_IMPL_OP_2(operator>>, PyNumber_Rshift)
-NB_IMPL_OP_2(floor_div,  PyNumber_FloorDivide)
-NB_IMPL_OP_2_I(operator+=, PyNumber_InPlaceAdd)
-NB_IMPL_OP_2_I(operator%=, PyNumber_InPlaceRemainder)
-NB_IMPL_OP_2_I(operator-=, PyNumber_InPlaceSubtract)
-NB_IMPL_OP_2_I(operator*=, PyNumber_InPlaceMultiply)
-NB_IMPL_OP_2_I(operator/=, PyNumber_InPlaceTrueDivide)
-NB_IMPL_OP_2_I(operator|=, PyNumber_InPlaceOr)
-NB_IMPL_OP_2_I(operator&=, PyNumber_InPlaceAnd)
-NB_IMPL_OP_2_I(operator^=, PyNumber_InPlaceXor)
-NB_IMPL_OP_2_I(operator<<=,PyNumber_InPlaceLshift)
-NB_IMPL_OP_2_I(operator>>=,PyNumber_InPlaceRshift)
-
-#undef NB_DECL_COMP
-#undef NB_IMPL_COMP
-#undef NB_DECL_OP_1
-#undef NB_IMPL_OP_1
-#undef NB_DECL_OP_2
-#undef NB_IMPL_OP_2
-#undef NB_DECL_OP_2_I
-#undef NB_IMPL_OP_2_I
-#undef NB_IMPL_OP_2_IO
-
-NAMESPACE_END(detail)
-
-inline detail::dict_iterator dict::begin() const { return { *this }; }
-inline detail::dict_iterator dict::end() const { return { }; }
-
-#if !defined(Py_LIMITED_API) && !defined(PYPY_VERSION)
-inline detail::fast_iterator tuple::begin() const {
-    return ((PyTupleObject *) m_ptr)->ob_item;
-}
-inline detail::fast_iterator tuple::end() const {
-    PyTupleObject *v = (PyTupleObject *) m_ptr;
-    return v->ob_item + v->ob_base.ob_size;
-}
-inline detail::fast_iterator list::begin() const {
-    return ((PyListObject *) m_ptr)->ob_item;
-}
-inline detail::fast_iterator list::end() const {
-    PyListObject *v = (PyListObject *) m_ptr;
-    return v->ob_item + v->ob_base.ob_size;
-}
-#endif
-
-template <typename T> void del(detail::accessor<T> &a) { a.del(); }
-template <typename T> void del(detail::accessor<T> &&a) { a.del(); }
-
-NAMESPACE_END(NB_NAMESPACE)
diff --git a/src/nanobind/include/nanobind/ndarray.h b/src/nanobind/include/nanobind/ndarray.h
deleted file mode 100644
index 0dc600d..0000000
--- a/src/nanobind/include/nanobind/ndarray.h
+++ /dev/null
@@ -1,590 +0,0 @@
-/*
-    nanobind/ndarray.h: functionality to exchange n-dimensional arrays with
-    other array programming frameworks (NumPy, PyTorch, etc.)
-
-    Copyright (c) 2022 Wenzel Jakob
-
-    All rights reserved. Use of this source code is governed by a
-    BSD-style license that can be found in the LICENSE file.
-
-    The API below is based on the DLPack project
-    (https://github.com/dmlc/dlpack/blob/main/include/dlpack/dlpack.h)
-*/
-
-#pragma once
-
-#include <nanobind/nanobind.h>
-#include <initializer_list>
-
-NAMESPACE_BEGIN(NB_NAMESPACE)
-
-/// dlpack API/ABI data structures are part of a separate namespace
-NAMESPACE_BEGIN(dlpack)
-
-enum class dtype_code : uint8_t {
-    Int = 0, UInt = 1, Float = 2, Bfloat = 4, Complex = 5, Bool = 6
-};
-
-struct device {
-    int32_t device_type = 0;
-    int32_t device_id = 0;
-};
-
-struct dtype {
-    uint8_t code = 0;
-    uint8_t bits = 0;
-    uint16_t lanes = 0;
-
-    constexpr bool operator==(const dtype &o) const {
-        return code == o.code && bits == o.bits && lanes == o.lanes;
-    }
-
-    constexpr bool operator!=(const dtype &o) const { return !operator==(o); }
-};
-
-struct dltensor {
-    void *data = nullptr;
-    nanobind::dlpack::device device;
-    int32_t ndim = 0;
-    nanobind::dlpack::dtype dtype;
-    int64_t *shape = nullptr;
-    int64_t *strides = nullptr;
-    uint64_t byte_offset = 0;
-};
-
-NAMESPACE_END(dlpack)
-
-#define NB_FRAMEWORK(Name, Value, label)                                       \
-    struct Name {                                                              \
-        static constexpr auto name = detail::const_name(label);                \
-        static constexpr int value = Value;                                    \
-        static constexpr bool is_framework = true;                             \
-    }
-
-#define NB_DEVICE(Name, Value)                                                 \
-    struct Name {                                                              \
-        static constexpr auto name = detail::const_name("device='" #Name "'"); \
-        static constexpr int value = Value;                                    \
-        static constexpr bool is_device_type = true;                           \
-    }
-
-#define NB_ORDER(Name, Value)                                                  \
-    struct Name {                                                              \
-        static constexpr auto name = detail::const_name("order='" Value "'");  \
-        static constexpr char value = Value[0];                                \
-        static constexpr bool is_order = true;                                 \
-    }
-
-NB_ORDER(c_contig, "C");
-NB_ORDER(f_contig, "F");
-NB_ORDER(any_contig, "A");
-
-NB_FRAMEWORK(no_framework, 0, "ndarray");
-NB_FRAMEWORK(numpy, 1, "numpy.ndarray");
-NB_FRAMEWORK(pytorch, 2, "torch.Tensor");
-NB_FRAMEWORK(tensorflow, 3, "tensorflow.python.framework.ops.EagerTensor");
-NB_FRAMEWORK(jax, 4, "jaxlib.xla_extension.DeviceArray");
-NB_FRAMEWORK(cupy, 5, "cupy.ndarray");
-
-NAMESPACE_BEGIN(device)
-NB_DEVICE(none, 0); NB_DEVICE(cpu, 1); NB_DEVICE(cuda, 2);
-NB_DEVICE(cuda_host, 3); NB_DEVICE(opencl, 4); NB_DEVICE(vulkan, 7);
-NB_DEVICE(metal, 8); NB_DEVICE(rocm, 10); NB_DEVICE(rocm_host, 11);
-NB_DEVICE(cuda_managed, 13); NB_DEVICE(oneapi, 14);
-NAMESPACE_END(device)
-
-#undef NB_FRAMEWORK
-#undef NB_DEVICE
-#undef NB_ORDER
-
-template <typename T> struct ndarray_traits {
-    static constexpr bool is_complex = detail::is_complex_v<T>;
-    static constexpr bool is_float   = std::is_floating_point_v<T>;
-    static constexpr bool is_bool    = std::is_same_v<std::remove_cv_t<T>, bool>;
-    static constexpr bool is_int     = std::is_integral_v<T> && !is_bool;
-    static constexpr bool is_signed  = std::is_signed_v<T>;
-};
-
-NAMESPACE_BEGIN(detail)
-
-template <typename T, typename /* SFINAE */ = int> struct dtype_traits {
-    using traits = ndarray_traits<T>;
-
-    static constexpr int matches = traits::is_bool + traits::is_complex +
-                                   traits::is_float + traits::is_int;
-    static_assert(matches <= 1, "dtype matches multiple type categories!");
-
-    static constexpr dlpack::dtype value{
-        (uint8_t) ((traits::is_bool ? (int) dlpack::dtype_code::Bool : 0) +
-                   (traits::is_complex ? (int) dlpack::dtype_code::Complex : 0) +
-                   (traits::is_float ? (int) dlpack::dtype_code::Float : 0) +
-                   (traits::is_int &&  traits::is_signed ? (int) dlpack::dtype_code::Int : 0) +
-                   (traits::is_int && !traits::is_signed ? (int) dlpack::dtype_code::UInt : 0)),
-        (uint8_t) matches ? sizeof(T) * 8 : 0,
-        matches ? 1 : 0
-    };
-
-    static constexpr auto name =
-        const_name<traits::is_complex>("complex", "") +
-        const_name<traits::is_int &&  traits::is_signed>("int", "") +
-        const_name<traits::is_int && !traits::is_signed>("uint", "") +
-        const_name<traits::is_float>("float", "") +
-        const_name<traits::is_bool>(const_name("bool"), const_name<sizeof(T) * 8>());
-};
-
-template <> struct dtype_traits<void> {
-    static constexpr dlpack::dtype value{ 0, 0, 0 };
-    static constexpr auto name = descr<0>();
-};
-
-template <typename T> struct dtype_traits<const T> {
-    static constexpr dlpack::dtype value = dtype_traits<T>::value;
-    static constexpr auto name = dtype_traits<T>::name;
-};
-
-template <ssize_t... Is> struct shape {
-    static constexpr auto name =
-        const_name("shape=(") +
-        concat(const_name<Is == -1>(const_name("*"),
-                                    const_name<(size_t) Is>())...) + const_name(")");
-    static_assert(
-        ((Is >= 0 || Is == -1) && ...),
-        "The arguments to nanobind::shape must either be positive or equal to -1"
-    );
-
-    static void put(int64_t *out) {
-        size_t ctr = 0;
-        ((out[ctr++] = Is), ...);
-    }
-
-    static void put(size_t *out) {
-        if constexpr (((Is == -1) || ...))
-            detail::fail("Negative ndarray sizes are not allowed here!");
-        size_t ctr = 0;
-        ((out[ctr++] = (size_t) Is), ...);
-    }
-};
-
-template <typename T>
-constexpr bool is_ndarray_scalar_v = dtype_traits<T>::value.bits != 0;
-
-template <typename> struct ndim_shape;
-template <size_t... S> struct ndim_shape<std::index_sequence<S...>> {
-    using type = shape<((void) S, -1)...>;
-};
-
-NAMESPACE_END(detail)
-
-using detail::shape;
-
-struct ro { };
-
-template <size_t N>
-using ndim = typename detail::ndim_shape<std::make_index_sequence<N>>::type;
-
-template <typename T> constexpr dlpack::dtype dtype() {
-    return detail::dtype_traits<T>::value;
-}
-
-NAMESPACE_BEGIN(detail)
-
-/// Sentinel type to initialize ndarray_config_t<>
-struct unused {
-    using type = void;
-    static constexpr int value = 0;
-    static constexpr auto name = descr<0>();
-};
-
-/// ndarray_config describes a requested array configuration
-struct ndarray_config {
-    int device_type = 0;
-    char order = '\0';
-    bool ro = false;
-    dlpack::dtype dtype { };
-    int32_t ndim = -1;
-    int64_t *shape = nullptr;
-
-    ndarray_config() = default;
-    template <typename T> ndarray_config(T)
-        : device_type(T::DeviceType::value),
-          order((char) T::Order::value),
-          ro(std::is_const_v<typename T::Scalar>),
-          dtype(nanobind::dtype<typename T::Scalar>()),
-          ndim(T::N),
-          shape(nullptr) { }
-};
-
-/// ndarray_config_t collects nd-array template parameters in a structured way.
-/// Its "storage" is purely based on types members
-template <typename /* SFINAE */ = int, typename...> struct ndarray_config_t;
-
-template <> struct ndarray_config_t<int> {
-    using Framework = no_framework;
-    using Scalar = void;
-    using Shape = unused;
-    using Order = unused;
-    using DeviceType = unused;
-    static constexpr int32_t N = -1;
-};
-
-// Template infrastructure to collect ndarray annotations and fail if duplicates are found
-template <typename... Args> struct ndarray_config_t<int, ro, Args...> : ndarray_config_t<int, Args...> {
-    using Scalar = std::add_const_t<typename ndarray_config_t<int, Args...>::Scalar>;
-};
-
-template <typename... Args> struct ndarray_config_t<int, unused, Args...> : ndarray_config_t<int, Args...> { };
-
-template <typename Arg, typename... Args> struct ndarray_config_t<enable_if_t<is_ndarray_scalar_v<Arg>>, Arg, Args...> : ndarray_config_t<int, Args...> {
-    using Scalar = std::conditional_t<
-        std::is_const_v<typename ndarray_config_t<int, Args...>::Scalar>,
-        std::add_const_t<Arg>, Arg>;
-};
-
-template <typename Arg, typename... Args> struct ndarray_config_t<enable_if_t<Arg::is_device_type>, Arg, Args...> : ndarray_config_t<int, Args...> {
-    using DeviceType = Arg;
-};
-
-template <typename Arg, typename... Args> struct ndarray_config_t<enable_if_t<Arg::is_framework>, Arg, Args...> : ndarray_config_t<int, Args...> {
-    using Framework = Arg;
-};
-
-template <typename Arg, typename... Args> struct ndarray_config_t<enable_if_t<Arg::is_order>, Arg, Args...> : ndarray_config_t<int, Args...> {
-    using Order = Arg;
-};
-
-template <ssize_t... Is, typename... Args> struct ndarray_config_t<int, shape<Is...>, Args...> : ndarray_config_t<int, Args...> {
-    using Shape = shape<Is...>;
-    static constexpr int32_t N = sizeof...(Is);
-};
-
-NAMESPACE_END(detail)
-
-template <typename Scalar, size_t Dim, char Order> struct ndarray_view {
-    ndarray_view() = default;
-    ndarray_view(const ndarray_view &) = default;
-    ndarray_view(ndarray_view &&) = default;
-    ndarray_view &operator=(const ndarray_view &) = default;
-    ndarray_view &operator=(ndarray_view &&) noexcept = default;
-    ~ndarray_view() noexcept = default;
-
-    template <typename... Args> NB_INLINE Scalar &operator()(Args... indices) const {
-        static_assert(
-            sizeof...(Args) == Dim,
-            "ndarray_view::operator(): invalid number of arguments");
-
-        const int64_t indices_i64[] { (int64_t) indices... };
-        int64_t offset = 0;
-        for (size_t i = 0; i < Dim; ++i)
-            offset += indices_i64[i] * m_strides[i];
-
-        return *(m_data + offset);
-    }
-
-    size_t ndim() const { return Dim; }
-    size_t shape(size_t i) const { return m_shape[i]; }
-    int64_t stride(size_t i) const { return m_strides[i]; }
-    Scalar *data() const { return m_data; }
-
-private:
-    template <typename...> friend class ndarray;
-
-    template <size_t... I1, ssize_t... I2>
-    ndarray_view(Scalar *data, const int64_t *shape, const int64_t *strides,
-                 std::index_sequence<I1...>, nanobind::shape<I2...>)
-        : m_data(data) {
-
-        /* Initialize shape/strides with compile-time knowledge if
-           available (to permit vectorization, loop unrolling, etc.) */
-        ((m_shape[I1] = (I2 == -1) ? shape[I1] : (int64_t) I2), ...);
-        ((m_strides[I1] = strides[I1]), ...);
-
-        if constexpr (Order == 'F') {
-            m_strides[0] = 1;
-            for (size_t i = 1; i < Dim; ++i)
-                m_strides[i] = m_strides[i - 1] * m_shape[i - 1];
-        } else if constexpr (Order == 'C') {
-            m_strides[Dim - 1] = 1;
-            for (Py_ssize_t i = (Py_ssize_t) Dim - 2; i >= 0; --i)
-                m_strides[i] = m_strides[i + 1] * m_shape[i + 1];
-        }
-    }
-
-    Scalar *m_data = nullptr;
-    int64_t m_shape[Dim] { };
-    int64_t m_strides[Dim] { };
-};
-
-
-template <typename... Args> class ndarray {
-public:
-    template <typename...> friend class ndarray;
-
-    using Config = detail::ndarray_config_t<int, Args...>;
-    using Scalar = typename Config::Scalar;
-    static constexpr bool ReadOnly = std::is_const_v<Scalar>;
-    static constexpr char Order = Config::Order::value;
-    static constexpr int DeviceType = Config::DeviceType::value;
-    using VoidPtr = std::conditional_t<ReadOnly, const void *, void *>;
-
-    ndarray() = default;
-
-    explicit ndarray(detail::ndarray_handle *handle) : m_handle(handle) {
-        if (handle)
-            m_dltensor = *detail::ndarray_inc_ref(handle);
-    }
-
-    template <typename... Args2>
-    explicit ndarray(const ndarray<Args2...> &other) : ndarray(other.m_handle) { }
-
-    ndarray(VoidPtr data,
-            size_t ndim,
-            const size_t *shape,
-            handle owner = { },
-            const int64_t *strides = nullptr,
-            dlpack::dtype dtype = nanobind::dtype<Scalar>(),
-            int device_type = DeviceType,
-            int device_id = 0,
-            char order = Order) {
-
-        m_handle = detail::ndarray_create(
-            (void *) data, ndim, shape, owner.ptr(), strides, dtype,
-            ReadOnly, device_type, device_id, order);
-
-        m_dltensor = *detail::ndarray_inc_ref(m_handle);
-    }
-
-    ndarray(VoidPtr data,
-            std::initializer_list<size_t> shape = { },
-            handle owner = { },
-            std::initializer_list<int64_t> strides = { },
-            dlpack::dtype dtype = nanobind::dtype<Scalar>(),
-            int device_type = DeviceType,
-            int device_id = 0,
-            char order = Order) {
-
-        size_t shape_size = shape.size();
-
-        if (strides.size() != 0 && strides.size() != shape_size)
-            detail::fail("ndarray(): shape and strides have incompatible size!");
-
-        size_t shape_buf[Config::N <= 0 ? 1 : Config::N];
-        const size_t *shape_ptr = shape.begin();
-
-        if constexpr (Config::N > 0) {
-            if (!shape_size) {
-                Config::Shape::put(shape_buf);
-                shape_size = Config::N;
-                shape_ptr = shape_buf;
-            }
-        } else {
-            (void) shape_buf;
-        }
-
-        m_handle = detail::ndarray_create(
-            (void *) data, shape_size, shape_ptr, owner.ptr(),
-            (strides.size() == 0) ? nullptr : strides.begin(), dtype,
-            ReadOnly, device_type, device_id, order);
-
-        m_dltensor = *detail::ndarray_inc_ref(m_handle);
-    }
-
-    ~ndarray() {
-        detail::ndarray_dec_ref(m_handle);
-    }
-
-    ndarray(const ndarray &t) : m_handle(t.m_handle), m_dltensor(t.m_dltensor) {
-        detail::ndarray_inc_ref(m_handle);
-    }
-
-    ndarray(ndarray &&t) noexcept : m_handle(t.m_handle), m_dltensor(t.m_dltensor) {
-        t.m_handle = nullptr;
-        t.m_dltensor = dlpack::dltensor();
-    }
-
-    ndarray &operator=(ndarray &&t) noexcept {
-        detail::ndarray_dec_ref(m_handle);
-        m_handle = t.m_handle;
-        m_dltensor = t.m_dltensor;
-        t.m_handle = nullptr;
-        t.m_dltensor = dlpack::dltensor();
-        return *this;
-    }
-
-    ndarray &operator=(const ndarray &t) {
-        detail::ndarray_inc_ref(t.m_handle);
-        detail::ndarray_dec_ref(m_handle);
-        m_handle = t.m_handle;
-        m_dltensor = t.m_dltensor;
-        return *this;
-    }
-
-    dlpack::dtype dtype() const { return m_dltensor.dtype; }
-    size_t ndim() const { return (size_t) m_dltensor.ndim; }
-    size_t shape(size_t i) const { return (size_t) m_dltensor.shape[i]; }
-    int64_t stride(size_t i) const { return m_dltensor.strides[i]; }
-    const int64_t* shape_ptr() const { return m_dltensor.shape; }
-    const int64_t* stride_ptr() const { return m_dltensor.strides; }
-    bool is_valid() const { return m_handle != nullptr; }
-    int device_type() const { return (int) m_dltensor.device.device_type; }
-    int device_id() const { return (int) m_dltensor.device.device_id; }
-    detail::ndarray_handle *handle() const { return m_handle; }
-
-    size_t size() const {
-        size_t ret = is_valid();
-        for (size_t i = 0; i < ndim(); ++i)
-            ret *= shape(i);
-        return ret;
-    }
-
-    size_t itemsize() const { return ((size_t) dtype().bits + 7) / 8; }
-    size_t nbytes() const { return ((size_t) dtype().bits * size() + 7) / 8; }
-
-    Scalar *data() const {
-        return (Scalar *) ((uint8_t *) m_dltensor.data +
-                           m_dltensor.byte_offset);
-    }
-
-    template <typename... Args2>
-    NB_INLINE auto& operator()(Args2... indices) const {
-        return *(Scalar *) ((uint8_t *) m_dltensor.data +
-                            byte_offset(indices...));
-    }
-
-    template <typename... Args2> NB_INLINE auto view() const {
-        using namespace detail;
-        using Config2 = detail::ndarray_config_t<int, Args2..., Args...>;
-        using Scalar2 = typename Config2::Scalar;
-        constexpr size_t N = Config2::N >= 0 ? Config2::N : 0;
-
-        constexpr bool has_scalar = !std::is_void_v<Scalar2>,
-                       has_shape  = Config2::N >= 0;
-
-        static_assert(has_scalar,
-            "To use the ndarray::view<..>() method, you must add a scalar type "
-            "annotation (e.g. 'float') to the template parameters of the parent "
-            "ndarray, or to the call to .view<..>()");
-
-        static_assert(has_shape,
-            "To use the ndarray::view<..>() method, you must add a shape<..> "
-            "or ndim<..> annotation to the template parameters of the parent "
-            "ndarray, or to the call to .view<..>()");
-
-        if constexpr (has_scalar && has_shape) {
-            using Result = ndarray_view<Scalar2, N, Config2::Order::value>;
-            return Result((Scalar2 *) data(), shape_ptr(), stride_ptr(),
-                          std::make_index_sequence<N>(),
-                          typename Config2::Shape());
-        } else {
-            return nullptr;
-        }
-    }
-
-    auto cast(rv_policy rvp = rv_policy::automatic, class handle parent = {});
-
-private:
-    template <typename... Args2>
-    NB_INLINE int64_t byte_offset(Args2... indices) const {
-        constexpr bool has_scalar = !std::is_void_v<Scalar>,
-                       has_shape  = Config::N != -1;
-
-        static_assert(has_scalar,
-            "To use ndarray::operator(), you must add a scalar type "
-            "annotation (e.g. 'float') to the ndarray template parameters.");
-
-        static_assert(has_shape,
-            "To use ndarray::operator(), you must add a shape<> or "
-            "ndim<> annotation to the ndarray template parameters.");
-
-        if constexpr (has_scalar && has_shape) {
-            static_assert(sizeof...(Args2) == (size_t) Config::N,
-                          "ndarray::operator(): invalid number of arguments");
-
-            size_t counter = 0;
-            int64_t index = 0;
-            ((index += int64_t(indices) * m_dltensor.strides[counter++]), ...);
-
-            return (int64_t) m_dltensor.byte_offset + index * sizeof(Scalar);
-        } else {
-            return 0;
-        }
-    }
-
-    detail::ndarray_handle *m_handle = nullptr;
-    dlpack::dltensor m_dltensor;
-};
-
-inline bool ndarray_check(handle h) { return detail::ndarray_check(h.ptr()); }
-
-NAMESPACE_BEGIN(detail)
-
-template <typename T> struct dtype_name {
-    static constexpr auto name = detail::const_name("dtype=") + dtype_traits<T>::name;
-};
-
-template <> struct dtype_name<void> : unused { };
-template <> struct dtype_name<const void> : unused { };
-
-template <typename T> struct dtype_const_name {
-    static constexpr auto name = const_name<std::is_const_v<T>>("writable=False", "");
-};
-
-template <typename... Args> struct type_caster<ndarray<Args...>> {
-    using Config = detail::ndarray_config_t<int, Args...>;
-    using Scalar = typename Config::Scalar;
-
-    NB_TYPE_CASTER(ndarray<Args...>,
-                   Config::Framework::name +
-                   const_name("[") +
-                       concat_maybe(dtype_name<Scalar>::name,
-                                    Config::Shape::name,
-                                    Config::Order::name,
-                                    Config::DeviceType::name,
-                                    dtype_const_name<Scalar>::name) +
-                   const_name("]"))
-
-    bool from_python(handle src, uint8_t flags, cleanup_list *cleanup) noexcept {
-        if (src.is_none() && flags & (uint8_t) cast_flags::accepts_none) {
-            value = ndarray<Args...>();
-            return true;
-        }
-
-        int64_t shape_buf[Config::N <= 0 ? 1 : Config::N];
-        ndarray_config config{Config()};
-
-        if constexpr (Config::N > 0) {
-            Config::Shape::put(shape_buf);
-            config.shape = shape_buf;
-        } else {
-            (void) shape_buf;
-        }
-
-        value = Value(ndarray_import(src.ptr(), &config,
-                                     flags & (uint8_t) cast_flags::convert,
-                                     cleanup));
-
-        return value.is_valid();
-    }
-
-    static handle from_cpp(const ndarray<Args...> &tensor, rv_policy policy,
-                           cleanup_list *cleanup) noexcept {
-        return ndarray_export(tensor.handle(), Config::Framework::value, policy, cleanup);
-    }
-};
-
-template <typename... Args>
-class ndarray_object : public object {
-public:
-    using object::object;
-    using object::operator=;
-    static constexpr auto Name = type_caster<ndarray<Args...>>::Name;
-};
-
-NAMESPACE_END(detail)
-
-template <typename... Args>
-auto ndarray<Args...>::cast(rv_policy rvp, class handle parent) {
-    return borrow<detail::ndarray_object<Args...>>(
-        nanobind::cast(*this, rvp, parent));
-}
-
-NAMESPACE_END(NB_NAMESPACE)
diff --git a/src/nanobind/include/nanobind/operators.h b/src/nanobind/include/nanobind/operators.h
deleted file mode 100644
index e8ebb14..0000000
--- a/src/nanobind/include/nanobind/operators.h
+++ /dev/null
@@ -1,149 +0,0 @@
-/*
-    nanobind/operators.h: convenience functionality for operator overloading
-
-    Copyright (c) 2022 Wenzel Jakob
-
-    All rights reserved. Use of this source code is governed by a
-    BSD-style license that can be found in the LICENSE file.
-*/
-#pragma once
-
-#include <nanobind/nanobind.h>
-
-NAMESPACE_BEGIN(NB_NAMESPACE)
-NAMESPACE_BEGIN(detail)
-
-/// Enumeration with all supported operator types
-enum op_id : int {
-    op_add, op_sub, op_mul, op_div, op_mod, op_divmod, op_pow, op_lshift,
-    op_rshift, op_and, op_xor, op_or, op_neg, op_pos, op_abs, op_invert,
-    op_int, op_long, op_float, op_str, op_cmp, op_gt, op_ge, op_lt, op_le,
-    op_eq, op_ne, op_iadd, op_isub, op_imul, op_idiv, op_imod, op_ilshift,
-    op_irshift, op_iand, op_ixor, op_ior, op_complex, op_bool, op_nonzero,
-    op_repr, op_truediv, op_itruediv, op_hash
-};
-
-enum op_type : int {
-    op_l, /* base type on left */
-    op_r, /* base type on right */
-    op_u  /* unary operator */
-};
-
-struct self_t { };
-[[maybe_unused]] static const self_t self = self_t();
-
-/// Type for an unused type slot
-struct undefined_t { };
-
-/// base template of operator implementations
-template <op_id, op_type, typename B, typename L, typename R> struct op_impl { };
-
-/// Operator implementation generator
-template <op_id id, op_type ot, typename L, typename R> struct op_ {
-    template <typename Class, typename... Extra> void execute(Class &cl, const Extra&... extra) const {
-        using Type = typename Class::Type;
-        using Lt = std::conditional_t<std::is_same_v<L, self_t>, Type, L>;
-        using Rt = std::conditional_t<std::is_same_v<R, self_t>, Type, R>;
-        using Op = op_impl<id, ot, Type, Lt, Rt>;
-        cl.def(Op::name(), &Op::execute, is_operator(), Op::default_policy, extra...);
-    }
-
-    template <typename Class, typename... Extra> void execute_cast(Class &cl, const Extra&... extra) const {
-        using Type = typename Class::Type;
-        using Lt = std::conditional_t<std::is_same_v<L, self_t>, Type, L>;
-        using Rt = std::conditional_t<std::is_same_v<R, self_t>, Type, R>;
-        using Op = op_impl<id, ot, Type, Lt, Rt>;
-        cl.def(Op::name(), &Op::execute_cast, is_operator(), Op::default_policy, extra...);
-    }
-};
-
-#define NB_BINARY_OPERATOR(id, rid, op, expr)                                          \
-template <typename B, typename L, typename R> struct op_impl<op_##id, op_l, B, L, R> { \
-    static constexpr rv_policy default_policy = rv_policy::automatic;                  \
-    static char const* name() { return "__" #id "__"; }                                \
-    static auto execute(const L &l, const R &r) -> decltype(expr) { return (expr); }   \
-    static B execute_cast(const L &l, const R &r) { return B(expr); }                  \
-};                                                                                     \
-template <typename B, typename L, typename R> struct op_impl<op_##id, op_r, B, L, R> { \
-    static constexpr rv_policy default_policy = rv_policy::automatic;                  \
-    static char const* name() { return "__" #rid "__"; }                               \
-    static auto execute(const R &r, const L &l) -> decltype(expr) { return (expr); }   \
-    static B execute_cast(const R &r, const L &l) { return B(expr); }                  \
-};                                                                                     \
-inline op_<op_##id, op_l, self_t, self_t> op(const self_t &, const self_t &) {         \
-    return op_<op_##id, op_l, self_t, self_t>();                                       \
-}                                                                                      \
-template <typename T> op_<op_##id, op_l, self_t, T> op(const self_t &, const T &) {    \
-    return op_<op_##id, op_l, self_t, T>();                                            \
-}                                                                                      \
-template <typename T> op_<op_##id, op_r, T, self_t> op(const T &, const self_t &) {    \
-    return op_<op_##id, op_r, T, self_t>();                                            \
-}
-
-#define NB_INPLACE_OPERATOR(id, op, expr)                                              \
-template <typename B, typename L, typename R> struct op_impl<op_##id, op_l, B, L, R> { \
-    static constexpr rv_policy default_policy = rv_policy::move;                       \
-    static char const* name() { return "__" #id "__"; }                                \
-    static auto execute(L &l, const R &r) -> decltype(expr) { return expr; }           \
-    static B execute_cast(L &l, const R &r) { return B(expr); }                        \
-};                                                                                     \
-template <typename T> op_<op_##id, op_l, self_t, T> op(const self_t &, const T &) {    \
-    return op_<op_##id, op_l, self_t, T>();                                            \
-}
-
-#define NB_UNARY_OPERATOR(id, op, expr)                                                \
-template <typename B, typename L> struct op_impl<op_##id, op_u, B, L, undefined_t> {   \
-    static constexpr rv_policy default_policy = rv_policy::automatic;                  \
-    static char const* name() { return "__" #id "__"; }                                \
-    static auto execute(const L &l) -> decltype(expr) { return expr; }                 \
-    static B execute_cast(const L &l) { return B(expr); }                              \
-};                                                                                     \
-inline op_<op_##id, op_u, self_t, undefined_t> op(const self_t &) {                    \
-    return op_<op_##id, op_u, self_t, undefined_t>();                                  \
-}
-
-NB_BINARY_OPERATOR(sub,       rsub,         operator-,    l - r)
-NB_BINARY_OPERATOR(add,       radd,         operator+,    l + r)
-NB_BINARY_OPERATOR(mul,       rmul,         operator*,    l * r)
-NB_BINARY_OPERATOR(truediv,   rtruediv,     operator/,    l / r)
-NB_BINARY_OPERATOR(mod,       rmod,         operator%,    l % r)
-NB_BINARY_OPERATOR(lshift,    rlshift,      operator<<,   l << r)
-NB_BINARY_OPERATOR(rshift,    rrshift,      operator>>,   l >> r)
-NB_BINARY_OPERATOR(and,       rand,         operator&,    l & r)
-NB_BINARY_OPERATOR(xor,       rxor,         operator^,    l ^ r)
-NB_BINARY_OPERATOR(or,        ror,          operator|,    l | r)
-NB_BINARY_OPERATOR(gt,        lt,           operator>,    l > r)
-NB_BINARY_OPERATOR(ge,        le,           operator>=,   l >= r)
-NB_BINARY_OPERATOR(lt,        gt,           operator<,    l < r)
-NB_BINARY_OPERATOR(le,        ge,           operator<=,   l <= r)
-NB_BINARY_OPERATOR(eq,        eq,           operator==,   l == r)
-NB_BINARY_OPERATOR(ne,        ne,           operator!=,   l != r)
-NB_INPLACE_OPERATOR(iadd,     operator+=,   l += r)
-NB_INPLACE_OPERATOR(isub,     operator-=,   l -= r)
-NB_INPLACE_OPERATOR(imul,     operator*=,   l *= r)
-NB_INPLACE_OPERATOR(itruediv, operator/=,   l /= r)
-NB_INPLACE_OPERATOR(imod,     operator%=,   l %= r)
-NB_INPLACE_OPERATOR(ilshift,  operator<<=,  l <<= r)
-NB_INPLACE_OPERATOR(irshift,  operator>>=,  l >>= r)
-NB_INPLACE_OPERATOR(iand,     operator&=,   l &= r)
-NB_INPLACE_OPERATOR(ixor,     operator^=,   l ^= r)
-NB_INPLACE_OPERATOR(ior,      operator|=,   l |= r)
-NB_UNARY_OPERATOR(neg,        operator-,    -l)
-NB_UNARY_OPERATOR(pos,        operator+,    +l)
-NB_UNARY_OPERATOR(invert,     operator~,    (~l))
-NB_UNARY_OPERATOR(bool,       operator!,    !!l)
-NB_UNARY_OPERATOR(abs,        abs,          std::abs(l))
-NB_UNARY_OPERATOR(hash,       hash,         std::hash<L>()(l))
-
-#undef NB_BINARY_OPERATOR
-#undef NB_INPLACE_OPERATOR
-#undef NB_UNARY_OPERATOR
-
-NAMESPACE_END(detail)
-
-// Add named operators so that they are accessible via `nb::`.
-using detail::self;
-using detail::hash;
-using detail::abs;
-
-NAMESPACE_END(NB_NAMESPACE)
diff --git a/src/nanobind/include/nanobind/stl/array.h b/src/nanobind/include/nanobind/stl/array.h
deleted file mode 100644
index 388b866..0000000
--- a/src/nanobind/include/nanobind/stl/array.h
+++ /dev/null
@@ -1,22 +0,0 @@
-/*
-    nanobind/stl/array.h: type caster for std::array<...>
-
-    Copyright (c) 2022 Wenzel Jakob
-
-    All rights reserved. Use of this source code is governed by a
-    BSD-style license that can be found in the LICENSE file.
-*/
-
-#pragma once
-
-#include "detail/nb_array.h"
-#include <array>
-
-NAMESPACE_BEGIN(NB_NAMESPACE)
-NAMESPACE_BEGIN(detail)
-
-template <typename Type, size_t Size> struct type_caster<std::array<Type, Size>>
- : array_caster<std::array<Type, Size>, Type, Size> { };
-
-NAMESPACE_END(detail)
-NAMESPACE_END(NB_NAMESPACE)
diff --git a/src/nanobind/include/nanobind/stl/bind_map.h b/src/nanobind/include/nanobind/stl/bind_map.h
deleted file mode 100644
index 1431167..0000000
--- a/src/nanobind/include/nanobind/stl/bind_map.h
+++ /dev/null
@@ -1,181 +0,0 @@
-/*
-    nanobind/stl/bind_map.h: Automatic creation of bindings for map-style containers
-
-    All rights reserved. Use of this source code is governed by a
-    BSD-style license that can be found in the LICENSE file.
-*/
-
-#pragma once
-
-#include <nanobind/nanobind.h>
-#include <nanobind/make_iterator.h>
-#include <nanobind/operators.h>
-#include <nanobind/stl/detail/traits.h>
-
-NAMESPACE_BEGIN(NB_NAMESPACE)
-NAMESPACE_BEGIN(detail)
-
-template <typename Map, typename Key, typename Value>
-inline void map_set(Map &m, const Key &k, const Value &v) {
-    if constexpr (detail::is_copy_assignable_v<Value>) {
-        m[k] = v;
-    } else {
-        auto r = m.emplace(k, v);
-        if (!r.second) {
-            // Value is not copy-assignable. Erase and retry
-            m.erase(r.first);
-            m.emplace(k, v);
-        }
-    }
-}
-
-NAMESPACE_END(detail)
-
-template <typename Map,
-          rv_policy Policy = rv_policy::automatic_reference,
-          typename... Args>
-class_<Map> bind_map(handle scope, const char *name, Args &&...args) {
-    using Key = typename Map::key_type;
-    using Value = typename Map::mapped_type;
-
-    using ValueRef = typename detail::iterator_value_access<
-        typename Map::iterator>::result_type;
-
-    static_assert(
-        !detail::is_base_caster_v<detail::make_caster<Value>> ||
-        detail::is_copy_constructible_v<Value> ||
-        (Policy != rv_policy::automatic_reference &&
-         Policy != rv_policy::copy),
-        "bind_map(): the generated __getitem__ would copy elements, so the "
-        "value type must be copy-constructible");
-
-    handle cl_cur = type<Map>();
-    if (cl_cur.is_valid()) {
-        // Binding already exists, don't re-create
-        return borrow<class_<Map>>(cl_cur);
-    }
-
-    auto cl = class_<Map>(scope, name, std::forward<Args>(args)...)
-        .def(init<>(),
-             "Default constructor")
-
-        .def("__len__", [](const Map &m) { return m.size(); })
-
-        .def("__bool__",
-             [](const Map &m) { return !m.empty(); },
-             "Check whether the map is nonempty")
-
-        .def("__repr__",
-             [](handle_t<Map> h) {
-                return steal<str>(detail::repr_map(h.ptr()));
-             })
-
-        .def("__contains__",
-             [](const Map &m, const Key &k) { return m.find(k) != m.end(); })
-
-        .def("__contains__", // fallback for incompatible types
-             [](const Map &, handle) { return false; })
-
-        .def("__iter__",
-             [](Map &m) {
-                 return make_key_iterator<Policy>(type<Map>(), "KeyIterator",
-                                                  m.begin(), m.end());
-             },
-             keep_alive<0, 1>())
-
-        .def("__getitem__",
-             [](Map &m, const Key &k) -> ValueRef {
-                 auto it = m.find(k);
-                 if (it == m.end())
-                     throw key_error();
-                 return (*it).second;
-             }, Policy)
-
-        .def("__delitem__",
-            [](Map &m, const Key &k) {
-                auto it = m.find(k);
-                if (it == m.end())
-                    throw key_error();
-                m.erase(it);
-            })
-
-        .def("clear", [](Map &m) { m.clear(); },
-             "Remove all items");
-
-
-    if constexpr (detail::is_copy_constructible_v<Map>) {
-        cl.def(init<const Map &>(), "Copy constructor");
-
-        cl.def("__init__", [](Map *m, typed<dict, Key, Value> d) {
-            new (m) Map();
-            for (auto [k, v] : borrow<dict>(std::move(d)))
-                m->emplace(cast<Key>(k), cast<Value>(v));
-        }, "Construct from a dictionary");
-
-        implicitly_convertible<dict, Map>();
-    }
-
-    // Assignment operator for copy-assignable/copy-constructible types
-    if constexpr (detail::is_copy_assignable_v<Value> ||
-                  detail::is_copy_constructible_v<Value>) {
-        cl.def("__setitem__", [](Map &m, const Key &k, const Value &v) {
-            detail::map_set<Map, Key, Value>(m, k, v);
-        });
-
-        cl.def("update", [](Map &m, const Map &m2) {
-            for (auto &kv : m2)
-                detail::map_set<Map, Key, Value>(m, kv.first, kv.second);
-        },
-        "Update the map with element from `arg`");
-    }
-
-    if constexpr (detail::is_equality_comparable_v<Map>) {
-        cl.def(self == self, sig("def __eq__(self, arg: object, /) -> bool"))
-          .def(self != self, sig("def __ne__(self, arg: object, /) -> bool"));
-    }
-
-    // Item, value, and key views
-    struct KeyView   { Map &map; };
-    struct ValueView { Map &map; };
-    struct ItemView  { Map &map; };
-
-    class_<ItemView>(cl, "ItemView")
-        .def("__len__", [](ItemView &v) { return v.map.size(); })
-        .def("__iter__",
-             [](ItemView &v) {
-                 return make_iterator<Policy>(type<Map>(), "ItemIterator",
-                                              v.map.begin(), v.map.end());
-             },
-             keep_alive<0, 1>());
-
-    class_<KeyView>(cl, "KeyView")
-        .def("__contains__", [](KeyView &v, const Key &k) { return v.map.find(k) != v.map.end(); })
-        .def("__contains__", [](KeyView &, handle) { return false; })
-        .def("__len__", [](KeyView &v) { return v.map.size(); })
-        .def("__iter__",
-             [](KeyView &v) {
-                 return make_key_iterator<Policy>(type<Map>(), "KeyIterator",
-                                                  v.map.begin(), v.map.end());
-             },
-             keep_alive<0, 1>());
-
-    class_<ValueView>(cl, "ValueView")
-        .def("__len__", [](ValueView &v) { return v.map.size(); })
-        .def("__iter__",
-             [](ValueView &v) {
-                 return make_value_iterator<Policy>(type<Map>(), "ValueIterator",
-                                                    v.map.begin(), v.map.end());
-             },
-             keep_alive<0, 1>());
-
-    cl.def("keys",   [](Map &m) { return new KeyView{m};   }, keep_alive<0, 1>(),
-           "Returns an iterable view of the map's keys.");
-    cl.def("values", [](Map &m) { return new ValueView{m}; }, keep_alive<0, 1>(),
-           "Returns an iterable view of the map's values.");
-    cl.def("items",  [](Map &m) { return new ItemView{m};  }, keep_alive<0, 1>(),
-           "Returns an iterable view of the map's items.");
-
-    return cl;
-}
-
-NAMESPACE_END(NB_NAMESPACE)
diff --git a/src/nanobind/include/nanobind/stl/bind_vector.h b/src/nanobind/include/nanobind/stl/bind_vector.h
deleted file mode 100644
index 721b1b3..0000000
--- a/src/nanobind/include/nanobind/stl/bind_vector.h
+++ /dev/null
@@ -1,225 +0,0 @@
-/*
-    nanobind/stl/bind_vector.h: Automatic creation of bindings for vector-style containers
-
-    Copyright (c) 2022 Wenzel Jakob
-
-    All rights reserved. Use of this source code is governed by a
-    BSD-style license that can be found in the LICENSE file.
-*/
-
-#pragma once
-
-#include <nanobind/nanobind.h>
-#include <nanobind/operators.h>
-#include <nanobind/make_iterator.h>
-#include <nanobind/stl/detail/traits.h>
-#include <vector>
-#include <algorithm>
-
-NAMESPACE_BEGIN(NB_NAMESPACE)
-NAMESPACE_BEGIN(detail)
-
-inline size_t wrap(Py_ssize_t i, size_t n) {
-    if (i < 0)
-        i += (Py_ssize_t) n;
-
-    if (i < 0 || (size_t) i >= n)
-        throw index_error();
-
-    return (size_t) i;
-}
-
-template <> struct iterator_access<typename std::vector<bool>::iterator> {
-    using result_type = bool;
-    result_type operator()(typename std::vector<bool>::iterator &it) const { return *it; }
-};
-
-NAMESPACE_END(detail)
-
-
-template <typename Vector,
-          rv_policy Policy = rv_policy::automatic_reference,
-          typename... Args>
-class_<Vector> bind_vector(handle scope, const char *name, Args &&...args) {
-    using ValueRef = typename detail::iterator_access<typename Vector::iterator>::result_type;
-    using Value = std::decay_t<ValueRef>;
-
-    static_assert(
-        !detail::is_base_caster_v<detail::make_caster<Value>> ||
-        detail::is_copy_constructible_v<Value> ||
-        (Policy != rv_policy::automatic_reference &&
-         Policy != rv_policy::copy),
-        "bind_vector(): the generated __getitem__ would copy elements, so the "
-        "element type must be copy-constructible");
-
-    handle cl_cur = type<Vector>();
-    if (cl_cur.is_valid()) {
-        // Binding already exists, don't re-create
-        return borrow<class_<Vector>>(cl_cur);
-    }
-
-    auto cl = class_<Vector>(scope, name, std::forward<Args>(args)...)
-        .def(init<>(), "Default constructor")
-
-        .def("__len__", [](const Vector &v) { return v.size(); })
-
-        .def("__bool__",
-             [](const Vector &v) { return !v.empty(); },
-             "Check whether the vector is nonempty")
-
-        .def("__repr__",
-             [](handle_t<Vector> h) {
-                return steal<str>(detail::repr_list(h.ptr()));
-             })
-
-        .def("__iter__",
-             [](Vector &v) {
-                 return make_iterator<Policy>(type<Vector>(), "Iterator",
-                                              v.begin(), v.end());
-             }, keep_alive<0, 1>())
-
-        .def("__getitem__",
-             [](Vector &v, Py_ssize_t i) -> ValueRef {
-                 return v[detail::wrap(i, v.size())];
-             }, Policy)
-
-        .def("clear", [](Vector &v) { v.clear(); },
-             "Remove all items from list.");
-
-    if constexpr (detail::is_copy_constructible_v<Value>) {
-        cl.def(init<const Vector &>(),
-               "Copy constructor");
-
-        cl.def("__init__", [](Vector *v, typed<iterable, Value> seq) {
-            new (v) Vector();
-            v->reserve(len_hint(seq));
-            for (handle h : seq)
-                v->push_back(cast<Value>(h));
-        }, "Construct from an iterable object");
-
-        implicitly_convertible<iterable, Vector>();
-
-        cl.def("append",
-               [](Vector &v, const Value &value) { v.push_back(value); },
-               "Append `arg` to the end of the list.")
-
-          .def("insert",
-               [](Vector &v, Py_ssize_t i, const Value &x) {
-                   if (i < 0)
-                       i += (Py_ssize_t) v.size();
-                   if (i < 0 || (size_t) i > v.size())
-                       throw index_error();
-                   v.insert(v.begin() + i, x);
-               },
-               "Insert object `arg1` before index `arg0`.")
-
-           .def("pop",
-                [](Vector &v, Py_ssize_t i) {
-                    size_t index = detail::wrap(i, v.size());
-                    Value result = std::move(v[index]);
-                    v.erase(v.begin() + index);
-                    return result;
-                },
-                arg("index") = -1,
-                "Remove and return item at `index` (default last).")
-
-          .def("extend",
-               [](Vector &v, const Vector &src) {
-                   v.insert(v.end(), src.begin(), src.end());
-               },
-               "Extend `self` by appending elements from `arg`.")
-
-          .def("__setitem__",
-               [](Vector &v, Py_ssize_t i, const Value &value) {
-                   v[detail::wrap(i, v.size())] = value;
-               })
-
-          .def("__delitem__",
-               [](Vector &v, Py_ssize_t i) {
-                   v.erase(v.begin() + detail::wrap(i, v.size()));
-               })
-
-          .def("__getitem__",
-               [](const Vector &v, const slice &slice) -> Vector * {
-                   auto [start, stop, step, length] = slice.compute(v.size());
-                   auto *seq = new Vector();
-                   seq->reserve(length);
-
-                   for (size_t i = 0; i < length; ++i) {
-                       seq->push_back(v[start]);
-                       start += step;
-                   }
-
-                   return seq;
-               })
-
-          .def("__setitem__",
-               [](Vector &v, const slice &slice, const Vector &value) {
-                   auto [start, stop, step, length] = slice.compute(v.size());
-
-                   if (length != value.size())
-                       throw index_error(
-                           "The left and right hand side of the slice "
-                           "assignment have mismatched sizes!");
-
-                   for (size_t i = 0; i < length; ++i) {
-                       v[start] = value[i];
-                       start += step;
-                    }
-               })
-
-          .def("__delitem__",
-               [](Vector &v, const slice &slice) {
-                   auto [start, stop, step, length] = slice.compute(v.size());
-                   if (length == 0)
-                       return;
-
-                   stop = start + (length - 1) * step;
-                   if (start > stop) {
-                       std::swap(start, stop);
-                       step = -step;
-                   }
-
-                   if (step == 1) {
-                       v.erase(v.begin() + start, v.begin() + stop + 1);
-                   } else {
-                       for (size_t i = 0; i < length; ++i) {
-                           v.erase(v.begin() + stop);
-                           stop -= step;
-                       }
-                   }
-               });
-    }
-
-    if constexpr (detail::is_equality_comparable_v<Value>) {
-        cl.def(self == self, sig("def __eq__(self, arg: object, /) -> bool"))
-          .def(self != self, sig("def __ne__(self, arg: object, /) -> bool"))
-
-          .def("__contains__",
-               [](const Vector &v, const Value &x) {
-                   return std::find(v.begin(), v.end(), x) != v.end();
-               })
-
-          .def("__contains__", // fallback for incompatible types
-               [](const Vector &, handle) { return false; })
-
-          .def("count",
-               [](const Vector &v, const Value &x) {
-                   return std::count(v.begin(), v.end(), x);
-               }, "Return number of occurrences of `arg`.")
-
-          .def("remove",
-               [](Vector &v, const Value &x) {
-                   auto p = std::find(v.begin(), v.end(), x);
-                   if (p != v.end())
-                       v.erase(p);
-                   else
-                       throw value_error();
-               },
-               "Remove first occurrence of `arg`.");
-    }
-
-    return cl;
-}
-
-NAMESPACE_END(NB_NAMESPACE)
diff --git a/src/nanobind/include/nanobind/stl/chrono.h b/src/nanobind/include/nanobind/stl/chrono.h
deleted file mode 100644
index 75a4a6e..0000000
--- a/src/nanobind/include/nanobind/stl/chrono.h
+++ /dev/null
@@ -1,239 +0,0 @@
-/*
-    nanobind/stl/chrono.h: conversion between std::chrono and python's datetime
-
-    Copyright (c) 2023 Hudson River Trading LLC <opensource@hudson-trading.com> and
-                       Trent Houliston <trent@houliston.me> and
-                       Wenzel Jakob <wenzel.jakob@epfl.ch>
-
-    All rights reserved. Use of this source code is governed by a
-    BSD-style license that can be found in the LICENSE file.
-*/
-#pragma once
-
-#include <nanobind/nanobind.h>
-
-#if !defined(__STDC_WANT_LIB_EXT1__)
-#define __STDC_WANT_LIB_EXT1__ 1 // for localtime_s
-#endif
-#include <time.h>
-
-#include <chrono>
-#include <cmath>
-#include <ctime>
-#include <limits>
-
-#include <nanobind/stl/detail/chrono.h>
-
-// Casts a std::chrono type (either a duration or a time_point) to/from
-// Python timedelta objects, or from a Python float representing seconds.
-template <typename type> class duration_caster {
-public:
-    using rep = typename type::rep;
-    using period = typename type::period;
-    using duration_t = std::chrono::duration<rep, period>;
-
-    bool from_python(handle src, uint8_t /*flags*/, cleanup_list*) noexcept {
-        namespace ch = std::chrono;
-
-        if (!src) return false;
-
-        // support for signed 25 bits is required by the standard
-        using days = ch::duration<int_least32_t, std::ratio<86400>>;
-
-        // If invoked with datetime.delta object, unpack it
-        int dd, ss, uu;
-        try {
-            if (unpack_timedelta(src.ptr(), &dd, &ss, &uu)) {
-                value = type(ch::duration_cast<duration_t>(
-                                 days(dd) + ch::seconds(ss) + ch::microseconds(uu)));
-                return true;
-            }
-        } catch (python_error& e) {
-            e.discard_as_unraisable(src.ptr());
-            return false;
-        }
-
-        // If invoked with a float we assume it is seconds and convert
-        int is_float;
-#if defined(Py_LIMITED_API)
-        is_float = PyType_IsSubtype(Py_TYPE(src.ptr()), &PyFloat_Type);
-#else
-        is_float = PyFloat_Check(src.ptr());
-#endif
-        if (is_float) {
-            value = type(ch::duration_cast<duration_t>(
-                             ch::duration<double>(PyFloat_AsDouble(src.ptr()))));
-            return true;
-        }
-        return false;
-    }
-
-    // If this is a duration just return it back
-    static const duration_t& get_duration(const duration_t& src) {
-        return src;
-    }
-
-    // If this is a time_point get the time_since_epoch
-    template <typename Clock>
-    static duration_t get_duration(
-            const std::chrono::time_point<Clock, duration_t>& src) {
-        return src.time_since_epoch();
-    }
-
-    static handle from_cpp(const type& src, rv_policy, cleanup_list*) noexcept {
-        namespace ch = std::chrono;
-
-        // Use overloaded function to get our duration from our source
-        // Works out if it is a duration or time_point and get the duration
-        auto d = get_duration(src);
-
-        // Declare these special duration types so the conversions happen with the correct primitive types (int)
-        using dd_t = ch::duration<int, std::ratio<86400>>;
-        using ss_t = ch::duration<int, std::ratio<1>>;
-        using us_t = ch::duration<int, std::micro>;
-
-        auto dd = ch::duration_cast<dd_t>(d);
-        auto subd = d - dd;
-        auto ss = ch::duration_cast<ss_t>(subd);
-        auto us = ch::duration_cast<us_t>(subd - ss);
-        return pack_timedelta(dd.count(), ss.count(), us.count());
-    }
-
-    #if PY_VERSION_HEX < 0x03090000
-        NB_TYPE_CASTER(type, io_name("typing.Union[datetime.timedelta, float]",
-                                     "datetime.timedelta"))
-    #else
-        NB_TYPE_CASTER(type, io_name("datetime.timedelta | float",
-                                     "datetime.timedelta"))
-    #endif
-};
-
-template <class... Args>
-auto can_localtime_s(Args*... args) ->
-    decltype((localtime_s(args...), std::true_type{}));
-std::false_type can_localtime_s(...);
-
-template <class... Args>
-auto can_localtime_r(Args*... args) ->
-    decltype((localtime_r(args...), std::true_type{}));
-std::false_type can_localtime_r(...);
-
-template <class Time, class Buf>
-inline std::tm *localtime_thread_safe(const Time *time, Buf *buf) {
-    if constexpr (decltype(can_localtime_s(time, buf))::value) {
-        // C11 localtime_s
-        std::tm* ret = localtime_s(time, buf);
-        return ret;
-    } else if constexpr (decltype(can_localtime_s(buf, time))::value) {
-        // Microsoft localtime_s (with parameters switched and errno_t return)
-        int ret = localtime_s(buf, time);
-        return ret == 0 ? buf : nullptr;
-    } else {
-        static_assert(decltype(can_localtime_r(time, buf))::value,
-                      "<nanobind/stl/chrono.h> type caster requires "
-                      "that your C library support localtime_r or localtime_s");
-        std::tm* ret = localtime_r(time, buf);
-        return ret;
-    }
-}
-
-// Cast between times on the system clock and datetime.datetime instances
-// (also supports datetime.date and datetime.time for Python->C++ conversions)
-template <typename Duration>
-class type_caster<std::chrono::time_point<std::chrono::system_clock, Duration>> {
-public:
-    using type = std::chrono::time_point<std::chrono::system_clock, Duration>;
-    bool from_python(handle src, uint8_t /*flags*/, cleanup_list*) noexcept {
-        namespace ch = std::chrono;
-
-        if (!src)
-            return false;
-
-        std::tm cal;
-        ch::microseconds msecs;
-        int yy, mon, dd, hh, min, ss, uu;
-        try {
-            if (!unpack_datetime(src.ptr(), &yy, &mon, &dd,
-                                 &hh, &min, &ss, &uu)) {
-                return false;
-            }
-        } catch (python_error& e) {
-            e.discard_as_unraisable(src.ptr());
-            return false;
-        }
-        cal.tm_sec = ss;
-        cal.tm_min = min;
-        cal.tm_hour = hh;
-        cal.tm_mday = dd;
-        cal.tm_mon = mon - 1;
-        cal.tm_year = yy - 1900;
-        cal.tm_isdst = -1;
-        msecs = ch::microseconds(uu);
-        value = ch::time_point_cast<Duration>(
-                ch::system_clock::from_time_t(std::mktime(&cal)) + msecs);
-        return true;
-    }
-
-    static handle from_cpp(const type& src, rv_policy, cleanup_list*) noexcept {
-        namespace ch = std::chrono;
-
-        // Get out microseconds, and make sure they are positive, to
-        // avoid bug in eastern hemisphere time zones
-        // (cfr. https://github.com/pybind/pybind11/issues/2417). Note
-        // that if us_t is 32 bits and we get a time_point that also
-        // has a 32-bit time_since_epoch (perhaps because it's
-        // measuring time in minutes or something), then writing `src
-        // - us` below can lead to overflow based on how common_type
-        // is defined on durations. Defining us_t to store 64-bit
-        // microseconds works around this.
-        using us_t = ch::duration<std::int64_t, std::micro>;
-        auto us = ch::duration_cast<us_t>(src.time_since_epoch() %
-                                          ch::seconds(1));
-        if (us.count() < 0)
-            us += ch::seconds(1);
-
-        // Subtract microseconds BEFORE `system_clock::to_time_t`, because:
-        // > If std::time_t has lower precision, it is implementation-defined
-        //   whether the value is rounded or truncated.
-        // (https://en.cppreference.com/w/cpp/chrono/system_clock/to_time_t)
-        std::time_t tt = ch::system_clock::to_time_t(
-                ch::time_point_cast<ch::system_clock::duration>(src - us));
-
-        std::tm localtime;
-        if (!localtime_thread_safe(&tt, &localtime)) {
-            PyErr_Format(PyExc_ValueError,
-                         "Unable to represent system_clock in local time; "
-                         "got time_t %ld", static_cast<std::int64_t>(tt));
-            return handle();
-        }
-        return pack_datetime(localtime.tm_year + 1900,
-                             localtime.tm_mon + 1,
-                             localtime.tm_mday,
-                             localtime.tm_hour,
-                             localtime.tm_min,
-                             localtime.tm_sec,
-                             (int) us.count());
-    }
-    #if PY_VERSION_HEX < 0x03090000
-        NB_TYPE_CASTER(type, io_name("typing.Union[datetime.datetime, datetime.date, datetime.time]",
-                                     "datetime.datetime"))
-    #else
-        NB_TYPE_CASTER(type, io_name("datetime.datetime | datetime.date | datetime.time",
-                                     "datetime.datetime"))
-    #endif
-};
-
-// Other clocks that are not the system clock are not measured as
-// datetime.datetime objects since they are not measured on calendar
-// time. So instead we just make them timedeltas; or if they have
-// passed us a time as a float, we convert that.
-template <typename Clock, typename Duration>
-class type_caster<std::chrono::time_point<Clock, Duration>>
-  : public duration_caster<std::chrono::time_point<Clock, Duration>> {};
-
-template <typename Rep, typename Period>
-class type_caster<std::chrono::duration<Rep, Period>>
-  : public duration_caster<std::chrono::duration<Rep, Period>> {};
-
-NAMESPACE_END(detail)
-NAMESPACE_END(NB_NAMESPACE)
diff --git a/src/nanobind/include/nanobind/stl/complex.h b/src/nanobind/include/nanobind/stl/complex.h
deleted file mode 100644
index b40c02b..0000000
--- a/src/nanobind/include/nanobind/stl/complex.h
+++ /dev/null
@@ -1,54 +0,0 @@
-/*
-    nanobind/stl/complex.h: type caster for std::complex<...>
-
-    Copyright (c) 2023 Degottex Gilles and Wenzel Jakob
-    Copyright (c) 2025 High Performance Kernels LLC
-
-    All rights reserved. Use of this source code is governed by a
-    BSD-style license that can be found in the LICENSE file.
-*/
-
-#pragma once
-
-#include <nanobind/nanobind.h>
-#include <complex>
-
-NAMESPACE_BEGIN(NB_NAMESPACE)
-NAMESPACE_BEGIN(detail)
-
-NB_CORE bool load_cmplx(PyObject*, uint8_t flags, std::complex<double> *out) noexcept;
-
-template <typename T> struct type_caster<std::complex<T>> {
-    NB_TYPE_CASTER(std::complex<T>, const_name("complex"))
-
-    bool from_python(handle src, uint8_t flags, cleanup_list*) noexcept {
-        std::complex<double> cmplx;
-        if (!load_cmplx(src.ptr(), flags, &cmplx))
-            return false;
-        if constexpr (std::is_same_v<T, double>) {
-            value = cmplx;
-            return true;
-        } else {
-            T re = (T) cmplx.real();
-            T im = (T) cmplx.imag();
-            if ((flags & (uint8_t) cast_flags::convert)
-                    ||  (((double) re == cmplx.real()
-                             || (re != re && cmplx.real() != cmplx.real()))
-                      && ((double) im == cmplx.imag()
-                             || (im != im && cmplx.imag() != cmplx.imag())))) {
-                value = std::complex<T>(re, im);
-                return true;
-            }
-            return false;
-        }
-    }
-
-    static handle from_cpp(const std::complex<T>& value, rv_policy,
-                           cleanup_list*) noexcept {
-        return PyComplex_FromDoubles((double) value.real(),
-                                     (double) value.imag());
-    }
-};
-
-NAMESPACE_END(detail)
-NAMESPACE_END(NB_NAMESPACE)
diff --git a/src/nanobind/include/nanobind/stl/detail/chrono.h b/src/nanobind/include/nanobind/stl/detail/chrono.h
deleted file mode 100644
index b4815c5..0000000
--- a/src/nanobind/include/nanobind/stl/detail/chrono.h
+++ /dev/null
@@ -1,299 +0,0 @@
-/*
-    nanobind/stl/chrono.h: conversion between std::chrono and python's datetime
-
-    Copyright (c) 2023 Hudson River Trading LLC <opensource@hudson-trading.com>
-
-    All rights reserved. Use of this source code is governed by a
-    BSD-style license that can be found in the LICENSE file.
-*/
-#pragma once
-
-#include <nanobind/nanobind.h>
-
-// Functions for working with objects in the Python 'datetime' module,
-// used by the std::chrono type caster in <nanobind/stl/chrono.h>.
-// This is pretty straightforward except on Limited API builds.
-// Note that while PyPy does provide <datetime.h>, it implements
-// the macro-like calls there (PyDateTime_DATE_GET_HOUR, etc) as full
-// function calls that can fail. We use the limited-API logic on PyPy
-// in order to be able to handle errors better.
-
-#if !defined(Py_LIMITED_API) && !defined(PYPY_VERSION)
-#  include <datetime.h>
-#endif
-
-#if defined(__GNUC__)
-// warning: warning: declaration of '...' with attribute 'noinline' follows inline declaration
-#  pragma GCC diagnostic push
-#  pragma GCC diagnostic ignored "-Wattributes"
-#endif
-
-NAMESPACE_BEGIN(NB_NAMESPACE)
-NAMESPACE_BEGIN(detail)
-
-// Unpack a datetime.timedelta object into integer days, seconds, and
-// microseconds. Returns true if successful, false if `o` is not a timedelta,
-// or throws nb::python_error if something else went wrong.
-bool unpack_timedelta(PyObject *o, int *days, int *secs, int *usecs);
-
-// Unpack a datetime.date, datetime.time, or datetime.datetime object into
-// integer year, month, day, hour, minute, second, and microsecond fields.
-// Time objects will be considered to represent that time on Jan 1, 1970.
-// Date objects will be considered to represent midnight on that date.
-// Returns true if succesful, false if `o` is not a date, time, or datetime,
-// or throws nb::python_error if something else went wrong.
-bool unpack_datetime(PyObject *o, int *year, int *month, int *day,
-                     int *hour, int *minute, int *second,
-                     int *usec);
-
-// Create a datetime.timedelta object from integer days, seconds, and
-// microseconds.  Returns a new reference, or nullptr and sets the
-// Python error indicator on error.
-PyObject* pack_timedelta(int days, int secs, int usecs) noexcept;
-
-// Create a timezone-naive datetime.datetime object from its components.
-// Returns a new reference, or nullptr and sets the Python error indicator
-// on error.
-PyObject* pack_datetime(int year, int month, int day,
-                        int hour, int minute, int second,
-                        int usec) noexcept;
-
-// Note: Several of the functions defined in this header are marked
-// 'inline' for linkage purposes (since they might be in multiple
-// translation units and the linker should pick one) but NB_NOINLINE
-// because we don't want the bloat of actually inlining them. They are
-// defined in this header instead of in the built nanobind library in
-// order to avoid increasing the library size for users who don't care
-// about datetimes.
-
-#if defined(Py_LIMITED_API) || defined(PYPY_VERSION)
-
-struct datetime_types_t {
-    // Types defined by the datetime module
-    handle datetime;
-    handle time;
-    handle date;
-    handle timedelta;
-
-    // Ensure that the above four handles point to valid Python objects.
-    // If unable, throw nb::python_error.
-    void ensure_ready() {
-        if (datetime.is_valid())
-            return;
-
-        object mod = module_::import_("datetime");
-        object datetime_o = mod.attr("datetime");
-        object time_o = mod.attr("time");
-        object date_o = mod.attr("date");
-        object timedelta_o = mod.attr("timedelta");
-
-        // Leak references to these datetime types. We could improve upon
-        // this by storing them in the internals structure and decref'ing
-        // in internals_cleanup(), but it doesn't seem worthwhile for
-        // something this fundamental. We can't store nb::object in this
-        // structure because it might be destroyed after the Python
-        // interpreter has finalized.
-        datetime = datetime_o.release();
-        time = time_o.release();
-        date = date_o.release();
-        timedelta = timedelta_o.release();
-    }
-};
-
-inline datetime_types_t datetime_types;
-
-// Set *dest to the integer value of getattr(o, name). Returns true
-// on success, false and sets the Python error indicator on failure.
-// The attribute value must be a Python integer object; other types
-// of numbers are not supported.
-NB_NOINLINE inline bool set_from_int_attr(int *dest, PyObject *o,
-                                          const char *name) noexcept {
-    PyObject *value = PyObject_GetAttrString(o, name);
-    if (!value)
-        return false;
-    long lval = PyLong_AsLong(value);
-    if (lval == -1 && PyErr_Occurred()) {
-        Py_DECREF(value);
-        return false;
-    }
-    if (lval < std::numeric_limits<int>::min() ||
-        lval > std::numeric_limits<int>::max()) {
-        PyErr_Format(PyExc_OverflowError,
-                     "%R attribute '%s' (%R) does not fit in an int",
-                     o, name, value);
-        Py_DECREF(value);
-        return false;
-    }
-    Py_DECREF(value);
-    *dest = static_cast<int>(lval);
-    return true;
-}
-
-NB_NOINLINE inline bool unpack_timedelta(PyObject *o, int *days,
-                                         int *secs, int *usecs) {
-    datetime_types.ensure_ready();
-    if (PyType_IsSubtype(Py_TYPE(o),
-                         (PyTypeObject *) datetime_types.timedelta.ptr())) {
-        if (!set_from_int_attr(days, o, "days") ||
-            !set_from_int_attr(secs, o, "seconds") ||
-            !set_from_int_attr(usecs, o, "microseconds")) {
-            raise_python_error();
-        }
-        return true;
-    }
-    return false;
-}
-
-NB_NOINLINE inline bool unpack_datetime(PyObject *o,
-                                        int *year, int *month, int *day,
-                                        int *hour, int *minute, int *second,
-                                        int *usec) {
-    datetime_types.ensure_ready();
-    if (PyType_IsSubtype(Py_TYPE(o),
-                         (PyTypeObject *) datetime_types.datetime.ptr())) {
-        if (!set_from_int_attr(usec, o, "microsecond") ||
-            !set_from_int_attr(second, o, "second") ||
-            !set_from_int_attr(minute, o, "minute") ||
-            !set_from_int_attr(hour, o, "hour") ||
-            !set_from_int_attr(day, o, "day") ||
-            !set_from_int_attr(month, o, "month") ||
-            !set_from_int_attr(year, o, "year")) {
-            raise_python_error();
-        }
-        return true;
-    }
-    if (PyType_IsSubtype(Py_TYPE(o),
-                         (PyTypeObject *) datetime_types.date.ptr())) {
-        *usec = *second = *minute = *hour = 0;
-        if (!set_from_int_attr(day, o, "day") ||
-            !set_from_int_attr(month, o, "month") ||
-            !set_from_int_attr(year, o, "year")) {
-            raise_python_error();
-        }
-        return true;
-    }
-    if (PyType_IsSubtype(Py_TYPE(o),
-                         (PyTypeObject *) datetime_types.time.ptr())) {
-        *day = 1;
-        *month = 1;
-        *year = 1970;
-        if (!set_from_int_attr(usec, o, "microsecond") ||
-            !set_from_int_attr(second, o, "second") ||
-            !set_from_int_attr(minute, o, "minute") ||
-            !set_from_int_attr(hour, o, "hour")) {
-            raise_python_error();
-        }
-        return true;
-    }
-    return false;
-}
-
-inline PyObject* pack_timedelta(int days, int secs, int usecs) noexcept {
-    try {
-        datetime_types.ensure_ready();
-        return datetime_types.timedelta(days, secs, usecs).release().ptr();
-    } catch (python_error& e) {
-        e.restore();
-        return nullptr;
-    }
-}
-
-inline PyObject* pack_datetime(int year, int month, int day,
-                               int hour, int minute, int second,
-                               int usec) noexcept {
-    try {
-        datetime_types.ensure_ready();
-        return datetime_types.datetime(
-                year, month, day, hour, minute, second, usec).release().ptr();
-    } catch (python_error& e) {
-        e.restore();
-        return nullptr;
-    }
-}
-
-#else // !defined(Py_LIMITED_API) && !defined(PYPY_VERSION)
-
-NB_NOINLINE inline bool unpack_timedelta(PyObject *o, int *days,
-                                         int *secs, int *usecs) {
-    if (!PyDateTimeAPI) {
-        PyDateTime_IMPORT;
-        if (!PyDateTimeAPI)
-            raise_python_error();
-    }
-    if (PyDelta_Check(o)) {
-        *days = PyDateTime_DELTA_GET_DAYS(o);
-        *secs = PyDateTime_DELTA_GET_SECONDS(o);
-        *usecs = PyDateTime_DELTA_GET_MICROSECONDS(o);
-        return true;
-    }
-    return false;
-}
-
-NB_NOINLINE inline bool unpack_datetime(PyObject *o,
-                                        int *year, int *month, int *day,
-                                        int *hour, int *minute, int *second,
-                                        int *usec) {
-    if (!PyDateTimeAPI) {
-        PyDateTime_IMPORT;
-        if (!PyDateTimeAPI)
-            raise_python_error();
-    }
-    if (PyDateTime_Check(o)) {
-        *usec = PyDateTime_DATE_GET_MICROSECOND(o);
-        *second = PyDateTime_DATE_GET_SECOND(o);
-        *minute = PyDateTime_DATE_GET_MINUTE(o);
-        *hour = PyDateTime_DATE_GET_HOUR(o);
-        *day = PyDateTime_GET_DAY(o);
-        *month = PyDateTime_GET_MONTH(o);
-        *year = PyDateTime_GET_YEAR(o);
-        return true;
-    }
-    if (PyDate_Check(o)) {
-        *usec = 0;
-        *second = 0;
-        *minute = 0;
-        *hour = 0;
-        *day = PyDateTime_GET_DAY(o);
-        *month = PyDateTime_GET_MONTH(o);
-        *year = PyDateTime_GET_YEAR(o);
-        return true;
-    }
-    if (PyTime_Check(o)) {
-        *usec = PyDateTime_TIME_GET_MICROSECOND(o);
-        *second = PyDateTime_TIME_GET_SECOND(o);
-        *minute = PyDateTime_TIME_GET_MINUTE(o);
-        *hour = PyDateTime_TIME_GET_HOUR(o);
-        *day = 1;
-        *month = 1;
-        *year = 1970;
-        return true;
-    }
-    return false;
-}
-
-inline PyObject* pack_timedelta(int days, int secs, int usecs) noexcept {
-    if (!PyDateTimeAPI) {
-        PyDateTime_IMPORT;
-        if (!PyDateTimeAPI)
-            return nullptr;
-    }
-    return PyDelta_FromDSU(days, secs, usecs);
-}
-
-inline PyObject* pack_datetime(int year, int month, int day,
-                               int hour, int minute, int second,
-                               int usec) noexcept {
-    if (!PyDateTimeAPI) {
-        PyDateTime_IMPORT;
-        if (!PyDateTimeAPI)
-            return nullptr;
-    }
-    return PyDateTime_FromDateAndTime(year, month, day,
-                                      hour, minute, second, usec);
-}
-
-#endif // !defined(Py_LIMITED_API) && !defined(PYPY_VERSION)
-//
-#if defined(__GNUC__)
-#  pragma GCC diagnostic pop
-#endif
diff --git a/src/nanobind/include/nanobind/stl/detail/nb_array.h b/src/nanobind/include/nanobind/stl/detail/nb_array.h
deleted file mode 100644
index 728f9c5..0000000
--- a/src/nanobind/include/nanobind/stl/detail/nb_array.h
+++ /dev/null
@@ -1,67 +0,0 @@
-#pragma once
-
-#include <nanobind/nanobind.h>
-
-NAMESPACE_BEGIN(NB_NAMESPACE)
-NAMESPACE_BEGIN(detail)
-
-template <typename Array, typename Entry, size_t Size> struct array_caster {
-    NB_TYPE_CASTER(Array, io_name(NB_TYPING_SEQUENCE, NB_TYPING_LIST) +
-                              const_name("[") + make_caster<Entry>::Name +
-                              const_name("]"))
-
-    using Caster = make_caster<Entry>;
-
-    bool from_python(handle src, uint8_t flags, cleanup_list *cleanup) noexcept {
-        PyObject *temp;
-
-        /* Will initialize 'temp' (NULL in the case of a failure.) */
-        PyObject **o = seq_get_with_size(src.ptr(), Size, &temp);
-
-        Caster caster;
-        bool success = o != nullptr;
-
-        flags = flags_for_local_caster<Entry>(flags);
-
-        if (success) {
-            for (size_t i = 0; i < Size; ++i) {
-                if (!caster.from_python(o[i], flags, cleanup) ||
-                    !caster.template can_cast<Entry>()) {
-                    success = false;
-                    break;
-                }
-
-                value[i] = caster.operator cast_t<Entry>();
-            }
-
-            Py_XDECREF(temp);
-        }
-
-        return success;
-    }
-
-    template <typename T>
-    static handle from_cpp(T &&src, rv_policy policy, cleanup_list *cleanup) {
-        object ret = steal(PyList_New(Size));
-
-        if (ret.is_valid()) {
-            Py_ssize_t index = 0;
-
-            for (auto &value : src) {
-                handle h = Caster::from_cpp(forward_like_<T>(value), policy, cleanup);
-
-                if (!h.is_valid()) {
-                    ret.reset();
-                    break;
-                }
-
-                NB_LIST_SET_ITEM(ret.ptr(), index++, h.ptr());
-            }
-        }
-
-        return ret.release();
-    }
-};
-
-NAMESPACE_END(detail)
-NAMESPACE_END(NB_NAMESPACE)
diff --git a/src/nanobind/include/nanobind/stl/detail/nb_dict.h b/src/nanobind/include/nanobind/stl/detail/nb_dict.h
deleted file mode 100644
index 24f77ea..0000000
--- a/src/nanobind/include/nanobind/stl/detail/nb_dict.h
+++ /dev/null
@@ -1,95 +0,0 @@
-/*
-    nanobind/stl/detail/nb_dict.h: base class of dict casters
-
-    Copyright (c) 2022 Matej Ferencevic and Wenzel Jakob
-
-    All rights reserved. Use of this source code is governed by a
-    BSD-style license that can be found in the LICENSE file.
-*/
-
-#pragma once
-
-#include <nanobind/nanobind.h>
-
-NAMESPACE_BEGIN(NB_NAMESPACE)
-NAMESPACE_BEGIN(detail)
-
-template <typename Dict, typename Key, typename Val> struct dict_caster {
-    NB_TYPE_CASTER(Dict, io_name(NB_TYPING_MAPPING, NB_TYPING_DICT) +
-                             const_name("[") + make_caster<Key>::Name +
-                             const_name(", ") + make_caster<Val>::Name +
-                             const_name("]"))
-
-    using KeyCaster = make_caster<Key>;
-    using ValCaster = make_caster<Val>;
-
-    bool from_python(handle src, uint8_t flags, cleanup_list *cleanup) noexcept {
-        value.clear();
-
-        PyObject *items = PyMapping_Items(src.ptr());
-        if (items == nullptr) {
-            PyErr_Clear();
-            return false;
-        }
-
-        // 'items' is safe to access without locking and reference counting, it
-        // is unique to this thread
-        Py_ssize_t size = NB_LIST_GET_SIZE(items);
-        bool success = size >= 0;
-
-        uint8_t flags_key = flags_for_local_caster<Key>(flags),
-                flags_val = flags_for_local_caster<Val>(flags);
-
-        KeyCaster key_caster;
-        ValCaster val_caster;
-        for (Py_ssize_t i = 0; i < size; ++i) {
-            PyObject *item = NB_LIST_GET_ITEM(items, i);
-            PyObject *key = NB_TUPLE_GET_ITEM(item, 0);
-            PyObject *val = NB_TUPLE_GET_ITEM(item, 1);
-
-            if (!key_caster.from_python(key, flags_key, cleanup) ||
-                !key_caster.template can_cast<Key>()) {
-                success = false;
-                break;
-            }
-
-            if (!val_caster.from_python(val, flags_val, cleanup) ||
-                !val_caster.template can_cast<Val>()) {
-                success = false;
-                break;
-            }
-
-            value.emplace(key_caster.operator cast_t<Key>(),
-                          val_caster.operator cast_t<Val>());
-        }
-
-        Py_DECREF(items);
-
-        return success;
-    }
-
-    template <typename T>
-    static handle from_cpp(T &&src, rv_policy policy, cleanup_list *cleanup) {
-        dict ret;
-
-        if (ret.is_valid()) {
-            for (auto &item : src) {
-                object k = steal(KeyCaster::from_cpp(
-                    forward_like_<T>(item.first), policy, cleanup));
-                object e = steal(ValCaster::from_cpp(
-                    forward_like_<T>(item.second), policy, cleanup));
-
-                if (!k.is_valid() || !e.is_valid() ||
-                    PyDict_SetItem(ret.ptr(), k.ptr(), e.ptr()) != 0) {
-                    ret.reset();
-                    break;
-                }
-            }
-        }
-
-        return ret.release();
-    }
-};
-
-NAMESPACE_END(detail)
-NAMESPACE_END(NB_NAMESPACE)
diff --git a/src/nanobind/include/nanobind/stl/detail/nb_list.h b/src/nanobind/include/nanobind/stl/detail/nb_list.h
deleted file mode 100644
index 5874f7d..0000000
--- a/src/nanobind/include/nanobind/stl/detail/nb_list.h
+++ /dev/null
@@ -1,83 +0,0 @@
-/*
-    nanobind/stl/detail/nb_list.h: base class of list casters
-
-    Copyright (c) 2022 Wenzel Jakob
-
-    All rights reserved. Use of this source code is governed by a
-    BSD-style license that can be found in the LICENSE file.
-*/
-
-#pragma once
-
-#include <nanobind/nanobind.h>
-
-NAMESPACE_BEGIN(NB_NAMESPACE)
-NAMESPACE_BEGIN(detail)
-
-template <typename List, typename Entry> struct list_caster {
-    NB_TYPE_CASTER(List, io_name(NB_TYPING_SEQUENCE, NB_TYPING_LIST) +
-                              const_name("[") + make_caster<Entry>::Name +
-                              const_name("]"))
-
-    using Caster = make_caster<Entry>;
-
-    template <typename T> using has_reserve = decltype(std::declval<T>().reserve(0));
-
-    bool from_python(handle src, uint8_t flags, cleanup_list *cleanup) noexcept {
-        size_t size;
-        PyObject *temp;
-
-        /* Will initialize 'size' and 'temp'. All return values and
-           return parameters are zero/NULL in the case of a failure. */
-        PyObject **o = seq_get(src.ptr(), &size, &temp);
-
-        value.clear();
-
-        if constexpr (is_detected_v<has_reserve, List>)
-            value.reserve(size);
-
-        Caster caster;
-        bool success = o != nullptr;
-
-        flags = flags_for_local_caster<Entry>(flags);
-
-        for (size_t i = 0; i < size; ++i) {
-            if (!caster.from_python(o[i], flags, cleanup) ||
-                !caster.template can_cast<Entry>()) {
-                success = false;
-                break;
-            }
-
-            value.push_back(caster.operator cast_t<Entry>());
-        }
-
-        Py_XDECREF(temp);
-
-        return success;
-    }
-
-    template <typename T>
-    static handle from_cpp(T &&src, rv_policy policy, cleanup_list *cleanup) {
-        object ret = steal(PyList_New(src.size()));
-
-        if (ret.is_valid()) {
-            Py_ssize_t index = 0;
-
-            for (auto &&value : src) {
-                handle h = Caster::from_cpp(forward_like_<T>(value), policy, cleanup);
-
-                if (!h.is_valid()) {
-                    ret.reset();
-                    break;
-                }
-
-                NB_LIST_SET_ITEM(ret.ptr(), index++, h.ptr());
-            }
-        }
-
-        return ret.release();
-    }
-};
-
-NAMESPACE_END(detail)
-NAMESPACE_END(NB_NAMESPACE)
diff --git a/src/nanobind/include/nanobind/stl/detail/nb_optional.h b/src/nanobind/include/nanobind/stl/detail/nb_optional.h
deleted file mode 100644
index deda218..0000000
--- a/src/nanobind/include/nanobind/stl/detail/nb_optional.h
+++ /dev/null
@@ -1,49 +0,0 @@
-/*
-    nanobind/stl/optional.h: type caster for std::optional<...>
-
-    Copyright (c) 2022 Yoshiki Matsuda and Wenzel Jakob
-
-    All rights reserved. Use of this source code is governed by a
-    BSD-style license that can be found in the LICENSE file.
-*/
-
-#pragma once
-
-#include <nanobind/nanobind.h>
-
-NAMESPACE_BEGIN(NB_NAMESPACE)
-NAMESPACE_BEGIN(detail)
-
-template <typename Optional, typename T = typename Optional::value_type>
-struct optional_caster {
-    using Caster = make_caster<T>;
-
-    NB_TYPE_CASTER(Optional, optional_name(Caster::Name))
-
-    bool from_python(handle src, uint8_t flags, cleanup_list* cleanup) noexcept {
-        if (src.is_none()) {
-            value.reset();
-            return true;
-        }
-
-        Caster caster;
-        if (!caster.from_python(src, flags_for_local_caster<T>(flags), cleanup) ||
-            !caster.template can_cast<T>())
-            return false;
-
-        value.emplace(caster.operator cast_t<T>());
-
-        return true;
-    }
-
-    template <typename T_>
-    static handle from_cpp(T_ &&value, rv_policy policy, cleanup_list *cleanup) noexcept {
-        if (!value)
-            return none().release();
-
-        return Caster::from_cpp(forward_like_<T_>(*value), policy, cleanup);
-    }
-};
-
-NAMESPACE_END(detail)
-NAMESPACE_END(NB_NAMESPACE)
diff --git a/src/nanobind/include/nanobind/stl/detail/nb_set.h b/src/nanobind/include/nanobind/stl/detail/nb_set.h
deleted file mode 100644
index d3a3250..0000000
--- a/src/nanobind/include/nanobind/stl/detail/nb_set.h
+++ /dev/null
@@ -1,81 +0,0 @@
-/*
-    nanobind/stl/detail/nb_set.h: base class of set casters
-
-    Copyright (c) 2022 Raymond Yun Fei and Wenzel Jakob
-
-    All rights reserved. Use of this source code is governed by a
-    BSD-style license that can be found in the LICENSE file.
-*/
-
-#pragma once
-
-#include <nanobind/nanobind.h>
-
-NAMESPACE_BEGIN(NB_NAMESPACE)
-NAMESPACE_BEGIN(detail)
-
-template <typename Set, typename Key> struct set_caster {
-    NB_TYPE_CASTER(Set, io_name(NB_TYPING_ABSTRACT_SET, NB_TYPING_SET) +
-                            const_name("[") + make_caster<Key>::Name +
-                            const_name("]"))
-
-    using Caster = make_caster<Key>;
-
-    bool from_python(handle src, uint8_t flags, cleanup_list *cleanup) noexcept {
-        value.clear();
-
-        PyObject* iter = PyObject_GetIter(src.ptr());
-        if (!iter) {
-            PyErr_Clear();
-            return false;
-        }
-
-        bool success = true;
-        Caster key_caster;
-        PyObject *key;
-
-        flags = flags_for_local_caster<Key>(flags);
-
-        while ((key = PyIter_Next(iter)) != nullptr) {
-            success &= (key_caster.from_python(key, flags, cleanup) &&
-                        key_caster.template can_cast<Key>());
-            Py_DECREF(key);
-
-            if (!success)
-                break;
-
-            value.emplace(key_caster.operator cast_t<Key>());
-        }
-
-        if (PyErr_Occurred()) {
-            PyErr_Clear();
-            success = false;
-        }
-
-        Py_DECREF(iter);
-
-        return success;
-    }
-
-    template <typename T>
-    static handle from_cpp(T &&src, rv_policy policy, cleanup_list *cleanup) {
-        object ret = steal(PySet_New(nullptr));
-
-        if (ret.is_valid()) {
-            for (auto& key : src) {
-                object k = steal(
-                    Caster::from_cpp(forward_like_<T>(key), policy, cleanup));
-
-                if (!k.is_valid() || PySet_Add(ret.ptr(), k.ptr()) != 0) {
-                    ret.reset();
-                    break;
-                }
-            }
-        }
-
-        return ret.release();
-    }
-};
-
-NAMESPACE_END(detail)
-NAMESPACE_END(NB_NAMESPACE)
diff --git a/src/nanobind/include/nanobind/stl/detail/traits.h b/src/nanobind/include/nanobind/stl/detail/traits.h
deleted file mode 100644
index 24917c3..0000000
--- a/src/nanobind/include/nanobind/stl/detail/traits.h
+++ /dev/null
@@ -1,92 +0,0 @@
-/*
-    nanobind/stl/detail/traits.h: detail::is_copy_constructible<T>
-    partial overloads for STL types
-
-    Adapted from pybind11.
-
-    All rights reserved. Use of this source code is governed by a
-    BSD-style license that can be found in the LICENSE file.
-*/
-
-#pragma once
-
-#include <nanobind/nanobind.h>
-
-NAMESPACE_BEGIN(NB_NAMESPACE)
-NAMESPACE_BEGIN(detail)
-
-/* The builtin `std::is_copy_constructible` type trait merely checks whether
-   a copy constructor is present and returns `true` even when the this copy
-   constructor cannot be compiled. This a problem for older STL types like
-   `std::vector<T>` when `T` is noncopyable. The alternative below recurses
-   into STL types to work around this problem. */
-
-template <typename T>
-struct is_copy_constructible<
-    T, enable_if_t<
-           std::is_same_v<typename T::value_type &, typename T::reference> &&
-           std::is_copy_constructible_v<T> &&
-           !std::is_same_v<T, typename T::value_type>>> {
-    static constexpr bool value =
-        is_copy_constructible<typename T::value_type>::value;
-};
-
-// std::pair is copy-constructible <=> both constituents are copy-constructible
-template <typename T1, typename T2>
-struct is_copy_constructible<std::pair<T1, T2>> {
-    static constexpr bool value =
-        is_copy_constructible<T1>::value &&
-        is_copy_constructible<T2>::value;
-};
-
-// Analogous template for checking copy-assignability
-template <typename T, typename SFINAE = int>
-struct is_copy_assignable : std::is_copy_assignable<T> { };
-
-template <typename T>
-struct is_copy_assignable<T,
-                          enable_if_t<std::is_copy_assignable_v<T> &&
-                                      std::is_same_v<typename T::value_type &,
-                                                     typename T::reference>>> {
-    static constexpr bool value = is_copy_assignable<typename T::value_type>::value;
-};
-
-template <typename T1, typename T2>
-struct is_copy_assignable<std::pair<T1, T2>> {
-    static constexpr bool value =
-            is_copy_assignable<T1>::value &&
-            is_copy_assignable<T2>::value;
-};
-
-template <typename T>
-constexpr bool is_copy_assignable_v = is_copy_assignable<T>::value;
-
-// Analogous template for checking comparability
-template <typename T> using comparable_test = decltype(std::declval<T>() == std::declval<T>());
-
-template <typename T, typename SFINAE = int>
-struct is_equality_comparable {
-    static constexpr bool value = is_detected_v<comparable_test, T>;
-};
-
-template <typename T>
-struct is_equality_comparable<T, enable_if_t<is_detected_v<comparable_test, T> &&
-                                      std::is_same_v<typename T::value_type &,
-                                                     typename T::reference>>> {
-    static constexpr bool value = is_equality_comparable<typename T::value_type>::value;
-};
-
-template <typename T1, typename T2>
-struct is_equality_comparable<std::pair<T1, T2>> {
-    static constexpr bool value =
-            is_equality_comparable<T1>::value &&
-            is_equality_comparable<T2>::value;
-};
-
-
-template <typename T>
-constexpr bool is_equality_comparable_v = is_equality_comparable<T>::value;
-
-NAMESPACE_END(detail)
-NAMESPACE_END(NB_NAMESPACE)
-
diff --git a/src/nanobind/include/nanobind/stl/filesystem.h b/src/nanobind/include/nanobind/stl/filesystem.h
deleted file mode 100644
index 78af550..0000000
--- a/src/nanobind/include/nanobind/stl/filesystem.h
+++ /dev/null
@@ -1,93 +0,0 @@
-/*
-    nanobind/stl/filesystem.h: type caster for std::filesystem
-
-    Copyright (c) 2023 Qingnan Zhou and Wenzel Jakob
-
-    All rights reserved. Use of this source code is governed by a
-    BSD-style license that can be found in the LICENSE file.
-*/
-#pragma once
-
-#include <nanobind/nanobind.h>
-
-#include <filesystem>
-#include <string>
-
-NAMESPACE_BEGIN(NB_NAMESPACE)
-NAMESPACE_BEGIN(detail)
-
-template <>
-struct type_caster<std::filesystem::path> {
-
-    static handle from_cpp(const std::filesystem::path &path, rv_policy,
-                           cleanup_list *) noexcept {
-        str py_str = to_py_str(path.native());
-        if (py_str.is_valid()) {
-            try {
-                return module_::import_("pathlib")
-                    .attr("Path")(py_str)
-                    .release();
-            } catch (python_error &e) {
-                e.restore();
-            }
-        }
-        return handle();
-    }
-
-    template <typename Char = typename std::filesystem::path::value_type>
-    bool from_python(handle src, uint8_t, cleanup_list *) noexcept {
-        bool success = false;
-
-        /* PyUnicode_FSConverter and PyUnicode_FSDecoder normally take care of
-           calling PyOS_FSPath themselves, but that's broken on PyPy (see PyPy
-           issue #3168) so we do it ourselves instead. */
-        PyObject *buf = PyOS_FSPath(src.ptr());
-        if (buf) {
-            PyObject *native = nullptr;
-            if constexpr (std::is_same_v<Char, char>) {
-                if (PyUnicode_FSConverter(buf, &native)) {
-                    if (char* s = PyBytes_AsString(native)) {
-                        value = s; // Points to internal buffer, no need to free
-                        success = true;
-                    }
-                }
-            } else {
-                if (PyUnicode_FSDecoder(buf, &native)) {
-                    if (wchar_t *s = PyUnicode_AsWideCharString(native, nullptr)) {
-                        value = s;
-                        PyMem_Free(s); // New string, must free
-                        success = true;
-                    }
-                }
-            }
-
-            Py_DECREF(buf);
-            Py_XDECREF(native);
-        }
-
-        if (!success)
-            PyErr_Clear();
-
-        return success;
-    }
-
-#if PY_VERSION_HEX < 0x03090000
-    NB_TYPE_CASTER(std::filesystem::path, io_name("typing.Union[str, os.PathLike]", "pathlib.Path"))
-#else
-    NB_TYPE_CASTER(std::filesystem::path, io_name("str | os.PathLike", "pathlib.Path"))
-#endif
-
-private:
-    static str to_py_str(const std::string &s) {
-        return steal<str>(
-            PyUnicode_DecodeFSDefaultAndSize(s.c_str(), (Py_ssize_t) s.size()));
-    }
-
-    static str to_py_str(const std::wstring &s) {
-        return steal<str>(
-            PyUnicode_FromWideChar(s.c_str(), (Py_ssize_t) s.size()));
-    }
-};
-
-NAMESPACE_END(detail)
-NAMESPACE_END(NB_NAMESPACE)
diff --git a/src/nanobind/include/nanobind/stl/function.h b/src/nanobind/include/nanobind/stl/function.h
deleted file mode 100644
index b962340..0000000
--- a/src/nanobind/include/nanobind/stl/function.h
+++ /dev/null
@@ -1,95 +0,0 @@
-/*
-    nanobind/stl/function.h: type caster for std::function<...>
-
-    Copyright (c) 2022 Wenzel Jakob
-
-    All rights reserved. Use of this source code is governed by a
-    BSD-style license that can be found in the LICENSE file.
-*/
-
-#pragma once
-
-#include <nanobind/nanobind.h>
-#include <functional>
-
-NAMESPACE_BEGIN(NB_NAMESPACE)
-NAMESPACE_BEGIN(detail)
-
-struct pyfunc_wrapper {
-    PyObject *f;
-
-    explicit pyfunc_wrapper(PyObject *f) : f(f) {
-        Py_INCREF(f);
-    }
-
-    pyfunc_wrapper(pyfunc_wrapper &&w) noexcept : f(w.f) {
-        w.f = nullptr;
-    }
-
-    pyfunc_wrapper(const pyfunc_wrapper &w) : f(w.f) {
-        if (f) {
-            gil_scoped_acquire acq;
-            Py_INCREF(f);
-        }
-    }
-
-    ~pyfunc_wrapper() {
-        if (f) {
-            gil_scoped_acquire acq;
-            Py_DECREF(f);
-        }
-    }
-
-    pyfunc_wrapper &operator=(const pyfunc_wrapper) = delete;
-    pyfunc_wrapper &operator=(pyfunc_wrapper &&) = delete;
-};
-
-template <typename Return, typename... Args>
-struct type_caster<std::function<Return(Args...)>> {
-    using ReturnCaster = make_caster<
-        std::conditional_t<std::is_void_v<Return>, void_type, Return>>;
-
-    NB_TYPE_CASTER(std::function <Return(Args...)>,
-                   const_name(NB_TYPING_CALLABLE "[[") +
-                       concat(make_caster<Args>::Name...) + const_name("], ") +
-                       ReturnCaster::Name + const_name("]"))
-
-    struct pyfunc_wrapper_t : pyfunc_wrapper {
-        using pyfunc_wrapper::pyfunc_wrapper;
-
-        Return operator()(Args... args) const {
-            gil_scoped_acquire acq;
-            return cast<Return>(handle(f)((forward_t<Args>) args...));
-        }
-    };
-
-    bool from_python(handle src, uint8_t flags, cleanup_list *) noexcept {
-        if (src.is_none())
-            return flags & cast_flags::convert;
-
-        if (!PyCallable_Check(src.ptr()))
-            return false;
-
-        value = pyfunc_wrapper_t(src.ptr());
-
-        return true;
-    }
-
-    static handle from_cpp(const Value &value, rv_policy rvp,
-                           cleanup_list *) noexcept {
-        const pyfunc_wrapper_t *wrapper = value.template target<pyfunc_wrapper_t>();
-        if (wrapper)
-            return handle(wrapper->f).inc_ref();
-
-        if (rvp == rv_policy::none)
-            return handle();
-
-        if (!value)
-            return none().release();
-
-        return cpp_function(value).release();
-    }
-};
-
-NAMESPACE_END(detail)
-NAMESPACE_END(NB_NAMESPACE)
diff --git a/src/nanobind/include/nanobind/stl/list.h b/src/nanobind/include/nanobind/stl/list.h
deleted file mode 100644
index 2073003..0000000
--- a/src/nanobind/include/nanobind/stl/list.h
+++ /dev/null
@@ -1,22 +0,0 @@
-/*
-    nanobind/stl/list.h: type caster for std::list<...>
-
-    Copyright (c) 2022 Wenzel Jakob
-
-    All rights reserved. Use of this source code is governed by a
-    BSD-style license that can be found in the LICENSE file.
-*/
-
-#pragma once
-
-#include "detail/nb_list.h"
-#include <list>
-
-NAMESPACE_BEGIN(NB_NAMESPACE)
-NAMESPACE_BEGIN(detail)
-
-template <typename Type, typename Alloc> struct type_caster<std::list<Type, Alloc>>
- : list_caster<std::list<Type, Alloc>, Type> { };
-
-NAMESPACE_END(detail)
-NAMESPACE_END(NB_NAMESPACE)
diff --git a/src/nanobind/include/nanobind/stl/map.h b/src/nanobind/include/nanobind/stl/map.h
deleted file mode 100644
index 48cdcab..0000000
--- a/src/nanobind/include/nanobind/stl/map.h
+++ /dev/null
@@ -1,23 +0,0 @@
-/*
-    nanobind/stl/map.h: type caster for std::map<...>
-
-    Copyright (c) 2022 Matej Ferencevic and Wenzel Jakob
-
-    All rights reserved. Use of this source code is governed by a
-    BSD-style license that can be found in the LICENSE file.
-*/
-
-#pragma once
-
-#include "detail/nb_dict.h"
-#include <map>
-
-NAMESPACE_BEGIN(NB_NAMESPACE)
-NAMESPACE_BEGIN(detail)
-
-template <typename Key, typename T, typename Compare, typename Alloc>
-struct type_caster<std::map<Key, T, Compare, Alloc>>
- : dict_caster<std::map<Key, T, Compare, Alloc>, Key, T> { };
-
-NAMESPACE_END(detail)
-NAMESPACE_END(NB_NAMESPACE)
diff --git a/src/nanobind/include/nanobind/stl/optional.h b/src/nanobind/include/nanobind/stl/optional.h
deleted file mode 100644
index 61ca923..0000000
--- a/src/nanobind/include/nanobind/stl/optional.h
+++ /dev/null
@@ -1,27 +0,0 @@
-/*
-    nanobind/stl/optional.h: type caster for std::optional<...>
-
-    Copyright (c) 2022 Yoshiki Matsuda and Wenzel Jakob
-
-    All rights reserved. Use of this source code is governed by a
-    BSD-style license that can be found in the LICENSE file.
-*/
-
-#pragma once
-
-#include "detail/nb_optional.h"
-#include <optional>
-
-NAMESPACE_BEGIN(NB_NAMESPACE)
-NAMESPACE_BEGIN(detail)
-
-template <typename T> struct remove_opt_mono<std::optional<T>>
-    : remove_opt_mono<T> { };
-
-template <typename T>
-struct type_caster<std::optional<T>> : optional_caster<std::optional<T>> {};
-
-template <> struct type_caster<std::nullopt_t> : none_caster<std::nullopt_t> { };
-
-NAMESPACE_END(detail)
-NAMESPACE_END(NB_NAMESPACE)
diff --git a/src/nanobind/include/nanobind/stl/pair.h b/src/nanobind/include/nanobind/stl/pair.h
deleted file mode 100644
index 596b3d3..0000000
--- a/src/nanobind/include/nanobind/stl/pair.h
+++ /dev/null
@@ -1,92 +0,0 @@
-/*
-    nanobind/stl/pair.h: type caster for std::pair<...>
-
-    Copyright (c) 2022 Wenzel Jakob
-
-    All rights reserved. Use of this source code is governed by a
-    BSD-style license that can be found in the LICENSE file.
-*/
-
-#pragma once
-
-#include <nanobind/nanobind.h>
-#include <utility>
-
-NAMESPACE_BEGIN(NB_NAMESPACE)
-NAMESPACE_BEGIN(detail)
-
-template <typename T1, typename T2> struct type_caster<std::pair<T1, T2>> {
-    using Value = std::pair<T1, T2>;
-
-    // Sub type casters
-    using Caster1 = make_caster<T1>;
-    using Caster2 = make_caster<T2>;
-
-    /// This caster constructs instances on the fly (otherwise it would not be
-    /// able to handle pairs containing references). Because of this, only the
-    /// `operator Value()` cast operator is implemented below, and the type
-    /// alias below informs users of this class of this fact.
-    template <typename T> using Cast = Value;
-
-    // Value name for docstring generation
-    static constexpr auto Name =
-        const_name(NB_TYPING_TUPLE "[") + concat(Caster1::Name, Caster2::Name) + const_name("]");
-
-    /// Python -> C++ caster, populates `caster1` and `caster2` upon success
-    bool from_python(handle src, uint8_t flags,
-                     cleanup_list *cleanup) noexcept {
-        PyObject *temp; // always initialized by the following line
-        PyObject **o = seq_get_with_size(src.ptr(), 2, &temp);
-
-        bool success = o &&
-                       caster1.from_python(o[0], flags, cleanup) &&
-                       caster2.from_python(o[1], flags, cleanup);
-
-        Py_XDECREF(temp);
-
-        return success;
-    }
-
-    template <typename T>
-    static handle from_cpp(T *value, rv_policy policy, cleanup_list *cleanup) {
-        if (!value)
-            return none().release();
-        return from_cpp(*value, policy, cleanup);
-    }
-
-    template <typename T>
-    static handle from_cpp(T &&value, rv_policy policy,
-                           cleanup_list *cleanup) noexcept {
-        object o1 = steal(
-            Caster1::from_cpp(forward_like_<T>(value.first), policy, cleanup));
-        if (!o1.is_valid())
-            return {};
-
-        object o2 = steal(
-            Caster2::from_cpp(forward_like_<T>(value.second), policy, cleanup));
-        if (!o2.is_valid())
-            return {};
-
-        PyObject *r = PyTuple_New(2);
-        NB_TUPLE_SET_ITEM(r, 0, o1.release().ptr());
-        NB_TUPLE_SET_ITEM(r, 1, o2.release().ptr());
-        return r;
-    }
-
-    template <typename T>
-    bool can_cast() const noexcept {
-        return caster1.template can_cast<T1>() && caster2.template can_cast<T2>();
-    }
-
-    /// Return the constructed tuple by copying from the sub-casters
-    explicit operator Value() {
-        return Value(caster1.operator cast_t<T1>(),
-                     caster2.operator cast_t<T2>());
-    }
-
-    Caster1 caster1;
-    Caster2 caster2;
-};
-
-NAMESPACE_END(detail)
-NAMESPACE_END(NB_NAMESPACE)
diff --git a/src/nanobind/include/nanobind/stl/set.h b/src/nanobind/include/nanobind/stl/set.h
deleted file mode 100644
index 69b7e21..0000000
--- a/src/nanobind/include/nanobind/stl/set.h
+++ /dev/null
@@ -1,24 +0,0 @@
-/*
-    nanobind/stl/set.h: type caster for std::set<...>
-
-    Copyright (c) 2022 Raymond Yun Fei and Wenzel Jakob
-
-    All rights reserved. Use of this source code is governed by a
-    BSD-style license that can be found in the LICENSE file.
-*/
-
-#pragma once
-
-#include "detail/nb_set.h"
-#include <set>
-
-NAMESPACE_BEGIN(NB_NAMESPACE)
-NAMESPACE_BEGIN(detail)
-
-template <typename Key, typename Compare, typename Alloc>
-struct type_caster<std::set<Key, Compare, Alloc>>
-    : set_caster<std::set<Key, Compare, Alloc>, Key> {
-};
-
-NAMESPACE_END(detail)
-NAMESPACE_END(NB_NAMESPACE)
diff --git a/src/nanobind/include/nanobind/stl/shared_ptr.h b/src/nanobind/include/nanobind/stl/shared_ptr.h
deleted file mode 100644
index a9a8654..0000000
--- a/src/nanobind/include/nanobind/stl/shared_ptr.h
+++ /dev/null
@@ -1,137 +0,0 @@
-/*
-    nanobind/stl/shared_ptr.h: Type caster for std::shared_ptr<T>
-
-    Copyright (c) 2022 Wenzel Jakob
-
-    All rights reserved. Use of this source code is governed by a
-    BSD-style license that can be found in the LICENSE file.
-*/
-
-#pragma once
-
-#include <nanobind/nanobind.h>
-#include <memory>
-
-NAMESPACE_BEGIN(NB_NAMESPACE)
-NAMESPACE_BEGIN(detail)
-
-// shared_ptr deleter that reduces the reference count of a Python object
-struct py_deleter {
-    void operator()(void *) noexcept {
-        // Don't run the deleter if the interpreter has been shut down
-        if (!is_alive())
-            return;
-        gil_scoped_acquire guard;
-        Py_DECREF(o);
-    }
-
-    PyObject *o;
-};
-
-/**
- * Create a std::shared_ptr for `ptr` that owns a reference to the Python
- * object `h`; if `ptr` is non-null, then the refcount of `h` is incremented
- * before creating the shared_ptr and decremented by its deleter.
- *
- * Usually this is instantiated with T = void, to reduce template bloat.
- * But if the pointee type uses enable_shared_from_this, we instantiate
- * with T = that type, in order to allow its internal weak_ptr to share
- * ownership with the shared_ptr we're creating.
- *
- * The next two functions are simultaneously marked as 'inline' (to avoid
- * linker errors) and 'NB_NOINLINE' (to avoid them being inlined into every
- * single shared_ptr type_caster, which would enlarge the binding size)
- */
-template <typename T>
-inline NB_NOINLINE std::shared_ptr<T>
-shared_from_python(T *ptr, handle h) noexcept {
-    if (ptr)
-        return std::shared_ptr<T>(ptr, py_deleter{ h.inc_ref().ptr() });
-    else
-        return std::shared_ptr<T>(nullptr);
-}
-
-inline NB_NOINLINE void shared_from_cpp(std::shared_ptr<void> &&ptr,
-                                        PyObject *o) noexcept {
-    keep_alive(o, new std::shared_ptr<void>(std::move(ptr)),
-               [](void *p) noexcept { delete (std::shared_ptr<void> *) p; });
-}
-
-template <typename T> struct type_caster<std::shared_ptr<T>> {
-    static constexpr bool IsClass = true;
-    using Caster = make_caster<T>;
-    using Td = std::decay_t<T>;
-
-    NB_TYPE_CASTER(std::shared_ptr<T>, Caster::Name)
-
-    static_assert(is_base_caster_v<Caster>,
-                  "Conversion of ``shared_ptr<T>`` requires that ``T`` is "
-                  "handled by nanobind's regular class binding mechanism. "
-                  "However, a type caster was registered to intercept this "
-                  "particular type, which is not allowed.");
-
-    bool from_python(handle src, uint8_t flags,
-                     cleanup_list *cleanup) noexcept {
-        Caster caster;
-        if (!caster.from_python(src, flags, cleanup))
-            return false;
-
-        Td *ptr = caster.operator Td *();
-        if constexpr (has_shared_from_this_v<T>) {
-            if (ptr) {
-                if (auto sp = ptr->weak_from_this().lock()) {
-                    // There is already a C++ shared_ptr for this object. Use it.
-                    value = std::static_pointer_cast<T>(std::move(sp));
-                    return true;
-                }
-            }
-            // Otherwise create a new one. Use shared_from_python<T>(...)
-            // so that future calls to ptr->shared_from_this() can share
-            // ownership with it.
-            value = shared_from_python(ptr, src);
-        } else {
-            value = std::static_pointer_cast<T>(
-                shared_from_python(static_cast<void *>(ptr), src));
-        }
-        return true;
-    }
-
-    static handle from_cpp(const Value &value, rv_policy,
-                           cleanup_list *cleanup) noexcept {
-        bool is_new = false;
-        handle result;
-
-        Td *ptr = (Td *) value.get();
-        const std::type_info *type = &typeid(Td);
-
-        constexpr bool has_type_hook =
-            !std::is_base_of_v<std::false_type, type_hook<Td>>;
-        if constexpr (has_type_hook)
-            type = type_hook<Td>::get(ptr);
-
-        if constexpr (!std::is_polymorphic_v<Td>) {
-            result = nb_type_put(type, ptr, rv_policy::reference,
-                                 cleanup, &is_new);
-        } else {
-            const std::type_info *type_p =
-                (!has_type_hook && ptr) ? &typeid(*ptr) : nullptr;
-
-            result = nb_type_put_p(type, type_p, ptr, rv_policy::reference,
-                                   cleanup, &is_new);
-        }
-
-        if (is_new) {
-            std::shared_ptr<void> pp;
-            if constexpr (std::is_const_v<T>)
-                pp = std::static_pointer_cast<void>(std::const_pointer_cast<Td>(value));
-            else
-                pp = std::static_pointer_cast<void>(value);
-            shared_from_cpp(std::move(pp), result.ptr());
-        }
-
-        return result;
-    }
-};
-
-NAMESPACE_END(detail)
-NAMESPACE_END(NB_NAMESPACE)
diff --git a/src/nanobind/include/nanobind/stl/string.h b/src/nanobind/include/nanobind/stl/string.h
deleted file mode 100644
index abf8281..0000000
--- a/src/nanobind/include/nanobind/stl/string.h
+++ /dev/null
@@ -1,39 +0,0 @@
-/*
-    nanobind/stl/string.h: type caster for std::string
-
-    Copyright (c) 2022 Wenzel Jakob
-
-    All rights reserved. Use of this source code is governed by a
-    BSD-style license that can be found in the LICENSE file.
-*/
-
-#pragma once
-
-#include <nanobind/nanobind.h>
-#include <string>
-
-NAMESPACE_BEGIN(NB_NAMESPACE)
-NAMESPACE_BEGIN(detail)
-
-template <> struct type_caster<std::string> {
-    NB_TYPE_CASTER(std::string, const_name("str"))
-
-    bool from_python(handle src, uint8_t, cleanup_list *) noexcept {
-        Py_ssize_t size;
-        const char *str = PyUnicode_AsUTF8AndSize(src.ptr(), &size);
-        if (!str) {
-            PyErr_Clear();
-            return false;
-        }
-        value = std::string(str, (size_t) size);
-        return true;
-    }
-
-    static handle from_cpp(const std::string &value, rv_policy,
-                           cleanup_list *) noexcept {
-        return PyUnicode_FromStringAndSize(value.c_str(), value.size());
-    }
-};
-
-NAMESPACE_END(detail)
-NAMESPACE_END(NB_NAMESPACE)
diff --git a/src/nanobind/include/nanobind/stl/string_view.h b/src/nanobind/include/nanobind/stl/string_view.h
deleted file mode 100644
index 62cc774..0000000
--- a/src/nanobind/include/nanobind/stl/string_view.h
+++ /dev/null
@@ -1,39 +0,0 @@
-/*
-    nanobind/stl/string_view.h: type caster for std::string_view
-
-    Copyright (c) 2022 Qingnan Zhou and Wenzel Jakob
-
-    All rights reserved. Use of this source code is governed by a
-    BSD-style license that can be found in the LICENSE file.
-*/
-
-#pragma once
-
-#include <nanobind/nanobind.h>
-#include <string_view>
-
-NAMESPACE_BEGIN(NB_NAMESPACE)
-NAMESPACE_BEGIN(detail)
-
-template <> struct type_caster<std::string_view> {
-    NB_TYPE_CASTER(std::string_view, const_name("str"))
-
-    bool from_python(handle src, uint8_t, cleanup_list *) noexcept {
-        Py_ssize_t size;
-        const char *str = PyUnicode_AsUTF8AndSize(src.ptr(), &size);
-        if (!str) {
-            PyErr_Clear();
-            return false;
-        }
-        value = std::string_view(str, (size_t) size);
-        return true;
-    }
-
-    static handle from_cpp(std::string_view value, rv_policy,
-                           cleanup_list *) noexcept {
-        return PyUnicode_FromStringAndSize(value.data(), value.size());
-    }
-};
-
-NAMESPACE_END(detail)
-NAMESPACE_END(NB_NAMESPACE)
diff --git a/src/nanobind/include/nanobind/stl/tuple.h b/src/nanobind/include/nanobind/stl/tuple.h
deleted file mode 100644
index ed99602..0000000
--- a/src/nanobind/include/nanobind/stl/tuple.h
+++ /dev/null
@@ -1,109 +0,0 @@
-/*
-    nanobind/stl/tuple.h: type caster for std::tuple<...>
-
-    Copyright (c) 2022 Wenzel Jakob
-
-    All rights reserved. Use of this source code is governed by a
-    BSD-style license that can be found in the LICENSE file.
-*/
-
-#pragma once
-
-#include <nanobind/nanobind.h>
-#include <tuple>
-
-NAMESPACE_BEGIN(NB_NAMESPACE)
-NAMESPACE_BEGIN(detail)
-
-template <typename... Ts> struct type_caster<std::tuple<Ts...>> {
-    static constexpr size_t N  = sizeof...(Ts),
-                            N1 = N > 0 ? N : 1;
-
-    using Value = std::tuple<Ts...>;
-    using Indices = std::make_index_sequence<N>;
-
-    static constexpr auto Name =
-        const_name(NB_TYPING_TUPLE "[") +
-        const_name<N == 0>(const_name("()"), concat(make_caster<Ts>::Name...)) +
-        const_name("]");
-
-    /// This caster constructs instances on the fly (otherwise it would not be
-    /// able to handle tuples containing references_). Because of this, only the
-    /// `operator Value()` cast operator is implemented below, and the type
-    /// alias below informs users of this class of this fact.
-    template <typename T> using Cast = Value;
-
-    bool from_python(handle src, uint8_t flags,
-                     cleanup_list *cleanup) noexcept {
-        return from_python_impl(src, flags, cleanup, Indices{});
-    }
-
-    template <size_t... Is>
-    bool from_python_impl(handle src, uint8_t flags, cleanup_list *cleanup,
-                          std::index_sequence<Is...>) noexcept {
-        (void) src; (void) flags; (void) cleanup;
-
-        PyObject *temp; // always initialized by the following line
-        PyObject **o = seq_get_with_size(src.ptr(), N, &temp);
-
-        bool success =
-            (o && ... &&
-             std::get<Is>(casters).from_python(o[Is], flags, cleanup));
-
-        Py_XDECREF(temp);
-
-        return success;
-    }
-
-    template <typename T>
-    static handle from_cpp(T&& value, rv_policy policy,
-                           cleanup_list *cleanup) noexcept {
-        return from_cpp_impl((forward_t<T>) value, policy, cleanup, Indices{});
-    }
-
-    template <typename T>
-    static handle from_cpp(T *value, rv_policy policy, cleanup_list *cleanup) {
-        if (!value)
-            return none().release();
-        return from_cpp_impl(*value, policy, cleanup, Indices{});
-    }
-
-    template <typename T, size_t... Is>
-    static handle from_cpp_impl(T &&value, rv_policy policy,
-                                cleanup_list *cleanup,
-                                std::index_sequence<Is...>) noexcept {
-        (void) value; (void) policy; (void) cleanup;
-        object o[N1];
-
-        bool success =
-            (... &&
-             ((o[Is] = steal(make_caster<Ts>::from_cpp(
-                   forward_like_<T>(std::get<Is>(value)), policy, cleanup))),
-              o[Is].is_valid()));
-
-        if (!success)
-            return handle();
-
-        PyObject *r = PyTuple_New(N);
-        (NB_TUPLE_SET_ITEM(r, Is, o[Is].release().ptr()), ...);
-        return r;
-    }
-
-    template <typename T>
-    bool can_cast() const noexcept { return can_cast_impl(Indices{}); }
-
-    explicit operator Value() { return cast_impl(Indices{}); }
-
-    template <size_t... Is>
-    bool can_cast_impl(std::index_sequence<Is...>) const noexcept {
-        return (std::get<Is>(casters).template can_cast<Ts>() && ...);
-    }
-    template <size_t... Is> Value cast_impl(std::index_sequence<Is...>) {
-        return Value(std::get<Is>(casters).operator cast_t<Ts>()...);
-    }
-
-    std::tuple<make_caster<Ts>...> casters;
-};
-
-NAMESPACE_END(detail)
-NAMESPACE_END(NB_NAMESPACE)
diff --git a/src/nanobind/include/nanobind/stl/unique_ptr.h b/src/nanobind/include/nanobind/stl/unique_ptr.h
deleted file mode 100644
index c7700f3..0000000
--- a/src/nanobind/include/nanobind/stl/unique_ptr.h
+++ /dev/null
@@ -1,178 +0,0 @@
-/*
-    nanobind/stl/unique_ptr.h: Type caster for std::unique_ptr<T>
-
-    Copyright (c) 2022 Wenzel Jakob
-
-    All rights reserved. Use of this source code is governed by a
-    BSD-style license that can be found in the LICENSE file.
-*/
-
-#pragma once
-
-#include <nanobind/nanobind.h>
-#include <memory>
-
-NAMESPACE_BEGIN(NB_NAMESPACE)
-
-// Deleter for std::unique_ptr<T> (handles ownership by both C++ and Python)
-template <typename T> struct deleter {
-    /// Instance should be cleared using a delete expression
-    deleter()  = default;
-
-    /// Instance owned by Python, reduce reference count upon deletion
-    deleter(handle h) : o(h.ptr()) { }
-
-    /// Does Python own storage of the underlying object
-    bool owned_by_python() const { return o != nullptr; }
-
-    /// Does C++ own storage of the underlying object
-    bool owned_by_cpp() const { return o == nullptr; }
-
-    /// Perform the requested deletion operation
-    void operator()(void *p) noexcept {
-        if (o) {
-            gil_scoped_acquire guard;
-            Py_DECREF(o);
-        } else {
-            delete (T *) p;
-        }
-    }
-
-    PyObject *o{nullptr};
-};
-
-NAMESPACE_BEGIN(detail)
-
-template <typename T, typename Deleter>
-struct type_caster<std::unique_ptr<T, Deleter>> {
-    static constexpr bool IsClass = true;
-    using Value = std::unique_ptr<T, Deleter>;
-    using Caster = make_caster<T>;
-    using Td = std::decay_t<T>;
-
-    static constexpr bool IsDefaultDeleter =
-        std::is_same_v<Deleter, std::default_delete<T>>;
-    static constexpr bool IsNanobindDeleter =
-        std::is_same_v<Deleter, deleter<T>>;
-
-    static_assert(is_base_caster_v<Caster>,
-                  "Conversion of ``unique_ptr<T>`` requires that ``T`` is "
-                  "handled by nanobind's regular class binding mechanism. "
-                  "However, a type caster was registered to intercept this "
-                  "particular type, which is not allowed.");
-
-    static_assert(IsDefaultDeleter || IsNanobindDeleter,
-                  "Binding std::unique_ptr<T, Deleter> requires that "
-                  "'Deleter' is either 'std::default_delete<T>' or "
-                  "'nanobind::deleter<T>'");
-
-    static constexpr auto Name = Caster::Name;
-    template <typename T_> using Cast = Value;
-
-    Caster caster;
-    handle src;
-
-    /* If true, the Python object has relinquished ownership but we have
-       not yet yielded a unique_ptr that holds ownership on the C++ side.
-
-       `nb_type_relinquish_ownership()` can fail, so we must check it in
-       `can_cast()`. If we do so, but then wind up not executing the cast
-       operator, we must remember to undo our relinquishment and push the
-       ownership back onto the Python side. For example, this might be
-       necessary if the Python object `[(foo, foo)]` is converted to
-       `std::vector<std::pair<std::unique_ptr<T>, std::unique_ptr<T>>>`;
-       the pair caster won't know that it can't cast the second element
-       until after it's verified that it can cast the first one. */
-    mutable bool inflight = false;
-
-    ~type_caster() {
-        if (inflight)
-            nb_type_restore_ownership(src.ptr(), IsDefaultDeleter);
-    }
-
-    bool from_python(handle src_, uint8_t, cleanup_list *) noexcept {
-        // Stash source python object
-        src = src_;
-
-        /* Try casting to a pointer of the underlying type. We pass flags=0 and
-           cleanup=nullptr to prevent implicit type conversions (they are
-           problematic since the instance then wouldn't be owned by 'src') */
-        return caster.from_python(src_, 0, nullptr);
-    }
-
-    template <typename T2>
-    static handle from_cpp(T2 *value, rv_policy policy,
-                           cleanup_list *cleanup) noexcept {
-        if (!value)
-            return handle();
-
-        return from_cpp(*value, policy, cleanup);
-    }
-
-    template <typename T2>
-    static handle from_cpp(T2 &&value,
-                           rv_policy, cleanup_list *cleanup) noexcept {
-
-        bool cpp_delete = true;
-        if constexpr (IsNanobindDeleter)
-            cpp_delete = value.get_deleter().owned_by_cpp();
-
-        Td *ptr = (Td *) value.get();
-        const std::type_info *type = &typeid(Td);
-        if (!ptr)
-            return none().release();
-
-        constexpr bool has_type_hook =
-            !std::is_base_of_v<std::false_type, type_hook<Td>>;
-        if constexpr (has_type_hook)
-            type = type_hook<Td>::get(ptr);
-
-        handle result;
-        if constexpr (!std::is_polymorphic_v<Td>) {
-            result = nb_type_put_unique(type, ptr, cleanup, cpp_delete);
-        } else {
-            const std::type_info *type_p =
-                (!has_type_hook && ptr) ? &typeid(*ptr) : nullptr;
-
-            result = nb_type_put_unique_p(type, type_p, ptr, cleanup, cpp_delete);
-        }
-
-        if (result.is_valid()) {
-            if (cpp_delete)
-                value.release();
-            else
-                value.reset();
-        }
-
-        return result;
-    }
-
-    template <typename T_>
-    bool can_cast() const noexcept {
-        if (src.is_none() || inflight)
-            return true;
-        else if (!nb_type_relinquish_ownership(src.ptr(), IsDefaultDeleter))
-            return false;
-        inflight = true;
-        return true;
-    }
-
-    explicit operator Value() {
-        if (!inflight && !src.is_none() &&
-            !nb_type_relinquish_ownership(src.ptr(), IsDefaultDeleter))
-            throw next_overload();
-
-        Td *p = caster.operator Td *();
-
-        Value value;
-        if constexpr (IsNanobindDeleter)
-            value = Value(p, deleter<T>(src.inc_ref()));
-        else
-            value = Value(p);
-        inflight = false;
-        return value;
-    }
-};
-
-NAMESPACE_END(detail)
-NAMESPACE_END(NB_NAMESPACE)
diff --git a/src/nanobind/include/nanobind/stl/unordered_map.h b/src/nanobind/include/nanobind/stl/unordered_map.h
deleted file mode 100644
index a6f94c9..0000000
--- a/src/nanobind/include/nanobind/stl/unordered_map.h
+++ /dev/null
@@ -1,23 +0,0 @@
-/*
-    nanobind/stl/unordered_map.h: type caster for std::unordered_map<...>
-
-    Copyright (c) 2022 Matej Ferencevic and Wenzel Jakob
-
-    All rights reserved. Use of this source code is governed by a
-    BSD-style license that can be found in the LICENSE file.
-*/
-
-#pragma once
-
-#include "detail/nb_dict.h"
-#include <unordered_map>
-
-NAMESPACE_BEGIN(NB_NAMESPACE)
-NAMESPACE_BEGIN(detail)
-
-template <typename Key, typename T, typename Compare, typename Alloc>
-struct type_caster<std::unordered_map<Key, T, Compare, Alloc>>
- : dict_caster<std::unordered_map<Key, T, Compare, Alloc>, Key, T> { };
-
-NAMESPACE_END(detail)
-NAMESPACE_END(NB_NAMESPACE)
diff --git a/src/nanobind/include/nanobind/stl/unordered_set.h b/src/nanobind/include/nanobind/stl/unordered_set.h
deleted file mode 100644
index e426b69..0000000
--- a/src/nanobind/include/nanobind/stl/unordered_set.h
+++ /dev/null
@@ -1,24 +0,0 @@
-/*
-    nanobind/stl/unordered_set.h: type caster for std::unordered_set<...>
-
-    Copyright (c) 2022 Raymond Yun Fei and Wenzel Jakob
-
-    All rights reserved. Use of this source code is governed by a
-    BSD-style license that can be found in the LICENSE file.
-*/
-
-#pragma once
-
-#include "detail/nb_set.h"
-#include <unordered_set>
-
-NAMESPACE_BEGIN(NB_NAMESPACE)
-NAMESPACE_BEGIN(detail)
-
-template <typename Key, typename Hash, typename Compare, typename Alloc>
-struct type_caster<std::unordered_set<Key, Hash, Compare, Alloc>>
-    : set_caster<std::unordered_set<Key, Hash, Compare, Alloc>, Key> {
-};
-
-NAMESPACE_END(detail)
-NAMESPACE_END(NB_NAMESPACE)
diff --git a/src/nanobind/include/nanobind/stl/variant.h b/src/nanobind/include/nanobind/stl/variant.h
deleted file mode 100644
index 27d39e2..0000000
--- a/src/nanobind/include/nanobind/stl/variant.h
+++ /dev/null
@@ -1,113 +0,0 @@
-/*
-    nanobind/stl/variant.h: type caster for std::variant<...>
-
-    Copyright (c) 2022 Yoshiki Matsuda and Wenzel Jakob
-
-    All rights reserved. Use of this source code is governed by a
-    BSD-style license that can be found in the LICENSE file.
-*/
-
-#pragma once
-
-#include <nanobind/nanobind.h>
-#include <variant>
-
-NAMESPACE_BEGIN(NB_NAMESPACE)
-NAMESPACE_BEGIN(detail)
-
-template <typename T, typename...>
-struct concat_variant { using type = T; };
-template <typename... Ts1, typename... Ts2, typename... Ts3>
-struct concat_variant<std::variant<Ts1...>, std::variant<Ts2...>, Ts3...>
-    : concat_variant<std::variant<Ts1..., Ts2...>, Ts3...> {};
-
-template <typename... Ts> struct remove_opt_mono<std::variant<Ts...>>
-    : concat_variant<std::conditional_t<std::is_same_v<std::monostate, Ts>, std::variant<>, std::variant<remove_opt_mono_t<Ts>>>...> {};
-
-template <> struct type_caster<std::monostate> : none_caster<std::monostate> { };
-
-template <bool Defaultable, typename... Ts>
-struct variant_caster_storage;
-
-template <typename... Ts>
-struct variant_caster_storage<true, Ts...> {
-    using Variant = std::variant<Ts...>;
-    Variant value;
-    Variant& get() { return value; }
-    template <typename T>
-    void store(T&& alternative) { value = (forward_t<T>) alternative; }
-};
-
-template <typename... Ts>
-struct variant_caster_storage<false, Ts...> {
-    using Variant = std::variant<Ts...>;
-    std::variant<std::monostate, Variant> value;
-    Variant& get() { return *std::get_if<1>(&value); }
-    template <typename T>
-    void store(T&& alternative) {
-        value.template emplace<1>((forward_t<T>) alternative);
-    }
-};
-
-template <typename T1, typename... Ts>
-constexpr bool variant_is_defaultable = std::is_default_constructible_v<T1>;
-
-template <typename... Ts>
-struct type_caster<std::variant<Ts...>>
-  : private variant_caster_storage<variant_is_defaultable<Ts...>, Ts...> {
-    // We don't use NB_TYPE_CASTER so that we can customize the cast operators
-    // to use `variant_caster_storage`, in order to support variants that are
-    // not default-constructible.
-    using Value = std::variant<Ts...>;
-    static constexpr auto Name = union_name(make_caster<Ts>::Name...);
-
-    template <typename T> using Cast = movable_cast_t<T>;
-    template <typename T> static constexpr bool can_cast() { return true; }
-    explicit operator Value*() { return &this->get(); }
-    explicit operator Value&() { return (Value &) this->get(); }
-    explicit operator Value&&() { return (Value &&) this->get(); }
-
-    template <typename T>
-    bool try_variant(const handle &src, uint8_t flags, cleanup_list *cleanup) {
-        using CasterT = make_caster<T>;
-
-        CasterT caster;
-
-        if (!caster.from_python(src, flags_for_local_caster<T>(flags), cleanup) ||
-            !caster.template can_cast<T>())
-            return false;
-
-        this->store(caster.operator cast_t<T>());
-
-        return true;
-    }
-
-    bool from_python(handle src, uint8_t flags, cleanup_list *cleanup) noexcept {
-        if (flags & (uint8_t) cast_flags::convert) {
-            if ((try_variant<Ts>(src, flags & ~(uint8_t)cast_flags::convert, cleanup) || ...)){
-                return true;
-            }
-        }
-        return (try_variant<Ts>(src, flags, cleanup) || ...);
-    }
-
-    template <typename T>
-    static handle from_cpp(T *value, rv_policy policy, cleanup_list *cleanup) {
-        if (!value)
-            return none().release();
-        return from_cpp(*value, policy, cleanup);
-    }
-
-    template <typename T>
-    static handle from_cpp(T &&value, rv_policy policy, cleanup_list *cleanup) noexcept {
-        return std::visit(
-            [&](auto &&v) {
-                return make_caster<decltype(v)>::from_cpp(
-                    std::forward<decltype(v)>(v), policy, cleanup);
-            },
-            std::forward<T>(value));
-    }
-};
-
-NAMESPACE_END(detail)
-NAMESPACE_END(NB_NAMESPACE)
diff --git a/src/nanobind/include/nanobind/stl/vector.h b/src/nanobind/include/nanobind/stl/vector.h
deleted file mode 100644
index 3414942..0000000
--- a/src/nanobind/include/nanobind/stl/vector.h
+++ /dev/null
@@ -1,22 +0,0 @@
-/*
-    nanobind/stl/vector.h: type caster for std::vector<...>
-
-    Copyright (c) 2022 Wenzel Jakob
-
-    All rights reserved. Use of this source code is governed by a
-    BSD-style license that can be found in the LICENSE file.
-*/
-
-#pragma once
-
-#include "detail/nb_list.h"
-#include <vector>
-
-NAMESPACE_BEGIN(NB_NAMESPACE)
-NAMESPACE_BEGIN(detail)
-
-template <typename Type, typename Alloc> struct type_caster<std::vector<Type, Alloc>>
- : list_caster<std::vector<Type, Alloc>, Type> { };
-
-NAMESPACE_END(detail)
-NAMESPACE_END(NB_NAMESPACE)
diff --git a/src/nanobind/include/nanobind/stl/wstring.h b/src/nanobind/include/nanobind/stl/wstring.h
deleted file mode 100644
index 838ab15..0000000
--- a/src/nanobind/include/nanobind/stl/wstring.h
+++ /dev/null
@@ -1,39 +0,0 @@
-/*
-    nanobind/stl/string.h: type caster for std::string
-
-    Copyright (c) 2022 Wenzel Jakob
-
-    All rights reserved. Use of this source code is governed by a
-    BSD-style license that can be found in the LICENSE file.
-*/
-
-#pragma once
-
-#include <nanobind/nanobind.h>
-#include <string>
-
-NAMESPACE_BEGIN(NB_NAMESPACE)
-NAMESPACE_BEGIN(detail)
-
-template <> struct type_caster<std::wstring> {
-    NB_TYPE_CASTER(std::wstring, const_name("str"))
-
-    bool from_python(handle src, uint8_t, cleanup_list *) noexcept {
-        Py_ssize_t size;
-        const wchar_t *str = PyUnicode_AsWideCharString(src.ptr(), &size);
-        if (!str) {
-            PyErr_Clear();
-            return false;
-        }
-        value = std::wstring(str, (size_t) size);
-        return true;
-    }
-
-    static handle from_cpp(const std::wstring &value, rv_policy,
-                           cleanup_list *) noexcept {
-        return PyUnicode_FromWideChar(value.c_str(), value.size());
-    }
-};
-
-NAMESPACE_END(detail)
-NAMESPACE_END(NB_NAMESPACE)
diff --git a/src/nanobind/include/nanobind/trampoline.h b/src/nanobind/include/nanobind/trampoline.h
deleted file mode 100644
index 2789e55..0000000
--- a/src/nanobind/include/nanobind/trampoline.h
+++ /dev/null
@@ -1,76 +0,0 @@
-/*
-    nanobind/trampoline.h: functionality for overriding C++ virtual
-    functions from within Python
-
-    Copyright (c) 2022 Wenzel Jakob
-
-    All rights reserved. Use of this source code is governed by a
-    BSD-style license that can be found in the LICENSE file.
-*/
-
-#pragma once
-
-#include <nanobind/nanobind.h>
-
-NAMESPACE_BEGIN(NB_NAMESPACE)
-NAMESPACE_BEGIN(detail)
-
-struct ticket;
-
-NB_CORE void trampoline_new(void **data, size_t size, void *ptr) noexcept;
-NB_CORE void trampoline_release(void **data, size_t size) noexcept;
-NB_CORE void trampoline_enter(void **data, size_t size, const char *name,
-                              bool pure, ticket *ticket);
-NB_CORE void trampoline_leave(ticket *ticket) noexcept;
-
-template <size_t Size> struct trampoline {
-    mutable void *data[2 * Size + 1];
-
-    NB_INLINE trampoline(void *ptr) { trampoline_new(data, Size, ptr); }
-    NB_INLINE ~trampoline() { trampoline_release(data, Size); }
-
-    NB_INLINE handle base() const { return (PyObject *) data[0]; }
-};
-
-struct ticket {
-    handle self;
-    handle key;
-    ticket *prev{};
-    PyGILState_STATE state{};
-
-    template <size_t Size>
-    NB_INLINE ticket(const trampoline<Size> &t, const char *name, bool pure) {
-        trampoline_enter(t.data, Size, name, pure, this);
-    }
-
-    NB_INLINE ~ticket() noexcept { trampoline_leave(this); }
-};
-
-#define NB_TRAMPOLINE(base, size)                                              \
-    using NBBase = base;                                                       \
-    using NBBase::NBBase;                                                      \
-    nanobind::detail::trampoline<size> nb_trampoline{ this }
-
-#define NB_OVERRIDE_NAME(name, func, ...)                                      \
-    using nb_ret_type = decltype(NBBase::func(__VA_ARGS__));                   \
-    nanobind::detail::ticket nb_ticket(nb_trampoline, name, false);            \
-    if (nb_ticket.key.is_valid()) {                                                       \
-        return nanobind::cast<nb_ret_type>(                                    \
-            nb_trampoline.base().attr(nb_ticket.key)(__VA_ARGS__));            \
-    } else                                                                     \
-        return NBBase::func(__VA_ARGS__)
-
-#define NB_OVERRIDE_PURE_NAME(name, func, ...)                                 \
-    using nb_ret_type = decltype(NBBase::func(__VA_ARGS__));                   \
-    nanobind::detail::ticket nb_ticket(nb_trampoline, name, true);             \
-    return nanobind::cast<nb_ret_type>(                                        \
-        nb_trampoline.base().attr(nb_ticket.key)(__VA_ARGS__))
-
-#define NB_OVERRIDE(func, ...)                                                 \
-    NB_OVERRIDE_NAME(#func, func, __VA_ARGS__)
-
-#define NB_OVERRIDE_PURE(func, ...)                                            \
-    NB_OVERRIDE_PURE_NAME(#func, func, __VA_ARGS__)
-
-NAMESPACE_END(detail)
-NAMESPACE_END(NB_NAMESPACE)
diff --git a/src/nanobind/include/nanobind/typing.h b/src/nanobind/include/nanobind/typing.h
deleted file mode 100644
index ed5ab90..0000000
--- a/src/nanobind/include/nanobind/typing.h
+++ /dev/null
@@ -1,31 +0,0 @@
-/*
-    nanobind/typing.h: Optional typing-related functionality
-
-    Copyright (c) 2024 Wenzel Jakob
-
-    All rights reserved. Use of this source code is governed by a
-    BSD-style license that can be found in the LICENSE file.
-*/
-
-#pragma once
-
-#include <nanobind/nanobind.h>
-
-NAMESPACE_BEGIN(NB_NAMESPACE)
-
-inline module_ typing() { return module_::import_("typing"); }
-
-template <typename... Args>
-object any_type() { return typing().attr("Any"); }
-
-template <typename... Args>
-object type_var(Args&&... args) {
-    return typing().attr("TypeVar")((detail::forward_t<Args>) args...);
-}
-
-template <typename... Args>
-object type_var_tuple(Args&&... args) {
-    return typing().attr("TypeVarTuple")((detail::forward_t<Args>) args...);
-}
-
-NAMESPACE_END(NB_NAMESPACE)
diff --git a/src/nanobind/pyproject.toml b/src/nanobind/pyproject.toml
deleted file mode 100644
index 9c5d6b3..0000000
--- a/src/nanobind/pyproject.toml
+++ /dev/null
@@ -1,58 +0,0 @@
-[build-system]
-requires = ["scikit-build-core >=0.10"]
-build-backend = "scikit_build_core.build"
-
-[project]
-name = "nanobind"
-version = "2.7.1-dev1"
-description = "nanobind: tiny and efficient C++/Python bindings"
-readme.content-type = "text/markdown"
-readme.text = """
-![nanobind logo](
-https://github.com/wjakob/nanobind/raw/master/docs/images/logo.jpg?raw=True)
-
-_nanobind_ is a small binding library that exposes C++ types in Python and
-vice versa. It is reminiscent of
-[Boost.Python](https://www.boost.org/doc/libs/1_64_0/libs/python/doc/html)
-and [pybind11](http://github.com/pybind/pybind11) and uses near-identical
-syntax. In contrast to these existing tools, nanobind is more efficient:
-bindings compile in a shorter amount of time, produce smaller binaries, and
-have better runtime performance.
-
-More concretely,
-[benchmarks](https://nanobind.readthedocs.io/en/latest/benchmark.html) show up
-to **~4× faster** compile time, **~5× smaller** binaries, and **~10× lower**
-runtime overheads compared to pybind11. nanobind also outperforms Cython in
-important metrics (**3-12×** binary size reduction, **1.6-4×** compilation time
-reduction, similar runtime performance).
-
-Please see the following links for tutorial and reference documentation in
-[HTML](https://nanobind.readthedocs.io/en/latest/) and
-[PDF](https://nanobind.readthedocs.io/_/downloads/en/latest/pdf/) formats.
-"""
-authors = [
-    { name = "Wenzel Jakob", email = "wenzel.jakob@epfl.ch" },
-]
-classifiers = [
-    "Intended Audience :: Developers",
-    "License :: OSI Approved :: BSD License",
-    "Programming Language :: C++",
-    "Programming Language :: Python :: 3 :: Only",
-    "Programming Language :: Python :: Implementation :: CPython",
-    "Programming Language :: Python :: Implementation :: PyPy",
-    "Topic :: Software Development :: Libraries :: Python Modules",
-    "Topic :: Utilities",
-]
-
-[project.urls]
-Homepage = "https://github.com/wjakob/nanobind"
-
-
-[tool.scikit-build]
-minimum-version = "build-system.requires"
-wheel.platlib = false
-cmake.define.NB_TEST = false
-
-
-[tool.pytest.ini_options]
-testpaths = [ "tests" ]
diff --git a/src/nanobind/src/__init__.py b/src/nanobind/src/__init__.py
deleted file mode 100644
index 371f67e..0000000
--- a/src/nanobind/src/__init__.py
+++ /dev/null
@@ -1,26 +0,0 @@
-import sys
-import os
-
-if sys.version_info < (3, 8):
-    raise ImportError("nanobind does not support Python < 3.8.")
-
-def source_dir() -> str:
-    "Return the path to the nanobind source directory."
-    return os.path.join(os.path.abspath(os.path.dirname(__file__)), "src")
-
-def include_dir() -> str:
-    "Return the path to the nanobind include directory"
-    return os.path.join(os.path.abspath(os.path.dirname(__file__)), "include")
-
-def cmake_dir() -> str:
-    "Return the path to the nanobind CMake module directory."
-    return os.path.join(os.path.abspath(os.path.dirname(__file__)), "cmake")
-
-__version__ = "2.7.1-dev1"
-
-__all__ = (
-    "__version__",
-    "source_dir",
-    "include_dir",
-    "cmake_dir",
-)
diff --git a/src/nanobind/src/__main__.py b/src/nanobind/src/__main__.py
deleted file mode 100644
index 78b8fec..0000000
--- a/src/nanobind/src/__main__.py
+++ /dev/null
@@ -1,36 +0,0 @@
-import argparse
-import sys
-import sysconfig  # type: ignore
-
-from . import __version__, include_dir, cmake_dir
-
-
-def main() -> None:
-    parser = argparse.ArgumentParser()
-    parser.add_argument(
-        "--version",
-        action="version",
-        version=__version__,
-        help="Print the version number.",
-    )
-    parser.add_argument(
-        "--include_dir",
-        action="store_true",
-        help="Print the path to the nanobind C++ header directory."
-    )
-    parser.add_argument(
-        "--cmake_dir",
-        action="store_true",
-        help="Print the path to the nanobind CMake module directory."
-    )
-    args = parser.parse_args()
-    if not sys.argv[1:]:
-        parser.print_help()
-    if args.include_dir:
-        print(include_dir())
-    if args.cmake_dir:
-        print(cmake_dir())
-
-
-if __name__ == "__main__":
-    main()
diff --git a/src/nanobind/src/buffer.h b/src/nanobind/src/buffer.h
deleted file mode 100644
index 2acce0e..0000000
--- a/src/nanobind/src/buffer.h
+++ /dev/null
@@ -1,166 +0,0 @@
-#pragma once
-
-#include <string.h>
-#include <stdarg.h>
-#include <stdio.h> // vsnprintf
-
-NAMESPACE_BEGIN(NB_NAMESPACE)
-NAMESPACE_BEGIN(detail)
-
-struct Buffer {
-public:
-    // Disable copy/move constructor and assignment
-    Buffer(const Buffer &) = delete;
-    Buffer(Buffer &&) = delete;
-    Buffer &operator=(const Buffer &) = delete;
-    Buffer &operator=(Buffer &&) = delete;
-
-    Buffer(size_t size = 0) : m_start((char *) malloc(size)) {
-        if (!m_start) {
-            fprintf(stderr, "Buffer::Buffer(): out of memory (unrecoverable error)!");
-            abort();
-        }
-        m_end = m_start + size;
-        if (size)
-            clear();
-    }
-
-    ~Buffer() {
-        free(m_start);
-    }
-
-    /// Append a string with the specified length
-    void put(const char *str, size_t size) {
-        if (m_cur + size >= m_end)
-            expand(size + 1 - remain());
-
-        memcpy(m_cur, str, size);
-        m_cur += size;
-        *m_cur = '\0';
-    }
-
-    /// Append a string
-    template <size_t N> void put(const char (&str)[N]) {
-        put(str, N - 1);
-    }
-
-    /// Append a dynamic string
-    void put_dstr(const char *str) { put(str, strlen(str)); }
-
-    /// Append a single character to the buffer
-    void put(char c) {
-        if (m_cur + 1 >= m_end)
-            expand();
-        *m_cur++ = c;
-        *m_cur = '\0';
-    }
-
-    /// Append multiple copies of a single character to the buffer
-    void put(char c, size_t count) {
-        if (m_cur + count >= m_end)
-            expand(count + 1 - remain());
-        for (size_t i = 0; i < count; ++i)
-            *m_cur++ = c;
-        *m_cur = '\0';
-    }
-
-    /// Append a formatted (printf-style) string to the buffer
-#if defined(__GNUC__)
-    __attribute__((__format__ (__printf__, 2, 3)))
-#endif
-    size_t fmt(const char *format, ...) {
-        size_t written;
-        do {
-            size_t size = remain();
-            va_list args;
-            va_start(args, format);
-            written = (size_t) vsnprintf(m_cur, size, format, args);
-            va_end(args);
-
-            if (written + 1 < size) {
-                m_cur += written;
-                break;
-            }
-
-            expand();
-        } while (true);
-
-        return written;
-    }
-
-    const char *get() { return m_start; }
-
-    void clear() {
-        m_cur = m_start;
-        if (m_start != m_end)
-            m_start[0] = '\0';
-    }
-
-    /// Remove the last 'n' characters
-    void rewind(size_t n) {
-        if (m_cur < m_start + n)
-            m_cur = m_start;
-        else
-            m_cur -= n;
-        *m_cur = '\0';
-    }
-
-    /// Append an unsigned 32 bit integer
-    void put_uint32(uint32_t value) {
-        const int digits = 10;
-        const char *num = "0123456789";
-        char buf[digits];
-        size_t i = digits;
-
-        do {
-            buf[--i] = num[value % 10];
-            value /= 10;
-        } while (value);
-
-        return put(buf + i, digits - i);
-    }
-
-    char *copy(size_t offset = 0) const {
-        size_t copy_size = size() + 1 - offset;
-        char *tmp = (char *) malloc(copy_size);
-        if (!tmp) {
-            fprintf(stderr, "Buffer::copy(): out of memory (unrecoverable error)!");
-            abort();
-        }
-        memcpy(tmp, m_start + offset, copy_size);
-        return tmp;
-    }
-
-    size_t size() const { return (size_t) (m_cur - m_start); }
-    size_t remain() const { return (size_t) (m_end - m_cur); }
-
-private:
-    NB_NOINLINE void expand(size_t minval = 2) {
-        size_t old_alloc_size = m_end - m_start,
-               new_alloc_size = 2 * old_alloc_size + minval,
-               used_size      = (size_t) (m_cur - m_start),
-               copy_size      = used_size + 1;
-
-        if (old_alloc_size < copy_size)
-            copy_size = old_alloc_size;
-
-        char *tmp = (char *) malloc(new_alloc_size);
-        if (!tmp) {
-            fprintf(stderr, "Buffer::expand(): out of memory (unrecoverable error)!");
-            abort();
-        }
-
-        memcpy(tmp, m_start, copy_size);
-        free(m_start);
-
-        m_start = tmp;
-        m_end = m_start + new_alloc_size;
-        m_cur = m_start + used_size;
-    }
-
-private:
-    char *m_start{nullptr}, *m_cur{nullptr}, *m_end{nullptr};
-};
-
-NAMESPACE_END(detail)
-NAMESPACE_END(NB_NAMESPACE)
diff --git a/src/nanobind/src/common.cpp b/src/nanobind/src/common.cpp
deleted file mode 100644
index 6b49703..0000000
--- a/src/nanobind/src/common.cpp
+++ /dev/null
@@ -1,1293 +0,0 @@
-/*
-    src/common.cpp: miscellaneous libnanobind functionality
-
-    Copyright (c) 2022 Wenzel Jakob
-
-    All rights reserved. Use of this source code is governed by a
-    BSD-style license that can be found in the LICENSE file.
-*/
-
-#include <nanobind/nanobind.h>
-#include <complex>
-#include "nb_internals.h"
-
-NAMESPACE_BEGIN(NB_NAMESPACE)
-NAMESPACE_BEGIN(detail)
-
-NB_NOINLINE static builtin_exception
-create_exception(exception_type type, const char *fmt, va_list args_) {
-    char buf[512];
-    va_list args;
-
-    va_copy(args, args_);
-    int size = vsnprintf(buf, sizeof(buf), fmt, args);
-    va_end(args);
-
-    if (size < (int) sizeof(buf)) {
-        return builtin_exception(type, buf);
-    } else {
-        scoped_pymalloc<char> temp(size + 1);
-
-        va_copy(args, args_);
-        vsnprintf(temp.get(), size + 1, fmt, args);
-        va_end(args);
-
-        return builtin_exception(type, temp.get());
-    }
-}
-
-#if defined(__GNUC__)
-    __attribute__((noreturn, __format__ (__printf__, 1, 2)))
-#else
-    [[noreturn]]
-#endif
-void raise(const char *fmt, ...) {
-    va_list args;
-    va_start(args, fmt);
-    builtin_exception err =
-        create_exception(exception_type::runtime_error, fmt, args);
-    va_end(args);
-    throw err;
-}
-
-#if defined(__GNUC__)
-    __attribute__((noreturn, __format__ (__printf__, 1, 2)))
-#else
-    [[noreturn]]
-#endif
-void raise_type_error(const char *fmt, ...) {
-    va_list args;
-    va_start(args, fmt);
-    builtin_exception err =
-        create_exception(exception_type::type_error, fmt, args);
-    va_end(args);
-    throw err;
-}
-
-/// Abort the process with a fatal error
-#if defined(__GNUC__)
-    __attribute__((noreturn, __format__ (__printf__, 1, 2)))
-#else
-    [[noreturn]]
-#endif
-void fail(const char *fmt, ...) noexcept {
-    va_list args;
-    fprintf(stderr, "Critical nanobind error: ");
-    va_start(args, fmt);
-    vfprintf(stderr, fmt, args);
-    va_end(args);
-    fprintf(stderr, "\n");
-    abort();
-}
-
-PyObject *capsule_new(const void *ptr, const char *name,
-        void (*cleanup)(void *) noexcept) noexcept {
-    auto capsule_cleanup = [](PyObject *o) {
-        auto cleanup_2 = (void (*)(void *))(PyCapsule_GetContext(o));
-        if (cleanup_2)
-            cleanup_2(PyCapsule_GetPointer(o, PyCapsule_GetName(o)));
-    };
-
-    PyObject *c = PyCapsule_New((void *) ptr, name, capsule_cleanup);
-
-    check(c, "nanobind::detail::capsule_new(): allocation failed!");
-
-    int rv = PyCapsule_SetContext(c, (void *) cleanup);
-    check(rv == 0, "nanobind::detail::capsule_new(): could not set context!");
-
-    return c;
-}
-
-void raise_python_error() {
-    check(PyErr_Occurred(),
-          "nanobind::detail::raise_python_error() called without "
-          "an error condition!");
-    throw python_error();
-}
-
-void raise_next_overload_if_null(void *p) {
-    if (NB_UNLIKELY(!p))
-        throw next_overload();
-}
-
-void raise_cast_error() {
-    throw cast_error();
-}
-
-// ========================================================================
-
-void cleanup_list::release() noexcept {
-    /* Don't decrease the reference count of the first
-       element, it stores the 'self' element. */
-    for (size_t i = 1; i < m_size; ++i)
-        Py_DECREF(m_data[i]);
-    if (m_capacity != Small)
-        free(m_data);
-    m_data = nullptr;
-}
-
-void cleanup_list::expand() noexcept {
-    uint32_t new_capacity = m_capacity * 2;
-    PyObject **new_data = (PyObject **) malloc(new_capacity * sizeof(PyObject *));
-    check(new_data, "nanobind::detail::cleanup_list::expand(): out of memory!");
-    memcpy(new_data, m_data, m_size * sizeof(PyObject *));
-    if (m_capacity != Small)
-        free(m_data);
-    m_data = new_data;
-    m_capacity = new_capacity;
-}
-
-// ========================================================================
-
-PyObject *module_new(const char *name, PyModuleDef *def) noexcept {
-    memset(def, 0, sizeof(PyModuleDef));
-    def->m_name = name;
-    def->m_size = -1;
-    PyObject *m = PyModule_Create(def);
-
-    check(m, "nanobind::detail::module_new(): allocation failed!");
-    return m;
-}
-
-PyObject *module_import(const char *name) {
-    PyObject *res = PyImport_ImportModule(name);
-    if (!res)
-        throw python_error();
-    return res;
-}
-
-PyObject *module_import(PyObject *o) {
-    PyObject *res = PyImport_Import(o);
-    if (!res)
-        throw python_error();
-    return res;
-}
-
-PyObject *module_new_submodule(PyObject *base, const char *name,
-                               const char *doc) noexcept {
-    const char *base_name, *tmp_str;
-    Py_ssize_t tmp_size = 0;
-    object tmp, res;
-
-    base_name = PyModule_GetName(base);
-    if (!base_name)
-        goto fail;
-
-    tmp = steal(PyUnicode_FromFormat("%s.%s", base_name, name));
-    if (!tmp.is_valid())
-        goto fail;
-
-    tmp_str = PyUnicode_AsUTF8AndSize(tmp.ptr(), &tmp_size);
-    if (!tmp_str)
-        goto fail;
-
-#if PY_VERSION_HEX < 0x030D00A0 || defined(Py_LIMITED_API)
-    res = borrow(PyImport_AddModule(tmp_str));
-#else
-    res = steal(PyImport_AddModuleRef(tmp_str));
-#endif
-
-    if (!res.is_valid())
-        goto fail;
-
-    if (doc) {
-        tmp = steal(PyUnicode_FromString(doc));
-        if (!tmp.is_valid())
-            goto fail;
-        if (PyObject_SetAttrString(res.ptr(), "__doc__", tmp.ptr()))
-            goto fail;
-    }
-
-    res.inc_ref(); // For PyModule_AddObject, which steals upon success
-    if (PyModule_AddObject(base, name, res.ptr())) {
-        res.dec_ref();
-        goto fail;
-    }
-
-    return res.release().ptr();
-
-fail:
-    raise_python_error();
-}
-
-// ========================================================================
-
-size_t obj_len(PyObject *o) {
-    Py_ssize_t res = PyObject_Size(o);
-    if (res < 0)
-        raise_python_error();
-    return (size_t) res;
-}
-
-size_t obj_len_hint(PyObject *o) noexcept {
-#if !defined(Py_LIMITED_API)
-    Py_ssize_t res = PyObject_LengthHint(o, 0);
-    if (res < 0) {
-        PyErr_Clear();
-        res = 0;
-    }
-    return (size_t) res;
-#else
-    PyTypeObject *tp = Py_TYPE(o);
-    lenfunc l = (lenfunc) type_get_slot(tp, Py_sq_length);
-    if (!l)
-        l = (lenfunc) type_get_slot(tp, Py_mp_length);
-
-    if (l) {
-        Py_ssize_t res = l(o);
-        if (res < 0) {
-            PyErr_Clear();
-            res = 0;
-        }
-        return (size_t) res;
-    }
-
-    try {
-        return cast<size_t>(handle(o).attr("__length_hint__")());
-    } catch (...) {
-        return 0;
-    }
-#endif
-}
-
-PyObject *obj_repr(PyObject *o) {
-    PyObject *res = PyObject_Repr(o);
-    if (!res)
-        raise_python_error();
-    return res;
-}
-
-bool obj_comp(PyObject *a, PyObject *b, int value) {
-    int rv = PyObject_RichCompareBool(a, b, value);
-    if (rv == -1)
-        raise_python_error();
-    return rv == 1;
-}
-
-PyObject *obj_op_1(PyObject *a, PyObject* (*op)(PyObject*)) {
-    PyObject *res = op(a);
-    if (!res)
-        raise_python_error();
-    return res;
-}
-
-PyObject *obj_op_2(PyObject *a, PyObject *b,
-                   PyObject *(*op)(PyObject *, PyObject *) ) {
-    PyObject *res = op(a, b);
-    if (!res)
-        raise_python_error();
-
-    return res;
-}
-
-PyObject *obj_vectorcall(PyObject *base, PyObject *const *args, size_t nargsf,
-                         PyObject *kwnames, bool method_call) {
-    PyObject *res = nullptr;
-    bool gil_error = false, cast_error = false;
-
-    size_t nargs_total = (size_t) (NB_VECTORCALL_NARGS(nargsf) +
-                         (kwnames ? NB_TUPLE_GET_SIZE(kwnames) : 0));
-
-#if !defined(Py_LIMITED_API)
-    if (!PyGILState_Check()) {
-        gil_error = true;
-        goto end;
-    }
-#endif
-
-    for (size_t i = 0; i < nargs_total; ++i) {
-        if (!args[i]) {
-            cast_error = true;
-            goto end;
-        }
-    }
-
-#if PY_VERSION_HEX < 0x03090000
-    if (method_call) {
-        PyObject *self = PyObject_GetAttr(args[0], /* name = */ base);
-        if (self) {
-            res = _PyObject_Vectorcall(self, (PyObject **) args + 1, nargsf - 1, kwnames);
-            Py_DECREF(self);
-        }
-    } else {
-        res = _PyObject_Vectorcall(base, (PyObject **) args, nargsf, kwnames);
-    }
-#else
-    res = (method_call ? PyObject_VectorcallMethod
-                       : PyObject_Vectorcall)(base, args, nargsf, kwnames);
-#endif
-
-end:
-    for (size_t i = 0; i < nargs_total; ++i)
-        Py_XDECREF(args[i]);
-    Py_XDECREF(kwnames);
-    Py_DECREF(base);
-
-    if (!res) {
-        if (cast_error)
-            raise_cast_error();
-        else if (gil_error)
-            raise("nanobind::detail::obj_vectorcall(): PyGILState_Check() failure.");
-        else
-            raise_python_error();
-    }
-
-    return res;
-}
-
-
-PyObject *obj_iter(PyObject *o) {
-    PyObject *result = PyObject_GetIter(o);
-    if (!result)
-        raise_python_error();
-    return result;
-}
-
-PyObject *obj_iter_next(PyObject *o) {
-    PyObject *result = PyIter_Next(o);
-    if (!result && PyErr_Occurred())
-        raise_python_error();
-    return result;
-}
-
-
-// ========================================================================
-
-PyObject *getattr(PyObject *obj, const char *key) {
-    PyObject *res = PyObject_GetAttrString(obj, key);
-    if (!res)
-        raise_python_error();
-    return res;
-}
-
-PyObject *getattr(PyObject *obj, PyObject *key) {
-    PyObject *res = PyObject_GetAttr(obj, key);
-    if (!res)
-        raise_python_error();
-    return res;
-}
-
-PyObject *getattr(PyObject *obj, const char *key_, PyObject *def) noexcept {
-#if (defined(Py_LIMITED_API) && PY_LIMITED_API < 0x030d0000) || defined(PYPY_VERSION)
-    str key(key_);
-    if (PyObject_HasAttr(obj, key.ptr())) {
-        PyObject *res = PyObject_GetAttr(obj, key.ptr());
-        if (res)
-            return res;
-        PyErr_Clear();
-    }
-#else
-    PyObject *res;
-    int rv;
-
-    #if PY_VERSION_HEX < 0x030d0000
-        rv = _PyObject_LookupAttr(obj, str(key_).ptr(), &res);
-    #else
-        rv = PyObject_GetOptionalAttrString(obj, key_, &res);
-    #endif
-
-    if (rv == 1)
-        return res;
-    else if (rv < 0)
-        PyErr_Clear();
-#endif
-
-    Py_XINCREF(def);
-    return def;
-}
-
-PyObject *getattr(PyObject *obj, PyObject *key, PyObject *def) noexcept {
-#if (defined(Py_LIMITED_API) && PY_LIMITED_API < 0x030d0000) || defined(PYPY_VERSION)
-    if (PyObject_HasAttr(obj, key)) {
-        PyObject *res = PyObject_GetAttr(obj, key);
-        if (res)
-            return res;
-        PyErr_Clear();
-    }
-#else
-    PyObject *res;
-    int rv;
-
-    #if PY_VERSION_HEX < 0x030d0000
-        rv = _PyObject_LookupAttr(obj, key, &res);
-    #else
-        rv = PyObject_GetOptionalAttr(obj, key, &res);
-    #endif
-
-    if (rv == 1)
-        return res;
-    else if (rv < 0)
-        PyErr_Clear();
-#endif
-
-    Py_XINCREF(def);
-    return def;
-}
-
-void getattr_or_raise(PyObject *obj, const char *key, PyObject **out) {
-    if (*out)
-        return;
-
-    PyObject *res = PyObject_GetAttrString(obj, key);
-    if (!res)
-        raise_python_error();
-
-    *out = res;
-}
-
-void getattr_or_raise(PyObject *obj, PyObject *key, PyObject **out) {
-    if (*out)
-        return;
-
-    PyObject *res = PyObject_GetAttr(obj, key);
-    if (!res)
-        raise_python_error();
-
-    *out = res;
-}
-
-void setattr(PyObject *obj, const char *key, PyObject *value) {
-    int rv = PyObject_SetAttrString(obj, key, value);
-    if (rv)
-        raise_python_error();
-}
-
-void setattr(PyObject *obj, PyObject *key, PyObject *value) {
-    int rv = PyObject_SetAttr(obj, key, value);
-    if (rv)
-        raise_python_error();
-}
-
-void delattr(PyObject *obj, const char *key) {
-    int rv = PyObject_DelAttrString(obj, key);
-    if (rv)
-        raise_python_error();
-}
-
-void delattr(PyObject *obj, PyObject *key) {
-    int rv = PyObject_DelAttr(obj, key);
-    if (rv)
-        raise_python_error();
-}
-
-// ========================================================================
-
-void getitem_or_raise(PyObject *obj, Py_ssize_t key, PyObject **out) {
-    if (*out)
-        return;
-
-    PyObject *res = PySequence_GetItem(obj, key);
-    if (!res)
-        raise_python_error();
-
-    *out = res;
-}
-
-void getitem_or_raise(PyObject *obj, const char *key_, PyObject **out) {
-    if (*out)
-        return;
-
-    PyObject *key, *res;
-
-    key = PyUnicode_FromString(key_);
-    if (!key)
-        raise_python_error();
-
-    res = PyObject_GetItem(obj, key);
-    Py_DECREF(key);
-
-    if (!res)
-        raise_python_error();
-
-    *out = res;
-}
-
-void getitem_or_raise(PyObject *obj, PyObject *key, PyObject **out) {
-    if (*out)
-        return;
-
-    PyObject *res = PyObject_GetItem(obj, key);
-    if (!res)
-        raise_python_error();
-
-    *out = res;
-}
-
-void setitem(PyObject *obj, Py_ssize_t key, PyObject *value) {
-    int rv = PySequence_SetItem(obj, key, value);
-    if (rv)
-        raise_python_error();
-}
-
-void setitem(PyObject *obj, const char *key_, PyObject *value) {
-    PyObject *key = PyUnicode_FromString(key_);
-    if (!key)
-        raise_python_error();
-
-    int rv = PyObject_SetItem(obj, key, value);
-    Py_DECREF(key);
-
-    if (rv)
-        raise_python_error();
-}
-
-void setitem(PyObject *obj, PyObject *key, PyObject *value) {
-    int rv = PyObject_SetItem(obj, key, value);
-    if (rv)
-        raise_python_error();
-}
-
-void delitem(PyObject *obj, Py_ssize_t key_) {
-    PyObject *key = PyLong_FromSsize_t(key_);
-    if (!key)
-        raise_python_error();
-
-    int rv = PyObject_DelItem(obj, key);
-    Py_DECREF(key);
-
-    if (rv)
-        raise_python_error();
-}
-
-void delitem(PyObject *obj, const char *key_) {
-    PyObject *key = PyUnicode_FromString(key_);
-    if (!key)
-        raise_python_error();
-
-    int rv = PyObject_DelItem(obj, key);
-    Py_DECREF(key);
-
-    if (rv)
-        raise_python_error();
-}
-
-void delitem(PyObject *obj, PyObject *key) {
-    int rv = PyObject_DelItem(obj, key);
-    if (rv)
-        raise_python_error();
-}
-
-// ========================================================================
-
-PyObject *str_from_obj(PyObject *o) {
-    PyObject *result = PyObject_Str(o);
-    if (!result)
-        raise_python_error();
-    return result;
-}
-
-PyObject *str_from_cstr(const char *str) {
-    PyObject *result = PyUnicode_FromString(str);
-    if (!result)
-        raise("nanobind::detail::str_from_cstr(): conversion error!");
-    return result;
-}
-
-PyObject *str_from_cstr_and_size(const char *str, size_t size) {
-    PyObject *result = PyUnicode_FromStringAndSize(str, (Py_ssize_t) size);
-    if (!result)
-        raise("nanobind::detail::str_from_cstr_and_size(): conversion error!");
-    return result;
-}
-
-// ========================================================================
-
-PyObject *bytes_from_obj(PyObject *o) {
-    PyObject *result = PyBytes_FromObject(o);
-    if (!result)
-        raise_python_error();
-    return result;
-}
-
-PyObject *bytes_from_cstr(const char *str) {
-    PyObject *result = PyBytes_FromString(str);
-    if (!result)
-        raise_python_error();
-    return result;
-}
-
-PyObject *bytes_from_cstr_and_size(const void *str, size_t size) {
-    PyObject *result = PyBytes_FromStringAndSize((const char *) str, (Py_ssize_t) size);
-    if (!result)
-        raise_python_error();
-    return result;
-}
-
-// ========================================================================
-
-PyObject *bytearray_from_obj(PyObject *o) {
-    PyObject *result = PyByteArray_FromObject(o);
-    if (!result)
-        raise_python_error();
-    return result;
-}
-
-PyObject *bytearray_from_cstr_and_size(const void *str, size_t size) {
-    PyObject *result = PyByteArray_FromStringAndSize((const char *) str, (Py_ssize_t) size);
-    if (!result)
-        raise_python_error();
-    return result;
-}
-
-
-// ========================================================================
-
-PyObject *bool_from_obj(PyObject *o) {
-    int rv = PyObject_IsTrue(o);
-    if (rv == -1)
-        raise_python_error();
-    return rv == 1 ? Py_True : Py_False;
-}
-
-PyObject *int_from_obj(PyObject *o) {
-    PyObject *result = PyNumber_Long(o);
-    if (!result)
-        raise_python_error();
-    return result;
-}
-
-PyObject *float_from_obj(PyObject *o) {
-    PyObject *result = PyNumber_Float(o);
-    if (!result)
-        raise_python_error();
-    return result;
-}
-
-// ========================================================================
-
-PyObject *tuple_from_obj(PyObject *o) {
-    PyObject *result = PySequence_Tuple(o);
-    if (!result)
-        raise_python_error();
-    return result;
-}
-
-PyObject *list_from_obj(PyObject *o) {
-    PyObject *result = PySequence_List(o);
-    if (!result)
-        raise_python_error();
-    return result;
-}
-
-PyObject *set_from_obj(PyObject *o) {
-    PyObject *result = PySet_New(o);
-    if (!result)
-        raise_python_error();
-    return result;
-}
-
-PyObject *frozenset_from_obj(PyObject *o) {
-    PyObject *result = PyFrozenSet_New(o);
-    if (!result)
-        raise_python_error();
-    return result;
-}
-
-// ========================================================================
-
-PyObject **seq_get(PyObject *seq, size_t *size_out, PyObject **temp_out) noexcept {
-    PyObject *temp = nullptr;
-    size_t size = 0;
-    PyObject **result = nullptr;
-
-    /* This function is used during overload resolution; if anything
-       goes wrong, it fails gracefully without reporting errors. Other
-       overloads will then be tried. */
-
-    if (PyUnicode_CheckExact(seq) || PyBytes_CheckExact(seq)) {
-        *size_out = 0;
-        *temp_out = nullptr;
-        return nullptr;
-    }
-
-#if !defined(Py_LIMITED_API) && !defined(PYPY_VERSION)
-    if (PyTuple_CheckExact(seq)) {
-        size = (size_t) PyTuple_GET_SIZE(seq);
-        result = ((PyTupleObject *) seq)->ob_item;
-        /* Special case for zero-sized lists/tuples. CPython
-           sets ob_item to NULL, which this function incidentally uses to
-           signal an error. Return a nonzero pointer that will, however,
-           still trigger a segfault if dereferenced. */
-        if (size == 0)
-            result = (PyObject **) 1;
-#  if !defined(NB_FREE_THREADED) // Require immutable holder in free-threaded mode
-    } else if (PyList_CheckExact(seq)) {
-        size = (size_t) PyList_GET_SIZE(seq);
-        result = ((PyListObject *) seq)->ob_item;
-        if (size == 0) // ditto
-            result = (PyObject **) 1;
-#  endif
-    } else if (PySequence_Check(seq)) {
-        temp = PySequence_Tuple(seq);
-
-        if (temp)
-            result = seq_get(temp, &size, temp_out);
-        else
-            PyErr_Clear();
-    }
-#else
-    /* There isn't a nice way to get a PyObject** in Py_LIMITED_API. This
-       is going to be slow, but hopefully also very future-proof.. */
-    if (PySequence_Check(seq)) {
-        Py_ssize_t size_seq = PySequence_Length(seq);
-
-        if (size_seq >= 0) {
-            result = (PyObject **) PyMem_Malloc(sizeof(PyObject *) *
-                                                (size_seq + 1));
-
-            if (result) {
-                result[size_seq] = nullptr;
-
-                for (Py_ssize_t i = 0; i < size_seq; ++i) {
-                    PyObject *o = PySequence_GetItem(seq, i);
-
-                    if (o) {
-                        result[i] = o;
-                    } else {
-                        for (Py_ssize_t j = 0; j < i; ++j)
-                            Py_DECREF(result[j]);
-
-                        PyMem_Free(result);
-                        result = nullptr;
-                        break;
-                    }
-                }
-            }
-
-            if (result) {
-                temp = PyCapsule_New(result, nullptr, [](PyObject *o) {
-                    PyObject **ptr = (PyObject **) PyCapsule_GetPointer(o, nullptr);
-                    for (size_t i = 0; ptr[i] != nullptr; ++i)
-                        Py_DECREF(ptr[i]);
-                    PyMem_Free(ptr);
-                });
-
-                if (temp) {
-                    size = (size_t) size_seq;
-                } else if (!temp) {
-                    PyErr_Clear();
-                    for (Py_ssize_t i = 0; i < size_seq; ++i)
-                        Py_DECREF(result[i]);
-
-                    PyMem_Free(result);
-                    result = nullptr;
-                }
-            }
-        } else if (size_seq < 0) {
-            PyErr_Clear();
-        }
-    }
-#endif
-
-    *temp_out = temp;
-    *size_out = size;
-    return result;
-}
-
-
-PyObject **seq_get_with_size(PyObject *seq, size_t size,
-                             PyObject **temp_out) noexcept {
-
-    /* This function is used during overload resolution; if anything
-       goes wrong, it fails gracefully without reporting errors. Other
-       overloads will then be tried. */
-
-    PyObject *temp = nullptr,
-             **result = nullptr;
-
-#if !defined(Py_LIMITED_API) && !defined(PYPY_VERSION)
-    if (PyTuple_CheckExact(seq)) {
-        if (size == (size_t) PyTuple_GET_SIZE(seq)) {
-            result = ((PyTupleObject *) seq)->ob_item;
-            /* Special case for zero-sized lists/tuples. CPython
-               sets ob_item to NULL, which this function incidentally uses to
-               signal an error. Return a nonzero pointer that will, however,
-               still trigger a segfault if dereferenced. */
-            if (size == 0)
-                result = (PyObject **) 1;
-        }
-#  if !defined(NB_FREE_THREADED) // Require immutable holder in free-threaded mode
-    } else if (PyList_CheckExact(seq)) {
-        if (size == (size_t) PyList_GET_SIZE(seq)) {
-            result = ((PyListObject *) seq)->ob_item;
-            if (size == 0) // ditto
-                result = (PyObject **) 1;
-        }
-#  endif
-    } else if (PySequence_Check(seq)) {
-        temp = PySequence_Tuple(seq);
-
-        if (temp)
-            result = seq_get_with_size(temp, size, temp_out);
-        else
-            PyErr_Clear();
-    }
-#else
-    /* There isn't a nice way to get a PyObject** in Py_LIMITED_API. This
-       is going to be slow, but hopefully also very future-proof.. */
-    if (PySequence_Check(seq)) {
-        Py_ssize_t size_seq = PySequence_Length(seq);
-
-        if (size == (size_t) size_seq) {
-            result =
-                (PyObject **) PyMem_Malloc(sizeof(PyObject *) * (size + 1));
-
-            if (result) {
-                result[size] = nullptr;
-
-                for (Py_ssize_t i = 0; i < size_seq; ++i) {
-                    PyObject *o = PySequence_GetItem(seq, i);
-
-                    if (o) {
-                        result[i] = o;
-                    } else {
-                        for (Py_ssize_t j = 0; j < i; ++j)
-                            Py_DECREF(result[j]);
-
-                        PyMem_Free(result);
-                        result = nullptr;
-                        break;
-                    }
-                }
-            }
-
-            if (result) {
-                temp = PyCapsule_New(result, nullptr, [](PyObject *o) {
-                    PyObject **ptr = (PyObject **) PyCapsule_GetPointer(o, nullptr);
-                    for (size_t i = 0; ptr[i] != nullptr; ++i)
-                        Py_DECREF(ptr[i]);
-                    PyMem_Free(ptr);
-                });
-
-                if (!temp) {
-                    PyErr_Clear();
-                    for (Py_ssize_t i = 0; i < size_seq; ++i)
-                        Py_DECREF(result[i]);
-
-                    PyMem_Free(result);
-                    result = nullptr;
-                }
-            }
-        } else if (size_seq < 0) {
-            PyErr_Clear();
-        }
-    }
-#endif
-
-    *temp_out = temp;
-    return result;
-}
-
-// ========================================================================
-
-static void property_install_impl(PyTypeObject *tp, PyObject *scope,
-                                  const char *name, PyObject *getter,
-                                  PyObject *setter) {
-    PyObject *m = getter ? getter : setter;
-    object doc = none();
-
-    if (m && (Py_TYPE(m) == internals->nb_func ||
-              Py_TYPE(m) == internals->nb_method)) {
-        func_data *f = nb_func_data(m);
-        if (f->flags & (uint32_t) func_flags::has_doc)
-            doc = str(f->doc);
-    }
-
-    handle(scope).attr(name) = handle(tp)(
-        getter ? handle(getter) : handle(Py_None),
-        setter ? handle(setter) : handle(Py_None),
-        handle(Py_None), // deleter
-        doc
-    );
-}
-
-void property_install(PyObject *scope, const char *name, PyObject *getter,
-                      PyObject *setter) noexcept {
-    property_install_impl(&PyProperty_Type, scope, name, getter, setter);
-}
-
-void property_install_static(PyObject *scope, const char *name,
-                             PyObject *getter, PyObject *setter) noexcept {
-    property_install_impl(nb_static_property_tp(), scope, name, getter,
-                          setter);
-}
-
-// ========================================================================
-
-void tuple_check(PyObject *tuple, size_t nargs) {
-    for (size_t i = 0; i < nargs; ++i) {
-        if (!NB_TUPLE_GET_ITEM(tuple, i))
-            raise_cast_error();
-    }
-}
-
-// ========================================================================
-
-void print(PyObject *value, PyObject *end, PyObject *file) {
-    if (!file)
-        file = PySys_GetObject("stdout");
-
-    int rv = PyFile_WriteObject(value, file, Py_PRINT_RAW);
-    if (rv)
-        raise_python_error();
-
-    if (end)
-        rv = PyFile_WriteObject(end, file, Py_PRINT_RAW);
-    else
-        rv = PyFile_WriteString("\n", file);
-
-    if (rv)
-        raise_python_error();
-}
-
-// ========================================================================
-
-NB_CORE bool load_cmplx(PyObject *ob, uint8_t flags,
-                        std::complex<double> *out) noexcept {
-    bool is_complex = PyComplex_CheckExact(ob),
-         convert = (flags & (uint8_t) cast_flags::convert);
-#if !defined(Py_LIMITED_API)
-    if (is_complex || convert) {
-        Py_complex result = PyComplex_AsCComplex(ob);
-        if (result.real != -1.0 || !PyErr_Occurred()) {
-            *out = std::complex<double>(result.real, result.imag);
-            return true;
-        } else {
-            PyErr_Clear();
-        }
-    }
-#else
-#if Py_LIMITED_API < 0x030D0000
-    // Before version 3.13, __complex__() was not called by the Stable ABI
-    // functions PyComplex_{Real,Imag}AsDouble(), so we do so ourselves.
-    if (!is_complex && convert
-            && !PyType_IsSubtype(Py_TYPE(ob), &PyComplex_Type)
-            && PyObject_HasAttrString(ob, "__complex__")) {
-        PyObject* tmp = PyObject_CallFunctionObjArgs(
-                (PyObject*) &PyComplex_Type, ob, NULL);
-        if (tmp) {
-            double re = PyComplex_RealAsDouble(tmp);
-            double im = PyComplex_ImagAsDouble(tmp);
-            Py_DECREF(tmp);
-            if ((re != -1.0 && im != -1.0) || !PyErr_Occurred()) {
-                *out = std::complex<double>(re, im);
-                return true;
-            }
-        }
-        PyErr_Clear();
-        return false;
-    }
-#endif
-    if (is_complex || convert) {
-        double re = PyComplex_RealAsDouble(ob);
-        double im = PyComplex_ImagAsDouble(ob);
-        if ((re != -1.0 && im != -1.0) || !PyErr_Occurred()) {
-            *out = std::complex<double>(re, im);
-            return true;
-        } else {
-            PyErr_Clear();
-        }
-    }
-#endif
-
-    return false;
-}
-
-bool load_f64(PyObject *o, uint8_t flags, double *out) noexcept {
-    bool is_float = PyFloat_CheckExact(o);
-
-#if !defined(Py_LIMITED_API)
-    if (NB_LIKELY(is_float)) {
-        *out = PyFloat_AS_DOUBLE(o);
-        return true;
-    }
-
-    is_float = false;
-#endif
-
-    if (is_float || (flags & (uint8_t) cast_flags::convert)) {
-        double result = PyFloat_AsDouble(o);
-
-        if (result != -1.0 || !PyErr_Occurred()) {
-            *out = result;
-            return true;
-        } else {
-            PyErr_Clear();
-        }
-    }
-
-    return false;
-}
-
-bool load_f32(PyObject *o, uint8_t flags, float *out) noexcept {
-    bool is_float = PyFloat_CheckExact(o);
-    bool convert = flags & (uint8_t) cast_flags::convert;
-
-#if !defined(Py_LIMITED_API)
-    if (NB_LIKELY(is_float)) {
-        double d = PyFloat_AS_DOUBLE(o);
-        float result = (float) d;
-        if (convert || (double) result == d || d != d) {
-            *out = result;
-            return true;
-        } else {
-            return false;
-        }
-    }
-
-    is_float = false;
-#endif
-
-    if (is_float || convert) {
-        double d = PyFloat_AsDouble(o);
-        if (d != -1.0 || !PyErr_Occurred()) {
-            float result = (float) d;
-            if (convert || (double) result == d || d != d) {
-                *out = result;
-                return true;
-            }
-        } else {
-            PyErr_Clear();
-        }
-    }
-
-    return false;
-}
-
-#if !defined(Py_LIMITED_API) && !defined(PYPY_VERSION) && PY_VERSION_HEX < 0x030c0000
-// Direct access for compact integers. These functions are
-// available as part of Python starting with version 3.12b1+
-
-NB_INLINE bool PyUnstable_Long_IsCompact(const PyLongObject *o) {
-    return abs(Py_SIZE(o)) <= 1;
-}
-
-NB_INLINE Py_ssize_t PyUnstable_Long_CompactValue(const PyLongObject *o) {
-    return Py_SIZE(o) * (Py_ssize_t) o->ob_digit[0];
-}
-#endif
-
-template <typename T, bool Recurse = true>
-NB_INLINE bool load_int(PyObject *o, uint32_t flags, T *out) noexcept {
-    if (NB_LIKELY(PyLong_CheckExact(o))) {
-#if !defined(Py_LIMITED_API) && !defined(PYPY_VERSION)
-        PyLongObject *l = (PyLongObject *) o;
-
-        // Fast path for compact integers
-        if (NB_LIKELY(PyUnstable_Long_IsCompact(l))) {
-            Py_ssize_t value = PyUnstable_Long_CompactValue(l);
-            T value_t = (T) value;
-
-            if (NB_UNLIKELY((std::is_unsigned_v<T> && value < 0) ||
-                            (sizeof(T) != sizeof(Py_ssize_t) &&
-                             value != (Py_ssize_t) value_t)))
-                return false;
-
-            *out = value_t;
-            return true;
-        }
-#endif
-
-        // Slow path
-        using T0 = std::conditional_t<sizeof(T) <= sizeof(long), long, long long>;
-        using Tp = std::conditional_t<std::is_signed_v<T>, T0, std::make_unsigned_t<T0>>;
-
-        Tp value_p;
-        if constexpr (std::is_unsigned_v<Tp>)
-            value_p = sizeof(T) <= sizeof(long) ? (Tp) PyLong_AsUnsignedLong(o)
-                                                : (Tp) PyLong_AsUnsignedLongLong(o);
-        else
-            value_p = sizeof(T) <= sizeof(long) ? (Tp) PyLong_AsLong(o)
-                                                : (Tp) PyLong_AsLongLong(o);
-
-        if (value_p == Tp(-1) && PyErr_Occurred()) {
-            PyErr_Clear();
-            return false;
-        }
-
-        T value = (T) value_p;
-        if constexpr (sizeof(Tp) != sizeof(T)) {
-            if (value_p != (Tp) value)
-                return false;
-        }
-
-        *out = value;
-        return true;
-    }
-
-    if constexpr (Recurse) {
-        if ((flags & (uint8_t) cast_flags::convert) && !PyFloat_Check(o)) {
-            PyObject* temp = PyNumber_Long(o);
-            if (temp) {
-                bool result = load_int<T, false>(temp, 0, out);
-                Py_DECREF(temp);
-                return result;
-            } else {
-                PyErr_Clear();
-            }
-        }
-    }
-
-    return false;
-}
-
-bool load_u8(PyObject *o, uint8_t flags, uint8_t *out) noexcept {
-    return load_int(o, flags, out);
-}
-
-bool load_i8(PyObject *o, uint8_t flags, int8_t *out) noexcept {
-    return load_int(o, flags, out);
-}
-
-bool load_u16(PyObject *o, uint8_t flags, uint16_t *out) noexcept {
-    return load_int(o, flags, out);
-}
-
-bool load_i16(PyObject *o, uint8_t flags, int16_t *out) noexcept {
-    return load_int(o, flags, out);
-}
-
-bool load_u32(PyObject *o, uint8_t flags, uint32_t *out) noexcept {
-    return load_int(o, flags, out);
-}
-
-bool load_i32(PyObject *o, uint8_t flags, int32_t *out) noexcept {
-    return load_int(o, flags, out);
-}
-
-bool load_u64(PyObject *o, uint8_t flags, uint64_t *out) noexcept {
-    return load_int(o, flags, out);
-}
-
-bool load_i64(PyObject *o, uint8_t flags, int64_t *out) noexcept {
-    return load_int(o, flags, out);
-}
-
-// ========================================================================
-
-void incref_checked(PyObject *o) noexcept {
-    if (!o)
-        return;
-#if !defined(Py_LIMITED_API)
-    if (!PyGILState_Check())
-        fail("nanobind::detail::incref_check(): attempted to change the "
-             "reference count of a Python object while the GIL was not held.");
-#endif
-    Py_INCREF(o);
-}
-
-void decref_checked(PyObject *o) noexcept {
-    if (!o)
-        return;
-#if !defined(Py_LIMITED_API)
-    if (!PyGILState_Check())
-        fail("nanobind::detail::decref_check(): attempted to change the "
-             "reference count of a Python object while the GIL was not held.");
-#endif
-    Py_DECREF(o);
-}
-
-// ========================================================================
-
-bool leak_warnings() noexcept {
-    return internals->print_leak_warnings;
-}
-
-bool implicit_cast_warnings() noexcept {
-    return internals->print_implicit_cast_warnings;
-}
-
-void set_leak_warnings(bool value) noexcept {
-    internals->print_leak_warnings = value;
-}
-
-void set_implicit_cast_warnings(bool value) noexcept {
-    internals->print_implicit_cast_warnings = value;
-}
-
-// ========================================================================
-
-void slice_compute(PyObject *slice, Py_ssize_t size, Py_ssize_t &start,
-                   Py_ssize_t &stop, Py_ssize_t &step,
-                   size_t &slice_length) {
-    if (PySlice_Unpack(slice, &start, &stop, &step) < 0)
-        detail::raise_python_error();
-    Py_ssize_t slice_length_ =
-        PySlice_AdjustIndices((Py_ssize_t) size, &start, &stop, step);
-    slice_length = (size_t) slice_length_;
-}
-
-bool iterable_check(PyObject *o) noexcept {
-#if !defined(Py_LIMITED_API)
-    return Py_TYPE(o)->tp_iter != nullptr || PySequence_Check(o);
-#else
-    PyObject *it = PyObject_GetIter(o);
-    if (it) {
-        Py_DECREF(it);
-        return true;
-    } else {
-        PyErr_Clear();
-        return false;
-    }
-#endif
-}
-
-// ========================================================================
-
-NB_CORE PyObject *repr_list(PyObject *o) {
-    object s = steal(nb_inst_name(o));
-    s += str("([");
-    size_t len = obj_len(o);
-    for (size_t i = 0; i < len; ++i) {
-        s += repr(handle(o)[i]);
-        if (i + 1 < len)
-            s += str(", ");
-    }
-    s += str("])");
-    return s.release().ptr();
-}
-
-NB_CORE PyObject *repr_map(PyObject *o) {
-    object s = steal(nb_inst_name(o));
-    s += str("({");
-    bool first = true;
-    for (handle kv : handle(o).attr("items")()) {
-        if (!first)
-            s += str(", ");
-        s += repr(kv[0]) + str(": ") + repr(kv[1]);
-        first = false;
-    }
-    s += str("})");
-    return s.release().ptr();
-}
-
-// ========================================================================
-
-bool issubclass(PyObject *a, PyObject *b) {
-    int rv = PyObject_IsSubclass(a, b);
-    if (rv == -1)
-        raise_python_error();
-    return bool(rv);
-}
-
-// ========================================================================
-
-PyObject *dict_get_item_ref_or_fail(PyObject *d, PyObject *k) {
-    PyObject *value;
-    bool error = false;
-
-#if PY_VERSION_HEX < 0x030D00A1 || defined(Py_LIMITED_API)
-    value = PyDict_GetItemWithError(d, k);
-    if (value)
-        Py_INCREF(value);
-    else
-        error = PyErr_Occurred();
-#else
-    error = PyDict_GetItemRef(d, k, &value) == -1;
-#endif
-    check(!error, "nanobind::detail::dict_get_item_ref_or_fail(): dictionary lookup failed!");
-    return value;
-}
-
-NAMESPACE_END(detail)
-NAMESPACE_END(NB_NAMESPACE)
diff --git a/src/nanobind/src/error.cpp b/src/nanobind/src/error.cpp
deleted file mode 100644
index 5d1d666..0000000
--- a/src/nanobind/src/error.cpp
+++ /dev/null
@@ -1,325 +0,0 @@
-/*
-    src/error.cpp: libnanobind functionality for exceptions
-
-    Copyright (c) 2022 Wenzel Jakob
-
-    All rights reserved. Use of this source code is governed by a
-    BSD-style license that can be found in the LICENSE file.
-*/
-
-#include <nanobind/nanobind.h>
-#include <cstdarg>
-#include "buffer.h"
-#include "nb_internals.h"
-
-NAMESPACE_BEGIN(NB_NAMESPACE)
-NAMESPACE_BEGIN(detail)
-
-// Protected by internals->mutex in free-threaded builds
-Buffer buf(128);
-
-NAMESPACE_END(detail)
-
-#if PY_VERSION_HEX >= 0x030C0000
-python_error::python_error() {
-    m_value = PyErr_GetRaisedException();
-    check(m_value,
-          "nanobind::python_error::python_error(): error indicator unset!");
-}
-
-python_error::~python_error() {
-    if (m_value) {
-        gil_scoped_acquire acq;
-        /* With GIL held */ {
-            // Clear error status in case the following executes Python code
-            error_scope scope;
-            Py_DECREF(m_value);
-        }
-    }
-
-    free(m_what);
-}
-
-python_error::python_error(const python_error &e)
-    : std::exception(e), m_value(e.m_value) {
-    if (m_value) {
-        gil_scoped_acquire acq;
-        Py_INCREF(m_value);
-    }
-    if (e.m_what)
-        m_what = detail::strdup_check(e.m_what);
-}
-
-python_error::python_error(python_error &&e) noexcept
-    : std::exception(e), m_value(e.m_value), m_what(e.m_what) {
-    e.m_value = nullptr;
-    e.m_what = nullptr;
-}
-
-void python_error::restore() noexcept {
-    check(m_value,
-          "nanobind::python_error::restore(): error was already restored!");
-
-    PyErr_SetRaisedException(m_value);
-    m_value = nullptr;
-}
-
-#else /* Exception handling for Python 3.11 and older versions */
-
-python_error::python_error() {
-    PyErr_Fetch(&m_type, &m_value, &m_traceback);
-    check(m_type,
-          "nanobind::python_error::python_error(): error indicator unset!");
-}
-
-python_error::~python_error() {
-    if (m_type) {
-        gil_scoped_acquire acq;
-        /* With GIL held */ {
-            // Clear error status in case the following executes Python code
-            error_scope scope;
-            Py_XDECREF(m_type);
-            Py_XDECREF(m_value);
-            Py_XDECREF(m_traceback);
-        }
-    }
-    free(m_what);
-}
-
-python_error::python_error(const python_error &e)
-    : std::exception(e), m_type(e.m_type), m_value(e.m_value),
-      m_traceback(e.m_traceback) {
-    if (m_type) {
-        gil_scoped_acquire acq;
-        Py_INCREF(m_type);
-        Py_XINCREF(m_value);
-        Py_XINCREF(m_traceback);
-    }
-    if (e.m_what)
-        m_what = detail::strdup_check(e.m_what);
-}
-
-python_error::python_error(python_error &&e) noexcept
-    : std::exception(e), m_type(e.m_type), m_value(e.m_value),
-      m_traceback(e.m_traceback), m_what(e.m_what) {
-    e.m_type = e.m_value = e.m_traceback = nullptr;
-    e.m_what = nullptr;
-}
-
-void python_error::restore() noexcept {
-    check(m_type,
-          "nanobind::python_error::restore(): error was already restored!");
-
-    PyErr_Restore(m_type, m_value, m_traceback);
-    m_type = m_value = m_traceback = nullptr;
-}
-
-#endif
-
-const char *python_error::what() const noexcept {
-    using namespace nanobind::detail;
-
-    // Return the existing error message if already computed once
-    if (m_what)
-        return m_what;
-
-    gil_scoped_acquire acq;
-    // 'buf' is protected by internals->mutex in free-threaded builds
-    lock_internals guard(internals);
-
-    // Try again with GIL held
-    if (m_what)
-        return m_what;
-
-#if PY_VERSION_HEX < 0x030C0000
-    PyErr_NormalizeException(&m_type, &m_value, &m_traceback);
-    check(m_type,
-          "nanobind::python_error::what(): PyErr_NormalizeException() failed!");
-
-    if (m_traceback) {
-        if (PyException_SetTraceback(m_value, m_traceback) < 0)
-            PyErr_Clear();
-    }
-
-    handle exc_type = m_type, exc_value = m_value;
-#else
-    handle exc_value = m_value, exc_type = exc_value.type();
-#endif
-    object exc_traceback = traceback();
-
-#if defined(Py_LIMITED_API) || defined(PYPY_VERSION)
-    object mod = module_::import_("traceback"),
-           result = mod.attr("format_exception")(exc_type, exc_value, exc_traceback);
-    m_what = strdup_check(borrow<str>(str("\n").attr("join")(result)).c_str());
-#else
-    buf.clear();
-    if (exc_traceback.is_valid()) {
-        PyTracebackObject *to = (PyTracebackObject *) exc_traceback.ptr();
-
-        // Get the deepest trace possible
-        while (to->tb_next)
-            to = to->tb_next;
-
-        PyFrameObject *frame = to->tb_frame;
-        Py_XINCREF(frame);
-
-        std::vector<PyFrameObject *, py_allocator<PyFrameObject *>> frames;
-
-        while (frame) {
-            frames.push_back(frame);
-#if PY_VERSION_HEX >= 0x03090000
-            frame = PyFrame_GetBack(frame);
-#else
-            frame = frame->f_back;
-            Py_XINCREF(frame);
-#endif
-        }
-
-        buf.put("Traceback (most recent call last):\n");
-        for (auto it = frames.rbegin(); it != frames.rend(); ++it) {
-            frame = *it;
-#if PY_VERSION_HEX >= 0x03090000
-            PyCodeObject *f_code = PyFrame_GetCode(frame);
-#else
-            PyCodeObject *f_code = frame->f_code;
-#endif
-            buf.put("  File \"");
-            buf.put_dstr(borrow<str>(f_code->co_filename).c_str());
-            buf.put("\", line ");
-            buf.put_uint32(PyFrame_GetLineNumber(frame));
-            buf.put(", in ");
-            buf.put_dstr(borrow<str>(f_code->co_name).c_str());
-            buf.put('\n');
-#if PY_VERSION_HEX >= 0x03090000
-            Py_DECREF(f_code);
-#endif
-            Py_DECREF(frame);
-        }
-    }
-
-    if (exc_type.is_valid()) {
-        object name = exc_type.attr("__name__");
-        buf.put_dstr(borrow<str>(name).c_str());
-        buf.put(": ");
-    }
-
-    if (exc_value.is_valid())
-        buf.put_dstr(str(m_value).c_str());
-    m_what = buf.copy();
-#endif
-
-    return m_what;
-}
-
-builtin_exception::builtin_exception(exception_type type, const char *what)
-    : std::runtime_error(what ? what : ""), m_type(type) { }
-builtin_exception::~builtin_exception() { }
-
-NAMESPACE_BEGIN(detail)
-
-void register_exception_translator(exception_translator t, void *payload) {
-    nb_translator_seq *cur  = &internals->translators,
-                      *next = new nb_translator_seq(*cur);
-    cur->next = next;
-    cur->payload = payload;
-    cur->translator = t;
-}
-
-NB_CORE PyObject *exception_new(PyObject *scope, const char *name,
-                                PyObject *base) {
-    object modname;
-    if (PyModule_Check(scope))
-        modname = getattr(scope, "__name__", handle());
-    else
-        modname = getattr(scope, "__module__", handle());
-
-    if (!modname.is_valid())
-        raise("nanobind::detail::exception_new(): could not determine module "
-              "name!");
-
-    str combined =
-        steal<str>(PyUnicode_FromFormat("%U.%s", modname.ptr(), name));
-
-    object result = steal(PyErr_NewException(combined.c_str(), base, nullptr));
-    check(result, "nanobind::detail::exception_new(): creation failed!");
-
-    if (hasattr(scope, name))
-        raise("nanobind::detail::exception_new(): an object of the same name "
-              "already exists!");
-
-    setattr(scope, name, result);
-    return result.release().ptr();
-}
-
-NAMESPACE_END(detail)
-
-static void chain_error_v(handle type, const char *fmt, va_list args) noexcept {
-#if PY_VERSION_HEX >= 0x030C0000
-    PyObject *value = PyErr_GetRaisedException();
-#else
-    PyObject *tp = nullptr, *value = nullptr, *traceback = nullptr;
-
-    PyErr_Fetch(&tp, &value, &traceback);
-
-    if (tp) {
-        PyErr_NormalizeException(&tp, &value, &traceback);
-        if (traceback) {
-            PyException_SetTraceback(value, traceback);
-            Py_DECREF(traceback);
-        }
-
-        Py_DECREF(tp);
-        tp = traceback = nullptr;
-    }
-#endif
-
-#if !defined(PYPY_VERSION)
-    PyErr_FormatV(type.ptr(), fmt, args);
-#else
-    PyObject *exc_str = PyUnicode_FromFormatV(fmt, args);
-    check(exc_str, "nanobind::detail::raise_from(): PyUnicode_FromFormatV() failed!");
-    PyErr_SetObject(type.ptr(), exc_str);
-    Py_DECREF(exc_str);
-#endif
-
-    if (!value)
-        return;
-
-    PyObject *value_2 = nullptr;
-#if PY_VERSION_HEX >= 0x030C0000
-    value_2 = PyErr_GetRaisedException();
-#else
-    PyErr_Fetch(&tp, &value_2, &traceback);
-    PyErr_NormalizeException(&tp, &value_2, &traceback);
-#endif
-
-    Py_INCREF(value);
-    PyException_SetCause(value_2, value); // steals
-    PyException_SetContext(value_2, value); // steals
-
-#if PY_VERSION_HEX >= 0x030C0000
-    PyErr_SetRaisedException(value_2);
-#else
-    PyErr_Restore(tp, value_2, traceback);
-#endif
-}
-
-void chain_error(handle type, const char *fmt, ...) noexcept {
-    va_list args;
-    va_start(args, fmt);
-    chain_error_v(type, fmt, args);
-    va_end(args);
-}
-
-void raise_from(python_error &e, handle type, const char *fmt, ...) {
-    e.restore();
-
-    va_list args;
-    va_start(args, fmt);
-    chain_error_v(type, fmt, args);
-    va_end(args);
-
-    detail::raise_python_error();
-}
-
-NAMESPACE_END(NB_NAMESPACE)
diff --git a/src/nanobind/src/hash.h b/src/nanobind/src/hash.h
deleted file mode 100644
index 2cf0536..0000000
--- a/src/nanobind/src/hash.h
+++ /dev/null
@@ -1,33 +0,0 @@
-//-----------------------------------------------------------------------------
-// Slightly adapted version of the MurmurHash3 codebase (originally by Austin
-// Appleby, in the public domain)
-//
-// The changes are as follows:
-//
-// - fmix32 and fmix64 are exported to other compilation units, since they
-//   are useful as a hash function for 32/64 bit integers and pointers.
-//-----------------------------------------------------------------------------
-
-#pragma once
-
-#include <cstdint>
-#include <cstdlib>
-
-inline uint32_t fmix32(uint32_t h) {
-    h ^= h >> 16;
-    h *= 0x85ebca6b;
-    h ^= h >> 13;
-    h *= 0xc2b2ae35;
-    h ^= h >> 16;
-
-    return h;
-}
-
-inline uint64_t fmix64(uint64_t k) {
-    k ^= k >> 33;
-    k *= (uint64_t) 0xff51afd7ed558ccdull;
-    k ^= k >> 33;
-    k *= (uint64_t) 0xc4ceb9fe1a85ec53ull;
-    k ^= k >> 33;
-    return k;
-}
diff --git a/src/nanobind/src/implicit.cpp b/src/nanobind/src/implicit.cpp
deleted file mode 100644
index 10702a0..0000000
--- a/src/nanobind/src/implicit.cpp
+++ /dev/null
@@ -1,75 +0,0 @@
-/*
-    src/implicit.cpp: functions for registering implicit conversions
-
-    Copyright (c) 2022 Wenzel Jakob
-
-    All rights reserved. Use of this source code is governed by a
-    BSD-style license that can be found in the LICENSE file.
-*/
-
-#include <nanobind/trampoline.h>
-#include "nb_internals.h"
-
-NAMESPACE_BEGIN(NB_NAMESPACE)
-NAMESPACE_BEGIN(detail)
-
-void implicitly_convertible(const std::type_info *src,
-                            const std::type_info *dst) noexcept {
-    nb_internals *internals_ = internals;
-    type_data *t = nb_type_c2p(internals_, dst);
-    check(t, "nanobind::detail::implicitly_convertible(src=%s, dst=%s): "
-             "destination type unknown!", type_name(src), type_name(dst));
-
-    lock_internals guard(internals_);
-    size_t size = 0;
-
-    if (t->flags & (uint32_t) type_flags::has_implicit_conversions) {
-        while (t->implicit.cpp && t->implicit.cpp[size])
-            size++;
-    } else {
-        t->implicit.cpp = nullptr;
-        t->implicit.py = nullptr;
-        t->flags |= (uint32_t) type_flags::has_implicit_conversions;
-    }
-
-    void **data = (void **) PyMem_Malloc(sizeof(void *) * (size + 2));
-
-    if (size)
-        memcpy(data, t->implicit.cpp, size * sizeof(void *));
-    data[size] = (void *) src;
-    data[size + 1] = nullptr;
-    PyMem_Free(t->implicit.cpp);
-    t->implicit.cpp = (decltype(t->implicit.cpp)) data;
-}
-
-void implicitly_convertible(bool (*predicate)(PyTypeObject *, PyObject *,
-                                              cleanup_list *),
-                            const std::type_info *dst) noexcept {
-    nb_internals *internals_ = internals;
-    type_data *t = nb_type_c2p(internals_, dst);
-    check(t, "nanobind::detail::implicitly_convertible(src=<predicate>, dst=%s): "
-             "destination type unknown!", type_name(dst));
-
-    lock_internals guard(internals_);
-    size_t size = 0;
-
-    if (t->flags & (uint32_t) type_flags::has_implicit_conversions) {
-        while (t->implicit.py && t->implicit.py[size])
-            size++;
-    } else {
-        t->implicit.cpp = nullptr;
-        t->implicit.py = nullptr;
-        t->flags |= (uint32_t) type_flags::has_implicit_conversions;
-    }
-
-    void **data = (void **) PyMem_Malloc(sizeof(void *) * (size + 2));
-    if (size)
-        memcpy(data, t->implicit.py, size * sizeof(void *));
-    data[size] = (void *) predicate;
-    data[size + 1] = nullptr;
-    PyMem_Free(t->implicit.py);
-    t->implicit.py = (decltype(t->implicit.py)) data;
-}
-
-NAMESPACE_END(detail)
-NAMESPACE_END(NB_NAMESPACE)
diff --git a/src/nanobind/src/nb_abi.h b/src/nanobind/src/nb_abi.h
deleted file mode 100644
index da704d9..0000000
--- a/src/nanobind/src/nb_abi.h
+++ /dev/null
@@ -1,102 +0,0 @@
-/*
-   src/nb_abi.h: this file computes tags that are used to isolate extensions
-   from each other in the case of platform or nanobind-related ABI
-   incompatibilities. The file is included by ``nb_internals.cpp`` and should
-   not be used directly.
-
-   The implementation of this file (specifically, the NB_PLATFORM_ABI_TAG) is
-   designed to be compatible with @rwgk's
-   https://github.com/pybind/pybind11/blob/master/include/pybind11/conduit/pybind11_platform_abi_id.h
-
-   Use of this source code is governed by a BSD-style license that can be found
-   in the LICENSE file.
-*/
-
-/// Tracks the version of nanobind's internal data structures
-#ifndef NB_INTERNALS_VERSION
-#  define NB_INTERNALS_VERSION 16
-#endif
-
-#if defined(__MINGW32__)
-#  define NB_COMPILER_TYPE "mingw"
-#elif defined(__CYGWIN__)
-#  define NB_COMPILER_TYPE "gcc_cygwin"
-#elif defined(_MSC_VER)
-#  define NB_COMPILER_TYPE "msvc"
-#elif defined(__clang__) || defined(__GNUC__)
-#  define NB_COMPILER_TYPE "system" // Assumed compatible with system compiler.
-#else
-#  error "Unknown compiler type. Please revise this code."
-#endif
-
-// Catch other conditions that imply ABI incompatibility
-// - MSVC builds with different CRT versions
-// - An anticipated MSVC ABI break ("vNext")
-// - Builds using libc++ with unstable ABIs
-// - Builds using libstdc++ with the legacy (pre-C++11) ABI, etc.
-#if defined(_MSC_VER)
-#  if defined(_MT) && defined(_DLL) // Corresponding to CL command line options /MD or /MDd.
-#    if (_MSC_VER) / 100 == 19
-#      define NB_BUILD_ABI "_md_mscver19"
-#    else
-#      error "Unknown MSVC major version. Please revise this code."
-#    endif
-#  elif defined(_MT) // Corresponding to CL command line options /MT or /MTd.
-#    define NB_BUILD_ABI "_mt_mscver" NB_TOSTRING(_MSC_VER)
-#  else
-#    if (_MSC_VER) / 100 == 19
-#      define NB_BUILD_ABI "_none_mscver19"
-#    else
-#      error "Unknown MSVC major version. Please revise this code."
-#    endif
-#  endif
-#elif defined(_LIBCPP_ABI_VERSION) // https://libcxx.llvm.org/DesignDocs/ABIVersioning.html
-#    define NB_BUILD_ABI "_libcpp_abi" NB_TOSTRING(_LIBCPP_ABI_VERSION)
-#elif defined(_GLIBCXX_USE_CXX11_ABI)
-#  if defined(__NVCOMPILER) && !defined(__GXX_ABI_VERSION)
-#    error  "Unknown platform or compiler (_GLIBCXX_USE_CXX11_ABI). Please revise this code."
-#  endif
-#  if defined(__GXX_ABI_VERSION) && __GXX_ABI_VERSION < 1002 || __GXX_ABI_VERSION >= 2000
-#    error "Unknown platform or compiler (__GXX_ABI_VERSION). Please revise this code."
-#  endif
-#  define NB_BUILD_ABI "_libstdcpp_gxx_abi_1xxx_use_cxx11_abi_" NB_TOSTRING(_GLIBCXX_USE_CXX11_ABI)
-#else
-#  error "Unknown platform or compiler. Please revise this code."
-#endif
-
-// On MSVC, debug and release builds are not ABI-compatible!
-#if defined(_MSC_VER) && defined(_DEBUG)
-#  define NB_BUILD_TYPE "_debug"
-#else
-#  define NB_BUILD_TYPE ""
-#endif
-
-// Tag to determine if inter-library C++ function can be safely dispatched
-#define NB_PLATFORM_ABI_TAG \
-    NB_COMPILER_TYPE NB_BUILD_ABI NB_BUILD_TYPE
-
-// Can have limited and non-limited-API extensions in the same process.
-// Nanobind data structures will differ, so these can't talk to each other
-#if defined(Py_LIMITED_API)
-#  define NB_STABLE_ABI "_stable"
-#else
-#  define NB_STABLE_ABI ""
-#endif
-
-// As above, but for free-threaded extensions
-#if defined(NB_FREE_THREADED)
-#  define NB_FREE_THREADED_ABI "_ft"
-#else
-#  define NB_FREE_THREADED_ABI ""
-#endif
-
-#if NB_VERSION_DEV > 0
-  #define NB_VERSION_DEV_STR "_dev" NB_TOSTRING(NB_VERSION_DEV)
-#else
-  #define NB_VERSION_DEV_STR ""
-#endif
-
-#define NB_ABI_TAG                                                             \
-    "v" NB_TOSTRING(NB_INTERNALS_VERSION)                                      \
-        NB_VERSION_DEV_STR "_" NB_PLATFORM_ABI_TAG NB_STABLE_ABI               \
-            NB_FREE_THREADED_ABI
diff --git a/src/nanobind/src/nb_combined.cpp b/src/nanobind/src/nb_combined.cpp
deleted file mode 100644
index f565ce0..0000000
--- a/src/nanobind/src/nb_combined.cpp
+++ /dev/null
@@ -1,85 +0,0 @@
-/* You can use this file to compile bindings using alternative build systems in
-   case the dependence on CMake is problematic. The following instructions
-   illustrate how to do this Linux. The commands will need to be updated to
-   target other operating systems, but that is beyond the scope of this writeup.
-   To investigate platform-dependent subtleties, read the CMake build system
-   or run it and examine the commands it generates.
-
-   Step 1: compile libnanobind
-
-   $ NB_DIR=<path to nanobind directory>
-
-   $ CXXFLAGS="-std=c++17 -fvisibility=hidden \
-       -DNDEBUG -DNB_COMPACT_ASSERTIONS \
-       `python3-config --includes` -fPIC \
-       -I $NB_DIR/include \
-       -I $NB_DIR/ext/robin_map/include"
-
-   $ g++ src/nb_combined.cpp $CXXFLAGS -O3 -fno-strict-aliasing \
-       -ffunction-sections -fdata-sections -c -o libnanobind.o
-
-   Step 2: compile the extension code
-
-   $ g++ my_ext.cpp $CXXFLAGS -Os -c -o my_ext.o
-
-   Step 3: link the extension code with libnanobind
-
-   $ g++ -shared -Wl,-s -Wl,--gc-sections my_ext.o libnanobind.o \
-       -o my_ext.cpython-310-x86_64-linux-gnu.so
-
-   A few comments about these compilation parameters:
-
-   - the '-ffunction-sections/-fdata-sections/--gc-sections' parameter ensure
-     that unused parts of libnanobind are removed from the compiled extension.
-
-   - the '-fno-strict-aliasing' part is needed by the libnanobind part. This
-     flag generally applies to code that uses significant amounts of 'raw'
-     CPython API code. You should ensure that libnanobind isn't merged with
-     other code via link time optimization (LTO), otherwise you may need to
-     specify '-fno-strict-aliasing' at the project level.
-
-   - The '-Wl,-s' parameter strips debug information from the generated shared
-     library. Similarly, '-DNDEBUG' and '-DNB_COMPACT_ASSERTIONS' are parameters
-     that improve performance and reduce binary size in release builds, but
-     which would be omitted in debug builds.
-
-   - here, the libnanobind part uses -O3 (optimization for highest peformance),
-     while the bindings use -Os (optimization for the smallest size). The
-     assumption here is that the code in 'my_ext.cpp' is glue code that isn't
-     performance sensitive but which can become very big in a perf.-optimized
-     build. I find generally this to be a good default, but you may have other
-     preferences. If in doubt, benchmark to see what works best.
-
-   - The suffix of the final shared library depends on the Python version and
-     platform. You can query the Python binary about the right extension via
-     "import sysconfig; print(sysconfig.get_config_var('EXT_SUFFIX'))"
-
-   - Some of the above details change when creating a limited API /
-     stable ABI build, which is possible starting with Python 3.12. See the
-     CMake build system for details.
-
-   - On macOS, linking should uses a "linker response file" to benefit from the
-     latest macOS linker technology ("chained fixups"). For details, see
-     https://developer.apple.com/videos/play/wwdc2022/110362/ and
-     https://github.com/python/cpython/issues/97524#issuecomment-1458855301.
-     The files 'cmake/darwin-ld-cpython.sym' and 'cmake/darwin-ld-pypy.sym'
-     provide symbol lists that are needed to do so.
-
-   - The CMake build system can also create a shared build of the 'libnanobind'
-     component, which is useful in complex binding projects that ship multiple
-     exension libraries. As you can see from the above long list, the current
-     build system automates quite a few tedious steps. My suggestion would be to
-     not roll your own unless you are 100% convinced that this is really needed.
-*/
-
-#include "nb_internals.cpp"
-#include "nb_func.cpp"
-#include "nb_type.cpp"
-#include "nb_enum.cpp"
-#include "nb_ndarray.cpp"
-#include "nb_static_property.cpp"
-#include "nb_ft.cpp"
-#include "error.cpp"
-#include "common.cpp"
-#include "implicit.cpp"
-#include "trampoline.cpp"
diff --git a/src/nanobind/src/nb_enum.cpp b/src/nanobind/src/nb_enum.cpp
deleted file mode 100644
index b09de00..0000000
--- a/src/nanobind/src/nb_enum.cpp
+++ /dev/null
@@ -1,303 +0,0 @@
-#include "nb_internals.h"
-#include "nb_ft.h"
-
-NAMESPACE_BEGIN(NB_NAMESPACE)
-NAMESPACE_BEGIN(detail)
-
-struct int64_hash {
-    size_t operator()(const int64_t value) const {
-        return (size_t) fmix64((uint64_t) value);
-    }
-};
-
-// This data structure is used to map Python instances to integers as well as
-// the inverse. We're reusing the type to avoid generating essentially the same
-// code for two template instantiations. The key/value types are big enough to
-// hold both.
-using enum_map = tsl::robin_map<int64_t, int64_t, int64_hash>;
-
-PyObject *enum_create(enum_init_data *ed) noexcept {
-    // Update hash table that maps from std::type_info to Python type
-    nb_internals *internals_ = internals;
-    bool success;
-    nb_type_map_slow::iterator it;
-
-    {
-        lock_internals guard(internals_);
-        std::tie(it, success) = internals_->type_c2p_slow.try_emplace(ed->type, nullptr);
-        if (!success) {
-            PyErr_WarnFormat(PyExc_RuntimeWarning, 1,
-                             "nanobind: type '%s' was already registered!\n",
-                             ed->name);
-            PyObject *tp = (PyObject *) it->second->type_py;
-            Py_INCREF(tp);
-            return tp;
-        }
-    }
-
-    handle scope(ed->scope);
-
-    bool is_arithmetic = ed->flags & (uint32_t) enum_flags::is_arithmetic;
-    bool is_flag = ed->flags & (uint32_t) enum_flags::is_flag;
-
-    str name(ed->name), qualname = name;
-    object modname;
-
-    if (PyModule_Check(ed->scope)) {
-        modname = getattr(scope, "__name__", handle());
-    } else {
-        modname = getattr(scope, "__module__", handle());
-
-        object scope_qualname = getattr(scope, "__qualname__", handle());
-        if (scope_qualname.is_valid())
-            qualname = steal<str>(
-                PyUnicode_FromFormat("%U.%U", scope_qualname.ptr(), name.ptr()));
-    }
-
-    const char *factory_name = "Enum";
-
-    if (is_arithmetic && is_flag)
-        factory_name = "IntFlag";
-    else if (is_flag)
-        factory_name = "Flag";
-    else if (is_arithmetic)
-        factory_name = "IntEnum";
-
-    object enum_mod = module_::import_("enum"),
-           factory = enum_mod.attr(factory_name),
-           result = factory(name, nanobind::tuple(),
-                            arg("module") = modname,
-                            arg("qualname") = qualname);
-
-    scope.attr(name) = result;
-    result.attr("__doc__") = ed->docstr ? str(ed->docstr) : none();
-
-    result.attr("__str__") = enum_mod.attr(is_flag ? factory_name : "Enum").attr("__str__");
-    result.attr("__repr__") = result.attr("__str__");
-
-    type_init_data *t = new type_init_data();
-    memset(t, 0, sizeof(type_data));
-    t->name = strdup_check(ed->name);
-    t->type = ed->type;
-    t->type_py = (PyTypeObject *) result.ptr();
-    t->flags = ed->flags;
-    t->enum_tbl.fwd = new enum_map();
-    t->enum_tbl.rev = new enum_map();
-    t->scope = ed->scope;
-
-    it.value() = t;
-
-    {
-        lock_internals guard(internals_);
-        internals_->type_c2p_slow[ed->type] = t;
-
-        #if !defined(NB_FREE_THREADED)
-            internals_->type_c2p_fast[ed->type] = t;
-        #endif
-    }
-
-    make_immortal(result.ptr());
-
-    result.attr("__nb_enum__") = capsule(t, [](void *p) noexcept {
-        type_init_data *t = (type_init_data *) p;
-        delete (enum_map *) t->enum_tbl.fwd;
-        delete (enum_map *) t->enum_tbl.rev;
-        nb_type_unregister(t);
-        free((char*) t->name);
-        delete t;
-    });
-
-    return result.release().ptr();
-}
-
-static type_init_data *enum_get_type_data(handle tp) {
-    return (type_init_data *) (borrow<capsule>(handle(tp).attr("__nb_enum__"))).data();
-}
-
-void enum_append(PyObject *tp_, const char *name_, int64_t value_,
-                 const char *doc) noexcept {
-    handle tp(tp_),
-           val_tp(&PyLong_Type),
-           obj_tp((PyObject *) &PyBaseObject_Type);
-
-    type_data *t = enum_get_type_data(tp);
-
-    object val;
-    if (t->flags & (uint32_t) enum_flags::is_signed)
-        val = steal(PyLong_FromLongLong((long long) value_));
-    else
-        val = steal(PyLong_FromUnsignedLongLong((unsigned long long) value_));
-
-    dict value_map = tp.attr("_value2member_map_"),
-         member_map = tp.attr("_member_map_");
-    list member_names = tp.attr("_member_names_");
-    str name(name_);
-
-    if (member_map.contains(name))
-        fail("refusing to add duplicate key \"%s\" to enumeration \"%s\"!",
-             name_, type_name(tp).c_str());
-
-    # if PY_VERSION_HEX >= 0x030B0000
-    // In Python 3.11+, update the flag and bit masks by hand,
-    // since enum._proto_member.__set_name__ is not called in this code path.
-    if (t->flags & (uint32_t) enum_flags::is_flag) {
-        setattr(tp, "_flag_mask_", tp.attr("_flag_mask_") | val);
-
-        bool is_single_bit = (value_ != 0) && (value_ & (value_ - 1)) == 0;
-        if (is_single_bit && hasattr(tp, "_singles_mask_"))
-            setattr(tp, "_singles_mask_", tp.attr("_singles_mask_") | val);
-
-        int_ bit_length = int_(tp.attr("_flag_mask_").attr("bit_length")());
-        setattr(tp, "_all_bits_", (int_(2) << bit_length) - int_(1));
-    }
-    #endif
-
-    object el;
-    if (issubclass(tp, val_tp))
-        el = val_tp.attr("__new__")(tp, val);
-    else
-        el = obj_tp.attr("__new__")(tp);
-
-    el.attr("_name_") = name;
-    el.attr("__objclass__") = tp;
-    el.attr("__init__")(val);
-    el.attr("_sort_order_") = len(member_names);
-    el.attr("_value_") = val;
-    el.attr("__doc__") = doc ? str(doc) : none();
-
-    // Compatibility with nanobind 1.x
-    el.attr("__name__") = name;
-
-    setattr(tp, name, el);
-
-    if (!value_map.contains(val)) {
-        member_names.append(name);
-        value_map[val] = el;
-    }
-
-    member_map[name] = el;
-
-    enum_map *fwd = (enum_map *) t->enum_tbl.fwd;
-    fwd->emplace(value_, (int64_t) (uintptr_t) el.ptr());
-
-    enum_map *rev = (enum_map *) t->enum_tbl.rev;
-    rev->emplace((int64_t) (uintptr_t) el.ptr(), value_);
-}
-
-bool enum_from_python(const std::type_info *tp, PyObject *o, int64_t *out, uint8_t flags) noexcept {
-    type_data *t = nb_type_c2p(internals, tp);
-    if (!t)
-        return false;
-
-    if ((t->flags & (uint32_t) enum_flags::is_flag) != 0 && Py_TYPE(o) == t->type_py) {
-        PyObject *value_o = PyObject_GetAttrString(o, "value");
-        if (value_o == nullptr) {
-            PyErr_Clear();
-            return false;
-        }
-        if ((t->flags & (uint32_t) enum_flags::is_signed)) {
-            long long value = PyLong_AsLongLong(value_o);
-            if (value == -1 && PyErr_Occurred()) {
-                PyErr_Clear();
-                return false;
-            }
-            *out = (int64_t) value;
-            return true;
-        } else {
-            unsigned long long value = PyLong_AsUnsignedLongLong(value_o);
-            if (value == (unsigned long long) -1 && PyErr_Occurred()) {
-                PyErr_Clear();
-                return false;
-            }
-            *out = (int64_t) value;
-            return true;
-        }
-    }
-
-    enum_map *rev = (enum_map *) t->enum_tbl.rev;
-    enum_map::iterator it = rev->find((int64_t) (uintptr_t) o);
-
-    if (it != rev->end()) {
-        *out = it->second;
-        return true;
-    }
-
-    if (flags & (uint8_t) cast_flags::convert) {
-        enum_map *fwd = (enum_map *) t->enum_tbl.fwd;
-
-        if (t->flags & (uint32_t) enum_flags::is_signed) {
-            long long value = PyLong_AsLongLong(o);
-            if (value == -1 && PyErr_Occurred()) {
-                PyErr_Clear();
-                return false;
-            }
-            enum_map::iterator it2 = fwd->find((int64_t) value);
-            if (it2 != fwd->end()) {
-                *out = (int64_t) value;
-                return true;
-            }
-        } else {
-            unsigned long long value = PyLong_AsUnsignedLongLong(o);
-            if (value == (unsigned long long) -1 && PyErr_Occurred()) {
-                PyErr_Clear();
-                return false;
-            }
-            enum_map::iterator it2 = fwd->find((int64_t) value);
-            if (it2 != fwd->end()) {
-                *out = (int64_t) value;
-                return true;
-            }
-        }
-
-    }
-
-    return false;
-}
-
-PyObject *enum_from_cpp(const std::type_info *tp, int64_t key) noexcept {
-    type_data *t = nb_type_c2p(internals, tp);
-    if (!t)
-        return nullptr;
-
-    enum_map *fwd = (enum_map *) t->enum_tbl.fwd;
-
-    enum_map::iterator it = fwd->find(key);
-    if (it != fwd->end()) {
-        PyObject *value = (PyObject *) it->second;
-        Py_INCREF(value);
-        return value;
-    }
-
-    uint32_t flags = t->flags;
-    if ((flags & (uint32_t) enum_flags::is_flag) != 0) {
-        handle enum_tp(t->type_py);
-
-        object val;
-        if (flags & (uint32_t) enum_flags::is_signed)
-            val = steal(PyLong_FromLongLong((long long) key));
-        else
-            val = steal(PyLong_FromUnsignedLongLong((unsigned long long) key));
-
-        return enum_tp.attr("__new__")(enum_tp, val).release().ptr();
-    }
-
-    if (flags & (uint32_t) enum_flags::is_signed)
-        PyErr_Format(PyExc_ValueError, "%lli is not a valid %s.",
-                     (long long) key, t->name);
-    else
-        PyErr_Format(PyExc_ValueError, "%llu is not a valid %s.",
-                     (unsigned long long) key, t->name);
-
-    return nullptr;
-}
-
-void enum_export(PyObject *tp) {
-    type_init_data *t = enum_get_type_data(tp);
-
-    handle scope = t->scope;
-    for (handle item: handle(tp))
-        scope.attr(item.attr("name")) = item;
-}
-
-NAMESPACE_END(detail)
-NAMESPACE_END(NB_NAMESPACE)
diff --git a/src/nanobind/src/nb_ft.cpp b/src/nanobind/src/nb_ft.cpp
deleted file mode 100644
index 8a470d1..0000000
--- a/src/nanobind/src/nb_ft.cpp
+++ /dev/null
@@ -1,56 +0,0 @@
-#include <nanobind/nanobind.h>
-#include "nb_ft.h"
-
-#if defined(Py_GIL_DISABLED)
-/// Make an object immortal when targeting free-threaded Python
-void make_immortal(PyObject *op) noexcept {
-    // See CPython's Objects/object.c
-    if (PyObject_IS_GC(op))
-        PyObject_GC_UnTrack(op);
-    op->ob_tid = _Py_UNOWNED_TID;
-    op->ob_ref_local = _Py_IMMORTAL_REFCNT_LOCAL;
-    op->ob_ref_shared = 0;
-}
-
-#if PY_VERSION_HEX < 0x030E00A5
-void nb_enable_try_inc_ref(PyObject *obj) noexcept {
-    // Since this is called during object construction, we know that we have
-    // the only reference to the object and can use a non-atomic write.
-    assert(obj->ob_ref_shared == 0);
-    obj->ob_ref_shared = _Py_REF_MAYBE_WEAKREF;
-}
-
-bool nb_try_inc_ref(PyObject *obj) noexcept {
-    // See https://github.com/python/cpython/blob/d05140f9f77d7dfc753dd1e5ac3a5962aaa03eff/Include/internal/pycore_object.h#L761
-    uint32_t local = _Py_atomic_load_uint32_relaxed(&obj->ob_ref_local);
-    local += 1;
-    if (local == 0) {
-        // immortal
-        return true;
-    }
-    if (_Py_IsOwnedByCurrentThread(obj)) {
-        _Py_atomic_store_uint32_relaxed(&obj->ob_ref_local, local);
-#ifdef Py_REF_DEBUG
-        _Py_INCREF_IncRefTotal();
-#endif
-        return true;
-    }
-    Py_ssize_t shared = _Py_atomic_load_ssize_relaxed(&obj->ob_ref_shared);
-    for (;;) {
-        // If the shared refcount is zero and the object is either merged
-        // or may not have weak references, then we cannot incref it.
-        if (shared == 0 || shared == _Py_REF_MERGED) {
-            return false;
-        }
-
-        if (_Py_atomic_compare_exchange_ssize(
-                &obj->ob_ref_shared, &shared, shared + (1 << _Py_REF_SHARED_SHIFT))) {
-#ifdef Py_REF_DEBUG
-            _Py_INCREF_IncRefTotal();
-#endif
-            return true;
-        }
-    }
-}
-#endif
-#endif
diff --git a/src/nanobind/src/nb_ft.h b/src/nanobind/src/nb_ft.h
deleted file mode 100644
index 1ff871a..0000000
--- a/src/nanobind/src/nb_ft.h
+++ /dev/null
@@ -1,39 +0,0 @@
-/*
-    src/nb_ft.h: implementation details related to free-threaded Python
-
-    Copyright (c) 2022 Wenzel Jakob
-
-    All rights reserved. Use of this source code is governed by a
-    BSD-style license that can be found in the LICENSE file.
-*/
-
-#pragma once
-
-#if !defined(Py_GIL_DISABLED)
-/// Trivial implementations for non-free-threaded Python
-inline void make_immortal(PyObject *) noexcept { }
-inline void nb_enable_try_inc_ref(PyObject *) noexcept { }
-inline bool nb_try_inc_ref(PyObject *obj) noexcept {
-    if (Py_REFCNT(obj) > 0) {
-        Py_INCREF(obj);
-        return true;
-    }
-    return false;
-}
-#else
-extern void make_immortal(PyObject *op) noexcept;
-
-#if PY_VERSION_HEX >= 0x030E00A5
-/// Sufficiently recent CPython versions provide an API for the following operations
-inline void nb_enable_try_inc_ref(PyObject *obj) noexcept {
-    PyUnstable_EnableTryIncRef(obj);
-}
-inline bool nb_try_inc_ref(PyObject *obj) noexcept {
-    return PyUnstable_TryIncRef(obj);
-}
-#else
-/// Otherwise, nanabind ships with a low-level implementation
-extern void nb_enable_try_inc_ref(PyObject *) noexcept;
-extern bool nb_try_inc_ref(PyObject *obj) noexcept;
-#endif
-#endif
diff --git a/src/nanobind/src/nb_func.cpp b/src/nanobind/src/nb_func.cpp
deleted file mode 100644
index 915b2fc..0000000
--- a/src/nanobind/src/nb_func.cpp
+++ /dev/null
@@ -1,1581 +0,0 @@
-/*
-    src/nb_func.cpp: nanobind function type
-
-    Copyright (c) 2022 Wenzel Jakob
-
-    All rights reserved. Use of this source code is governed by a
-    BSD-style license that can be found in the LICENSE file.
-*/
-
-#include "nb_internals.h"
-#include "buffer.h"
-#include "nb_ft.h"
-
-/// Maximum number of arguments supported by 'nb_vectorcall_simple'
-#define NB_MAXARGS_SIMPLE 8
-
-#if defined(__GNUG__)
-#  include <cxxabi.h>
-#endif
-
-#if defined(_MSC_VER)
-#  pragma warning(disable: 4706) // assignment within conditional expression
-#  pragma warning(disable: 6255) // _alloca indicates failure by raising a stack overflow exception
-#endif
-
-NAMESPACE_BEGIN(NB_NAMESPACE)
-NAMESPACE_BEGIN(detail)
-
-// Forward/external declarations
-extern Buffer buf;
-
-static PyObject *nb_func_vectorcall_simple_0(PyObject *, PyObject *const *,
-                                             size_t, PyObject *) noexcept;
-static PyObject *nb_func_vectorcall_simple_1(PyObject *, PyObject *const *,
-                                             size_t, PyObject *) noexcept;
-static PyObject *nb_func_vectorcall_simple(PyObject *, PyObject *const *,
-                                           size_t, PyObject *) noexcept;
-static PyObject *nb_func_vectorcall_complex(PyObject *, PyObject *const *,
-                                            size_t, PyObject *) noexcept;
-static uint32_t nb_func_render_signature(const func_data *f,
-                                         bool nb_signature_mode = false) noexcept;
-
-int nb_func_traverse(PyObject *self, visitproc visit, void *arg) {
-    size_t size = (size_t) Py_SIZE(self);
-
-    if (size) {
-        func_data *f = nb_func_data(self);
-
-        for (size_t i = 0; i < size; ++i) {
-            if (f->flags & (uint32_t) func_flags::has_args) {
-                for (size_t j = 0; j < f->nargs; ++j) {
-                    Py_VISIT(f->args[j].value);
-                }
-            }
-            ++f;
-        }
-    }
-
-    return 0;
-}
-
-int nb_func_clear(PyObject *self) {
-    size_t size = (size_t) Py_SIZE(self);
-
-    if (size) {
-        func_data *f = nb_func_data(self);
-
-        for (size_t i = 0; i < size; ++i) {
-            if (f->flags & (uint32_t) func_flags::has_args) {
-                for (size_t j = 0; j < f->nargs; ++j) {
-                    Py_CLEAR(f->args[j].value);
-                }
-            }
-            ++f;
-        }
-    }
-
-    return 0;
-}
-
-/// Free a function overload chain
-void nb_func_dealloc(PyObject *self) {
-    PyObject_GC_UnTrack(self);
-
-    size_t size = (size_t) Py_SIZE(self);
-    if (size) {
-        func_data *f = nb_func_data(self);
-
-        // Delete from registered function list
-#if !defined(NB_FREE_THREADED)
-        size_t n_deleted = internals->funcs.erase(self);
-        check(n_deleted == 1,
-              "nanobind::detail::nb_func_dealloc(\"%s\"): function not found!",
-              ((f->flags & (uint32_t) func_flags::has_name) ? f->name
-                                                        : "<anonymous>"));
-#endif
-
-        for (size_t i = 0; i < size; ++i) {
-            if (f->flags & (uint32_t) func_flags::has_free)
-                f->free_capture(f->capture);
-
-            if (f->flags & (uint32_t) func_flags::has_args) {
-                for (size_t j = 0; j < f->nargs; ++j) {
-                    const arg_data &arg = f->args[j];
-                    Py_XDECREF(arg.value);
-                    Py_XDECREF(arg.name_py);
-                    free((char *) arg.signature);
-                }
-            }
-
-            if (f->flags & (uint32_t) func_flags::has_doc)
-                free((char *) f->doc);
-
-            free((char *) f->name);
-            free(f->args);
-            free((char *) f->descr);
-            free(f->descr_types);
-            free(f->signature);
-            ++f;
-        }
-    }
-
-    PyObject_GC_Del(self);
-}
-
-int nb_bound_method_traverse(PyObject *self, visitproc visit, void *arg) {
-    nb_bound_method *mb = (nb_bound_method *) self;
-    Py_VISIT((PyObject *) mb->func);
-    Py_VISIT(mb->self);
-    return 0;
-}
-
-int nb_bound_method_clear(PyObject *self) {
-    nb_bound_method *mb = (nb_bound_method *) self;
-    Py_CLEAR(mb->func);
-    Py_CLEAR(mb->self);
-    return 0;
-}
-
-void nb_bound_method_dealloc(PyObject *self) {
-    nb_bound_method *mb = (nb_bound_method *) self;
-    PyObject_GC_UnTrack(self);
-    Py_DECREF((PyObject *) mb->func);
-    Py_DECREF(mb->self);
-    PyObject_GC_Del(self);
-}
-
-static arg_data method_args[2] = {
-    { "self", nullptr, nullptr, nullptr, 0 },
-    { nullptr, nullptr, nullptr, nullptr, 0 }
-};
-
-static bool set_builtin_exception_status(builtin_exception &e) {
-    PyObject *o;
-
-    switch (e.type()) {
-        case exception_type::runtime_error: o = PyExc_RuntimeError; break;
-        case exception_type::stop_iteration: o = PyExc_StopIteration; break;
-        case exception_type::index_error: o = PyExc_IndexError; break;
-        case exception_type::key_error: o = PyExc_KeyError; break;
-        case exception_type::value_error: o = PyExc_ValueError; break;
-        case exception_type::type_error: o = PyExc_TypeError; break;
-        case exception_type::buffer_error: o = PyExc_BufferError; break;
-        case exception_type::import_error: o = PyExc_ImportError; break;
-        case exception_type::attribute_error: o = PyExc_AttributeError; break;
-        case exception_type::next_overload: return false;
-        default:
-            check(false, "nanobind::detail::set_builtin_exception_status(): "
-                         "invalid exception type!");
-    }
-
-    PyErr_SetString(o, e.what());
-    return true;
-}
-
-void *malloc_check(size_t size) {
-    void *ptr = malloc(size);
-    if (!ptr)
-        fail("nanobind: malloc() failed!");
-    return ptr;
-}
-
-char *strdup_check(const char *s) {
-    char *result;
-    #if defined(_WIN32)
-        result = _strdup(s);
-    #else
-        result = strdup(s);
-    #endif
-    if (!result)
-        fail("nanobind: strdup() failed!");
-    return result;
-}
-
-/**
- * \brief Wrap a C++ function into a Python function object
- *
- * This is an implementation detail of nanobind::cpp_function.
- */
-PyObject *nb_func_new(const void *in_) noexcept {
-    func_data_prelim<0> *f = (func_data_prelim<0> *) in_;
-    arg_data *args_in = std::launder((arg_data *) f->args);
-
-    bool has_scope       = f->flags & (uint32_t) func_flags::has_scope,
-         has_name        = f->flags & (uint32_t) func_flags::has_name,
-         has_args        = f->flags & (uint32_t) func_flags::has_args,
-         has_var_args    = f->flags & (uint32_t) func_flags::has_var_kwargs,
-         has_var_kwargs  = f->flags & (uint32_t) func_flags::has_var_args,
-         can_mutate_args = f->flags & (uint32_t) func_flags::can_mutate_args,
-         has_doc         = f->flags & (uint32_t) func_flags::has_doc,
-         has_signature   = f->flags & (uint32_t) func_flags::has_signature,
-         is_implicit     = f->flags & (uint32_t) func_flags::is_implicit,
-         is_method       = f->flags & (uint32_t) func_flags::is_method,
-         return_ref      = f->flags & (uint32_t) func_flags::return_ref,
-         is_constructor  = false,
-         is_init         = false,
-         is_new          = false,
-         is_setstate     = false;
-
-    PyObject *name = nullptr;
-    PyObject *func_prev = nullptr;
-
-    char *name_cstr;
-    if (has_signature) {
-        name_cstr = extract_name("nanobind::detail::nb_func_new", "def ", f->name);
-        has_name = *name_cstr != '\0';
-    } else {
-        name_cstr = strdup_check(has_name ? f->name : "");
-    }
-
-    // Check for previous overloads
-    nb_internals *internals_ = internals;
-    if (has_scope && has_name) {
-        name = PyUnicode_InternFromString(name_cstr);
-        check(name, "nb::detail::nb_func_new(\"%s\"): invalid name.", name_cstr);
-
-        func_prev = PyObject_GetAttr(f->scope, name);
-        if (func_prev) {
-            if (Py_TYPE(func_prev) == internals_->nb_func ||
-                Py_TYPE(func_prev) == internals_->nb_method) {
-                func_data *fp = nb_func_data(func_prev);
-
-                check((fp->flags & (uint32_t) func_flags::is_method) ==
-                          (f->flags & (uint32_t) func_flags::is_method),
-                      "nb::detail::nb_func_new(\"%s\"): mismatched static/"
-                      "instance method flags in function overloads!",
-                      name_cstr);
-
-                /* Never append a method to an overload chain of a parent class;
-                   instead, hide the parent's overloads in this case */
-                if (fp->scope != f->scope)
-                    Py_CLEAR(func_prev);
-            } else if (name_cstr[0] == '_') {
-                Py_CLEAR(func_prev);
-            } else {
-                check(false,
-                      "nb::detail::nb_func_new(\"%s\"): cannot overload "
-                      "existing non-function object of the same name!", name_cstr);
-            }
-        } else {
-            PyErr_Clear();
-        }
-
-        is_init = strcmp(name_cstr, "__init__") == 0;
-        is_new = strcmp(name_cstr, "__new__") == 0;
-        is_setstate = strcmp(name_cstr, "__setstate__") == 0;
-
-        // Is this method a constructor that takes a class binding as first parameter?
-        is_constructor = is_method && (is_init || is_setstate) &&
-                         strncmp(f->descr, "({%}", 4) == 0;
-
-        // Don't use implicit conversions in copy constructors (causes infinite recursion)
-        // Notes:
-        //   f->nargs = C++ argument count.
-        //   f->descr_types = zero-terminated array of bound types among them.
-        //     Hence of size >= 2 for constructors, where f->descr_types[1] my be null.
-        //   f->args = array of Python arguments (nb::arg). Non-empty if has_args.
-        //   By contrast, fc->args below has size f->nargs.
-        if (is_constructor && f->nargs == 2 && f->descr_types[0] &&
-            f->descr_types[0] == f->descr_types[1]) {
-            if (has_args) {
-                f->args[0].flag &= ~(uint8_t) cast_flags::convert;
-            } else {
-                args_in = method_args + 1;
-                has_args = true;
-            }
-        }
-    }
-
-    // Create a new function and destroy the old one
-    Py_ssize_t prev_overloads = func_prev ? Py_SIZE(func_prev) : 0;
-    nb_func *func = (nb_func *) PyType_GenericAlloc(
-        is_method ? internals_->nb_method : internals_->nb_func, prev_overloads + 1);
-    check(func, "nb::detail::nb_func_new(\"%s\"): alloc. failed (1).",
-          name_cstr);
-
-    make_immortal((PyObject *) func);
-
-    // Check if the complex dispatch loop is needed
-    bool complex_call = can_mutate_args || has_var_kwargs || has_var_args ||
-                        f->nargs >= NB_MAXARGS_SIMPLE;
-
-    if (has_args) {
-        for (size_t i = is_method; i < f->nargs; ++i) {
-            arg_data &a = args_in[i - is_method];
-            complex_call |= a.name != nullptr || a.value != nullptr ||
-                            a.flag != cast_flags::convert;
-        }
-    }
-
-    uint32_t max_nargs = f->nargs;
-
-    const char *prev_doc = nullptr;
-
-    if (func_prev) {
-        nb_func *nb_func_prev = (nb_func *) func_prev;
-        complex_call |= nb_func_prev->complex_call;
-        max_nargs = std::max(max_nargs, nb_func_prev->max_nargs);
-
-        func_data *cur  = nb_func_data(func),
-                  *prev = nb_func_data(func_prev);
-
-        if (nb_func_prev->doc_uniform)
-            prev_doc = prev->doc;
-
-        memcpy(cur, prev, sizeof(func_data) * prev_overloads);
-        memset(prev, 0, sizeof(func_data) * prev_overloads);
-
-        ((PyVarObject *) func_prev)->ob_size = 0;
-
-#if !defined(NB_FREE_THREADED)
-        size_t n_deleted = internals_->funcs.erase(func_prev);
-        check(n_deleted == 1,
-              "nanobind::detail::nb_func_new(): internal update failed (1)!");
-#endif
-
-        Py_CLEAR(func_prev);
-    }
-
-    func->max_nargs = max_nargs;
-    func->complex_call = complex_call;
-
-
-    PyObject* (*vectorcall)(PyObject *, PyObject * const*, size_t, PyObject *);
-    if (complex_call) {
-        vectorcall = nb_func_vectorcall_complex;
-    } else {
-        if (f->nargs == 0 && !prev_overloads)
-            vectorcall = nb_func_vectorcall_simple_0;
-        else if (f->nargs == 1 && !prev_overloads)
-            vectorcall = nb_func_vectorcall_simple_1;
-        else
-            vectorcall = nb_func_vectorcall_simple;
-    }
-    func->vectorcall = vectorcall;
-
-#if !defined(NB_FREE_THREADED)
-    // Register the function
-    auto [it, success] = internals_->funcs.try_emplace(func, nullptr);
-    check(success,
-          "nanobind::detail::nb_func_new(): internal update failed (2)!");
-#endif
-
-    func_data *fc = nb_func_data(func) + prev_overloads;
-    memcpy(fc, f, sizeof(func_data_prelim<0>));
-    if (has_doc) {
-        if (fc->doc[0] == '\n')
-            fc->doc++;
-        if (fc->doc[0] == '\0') {
-            fc->doc = nullptr;
-            fc->flags &= ~(uint32_t) func_flags::has_doc;
-            has_doc = false;
-        } else {
-            fc->doc = strdup_check(fc->doc);
-        }
-    }
-
-    // Detect when an entire overload chain has the same docstring
-    func->doc_uniform =
-        (has_doc && ((prev_overloads == 0) ||
-                     (prev_doc && strcmp(fc->doc, prev_doc) == 0)));
-
-    if (is_constructor)
-        fc->flags |= (uint32_t) func_flags::is_constructor;
-    if (has_args)
-        fc->flags |= (uint32_t) func_flags::has_args;
-
-    fc->name = name_cstr;
-    fc->signature = has_signature ? strdup_check(f->name) : nullptr;
-
-    if (is_implicit) {
-        check(fc->flags & (uint32_t) func_flags::is_constructor,
-              "nb::detail::nb_func_new(\"%s\"): nanobind::is_implicit() "
-              "should only be specified for constructors.",
-              name_cstr);
-        check(f->nargs == 2,
-              "nb::detail::nb_func_new(\"%s\"): implicit constructors "
-              "should only have one argument.",
-              name_cstr);
-
-        if (f->descr_types[1])
-            implicitly_convertible(f->descr_types[1], f->descr_types[0]);
-    }
-
-    for (size_t i = 0;; ++i) {
-        if (!f->descr[i]) {
-            fc->descr = (char *) malloc_check(sizeof(char) * (i + 1));
-            memcpy((char *) fc->descr, f->descr, (i + 1) * sizeof(char));
-            break;
-        }
-    }
-
-    for (size_t i = 0;; ++i) {
-        if (!f->descr_types[i]) {
-            fc->descr_types = (const std::type_info **)
-                malloc_check(sizeof(const std::type_info *) * (i + 1));
-            memcpy(fc->descr_types, f->descr_types,
-                        (i + 1) * sizeof(const std::type_info *));
-            break;
-        }
-    }
-
-    if (has_args) {
-        fc->args = (arg_data *) malloc_check(sizeof(arg_data) * f->nargs);
-
-        if (is_method) // add implicit 'self' argument annotation
-            fc->args[0] = method_args[0];
-        for (size_t i = is_method; i < fc->nargs; ++i)
-            fc->args[i] = args_in[i - is_method];
-
-        for (size_t i = 0; i < fc->nargs; ++i) {
-            arg_data &a = fc->args[i];
-            if (a.name) {
-                a.name_py = PyUnicode_InternFromString(a.name);
-                a.name = PyUnicode_AsUTF8AndSize(a.name_py, nullptr);
-            } else {
-                a.name_py = nullptr;
-            }
-            if (a.value == Py_None)
-                a.flag |= (uint8_t) cast_flags::accepts_none;
-            a.signature = a.signature ? strdup_check(a.signature) : nullptr;
-            Py_XINCREF(a.value);
-        }
-    }
-
-    // Fast path for vector call object construction
-    if (((is_init && is_method) || (is_new && !is_method)) &&
-        nb_type_check(f->scope)) {
-        type_data *td = nb_type_data((PyTypeObject *) f->scope);
-        bool has_new = td->flags & (uint32_t) type_flags::has_new;
-
-        if (is_init) {
-            if (!has_new) {
-                td->init = func;
-            } else {
-                // Keep track of whether we have a __init__ overload that
-                // accepts no arguments (except self). If not, then we
-                // shouldn't allow calling the type object with no arguments,
-                // even though (for unpickling support) we probably do have
-                // a __new__ overload that accepts no arguments (except cls).
-                // This check is necessary because our type vectorcall shortcut
-                // skips Python's usual logic where __init__ is always called
-                // if __new__ returns an instance of the type.
-                bool noargs_ok = true;
-                for (uint32_t i = 1; i < fc->nargs - (uint32_t) has_var_kwargs; ++i) {
-                    if (has_var_args && i == fc->nargs_pos)
-                        continue; // skip `nb::args` since it can be empty
-                    if (has_args && fc->args[i].value != nullptr)
-                        continue; // arg with default is OK
-                    noargs_ok = false;
-                    break;
-                }
-                if (noargs_ok)
-                    td->flags |= (uint32_t) type_flags::has_nullary_new;
-            }
-        } else if (is_new) {
-            td->init = func;
-            td->flags |= (uint32_t) type_flags::has_new;
-        }
-    }
-
-    if (has_scope && name) {
-        int rv = PyObject_SetAttr(f->scope, name, (PyObject *) func);
-        check(rv == 0, "nb::detail::nb_func_new(\"%s\"): setattr. failed.",
-              name_cstr);
-    }
-
-    Py_XDECREF(name);
-
-    if (return_ref) {
-        return (PyObject *) func;
-    } else {
-        Py_DECREF(func);
-        return nullptr;
-    }
-}
-
-/// Used by nb_func_vectorcall: generate an error when overload resolution fails
-static NB_NOINLINE PyObject *
-nb_func_error_overload(PyObject *self, PyObject *const *args_in,
-                       size_t nargs_in, PyObject *kwargs_in) noexcept {
-    uint32_t count = (uint32_t) Py_SIZE(self);
-    func_data *f = nb_func_data(self);
-
-    if (f->flags & (uint32_t) func_flags::is_operator)
-        return not_implemented().release().ptr();
-
-    // The buffer 'buf' is protected by 'internals.mutex'
-    lock_internals guard(internals);
-
-    buf.clear();
-    buf.put_dstr(f->name);
-    buf.put("(): incompatible function arguments. The following argument types "
-            "are supported:\n");
-
-    // Mask default __new__ overload created by nb::new_()
-    if (strcmp(f->name, "__new__") == 0 && count > 1 && f->nargs == 1) {
-        count -= 1;
-        f += 1;
-    }
-
-    for (uint32_t i = 0; i < count; ++i) {
-        buf.put("    ");
-        buf.put_uint32(i + 1);
-        buf.put(". ");
-        nb_func_render_signature(f + i);
-        buf.put('\n');
-    }
-
-    buf.put("\nInvoked with types: ");
-    for (size_t i = 0; i < nargs_in; ++i) {
-        str name = steal<str>(nb_inst_name(args_in[i]));
-        buf.put_dstr(name.c_str());
-        if (i + 1 < nargs_in)
-            buf.put(", ");
-    }
-
-    if (kwargs_in) {
-        if (nargs_in)
-            buf.put(", ");
-        buf.put("kwargs = { ");
-
-        size_t nkwargs_in = (size_t) NB_TUPLE_GET_SIZE(kwargs_in);
-        for (size_t j = 0; j < nkwargs_in; ++j) {
-            PyObject *key   = NB_TUPLE_GET_ITEM(kwargs_in, j),
-                     *value = args_in[nargs_in + j];
-
-            const char *key_cstr = PyUnicode_AsUTF8AndSize(key, nullptr);
-            buf.put_dstr(key_cstr);
-            buf.put(": ");
-            str name = steal<str>(nb_inst_name(value));
-            buf.put_dstr(name.c_str());
-            buf.put(", ");
-        }
-        buf.rewind(2);
-        buf.put(" }");
-    }
-
-    PyErr_SetString(PyExc_TypeError, buf.get());
-    return nullptr;
-}
-
-/// Used by nb_func_vectorcall: generate an error when result conversion fails
-static NB_NOINLINE PyObject *nb_func_error_noconvert(PyObject *self,
-                                                     PyObject *const *, size_t,
-                                                     PyObject *) noexcept {
-    if (PyErr_Occurred())
-        return nullptr;
-    func_data *f = nb_func_data(self);
-
-    // The buffer 'buf' is protected by 'internals.mutex'
-    lock_internals guard(internals);
-
-    buf.clear();
-    buf.put("Unable to convert function return value to a Python "
-            "type! The signature was\n    ");
-    nb_func_render_signature(f);
-    PyErr_SetString(PyExc_TypeError, buf.get());
-    return nullptr;
-}
-
-/// Used by nb_func_vectorcall: convert a C++ exception into a Python error
-static NB_NOINLINE void nb_func_convert_cpp_exception() noexcept {
-    std::exception_ptr e = std::current_exception();
-
-    for (nb_translator_seq *cur = &internals->translators; cur;
-         cur = cur->next) {
-        try {
-            // Try exception translator & forward payload
-            cur->translator(e, cur->payload);
-            return;
-        } catch (...) {
-            e = std::current_exception();
-        }
-    }
-
-    PyErr_SetString(PyExc_SystemError,
-                    "nanobind::detail::nb_func_error_except(): exception "
-                    "could not be translated!");
-}
-
-/// Dispatch loop that is used to invoke functions created by nb_func_new
-static PyObject *nb_func_vectorcall_complex(PyObject *self,
-                                            PyObject *const *args_in,
-                                            size_t nargsf,
-                                            PyObject *kwargs_in) noexcept {
-    const size_t count      = (size_t) Py_SIZE(self),
-                 nargs_in   = (size_t) NB_VECTORCALL_NARGS(nargsf),
-                 nkwargs_in = kwargs_in ? (size_t) NB_TUPLE_GET_SIZE(kwargs_in) : 0;
-
-    func_data *fr = nb_func_data(self);
-
-    const bool is_method      = fr->flags & (uint32_t) func_flags::is_method,
-               is_constructor = fr->flags & (uint32_t) func_flags::is_constructor;
-
-    PyObject *result = nullptr,
-             *self_arg = (is_method && nargs_in > 0) ? args_in[0] : nullptr;
-
-    /* The following lines allocate memory on the stack, which is very efficient
-       but also potentially dangerous since it can be used to generate stack
-       overflows. We refuse unrealistically large number of 'kwargs' (the
-       'max_nargs' value is fine since it is specified by the bindings) */
-    if (nkwargs_in > 1024) {
-        PyErr_SetString(PyExc_TypeError,
-                        "nanobind::detail::nb_func_vectorcall(): too many (> "
-                        "1024) keyword arguments.");
-        return nullptr;
-    }
-
-    // Handler routine that will be invoked in case of an error condition
-    PyObject *(*error_handler)(PyObject *, PyObject *const *, size_t,
-                               PyObject *) noexcept = nullptr;
-
-    // Small array holding temporaries (implicit conversion/*args/**kwargs)
-    cleanup_list cleanup(self_arg);
-
-    // Preallocate stack memory for function dispatch
-    size_t max_nargs = ((nb_func *) self)->max_nargs;
-    PyObject **args = (PyObject **) alloca(max_nargs * sizeof(PyObject *));
-    uint8_t *args_flags = (uint8_t *) alloca(max_nargs * sizeof(uint8_t));
-    bool *kwarg_used = (bool *) alloca(nkwargs_in * sizeof(bool));
-
-    // Ensure that keyword argument names are interned. That makes it faster
-    // to compare them against pre-interned argument names in the overload chain.
-    // Normal function calls will have their keyword arguments already interned,
-    // but we can't rely on that; it fails for things like fn(**json.loads(...)).
-    PyObject **kwnames = nullptr;
-
-#if !defined(PYPY_VERSION) && !defined(Py_LIMITED_API)
-    bool kwnames_interned = true;
-    for (size_t i = 0; i < nkwargs_in; ++i) {
-        PyObject *key = NB_TUPLE_GET_ITEM(kwargs_in, i);
-        kwnames_interned &= ((PyASCIIObject *) key)->state.interned != 0;
-    }
-    if (kwargs_in && NB_LIKELY(kwnames_interned)) {
-        kwnames = ((PyTupleObject *) kwargs_in)->ob_item;
-        goto traverse_overloads;
-    }
-#endif
-
-    kwnames = (PyObject **) alloca(nkwargs_in * sizeof(PyObject *));
-    for (size_t i = 0; i < nkwargs_in; ++i) {
-        PyObject *key = NB_TUPLE_GET_ITEM(kwargs_in, i);
-        Py_INCREF(key);
-
-        kwnames[i] = key;
-        PyUnicode_InternInPlace(&kwnames[i]);
-        PyObject *key_interned = kwnames[i];
-
-        if (NB_LIKELY(key == key_interned)) // string was already interned
-            Py_DECREF(key);
-        else
-            cleanup.append(key_interned);
-    }
-
-#if !defined(PYPY_VERSION) && !defined(Py_LIMITED_API)
-  traverse_overloads:
-#endif
-
-    /*  The logic below tries to find a suitable overload using two passes
-        of the overload chain (or 1, if there are no overloads). The first pass
-        is strict and permits no implicit conversions, while the second pass
-        allows them.
-
-        The following is done per overload during a pass
-
-        1. Copy individual arguments while checking that named positional
-           arguments weren't *also* specified as kwarg. Substitute missing
-           entries using keyword arguments or default argument values provided
-           in the bindings, if available.
-
-        3. Ensure that either all keyword arguments were "consumed", or that
-           the function takes a kwargs argument to accept unconsumed kwargs.
-
-        4. Any positional arguments still left get put into a tuple (for args),
-           and any leftover kwargs get put into a dict.
-
-        5. Pack everything into a vector; if we have nb::args or nb::kwargs, they are an
-           extra tuple or dict at the end of the positional arguments.
-
-        6. Call the function call dispatcher (func_data::impl)
-
-        If one of these fail, move on to the next overload and keep trying
-        until we get a result other than NB_NEXT_OVERLOAD.
-    */
-
-    for (size_t pass = (count > 1) ? 0 : 1; pass < 2; ++pass) {
-        for (size_t k = 0; k < count; ++k) {
-            const func_data *f = fr + k;
-
-            const bool has_args       = f->flags & (uint32_t) func_flags::has_args,
-                       has_var_args   = f->flags & (uint32_t) func_flags::has_var_args,
-                       has_var_kwargs = f->flags & (uint32_t) func_flags::has_var_kwargs;
-
-            // Number of C++ parameters eligible to be filled from individual
-            // Python positional arguments
-            size_t nargs_pos = f->nargs_pos;
-
-            // Number of C++ parameters in total, except for a possible trailing
-            // nb::kwargs. All of these are eligible to be filled from individual
-            // Python arguments (keyword always, positional until index nargs_pos)
-            // except for a potential nb::args, which exists at index nargs_pos
-            // if has_var_args is true. We'll skip that one in the individual-args
-            // loop, and go back and fill it later with the unused positionals.
-            size_t nargs_step1 = f->nargs - has_var_kwargs;
-
-            if (nargs_in > nargs_pos && !has_var_args)
-                continue; // Too many positional arguments given for this overload
-
-            if (nargs_in < nargs_pos && !has_args)
-                continue; // Not enough positional arguments, insufficient
-                          // keyword/default arguments to fill in the blanks
-
-            memset(kwarg_used, 0, nkwargs_in * sizeof(bool));
-
-            // 1. Copy individual arguments, potentially substitute kwargs/defaults
-            size_t i = 0;
-            for (; i < nargs_step1; ++i) {
-                if (has_var_args && i == nargs_pos)
-                    continue; // skip nb::args parameter, will be handled below
-
-                PyObject *arg = nullptr;
-
-                uint8_t arg_flag = 1;
-
-                // If i >= nargs_pos, then this is a keyword-only parameter.
-                // (We skipped any *args parameter using the test above,
-                // and we set the bounds of nargs_step1 to not include any
-                // **kwargs parameter.) In that case we don't want to take
-                // a positional arg (which might validly exist and be
-                // destined for the *args) but we do still want to look for
-                // a matching keyword arg.
-                if (i < nargs_in && i < nargs_pos)
-                    arg = args_in[i];
-
-                if (has_args) {
-                    const arg_data &ad = f->args[i];
-
-                    if (kwargs_in && ad.name_py) {
-                        PyObject *hit = nullptr;
-                        for (size_t j = 0; j < nkwargs_in; ++j) {
-                            if (kwnames[j] == ad.name_py) {
-                                hit = args_in[nargs_in + j];
-                                kwarg_used[j] = true;
-                                break;
-                            }
-                        }
-
-                        if (hit) {
-                            if (arg)
-                                break; // conflict between keyword and positional arg.
-                            arg = hit;
-                        }
-                    }
-
-                    if (!arg)
-                        arg = ad.value;
-                    arg_flag = ad.flag;
-                }
-
-                if (!arg || (arg == Py_None && (arg_flag & cast_flags::accepts_none) == 0))
-                    break;
-
-                // Implicit conversion only active in the 2nd pass
-                args_flags[i] = arg_flag & ~uint8_t(pass == 0);
-                args[i] = arg;
-            }
-
-            // Skip this overload if any arguments were unavailable
-            if (i != nargs_step1)
-                continue;
-
-            // Deal with remaining positional arguments
-            if (has_var_args) {
-                PyObject *tuple = PyTuple_New(
-                    nargs_in > nargs_pos ? (Py_ssize_t) (nargs_in - nargs_pos) : 0);
-
-                for (size_t j = nargs_pos; j < nargs_in; ++j) {
-                    PyObject *o = args_in[j];
-                    Py_INCREF(o);
-                    NB_TUPLE_SET_ITEM(tuple, j - nargs_pos, o);
-                }
-
-                args[nargs_pos] = tuple;
-                args_flags[nargs_pos] = 0;
-                cleanup.append(tuple);
-            }
-
-            // Deal with remaining keyword arguments
-            if (has_var_kwargs) {
-                PyObject *dict = PyDict_New();
-                for (size_t j = 0; j < nkwargs_in; ++j) {
-                    PyObject *key = kwnames[j];
-                    if (!kwarg_used[j])
-                        PyDict_SetItem(dict, key, args_in[nargs_in + j]);
-                }
-
-                args[nargs_step1] = dict;
-                args_flags[nargs_step1] = 0;
-                cleanup.append(dict);
-            } else if (kwargs_in) {
-                bool success = true;
-                for (size_t j = 0; j < nkwargs_in; ++j)
-                    success &= kwarg_used[j];
-                if (!success)
-                    continue;
-            }
-
-
-            if (is_constructor)
-                args_flags[0] |= (uint8_t) cast_flags::construct;
-
-            rv_policy policy = (rv_policy) (f->flags & 0b111);
-
-            try {
-                result = nullptr;
-
-                // Found a suitable overload, let's try calling it
-                result = f->impl((void *) f->capture, args, args_flags,
-                                 policy, &cleanup);
-
-                if (NB_UNLIKELY(!result))
-                    error_handler = nb_func_error_noconvert;
-            } catch (builtin_exception &e) {
-                if (!set_builtin_exception_status(e))
-                    result = NB_NEXT_OVERLOAD;
-            } catch (python_error &e) {
-                e.restore();
-            } catch (...) {
-                nb_func_convert_cpp_exception();
-            }
-
-            if (result != NB_NEXT_OVERLOAD) {
-                if (is_constructor && result != nullptr) {
-                    nb_inst *self_arg_nb = (nb_inst *) self_arg;
-                    self_arg_nb->destruct = true;
-                    self_arg_nb->state = nb_inst::state_ready;
-                    if (NB_UNLIKELY(self_arg_nb->intrusive))
-                        nb_type_data(Py_TYPE(self_arg))
-                            ->set_self_py(inst_ptr(self_arg_nb), self_arg);
-                }
-
-                goto done;
-            }
-        }
-    }
-
-    error_handler = nb_func_error_overload;
-
-done:
-    if (NB_UNLIKELY(cleanup.used()))
-        cleanup.release();
-
-    if (NB_UNLIKELY(error_handler))
-        result = error_handler(self, args_in, nargs_in, kwargs_in);
-
-    return result;
-}
-
-/// Simplified nb_func_vectorcall variant for functions w/o keyword arguments
-static PyObject *nb_func_vectorcall_simple(PyObject *self,
-                                           PyObject *const *args_in,
-                                           size_t nargsf,
-                                           PyObject *kwargs_in) noexcept {
-    uint8_t args_flags[NB_MAXARGS_SIMPLE];
-    func_data *fr = nb_func_data(self);
-
-    const size_t count         = (size_t) Py_SIZE(self),
-                 nargs_in      = (size_t) NB_VECTORCALL_NARGS(nargsf);
-
-    const bool is_method      = fr->flags & (uint32_t) func_flags::is_method,
-               is_constructor = fr->flags & (uint32_t) func_flags::is_constructor;
-
-    PyObject *result = nullptr,
-             *self_arg = (is_method && nargs_in > 0) ? args_in[0] : nullptr;
-
-    // Small array holding temporaries (implicit conversion/*args/**kwargs)
-    cleanup_list cleanup(self_arg);
-
-    // Handler routine that will be invoked in case of an error condition
-    PyObject *(*error_handler)(PyObject *, PyObject *const *, size_t,
-                               PyObject *) noexcept = nullptr;
-
-    bool fail = kwargs_in != nullptr;
-    PyObject *none_ptr = Py_None;
-    for (size_t i = 0; i < nargs_in; ++i)
-        fail |= args_in[i] == none_ptr;
-
-    if (fail) { // keyword/None arguments unsupported in simple vectorcall
-        error_handler = nb_func_error_overload;
-        goto done;
-    }
-
-    for (size_t pass = (count > 1) ? 0 : 1; pass < 2; ++pass) {
-        for (int i = 0; i < NB_MAXARGS_SIMPLE; ++i)
-            args_flags[i] = (uint8_t) pass;
-
-        if (is_constructor)
-            args_flags[0] = (uint8_t) cast_flags::construct;
-
-        for (size_t k = 0; k < count; ++k) {
-            const func_data *f = fr + k;
-
-            if (nargs_in != f->nargs)
-                continue;
-
-            try {
-                result = nullptr;
-
-                // Found a suitable overload, let's try calling it
-                result = f->impl((void *) f->capture, (PyObject **) args_in,
-                                 args_flags, (rv_policy) (f->flags & 0b111),
-                                 &cleanup);
-
-                if (NB_UNLIKELY(!result))
-                    error_handler = nb_func_error_noconvert;
-            } catch (builtin_exception &e) {
-                if (!set_builtin_exception_status(e))
-                    result = NB_NEXT_OVERLOAD;
-            } catch (python_error &e) {
-                e.restore();
-            } catch (...) {
-                nb_func_convert_cpp_exception();
-            }
-
-            if (result != NB_NEXT_OVERLOAD) {
-                if (is_constructor && result != nullptr) {
-                    nb_inst *self_arg_nb = (nb_inst *) self_arg;
-                    self_arg_nb->destruct = true;
-                    self_arg_nb->state = nb_inst::state_ready;
-                    if (NB_UNLIKELY(self_arg_nb->intrusive))
-                        nb_type_data(Py_TYPE(self_arg))
-                            ->set_self_py(inst_ptr(self_arg_nb), self_arg);
-                }
-
-                goto done;
-            }
-        }
-    }
-
-    error_handler = nb_func_error_overload;
-
-done:
-    if (NB_UNLIKELY(cleanup.used()))
-        cleanup.release();
-
-    if (NB_UNLIKELY(error_handler))
-        result = error_handler(self, args_in, nargs_in, kwargs_in);
-
-    return result;
-}
-
-/// Simplified nb_func_vectorcall variant for non-overloaded functions with 0 args
-static PyObject *nb_func_vectorcall_simple_0(PyObject *self,
-                                             PyObject *const *args_in,
-                                             size_t nargsf,
-                                             PyObject *kwargs_in) noexcept {
-    func_data *fr = nb_func_data(self);
-    const size_t nargs_in = (size_t) NB_VECTORCALL_NARGS(nargsf);
-
-    // Handler routine that will be invoked in case of an error condition
-    PyObject *(*error_handler)(PyObject *, PyObject *const *, size_t,
-                               PyObject *) noexcept = nullptr;
-
-    PyObject *result = nullptr;
-
-    if (kwargs_in == nullptr && nargs_in == 0) {
-        try {
-            result = fr->impl((void *) fr->capture, (PyObject **) args_in,
-                              nullptr, (rv_policy) (fr->flags & 0b111), nullptr);
-            if (result == NB_NEXT_OVERLOAD)
-                error_handler = nb_func_error_overload;
-            else if (!result)
-                error_handler = nb_func_error_noconvert;
-        } catch (builtin_exception &e) {
-            if (!set_builtin_exception_status(e))
-                error_handler = nb_func_error_overload;
-        } catch (python_error &e) {
-            e.restore();
-        } catch (...) {
-            nb_func_convert_cpp_exception();
-        }
-    } else {
-        error_handler = nb_func_error_overload;
-    }
-
-    if (NB_UNLIKELY(error_handler))
-        result = error_handler(self, args_in, nargs_in, kwargs_in);
-
-    return result;
-}
-
-/// Simplified nb_func_vectorcall variant for non-overloaded functions with 1 arg
-static PyObject *nb_func_vectorcall_simple_1(PyObject *self,
-                                             PyObject *const *args_in,
-                                             size_t nargsf,
-                                             PyObject *kwargs_in) noexcept {
-    func_data *fr = nb_func_data(self);
-    const size_t nargs_in = (size_t) NB_VECTORCALL_NARGS(nargsf);
-    bool is_constructor = fr->flags & (uint32_t) func_flags::is_constructor;
-
-    // Handler routine that will be invoked in case of an error condition
-    PyObject *(*error_handler)(PyObject *, PyObject *const *, size_t,
-                               PyObject *) noexcept = nullptr;
-
-    PyObject *result = nullptr;
-
-    if (kwargs_in == nullptr && nargs_in == 1 && args_in[0] != Py_None) {
-        PyObject *arg = args_in[0];
-        cleanup_list cleanup(arg);
-        uint8_t args_flags[1] = {
-            (uint8_t) (is_constructor ? (1 | (uint8_t) cast_flags::construct) : 1)
-        };
-
-        try {
-            result = fr->impl((void *) fr->capture, (PyObject **) args_in,
-                              args_flags, (rv_policy) (fr->flags & 0b111), &cleanup);
-            if (result == NB_NEXT_OVERLOAD) {
-                error_handler = nb_func_error_overload;
-            } else if (!result) {
-                error_handler = nb_func_error_noconvert;
-            } else if (is_constructor) {
-                nb_inst *arg_nb = (nb_inst *) arg;
-                arg_nb->destruct = true;
-                arg_nb->state = nb_inst::state_ready;
-                if (NB_UNLIKELY(arg_nb->intrusive))
-                    nb_type_data(Py_TYPE(arg))
-                        ->set_self_py(inst_ptr(arg_nb), arg);
-            }
-        } catch (builtin_exception &e) {
-            if (!set_builtin_exception_status(e))
-                error_handler = nb_func_error_overload;
-        } catch (python_error &e) {
-            e.restore();
-        } catch (...) {
-            nb_func_convert_cpp_exception();
-        }
-
-        if (NB_UNLIKELY(cleanup.used()))
-            cleanup.release();
-    } else {
-        error_handler = nb_func_error_overload;
-    }
-
-    if (NB_UNLIKELY(error_handler))
-        result = error_handler(self, args_in, nargs_in, kwargs_in);
-
-    return result;
-}
-
-static PyObject *nb_bound_method_vectorcall(PyObject *self,
-                                            PyObject *const *args_in,
-                                            size_t nargsf,
-                                            PyObject *kwargs_in) noexcept {
-    nb_bound_method *mb = (nb_bound_method *) self;
-    size_t nargs = (size_t) NB_VECTORCALL_NARGS(nargsf);
-    const size_t buf_size = 5;
-    PyObject **args, *args_buf[buf_size], *temp = nullptr, *result;
-    bool alloc = false;
-
-    if (NB_LIKELY(nargsf & NB_VECTORCALL_ARGUMENTS_OFFSET)) {
-        args = (PyObject **) (args_in - 1);
-        temp = args[0];
-    } else {
-        size_t size = nargs + 1;
-        if (kwargs_in)
-            size += NB_TUPLE_GET_SIZE(kwargs_in);
-
-        if (size < buf_size) {
-            args = args_buf;
-        } else {
-            args = (PyObject **) PyMem_Malloc(size * sizeof(PyObject *));
-            if (!args)
-                return PyErr_NoMemory();
-            alloc = true;
-        }
-
-        memcpy(args + 1, args_in, sizeof(PyObject *) * (size - 1));
-    }
-
-    args[0] = mb->self;
-    result = mb->func->vectorcall((PyObject *) mb->func, args, nargs + 1, kwargs_in);
-    args[0] = temp;
-
-    if (NB_UNLIKELY(alloc))
-        PyMem_Free(args);
-
-    return result;
-}
-
-PyObject *nb_method_descr_get(PyObject *self, PyObject *inst, PyObject *) {
-    if (inst) {
-        /* Return a bound method. This should be avoidable in most cases via the
-           'CALL_METHOD' opcode and vector calls. Pytest rewrites the bytecode
-           in a way that breaks this optimization :-/ */
-
-        nb_bound_method *mb =
-            PyObject_GC_New(nb_bound_method, internals->nb_bound_method);
-        mb->func = (nb_func *) self;
-        mb->self = inst;
-        mb->vectorcall = nb_bound_method_vectorcall;
-
-        Py_INCREF(self);
-        Py_INCREF(inst);
-
-        return (PyObject *) mb;
-    } else {
-        Py_INCREF(self);
-        return self;
-    }
-}
-
-/// Render the function signature of a single function. Callers must hold the
-/// 'internals' mutex.
-static uint32_t nb_func_render_signature(const func_data *f,
-                                         bool nb_signature_mode) noexcept {
-    const bool is_method      = f->flags & (uint32_t) func_flags::is_method,
-               has_args       = f->flags & (uint32_t) func_flags::has_args,
-               has_var_args   = f->flags & (uint32_t) func_flags::has_var_args,
-               has_var_kwargs = f->flags & (uint32_t) func_flags::has_var_kwargs,
-               has_signature  = f->flags & (uint32_t) func_flags::has_signature;
-
-    nb_internals *internals_ = internals;
-    if (has_signature) {
-        const char *s = f->signature;
-
-        if (!nb_signature_mode) {
-            // go to last line of manually provided signature, strip away 'def ' prefix
-            const char *p = strrchr(s, '\n');
-            s = p ? (p + 1) : s;
-            if (strncmp(s, "def ", 4) == 0)
-                s += 4;
-        }
-
-        buf.put_dstr(s);
-        return 0;
-    }
-
-    if (nb_signature_mode)
-        buf.put("def ");
-
-    const std::type_info **descr_type = f->descr_types;
-    bool rv = false;
-
-    uint32_t arg_index = 0, n_default_args = 0;
-    buf.put_dstr(f->name);
-
-    for (const char *pc = f->descr; *pc != '\0'; ++pc) {
-        char c = *pc;
-
-        switch (c) {
-            case '@':
-                // Handle types that differ depending on whether they appear
-                // in an argument or a return value position
-                pc++;
-                if (!rv) {
-                    while (*pc && *pc != '@')
-                        buf.put(*pc++);
-                    if (*pc == '@')
-                        pc++;
-                    while (*pc && *pc != '@')
-                        pc++;
-                } else {
-                    while (*pc && *pc != '@')
-                        pc++;
-                    if (*pc == '@')
-                        pc++;
-                    while (*pc && *pc != '@')
-                        buf.put(*pc++);
-                }
-                break;
-
-            case '{':
-                {
-                    const char *arg_name = has_args ? f->args[arg_index].name : nullptr;
-
-                    // Argument name
-                    if (has_var_kwargs && arg_index + 1 == f->nargs) {
-                        buf.put("**");
-                        buf.put_dstr(arg_name ? arg_name : "kwargs");
-                        pc += 4; // strlen("dict")
-                        break;
-                    }
-
-                    if (arg_index == f->nargs_pos) {
-                        buf.put("*");
-                        if (has_var_args) {
-                            buf.put_dstr(arg_name ? arg_name : "args");
-                            pc += 5; // strlen("tuple")
-                            break;
-                        } else {
-                            buf.put(", ");
-                            // fall through to render the first keyword-only arg
-                        }
-                    }
-
-                    if (is_method && arg_index == 0) {
-                        buf.put("self");
-
-                        // Skip over type
-                        while (*pc != '}') {
-                            if (*pc == '%')
-                                descr_type++;
-                            pc++;
-                        }
-                        arg_index++;
-                        continue;
-                    } else if (arg_name) {
-                        buf.put_dstr(arg_name);
-                    } else {
-                        buf.put("arg");
-                        if (f->nargs > 1 + (uint32_t) is_method)
-                            buf.put_uint32(arg_index - is_method);
-                    }
-
-                    buf.put(": ");
-                    if (has_args && f->args[arg_index].flag &
-                                        (uint8_t) cast_flags::accepts_none) {
-#if PY_VERSION_HEX < 0x030A0000
-                            buf.put("typing.Optional[");
-                        #else
-                            // See below
-                        #endif
-                    }
-                }
-                break;
-
-            case '}':
-                // Default argument
-                if (has_args) {
-                    if (f->args[arg_index].flag & (uint8_t) cast_flags::accepts_none) {
-                        #if PY_VERSION_HEX < 0x030A0000
-                            buf.put(']');
-                        #else
-                            buf.put(" | None");
-                        #endif
-                    }
-
-                    if (f->args[arg_index].value) {
-                        const arg_data &arg = f->args[arg_index];
-                        if (nb_signature_mode) {
-                            buf.put(" = \\");
-                            if (arg.signature)
-                                buf.put('=');
-                            buf.put_uint32(n_default_args++);
-                        } else if (arg.signature) {
-                            buf.put(" = ");
-                            buf.put_dstr(arg.signature);
-                        } else {
-                            PyObject *o = arg.value, *str;
-
-                            {
-                                unlock_internals guard2(internals_);
-                                str = PyObject_Repr(o);
-                            }
-
-                            if (str) {
-                                Py_ssize_t size = 0;
-                                const char *cstr =
-                                    PyUnicode_AsUTF8AndSize(str, &size);
-                                if (!cstr) {
-                                    PyErr_Clear();
-                                } else {
-                                    buf.put(" = ");
-                                    buf.put(cstr, (size_t) size);
-                                }
-                                Py_DECREF(str);
-                            } else {
-                                PyErr_Clear();
-                            }
-                        }
-                    }
-                }
-
-                arg_index++;
-
-                if (arg_index == f->nargs_pos && !has_args)
-                    buf.put(", /");
-
-                break;
-
-            case '%':
-                check(*descr_type,
-                      "nb::detail::nb_func_render_signature(): missing type!");
-
-                if (!(is_method && arg_index == 0)) {
-                    bool found = false;
-                    auto it = internals_->type_c2p_slow.find(*descr_type);
-
-                    if (it != internals_->type_c2p_slow.end()) {
-                        handle th((PyObject *) it->second->type_py);
-                        buf.put_dstr((borrow<str>(th.attr("__module__"))).c_str());
-                        buf.put('.');
-                        buf.put_dstr((borrow<str>(th.attr("__qualname__"))).c_str());
-                        found = true;
-                    }
-                    if (!found) {
-                        if (nb_signature_mode)
-                            buf.put('"');
-                        char *name = type_name(*descr_type);
-                        buf.put_dstr(name);
-                        free(name);
-                        if (nb_signature_mode)
-                            buf.put('"');
-                    }
-                }
-
-                descr_type++;
-                break;
-
-            case '-':
-                if (pc[1] == '>')
-                    rv = true;
-                buf.put(c);
-                break;
-
-
-            default:
-                buf.put(c);
-                break;
-        }
-    }
-
-    check(arg_index == f->nargs && !*descr_type,
-          "nanobind::detail::nb_func_render_signature(%s): arguments inconsistent.",
-          f->name);
-
-    return n_default_args;
-}
-
-static PyObject *nb_func_get_name(PyObject *self) {
-    func_data *f = nb_func_data(self);
-    const char *name = "";
-    if (f->flags & (uint32_t) func_flags::has_name)
-        name = f->name;
-    return PyUnicode_FromString(name);
-}
-
-static PyObject *nb_func_get_qualname(PyObject *self) {
-    func_data *f = nb_func_data(self);
-    if ((f->flags & (uint32_t) func_flags::has_scope) &&
-        (f->flags & (uint32_t) func_flags::has_name)) {
-        PyObject *scope_name = PyObject_GetAttrString(f->scope, "__qualname__");
-        if (scope_name) {
-            return PyUnicode_FromFormat("%U.%s", scope_name, f->name);
-        } else {
-            PyErr_Clear();
-            return PyUnicode_FromString(f->name);
-        }
-    } else {
-        Py_INCREF(Py_None);
-        return Py_None;
-    }
-}
-
-static PyObject *nb_func_get_module(PyObject *self) {
-    func_data *f = nb_func_data(self);
-    if (f->flags & (uint32_t) func_flags::has_scope) {
-        return PyObject_GetAttrString(
-            f->scope, PyModule_Check(f->scope) ? "__name__" : "__module__");
-    } else {
-        Py_INCREF(Py_None);
-        return Py_None;
-    }
-}
-
-PyObject *nb_func_get_nb_signature(PyObject *self, void *) {
-    PyObject *docstr = nullptr, *item = nullptr, *sigstr = nullptr,
-             *defaults = nullptr;
-
-    func_data *f = nb_func_data(self);
-    uint32_t count = (uint32_t) Py_SIZE(self);
-    PyObject *result = PyTuple_New(count);
-    if (!result)
-        return nullptr;
-
-    for (uint32_t i = 0; i < count; ++i) {
-        docstr = item = sigstr = defaults = nullptr;
-
-        const func_data *fi = f + i;
-        if ((fi->flags & (uint32_t) func_flags::has_doc) &&
-            (!((nb_func *) self)->doc_uniform || i == 0)) {
-            docstr = PyUnicode_FromString(fi->doc);
-        } else {
-            docstr = Py_None;
-            Py_INCREF(docstr);
-        }
-
-        // The buffer 'buf' is protected by 'internals.mutex'
-        lock_internals guard(internals);
-
-        buf.clear();
-        uint32_t n_default_args = nb_func_render_signature(fi, true);
-
-        item = PyTuple_New(3);
-        sigstr = PyUnicode_FromString(buf.get());
-        if (n_default_args) {
-            defaults = PyTuple_New(n_default_args);
-        } else {
-            defaults = Py_None;
-            Py_INCREF(defaults);
-        }
-
-        if (!docstr || !sigstr || !item || !defaults)
-            goto fail;
-
-        if (n_default_args) {
-            size_t pos = 0;
-            for (uint32_t j = 0; j < fi->nargs; ++j) {
-                const arg_data &arg = fi->args[j];
-                PyObject *value = arg.value;
-                if (!value)
-                    continue;
-                if (arg.signature) {
-                    value = PyUnicode_FromString(arg.signature);
-                    if (!value)
-                        goto fail;
-                } else {
-                    Py_INCREF(value);
-                }
-                NB_TUPLE_SET_ITEM(defaults, pos, value);
-                pos++;
-            }
-
-            check(pos == n_default_args,
-                  "__nb_signature__: default argument counting inconsistency!");
-        }
-
-        NB_TUPLE_SET_ITEM(item, 0, sigstr);
-        NB_TUPLE_SET_ITEM(item, 1, docstr);
-        NB_TUPLE_SET_ITEM(item, 2, defaults);
-        NB_TUPLE_SET_ITEM(result, (Py_ssize_t) i, item);
-    }
-
-    return result;
-
-fail:
-    Py_XDECREF(docstr);
-    Py_XDECREF(sigstr);
-    Py_XDECREF(defaults);
-    Py_XDECREF(item);
-    Py_DECREF(result);
-    return nullptr;
-}
-
-PyObject *nb_func_get_doc(PyObject *self, void *) {
-    func_data *f = nb_func_data(self);
-    uint32_t count = (uint32_t) Py_SIZE(self);
-
-    // The buffer 'buf' is protected by 'internals.mutex'
-    lock_internals guard(internals);
-
-    buf.clear();
-
-    bool doc_found = false;
-
-    for (uint32_t i = 0; i < count; ++i) {
-        const func_data *fi = f + i;
-        nb_func_render_signature(fi);
-        buf.put('\n');
-        doc_found |= (fi->flags & (uint32_t) func_flags::has_doc) != 0;
-    }
-
-    if (doc_found) {
-        if (((nb_func *) self)->doc_uniform) {
-            buf.put('\n');
-            buf.put_dstr(f->doc);
-            buf.put('\n');
-        } else {
-            buf.put("\nOverloaded function.\n");
-            for (uint32_t i = 0; i < count; ++i) {
-                const func_data *fi = f + i;
-
-                buf.put('\n');
-                buf.put_uint32(i + 1);
-                buf.put(". ``");
-                nb_func_render_signature(fi);
-                buf.put("``\n\n");
-
-                if (fi->flags & (uint32_t) func_flags::has_doc) {
-                    buf.put_dstr(fi->doc);
-                    buf.put('\n');
-                }
-            }
-        }
-    }
-
-    if (buf.size() > 0) // remove last newline
-        buf.rewind(1);
-
-    return PyUnicode_FromString(buf.get());
-}
-
-// PyGetSetDef entry for __module__ is ignored in Python 3.8
-PyObject *nb_func_getattro(PyObject *self, PyObject *name_) {
-    const char *name = PyUnicode_AsUTF8AndSize(name_, nullptr);
-
-    if (!name)
-        return nullptr;
-    else if (strcmp(name, "__module__") == 0)
-        return nb_func_get_module(self);
-    else if (strcmp(name, "__name__") == 0)
-        return nb_func_get_name(self);
-    else if (strcmp(name, "__qualname__") == 0)
-        return nb_func_get_qualname(self);
-    else if (strcmp(name, "__doc__") == 0)
-        return nb_func_get_doc(self, nullptr);
-    else
-        return PyObject_GenericGetAttr(self, name_);
-}
-
-PyObject *nb_bound_method_getattro(PyObject *self, PyObject *name_) {
-    bool passthrough = false;
-    if (const char *name = PyUnicode_AsUTF8AndSize(name_, nullptr)) {
-        // These attributes do exist on nb_bound_method (because they
-        // exist on every type) but we want to take their special handling
-        // from nb_func_getattro instead.
-        passthrough = (strcmp(name, "__doc__") == 0 ||
-                       strcmp(name, "__module__") == 0);
-    }
-    if (!passthrough) {
-        if (PyObject* res = PyObject_GenericGetAttr(self, name_))
-            return res;
-        PyErr_Clear();
-    }
-    nb_func *func = ((nb_bound_method *) self)->func;
-    return nb_func_getattro((PyObject *) func, name_);
-}
-
-/// Excise a substring from 's'
-static void strexc(char *s, const char *sub) {
-    size_t len = strlen(sub);
-    if (len == 0)
-        return;
-
-    char *p = s;
-    while ((p = strstr(p, sub)))
-        memmove(p, p + len, strlen(p + len) + 1);
-}
-
-/// Return a readable string representation of a C++ type
-NB_NOINLINE char *type_name(const std::type_info *t) {
-    const char *name_in = t->name();
-
-#if defined(__GNUG__)
-    int status = 0;
-    char *name = abi::__cxa_demangle(name_in, nullptr, nullptr, &status);
-    if (!name)
-        return strdup_check(name_in);
-#else
-    char *name = strdup_check(name_in);
-    strexc(name, "class ");
-    strexc(name, "struct ");
-    strexc(name, "enum ");
-#endif
-    strexc(name, "nanobind::");
-    return name;
-}
-
-NAMESPACE_END(detail)
-NAMESPACE_END(NB_NAMESPACE)
diff --git a/src/nanobind/src/nb_internals.cpp b/src/nanobind/src/nb_internals.cpp
deleted file mode 100644
index 26ac46d..0000000
--- a/src/nanobind/src/nb_internals.cpp
+++ /dev/null
@@ -1,498 +0,0 @@
-/*
-    src/internals.cpp: internal libnanobind data structures
-
-    Copyright (c) 2022 Wenzel Jakob
-
-    All rights reserved. Use of this source code is governed by a
-    BSD-style license that can be found in the LICENSE file.
-*/
-
-#include <nanobind/nanobind.h>
-#include <structmember.h>
-#include "nb_internals.h"
-#include "nb_abi.h"
-#include <thread>
-
-#if defined(__GNUC__) && !defined(__clang__)
-#  pragma GCC diagnostic ignored "-Wmissing-field-initializers"
-#endif
-
-NAMESPACE_BEGIN(NB_NAMESPACE)
-NAMESPACE_BEGIN(detail)
-
-extern PyObject *nb_func_getattro(PyObject *, PyObject *);
-extern PyObject *nb_func_get_doc(PyObject *, void *);
-extern PyObject *nb_func_get_nb_signature(PyObject *, void *);
-extern PyObject *nb_bound_method_getattro(PyObject *, PyObject *);
-extern int nb_func_traverse(PyObject *, visitproc, void *);
-extern int nb_func_clear(PyObject *);
-extern void nb_func_dealloc(PyObject *);
-extern int nb_bound_method_traverse(PyObject *, visitproc, void *);
-extern int nb_bound_method_clear(PyObject *);
-extern void nb_bound_method_dealloc(PyObject *);
-extern PyObject *nb_method_descr_get(PyObject *, PyObject *, PyObject *);
-
-#if PY_VERSION_HEX >= 0x03090000
-#  define NB_HAVE_VECTORCALL_PY39_OR_NEWER NB_HAVE_VECTORCALL
-#else
-#  define NB_HAVE_VECTORCALL_PY39_OR_NEWER 0
-#endif
-
-static PyType_Slot nb_meta_slots[] = {
-    { Py_tp_base, nullptr },
-    { 0, nullptr }
-};
-
-static PyType_Spec nb_meta_spec = {
-    /* .name = */ "nanobind.nb_meta",
-    /* .basicsize = */ 0,
-    /* .itemsize = */ 0,
-    /* .flags = */ Py_TPFLAGS_DEFAULT,
-    /* .slots = */ nb_meta_slots
-};
-
-static PyMemberDef nb_func_members[] = {
-    { "__vectorcalloffset__", T_PYSSIZET,
-      (Py_ssize_t) offsetof(nb_func, vectorcall), READONLY, nullptr },
-    { nullptr, 0, 0, 0, nullptr }
-};
-
-static PyGetSetDef nb_func_getset[] = {
-    { "__doc__", nb_func_get_doc, nullptr, nullptr, nullptr },
-    { "__nb_signature__", nb_func_get_nb_signature, nullptr, nullptr, nullptr },
-    { nullptr, nullptr, nullptr, nullptr, nullptr }
-};
-
-static PyType_Slot nb_func_slots[] = {
-    { Py_tp_members, (void *) nb_func_members },
-    { Py_tp_getset, (void *) nb_func_getset },
-    { Py_tp_getattro, (void *) nb_func_getattro },
-    { Py_tp_traverse, (void *) nb_func_traverse },
-    { Py_tp_clear, (void *) nb_func_clear },
-    { Py_tp_dealloc, (void *) nb_func_dealloc },
-    { Py_tp_traverse, (void *) nb_func_traverse },
-    { Py_tp_new, (void *) PyType_GenericNew },
-    { Py_tp_call, (void *) PyVectorcall_Call },
-    { 0, nullptr }
-};
-
-static PyType_Spec nb_func_spec = {
-    /* .name = */ "nanobind.nb_func",
-    /* .basicsize = */ (int) sizeof(nb_func),
-    /* .itemsize = */ (int) sizeof(func_data),
-    /* .flags = */ Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC |
-                   NB_HAVE_VECTORCALL_PY39_OR_NEWER,
-    /* .slots = */ nb_func_slots
-};
-
-static PyType_Slot nb_method_slots[] = {
-    { Py_tp_members, (void *) nb_func_members },
-    { Py_tp_getset, (void *) nb_func_getset },
-    { Py_tp_getattro, (void *) nb_func_getattro },
-    { Py_tp_traverse, (void *) nb_func_traverse },
-    { Py_tp_clear, (void *) nb_func_clear },
-    { Py_tp_dealloc, (void *) nb_func_dealloc },
-    { Py_tp_descr_get, (void *) nb_method_descr_get },
-    { Py_tp_new, (void *) PyType_GenericNew },
-    { Py_tp_call, (void *) PyVectorcall_Call },
-    { 0, nullptr }
-};
-
-static PyType_Spec nb_method_spec = {
-    /*.name = */ "nanobind.nb_method",
-    /*.basicsize = */ (int) sizeof(nb_func),
-    /*.itemsize = */ (int) sizeof(func_data),
-    /*.flags = */ Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC |
-                  Py_TPFLAGS_METHOD_DESCRIPTOR |
-                  NB_HAVE_VECTORCALL_PY39_OR_NEWER,
-    /*.slots = */ nb_method_slots
-};
-
-static PyMemberDef nb_bound_method_members[] = {
-    { "__vectorcalloffset__", T_PYSSIZET,
-      (Py_ssize_t) offsetof(nb_bound_method, vectorcall), READONLY, nullptr },
-    { "__func__", T_OBJECT_EX,
-      (Py_ssize_t) offsetof(nb_bound_method, func), READONLY, nullptr },
-    { "__self__", T_OBJECT_EX,
-      (Py_ssize_t) offsetof(nb_bound_method, self), READONLY, nullptr },
-    { nullptr, 0, 0, 0, nullptr }
-};
-
-static PyType_Slot nb_bound_method_slots[] = {
-    { Py_tp_members, (void *) nb_bound_method_members },
-    { Py_tp_getattro, (void *) nb_bound_method_getattro },
-    { Py_tp_traverse, (void *) nb_bound_method_traverse },
-    { Py_tp_clear, (void *) nb_bound_method_clear },
-    { Py_tp_dealloc, (void *) nb_bound_method_dealloc },
-    { Py_tp_traverse, (void *) nb_bound_method_traverse },
-    { Py_tp_call, (void *) PyVectorcall_Call },
-    { 0, nullptr }
-};
-
-static PyType_Spec nb_bound_method_spec = {
-    /* .name = */ "nanobind.nb_bound_method",
-    /* .basicsize = */ (int) sizeof(nb_bound_method),
-    /* .itemsize = */ 0,
-    /* .flags = */ Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC |
-                   NB_HAVE_VECTORCALL_PY39_OR_NEWER,
-    /* .slots = */ nb_bound_method_slots
-};
-
-void default_exception_translator(const std::exception_ptr &p, void *) {
-    try {
-        std::rethrow_exception(p);
-    } catch (const std::bad_alloc &e) {
-        PyErr_SetString(PyExc_MemoryError, e.what());
-    } catch (const std::domain_error &e) {
-        PyErr_SetString(PyExc_ValueError, e.what());
-    } catch (const std::invalid_argument &e) {
-        PyErr_SetString(PyExc_ValueError, e.what());
-    } catch (const std::length_error &e) {
-        PyErr_SetString(PyExc_ValueError, e.what());
-    } catch (const std::out_of_range &e) {
-        PyErr_SetString(PyExc_IndexError, e.what());
-    } catch (const std::range_error &e) {
-        PyErr_SetString(PyExc_ValueError, e.what());
-    } catch (const std::overflow_error &e) {
-        PyErr_SetString(PyExc_OverflowError, e.what());
-    } catch (const std::exception &e) {
-        PyErr_SetString(PyExc_RuntimeError, e.what());
-    }
-}
-
-// Initialized once when the module is loaded, no locking needed
-nb_internals *internals = nullptr;
-PyTypeObject *nb_meta_cache = nullptr;
-
-static bool is_alive_value = false;
-static bool *is_alive_ptr = &is_alive_value;
-bool is_alive() noexcept { return *is_alive_ptr; }
-
-const char *abi_tag() { return NB_ABI_TAG; }
-
-static void internals_cleanup() {
-    nb_internals *p = internals;
-    if (!p)
-        return;
-
-    *is_alive_ptr = false;
-
-#if !defined(PYPY_VERSION) && !defined(NB_FREE_THREADED)
-    /* The memory leak checker is unsupported on PyPy, see
-       see https://foss.heptapod.net/pypy/pypy/-/issues/3855.
-
-       Leak reporting is explicitly disabled on free-threaded builds
-       for now because of the decision to immortalize function and
-       type objects. This may change in the future. */
-
-    bool print_leak_warnings = p->print_leak_warnings;
-
-    size_t inst_leaks = 0, keep_alive_leaks = 0;
-
-    // Shard locking no longer needed, Py_AtExit is single-threaded
-    for (size_t i = 0; i < p->shard_count; ++i) {
-        nb_shard &s = p->shards[i];
-        inst_leaks += s.inst_c2p.size();
-        keep_alive_leaks += s.keep_alive.size();
-    }
-
-#ifdef _DEBUG
-// in debug mode, show all leak records
-#define INC_CTR do {} while(0)
-#else
-// otherwise show just the first 10 or 20
-#define INC_CTR ctr++
-#endif
-
-    bool leak = inst_leaks > 0 || keep_alive_leaks > 0;
-
-    if (print_leak_warnings && inst_leaks > 0) {
-        fprintf(stderr, "nanobind: leaked %zu instances!\n", inst_leaks);
-
-#if !defined(Py_LIMITED_API)
-        auto print_leak = [](void* k, PyObject* v) {
-            type_data *tp = nb_type_data(Py_TYPE(v));
-            fprintf(stderr, " - leaked instance %p of type \"%s\"\n", k, tp->name);
-        };
-
-        int ctr = 0;
-        for (size_t i = 0; i < p->shard_count && ctr < 20; ++i) {
-            for (auto [k, v]: p->shards[i].inst_c2p) {
-                if (NB_UNLIKELY(nb_is_seq(v))) {
-                    nb_inst_seq* seq = nb_get_seq(v);
-                    for(; seq != nullptr && ctr < 20; seq = seq->next) {
-                        print_leak(k, seq->inst);
-                        INC_CTR;
-                    }
-                } else {
-                    print_leak(k, (PyObject*)v);
-                    INC_CTR;
-                }
-                if (ctr >= 20)
-                    break;
-            }
-        }
-        if (ctr >= 20) {
-            fprintf(stderr, " - ... skipped remainder\n");
-        }
-#endif
-    }
-
-    if (print_leak_warnings && keep_alive_leaks > 0)
-        fprintf(stderr, "nanobind: leaked %zu keep_alive records!\n",
-                keep_alive_leaks);
-
-    // Only report function/type leaks if actual nanobind instances were leaked
-#if !defined(NB_ABORT_ON_LEAK)
-    if (!leak)
-        print_leak_warnings = false;
-#endif
-
-    if (!p->type_c2p_slow.empty()) {
-        if (print_leak_warnings) {
-            fprintf(stderr, "nanobind: leaked %zu types!\n",
-                    p->type_c2p_slow.size());
-            int ctr = 0;
-            for (const auto &kv : p->type_c2p_slow) {
-                fprintf(stderr, " - leaked type \"%s\"\n", kv.second->name);
-                INC_CTR;
-                if (ctr == 10) {
-                    fprintf(stderr, " - ... skipped remainder\n");
-                    break;
-                }
-            }
-        }
-        leak = true;
-    }
-
-    if (!p->funcs.empty()) {
-        if (print_leak_warnings) {
-            fprintf(stderr, "nanobind: leaked %zu functions!\n",
-                    p->funcs.size());
-            int ctr = 0;
-            for (auto [f, p2] : p->funcs) {
-                fprintf(stderr, " - leaked function \"%s\"\n",
-                        nb_func_data(f)->name);
-                if (ctr == 10) {
-                    INC_CTR;
-                    fprintf(stderr, " - ... skipped remainder\n");
-                    break;
-                }
-            }
-        }
-        leak = true;
-    }
-
-    if (!leak) {
-        nb_translator_seq* t = p->translators.next;
-        while (t) {
-            nb_translator_seq *next = t->next;
-            delete t;
-            t = next;
-        }
-
-#if defined(NB_FREE_THREADED)
-        // This code won't run for now but is kept here for a time when
-        // immortalization isn't needed anymore.
-
-        PyThread_tss_delete(p->nb_static_property_disabled);
-        PyThread_tss_free(p->nb_static_property_disabled);
-        delete[] p->shards;
-#endif
-
-        delete p;
-        internals = nullptr;
-        nb_meta_cache = nullptr;
-    } else {
-        if (print_leak_warnings) {
-            fprintf(stderr, "nanobind: this is likely caused by a reference "
-                            "counting issue in the binding code.\n"
-                            "See https://nanobind.readthedocs.io/en/latest/refleaks.html");
-        }
-
-        #if defined(NB_ABORT_ON_LEAK) && !defined(NB_FREE_THREADED)
-            abort(); // Extra-strict behavior for the CI server
-        #endif
-    }
-#endif
-}
-
-NB_NOINLINE void init(const char *name) {
-    if (internals)
-        return;
-
-#if defined(PYPY_VERSION)
-    PyObject *dict = PyEval_GetBuiltins();
-#elif PY_VERSION_HEX < 0x03090000
-    PyObject *dict = PyInterpreterState_GetDict(_PyInterpreterState_Get());
-#else
-    PyObject *dict = PyInterpreterState_GetDict(PyInterpreterState_Get());
-#endif
-    check(dict, "nanobind::detail::init(): could not access internals dictionary!");
-
-    PyObject *key = PyUnicode_FromFormat("__nb_internals_%s_%s__",
-                                         abi_tag(), name ? name : "");
-    check(key, "nanobind::detail::init(): could not create dictionary key!");
-
-    PyObject *capsule = dict_get_item_ref_or_fail(dict, key);
-    if (capsule) {
-        Py_DECREF(key);
-        internals = (nb_internals *) PyCapsule_GetPointer(capsule, "nb_internals");
-        check(internals,
-              "nanobind::detail::internals_fetch(): capsule pointer is NULL!");
-        nb_meta_cache = internals->nb_meta;
-        is_alive_ptr = internals->is_alive_ptr;
-        Py_DECREF(capsule);
-        return;
-    }
-
-    nb_internals *p = new nb_internals();
-
-    size_t shard_count = 1;
-#if defined(NB_FREE_THREADED)
-    size_t hw_concurrency = std::thread::hardware_concurrency();
-    while (shard_count < hw_concurrency)
-        shard_count *= 2;
-    shard_count *= 2;
-    p->shards = new nb_shard[shard_count];
-    p->shard_mask = shard_count - 1;
-#endif
-    p->shard_count = shard_count;
-
-    str nb_name("nanobind");
-    p->nb_module = PyModule_NewObject(nb_name.ptr());
-
-    nb_meta_slots[0].pfunc = (PyObject *) &PyType_Type;
-    nb_meta_cache = p->nb_meta = (PyTypeObject *) PyType_FromSpec(&nb_meta_spec);
-    p->nb_type_dict = PyDict_New();
-    p->nb_func = (PyTypeObject *) PyType_FromSpec(&nb_func_spec);
-    p->nb_method = (PyTypeObject *) PyType_FromSpec(&nb_method_spec);
-    p->nb_bound_method = (PyTypeObject *) PyType_FromSpec(&nb_bound_method_spec);
-
-#if defined(NB_FREE_THREADED)
-    p->nb_static_property_disabled = PyThread_tss_alloc();
-    PyThread_tss_create(p->nb_static_property_disabled);
-#endif
-
-    for (size_t i = 0; i < shard_count; ++i) {
-        p->shards[i].keep_alive.min_load_factor(.1f);
-        p->shards[i].inst_c2p.min_load_factor(.1f);
-    }
-
-    check(p->nb_module && p->nb_meta && p->nb_type_dict && p->nb_func &&
-              p->nb_method && p->nb_bound_method,
-          "nanobind::detail::init(): initialization failed!");
-
-#if PY_VERSION_HEX < 0x03090000
-    p->nb_func->tp_flags |= NB_HAVE_VECTORCALL;
-    p->nb_func->tp_vectorcall_offset = offsetof(nb_func, vectorcall);
-    p->nb_method->tp_flags |= NB_HAVE_VECTORCALL;
-    p->nb_method->tp_vectorcall_offset = offsetof(nb_func, vectorcall);
-    p->nb_bound_method->tp_flags |= NB_HAVE_VECTORCALL;
-    p->nb_bound_method->tp_vectorcall_offset = offsetof(nb_bound_method, vectorcall);
-#endif
-
-#if defined(Py_LIMITED_API)
-    // Cache important functions from PyType_Type and PyProperty_Type
-    p->PyType_Type_tp_free = (freefunc) PyType_GetSlot(&PyType_Type, Py_tp_free);
-    p->PyType_Type_tp_init = (initproc) PyType_GetSlot(&PyType_Type, Py_tp_init);
-    p->PyType_Type_tp_dealloc =
-        (destructor) PyType_GetSlot(&PyType_Type, Py_tp_dealloc);
-    p->PyType_Type_tp_setattro =
-        (setattrofunc) PyType_GetSlot(&PyType_Type, Py_tp_setattro);
-    p->PyProperty_Type_tp_descr_get =
-        (descrgetfunc) PyType_GetSlot(&PyProperty_Type, Py_tp_descr_get);
-    p->PyProperty_Type_tp_descr_set =
-        (descrsetfunc) PyType_GetSlot(&PyProperty_Type, Py_tp_descr_set);
-
-    PyType_Slot dummy_slots[] = {
-        { Py_tp_base, &PyType_Type },
-        { 0, nullptr }
-    };
-
-    PyType_Spec dummy_spec = {
-        /* .name = */ "nanobind.dummy",
-        /* .basicsize = */ - (int) sizeof(void*),
-        /* .itemsize = */ 0,
-        /* .flags = */ Py_TPFLAGS_DEFAULT,
-        /* .slots = */ dummy_slots
-    };
-
-    // Determine the offset, at which types defined by nanobind begin
-    PyObject *dummy = PyType_FromMetaclass(
-        p->nb_meta, p->nb_module, &dummy_spec, nullptr);
-    p->type_data_offset =
-        (uint8_t *) PyObject_GetTypeData(dummy, p->nb_meta) - (uint8_t *) dummy;
-    Py_DECREF(dummy);
-#endif
-
-    p->translators = { default_exception_translator, nullptr, nullptr };
-    is_alive_value = true;
-    is_alive_ptr = &is_alive_value;
-    p->is_alive_ptr = is_alive_ptr;
-
-#if PY_VERSION_HEX < 0x030C0000 && !defined(PYPY_VERSION)
-    /* The implementation of typing.py on CPython <3.12 tends to introduce
-       spurious reference leaks that upset nanobind's leak checker. The
-       following band-aid, installs an 'atexit' handler that clears LRU caches
-       used in typing.py. To be resilient to potential future changes in
-       typing.py, the implementation fails silently if any step goes wrong. For
-       context, see https://github.com/python/cpython/issues/98253. */
-
-    const char *str =
-        "def cleanup():\n"
-        "    try:\n"
-        "        import sys\n"
-        "        fs = getattr(sys.modules.get('typing'), '_cleanups', None)\n"
-        "        if fs is not None:\n"
-        "            for f in fs:\n"
-        "                f()\n"
-        "    except:\n"
-        "        pass\n"
-        "import atexit\n"
-        "atexit.register(cleanup)\n"
-        "del atexit, cleanup";
-
-    PyObject *code = Py_CompileString(str, "<internal>", Py_file_input);
-    if (code) {
-        PyObject *result = PyEval_EvalCode(code, PyEval_GetGlobals(), nullptr);
-        if (!result)
-            PyErr_Clear();
-        Py_XDECREF(result);
-        Py_DECREF(code);
-    } else {
-        PyErr_Clear();
-    }
-#endif
-
-    if (Py_AtExit(internals_cleanup))
-        fprintf(stderr,
-                "Warning: could not install the nanobind cleanup handler! This "
-                "is needed to check for reference leaks and release remaining "
-                "resources at interpreter shutdown (e.g., to avoid leaks being "
-                "reported by tools like 'valgrind'). If you are a user of a "
-                "python extension library, you can ignore this warning.");
-
-    capsule = PyCapsule_New(p, "nb_internals", nullptr);
-    int rv = PyDict_SetItem(dict, key, capsule);
-    check(!rv && capsule,
-          "nanobind::detail::init(): capsule creation failed!");
-    Py_DECREF(capsule);
-    Py_DECREF(key);
-    internals = p;
-}
-
-#if defined(NB_COMPACT_ASSERTIONS)
-NB_NOINLINE void fail_unspecified() noexcept {
-    #if defined(NB_COMPACT_ASSERTION_MESSAGE)
-        fail(NB_COMPACT_ASSERTION_MESSAGE);
-    #else
-        fail("nanobind: encountered an unrecoverable error condition. Recompile "
-             "using the 'Debug' or 'RelWithDebInfo' modes to obtain further "
-             "information about this problem.");
-    #endif
-}
-#endif
-
-NAMESPACE_END(detail)
-NAMESPACE_END(NB_NAMESPACE)
diff --git a/src/nanobind/src/nb_internals.h b/src/nanobind/src/nb_internals.h
deleted file mode 100644
index ca79920..0000000
--- a/src/nanobind/src/nb_internals.h
+++ /dev/null
@@ -1,519 +0,0 @@
-#pragma once
-
-#if defined(__GNUC__)
-// Don't warn about missing fields in PyTypeObject declarations
-#  pragma GCC diagnostic ignored "-Wmissing-field-initializers"
-#elif defined(_MSC_VER)
-// Silence warnings that MSVC reports in robin_*.h
-#  pragma warning(disable: 4127) // conditional expression is constant
-#  pragma warning(disable: 4324) // structure was padded due to alignment specifier
-#  pragma warning(disable: 4293) // shift count negative or too big  <-- erroneously raised in a constexpr-disabled block
-#  pragma warning(disable: 4310) // cast truncates constant value <-- erroneously raised in a constexpr-disabled block
-#endif
-
-#include <nanobind/nanobind.h>
-#include <tsl/robin_map.h>
-#if defined(NB_FREE_THREADED)
-#include <atomic>
-#endif
-#include <cstring>
-#include <string_view>
-#include <functional>
-#include "hash.h"
-
-#if TSL_RH_VERSION_MAJOR != 1 || TSL_RH_VERSION_MINOR < 3
-#  error nanobind depends on tsl::robin_map, in particular version >= 1.3.0, <2.0.0
-#endif
-
-#if defined(_MSC_VER)
-#  define NB_THREAD_LOCAL __declspec(thread)
-#else
-#  define NB_THREAD_LOCAL __thread
-#endif
-
-NAMESPACE_BEGIN(NB_NAMESPACE)
-NAMESPACE_BEGIN(detail)
-
-#if defined(NB_COMPACT_ASSERTIONS)
-[[noreturn]] extern void fail_unspecified() noexcept;
-#  define check(cond, ...) if (NB_UNLIKELY(!(cond))) nanobind::detail::fail_unspecified()
-#else
-#  define check(cond, ...) if (NB_UNLIKELY(!(cond))) nanobind::detail::fail(__VA_ARGS__)
-#endif
-
-/// Nanobind function metadata (overloads, etc.)
-struct func_data : func_data_prelim<0> {
-    arg_data *args;
-    char *signature;
-};
-
-/// Python object representing an instance of a bound C++ type
-struct nb_inst { // usually: 24 bytes
-    PyObject_HEAD
-
-    /// Offset to the actual instance data
-    int32_t offset;
-
-    /// State of the C++ object this instance points to: is it constructed?
-    /// can we use it?
-    uint32_t state : 2;
-
-    // Values for `state`. Note that the numeric values of these are relied upon
-    // for an optimization in `nb_type_get()`.
-    static constexpr uint32_t state_uninitialized = 0; // not constructed
-    static constexpr uint32_t state_relinquished = 1; // owned by C++, don't touch
-    static constexpr uint32_t state_ready = 2; // constructed and usable
-
-    /**
-     * The variable 'offset' can either encode an offset relative to the
-     * nb_inst address that leads to the instance data, or it can encode a
-     * relative offset to a pointer that must be dereferenced to get to the
-     * instance data. 'direct' is 'true' in the former case.
-     */
-    uint32_t direct : 1;
-
-    /// Is the instance data co-located with the Python object?
-    uint32_t internal : 1;
-
-    /// Should the destructor be called when this instance is GCed?
-    uint32_t destruct : 1;
-
-    /// Should nanobind call 'operator delete' when this instance is GCed?
-    uint32_t cpp_delete : 1;
-
-    /// Does this instance hold references to others? (via internals.keep_alive)
-    uint32_t clear_keep_alive : 1;
-
-    /// Does this instance use intrusive reference counting?
-    uint32_t intrusive : 1;
-
-    // That's a lot of unused space. I wonder if there is a good use for it..
-    uint32_t unused : 24;
-};
-
-static_assert(sizeof(nb_inst) == sizeof(PyObject) + sizeof(uint32_t) * 2);
-
-/// Python object representing a bound C++ function
-struct nb_func {
-    PyObject_VAR_HEAD
-    PyObject* (*vectorcall)(PyObject *, PyObject * const*, size_t, PyObject *);
-    uint32_t max_nargs; // maximum value of func_data::nargs for any overload
-    bool complex_call;
-    bool doc_uniform;
-};
-
-/// Python object representing a `nb_ndarray` (which wraps a DLPack ndarray)
-struct nb_ndarray {
-    PyObject_HEAD
-    ndarray_handle *th;
-};
-
-/// Python object representing an `nb_method` bound to an instance (analogous to non-public PyMethod_Type)
-struct nb_bound_method {
-    PyObject_HEAD
-    PyObject* (*vectorcall)(PyObject *, PyObject * const*, size_t, PyObject *);
-    nb_func *func;
-    PyObject *self;
-};
-
-/// Pointers require a good hash function to randomize the mapping to buckets
-struct ptr_hash {
-    size_t operator()(const void *p) const {
-        // fmix32/64 from MurmurHash by Austin Appleby (public domain)
-        if constexpr (sizeof(void *) == 4)
-            return (size_t) fmix32((uint32_t) (uintptr_t) p);
-        else
-            return (size_t) fmix64((uint64_t) (uintptr_t) p);
-    }
-};
-
-// Minimal allocator definition, contains only the parts needed by tsl::*
-template <typename T> class py_allocator {
-public:
-    using value_type = T;
-    using pointer = T *;
-    using size_type = std::size_t;
-
-    py_allocator() = default;
-    py_allocator(const py_allocator &) = default;
-
-    template <typename U> py_allocator(const py_allocator<U> &) { }
-
-    pointer allocate(size_type n, const void * /*hint*/ = nullptr) noexcept {
-        void *p = PyMem_Malloc(n * sizeof(T));
-        if (!p)
-            fail("PyMem_Malloc(): out of memory!");
-        return static_cast<pointer>(p);
-    }
-
-    void deallocate(T *p, size_type /*n*/) noexcept { PyMem_Free(p); }
-};
-
-// Linked list of instances with the same pointer address. Usually just 1.
-struct nb_inst_seq {
-    PyObject *inst;
-    nb_inst_seq *next;
-};
-
-// Linked list of type aliases when there are multiple shared libraries with duplicate RTTI data
-struct nb_alias_chain {
-    const std::type_info *value;
-    nb_alias_chain *next;
-};
-
-// Weak reference list. Usually, there is just one entry
-struct nb_weakref_seq {
-    void (*callback)(void *) noexcept;
-    void *payload;
-    nb_weakref_seq *next;
-};
-
-struct std_typeinfo_hash {
-    size_t operator()(const std::type_info *a) const {
-        const char *name = a->name();
-        return std::hash<std::string_view>()({name, strlen(name)});
-    }
-};
-
-struct std_typeinfo_eq {
-    bool operator()(const std::type_info *a, const std::type_info *b) const {
-        return a->name() == b->name() || strcmp(a->name(), b->name()) == 0;
-    }
-};
-
-using nb_type_map_fast = tsl::robin_map<const std::type_info *, type_data *, ptr_hash>;
-using nb_type_map_slow = tsl::robin_map<const std::type_info *, type_data *,
-                                        std_typeinfo_hash, std_typeinfo_eq>;
-
-/// A simple pointer-to-pointer map that is reused a few times below (even if
-/// not 100% ideal) to avoid template code generation bloat.
-using nb_ptr_map  = tsl::robin_map<void *, void*, ptr_hash>;
-
-/// Convenience functions to deal with the pointer encoding in 'internals.inst_c2p'
-
-/// Does this entry store a linked list of instances?
-NB_INLINE bool         nb_is_seq(void *p)   { return ((uintptr_t) p) & 1; }
-
-/// Tag a nb_inst_seq* pointer as such
-NB_INLINE void*        nb_mark_seq(void *p) { return (void *) (((uintptr_t) p) | 1); }
-
-/// Retrieve the nb_inst_seq* pointer from an 'inst_c2p' value
-NB_INLINE nb_inst_seq* nb_get_seq(void *p)  { return (nb_inst_seq *) (((uintptr_t) p) ^ 1); }
-
-struct nb_translator_seq {
-    exception_translator translator;
-    void *payload;
-    nb_translator_seq *next = nullptr;
-};
-
-#if defined(NB_FREE_THREADED)
-#  define NB_SHARD_ALIGNMENT alignas(64)
-#else
-#  define NB_SHARD_ALIGNMENT
-#endif
-
-/**
- * The following data structure stores information associated with individual
- * instances. In free-threaded builds, it is split into multiple shards to avoid
- * lock contention.
- */
-struct NB_SHARD_ALIGNMENT nb_shard {
-    /**
-     * C++ -> Python instance map
-     *
-     * This associative data structure maps a C++ instance pointer onto its
-     * associated PyObject* (if bit 0 of the map value is zero) or a linked
-     * list of type `nb_inst_seq*` (if bit 0 is set---it must be cleared before
-     * interpreting the pointer in this case).
-     *
-     * The latter case occurs when several distinct Python objects reference
-     * the same memory address (e.g. a struct and its first member).
-     */
-    nb_ptr_map inst_c2p;
-
-    /// Dictionary storing keep_alive references
-    nb_ptr_map keep_alive;
-
-#if defined(NB_FREE_THREADED)
-    PyMutex mutex { };
-#endif
-};
-
-
-/**
- * Wraps a std::atomic if free-threading is enabled, otherwise a raw value.
- */
-#if defined(NB_FREE_THREADED)
-template<typename T>
-struct nb_maybe_atomic {
-  nb_maybe_atomic(T v) : value(v) {}
-
-  std::atomic<T> value;
-  T load_acquire() { return value.load(std::memory_order_acquire); }
-  T load_relaxed() { return value.load(std::memory_order_relaxed); }
-  void store_release(T w) { value.store(w, std::memory_order_release); }
-};
-#else
-template<typename T>
-struct nb_maybe_atomic {
-  nb_maybe_atomic(T v) : value(v) {}
-
-  T value;
-  T load_acquire() { return value; }
-  T load_relaxed() { return value; }
-  void store_release(T w) { value = w; }
-};
-#endif
-
-/**
- * `nb_internals` is the central data structure storing information related to
- * function/type bindings and instances. Separate nanobind extensions within the
- * same NB_DOMAIN furthermore share `nb_internals` to communicate with each
- * other, hence any changes here generally require an ABI version bump.
- *
- * The GIL protects the elements of this data structure from concurrent
- * modification. In free-threaded builds, a combination of locking schemes is
- * needed to achieve good performance.
- *
- * In particular, `inst_c2p` and `type_c2p_fast` are very hot and potentially
- * accessed several times while dispatching a single function call. The other
- * elements are accessed much less frequently and easier to deal with.
- *
- * The following list clarifies locking semantics for each member.
- *
- * - `nb_module`, `nb_meta`, `nb_func`, `nb_method`, `nb_bound_method`,
- *   `*_Type_tp_*`, `shard_count`, `is_alive_ptr`: these are initialized when
- *   loading the first nanobind extension within a domain, which happens within
- *   a critical section. They do not require locking.
- *
- * - `nb_type_dict`: created when the loading the first nanobind extension
- *   within a domain. While the dictionary itself is protected by its own
- *   lock, additional locking is needed to avoid races that create redundant
- *   entries. The `mutex` member is used for this.
- *
- * - `nb_static_property` and `nb_static_propert_descr_set`: created only once
- *   on demand, protected by `mutex`.
- *
- * - `nb_static_property_disabled`: needed to correctly implement assignments to
- *   static properties. Free-threaded builds store this flag using TLS to avoid
- *   concurrent modification.
- *
- * - `nb_static_property` and `nb_static_propert_descr_set`: created only once
- *   on demand, protected by `mutex`.
- *
- * - `nb_ndarray`: created only once on demand, protected by `mutex`.
- *
- * - `inst_c2p`: stores the C++ instance to Python object mapping. This
- *   data struture is *hot* and uses a sharded locking scheme to reduce
- *   lock contention.
- *
- * - `keep_alive`: stores lifetime dependencies (e.g., from the
- *   reference_internal return value policy). This data structure is
- *   potentially hot and shares the sharding scheme of `inst_c2p`.
- *
- * - `type_c2p_slow`: This is the ground-truth source of the `std::type_info`
- *   to `type_info *` mapping. Unrelated to free-threading, lookups into this
- *   data struture are generally costly because they use a string comparison on
- *   some platforms. Because it is only used as a fallback for 'type_c2p_fast',
- *   protecting this member via the global `mutex` is sufficient.
- *
- * - `type_c2p_fast`: this data structure is *hot* and mostly read. It maps
- *   `std::type_info` to `type_info *` but uses pointer-based comparisons.
- *   The implementation depends on the Python build.
- *
- * - `translators`: This is an append-to-front-only singly linked list traversed
- *    while raising exceptions. The main concern is losing elements during
- *    concurrent append operations. We assume that this data structure is only
- *    written during module initialization and don't use locking.
- *
- * - `funcs`: data structure for function leak tracking. Not used in
- *   free-threaded mode .
- *
- * - `print_leak_warnings`, `print_implicit_cast_warnings`: simple boolean
- *   flags. No protection against concurrent conflicting updates.
- */
-
-struct nb_internals {
-    /// Internal nanobind module
-    PyObject *nb_module;
-
-    /// Meta-metaclass of nanobind instances
-    PyTypeObject *nb_meta;
-
-    /// Dictionary with nanobind metaclass(es) for different payload sizes
-    PyObject *nb_type_dict;
-
-    /// Types of nanobind functions and methods
-    PyTypeObject *nb_func, *nb_method, *nb_bound_method;
-
-    /// Property variant for static attributes (created on demand)
-    nb_maybe_atomic<PyTypeObject *> nb_static_property = nullptr;
-    descrsetfunc nb_static_property_descr_set = nullptr;
-
-#if defined(NB_FREE_THREADED)
-    Py_tss_t *nb_static_property_disabled = nullptr;
-#else
-    bool nb_static_property_disabled = false;
-#endif
-
-    /// N-dimensional array wrapper (created on demand)
-    nb_maybe_atomic<PyTypeObject *> nb_ndarray = nullptr;
-
-#if defined(NB_FREE_THREADED)
-    nb_shard *shards = nullptr;
-    size_t shard_mask = 0;
-
-    // Heuristic shard selection (from pybind11 PR #5148 by @colesbury), uses
-    // high pointer bits to group allocations by individual threads/cores.
-    inline nb_shard &shard(void *p) {
-        uintptr_t highbits = ((uintptr_t) p) >> 20;
-        size_t index = ((size_t) fmix64((uint64_t) highbits)) & shard_mask;
-        return shards[index];
-    }
-#else
-    nb_shard shards[1];
-    inline nb_shard &shard(void *) { return shards[0]; }
-#endif
-
-#if !defined(NB_FREE_THREADED)
-    /// C++ -> Python type map -- fast version based on std::type_info pointer equality
-    nb_type_map_fast type_c2p_fast;
-#endif
-
-    /// C++ -> Python type map -- slow fallback version based on hashed strings
-    nb_type_map_slow type_c2p_slow;
-
-#if !defined(NB_FREE_THREADED)
-    /// nb_func/meth instance map for leak reporting (used as set, the value is unused)
-    /// In free-threaded mode, functions are immortal and don't require this data structure.
-    nb_ptr_map funcs;
-#endif
-
-    /// Registered C++ -> Python exception translators
-    nb_translator_seq translators;
-
-    /// Should nanobind print leak warnings on exit?
-    bool print_leak_warnings = true;
-
-    /// Should nanobind print warnings after implicit cast failures?
-    bool print_implicit_cast_warnings = true;
-
-    /// Pointer to a boolean that denotes if nanobind is fully initialized.
-    bool *is_alive_ptr = nullptr;
-
-#if defined(Py_LIMITED_API)
-    // Cache important functions from PyType_Type and PyProperty_Type
-    freefunc PyType_Type_tp_free;
-    initproc PyType_Type_tp_init;
-    destructor PyType_Type_tp_dealloc;
-    setattrofunc PyType_Type_tp_setattro;
-    descrgetfunc PyProperty_Type_tp_descr_get;
-    descrsetfunc PyProperty_Type_tp_descr_set;
-    size_t type_data_offset;
-#endif
-
-#if defined(NB_FREE_THREADED)
-    PyMutex mutex { };
-#endif
-
-    // Size of the 'shards' data structure. Only rarely accessed, hence at the end
-    size_t shard_count = 1;
-};
-
-/// Convenience macro to potentially access cached functions
-#if defined(Py_LIMITED_API)
-#  define NB_SLOT(type, name) internals->type##_##name
-#else
-#  define NB_SLOT(type, name) type.name
-#endif
-
-extern nb_internals *internals;
-extern PyTypeObject *nb_meta_cache;
-
-extern char *type_name(const std::type_info *t);
-
-// Forward declarations
-extern PyObject *inst_new_ext(PyTypeObject *tp, void *value);
-extern PyObject *inst_new_int(PyTypeObject *tp, PyObject *args, PyObject *kwds);
-extern PyTypeObject *nb_static_property_tp() noexcept;
-extern type_data *nb_type_c2p(nb_internals *internals,
-                              const std::type_info *type);
-extern void nb_type_unregister(type_data *t) noexcept;
-
-extern PyObject *call_one_arg(PyObject *fn, PyObject *arg) noexcept;
-
-/// Fetch the nanobind function record from a 'nb_func' instance
-NB_INLINE func_data *nb_func_data(void *o) {
-    return (func_data *) (((char *) o) + sizeof(nb_func));
-}
-
-#if defined(Py_LIMITED_API)
-extern type_data *nb_type_data_static(PyTypeObject *o) noexcept;
-#endif
-
-/// Fetch the nanobind type record from a 'nb_type' instance
-NB_INLINE type_data *nb_type_data(PyTypeObject *o) noexcept{
-    #if !defined(Py_LIMITED_API)
-        return (type_data *) (((char *) o) + sizeof(PyHeapTypeObject));
-    #else
-        return nb_type_data_static(o);
-    #endif
-}
-
-inline void *inst_ptr(nb_inst *self) {
-    void *ptr = (void *) ((intptr_t) self + self->offset);
-    return self->direct ? ptr : *(void **) ptr;
-}
-
-template <typename T> struct scoped_pymalloc {
-    scoped_pymalloc(size_t size = 1) {
-        ptr = (T *) PyMem_Malloc(size * sizeof(T));
-        if (!ptr)
-            fail("scoped_pymalloc(): could not allocate %zu bytes of memory!", size);
-    }
-    ~scoped_pymalloc() { PyMem_Free(ptr); }
-    T *release() {
-        T *temp = ptr;
-        ptr = nullptr;
-        return temp;
-    }
-    T *get() const { return ptr; }
-    T &operator[](size_t i) { return ptr[i]; }
-    T *operator->() { return ptr; }
-private:
-    T *ptr{ nullptr };
-};
-
-
-/// RAII lock/unlock guards for free-threaded builds
-#if defined(NB_FREE_THREADED)
-struct lock_shard {
-    nb_shard &s;
-    lock_shard(nb_shard &s) : s(s) { PyMutex_Lock(&s.mutex); }
-    ~lock_shard() { PyMutex_Unlock(&s.mutex); }
-};
-struct lock_internals {
-    nb_internals *i;
-    lock_internals(nb_internals *i) : i(i) { PyMutex_Lock(&i->mutex); }
-    ~lock_internals() { PyMutex_Unlock(&i->mutex); }
-};
-struct unlock_internals {
-    nb_internals *i;
-    unlock_internals(nb_internals *i) : i(i) { PyMutex_Unlock(&i->mutex); }
-    ~unlock_internals() { PyMutex_Lock(&i->mutex); }
-};
-#else
-struct lock_shard { lock_shard(nb_shard &) { } };
-struct lock_internals { lock_internals(nb_internals *) { } };
-struct unlock_internals { unlock_internals(nb_internals *) { } };
-struct lock_obj { lock_obj(PyObject *) { } };
-#endif
-
-extern char *strdup_check(const char *);
-extern void *malloc_check(size_t size);
-
-extern char *extract_name(const char *cmd, const char *prefix, const char *s);
-
-
-NAMESPACE_END(detail)
-NAMESPACE_END(NB_NAMESPACE)
diff --git a/src/nanobind/src/nb_ndarray.cpp b/src/nanobind/src/nb_ndarray.cpp
deleted file mode 100644
index 497f516..0000000
--- a/src/nanobind/src/nb_ndarray.cpp
+++ /dev/null
@@ -1,827 +0,0 @@
-#include <nanobind/ndarray.h>
-#include <atomic>
-#include "nb_internals.h"
-
-NAMESPACE_BEGIN(NB_NAMESPACE)
-NAMESPACE_BEGIN(detail)
-
-// ========================================================================
-
-struct managed_dltensor {
-    dlpack::dltensor dltensor;
-    void *manager_ctx;
-    void (*deleter)(managed_dltensor *);
-};
-
-struct ndarray_handle {
-    managed_dltensor *ndarray;
-    std::atomic<size_t> refcount;
-    PyObject *owner, *self;
-    bool free_shape;
-    bool free_strides;
-    bool call_deleter;
-    bool ro;
-};
-
-static void ndarray_capsule_destructor(PyObject *o) {
-    error_scope scope; // temporarily save any existing errors
-    managed_dltensor *mt =
-        (managed_dltensor *) PyCapsule_GetPointer(o, "dltensor");
-
-    if (mt)
-        ndarray_dec_ref((ndarray_handle *) mt->manager_ctx);
-    else
-        PyErr_Clear();
-}
-
-static void nb_ndarray_dealloc(PyObject *self) {
-    PyTypeObject *tp = Py_TYPE(self);
-    ndarray_dec_ref(((nb_ndarray *) self)->th);
-    PyObject_Free(self);
-    Py_DECREF(tp);
-}
-
-static int nd_ndarray_tpbuffer(PyObject *exporter, Py_buffer *view, int) {
-    nb_ndarray *self = (nb_ndarray *) exporter;
-
-    dlpack::dltensor &t = self->th->ndarray->dltensor;
-
-    if (t.device.device_type != device::cpu::value) {
-        PyErr_SetString(PyExc_BufferError, "Only CPU-allocated ndarrays can be "
-                                           "accessed via the buffer protocol!");
-        return -1;
-    }
-
-    const char *format = nullptr;
-    switch ((dlpack::dtype_code) t.dtype.code) {
-        case dlpack::dtype_code::Int:
-            switch (t.dtype.bits) {
-                case 8: format = "b"; break;
-                case 16: format = "h"; break;
-                case 32: format = "i"; break;
-                case 64: format = "q"; break;
-            }
-            break;
-
-        case dlpack::dtype_code::UInt:
-            switch (t.dtype.bits) {
-                case 8: format = "B"; break;
-                case 16: format = "H"; break;
-                case 32: format = "I"; break;
-                case 64: format = "Q"; break;
-            }
-            break;
-
-        case dlpack::dtype_code::Float:
-            switch (t.dtype.bits) {
-                case 16: format = "e"; break;
-                case 32: format = "f"; break;
-                case 64: format = "d"; break;
-            }
-            break;
-
-        case dlpack::dtype_code::Complex:
-            switch (t.dtype.bits) {
-                case 64: format = "Zf"; break;
-                case 128: format = "Zd"; break;
-            }
-            break;
-
-        case dlpack::dtype_code::Bool:
-            format = "?";
-            break;
-
-        default:
-            break;
-    }
-
-    if (!format || t.dtype.lanes != 1) {
-        PyErr_SetString(
-            PyExc_BufferError,
-            "Don't know how to convert DLPack dtype into buffer protocol format!");
-        return -1;
-    }
-
-    view->format = (char *) format;
-    view->itemsize = t.dtype.bits / 8;
-    view->buf = (void *) ((uintptr_t) t.data + t.byte_offset);
-    view->obj = exporter;
-    Py_INCREF(exporter);
-
-    Py_ssize_t len = view->itemsize;
-    scoped_pymalloc<Py_ssize_t> strides((size_t) t.ndim),
-                                  shape((size_t) t.ndim);
-
-    for (size_t i = 0; i < (size_t) t.ndim; ++i) {
-        len *= (Py_ssize_t) t.shape[i];
-        strides[i] = (Py_ssize_t) t.strides[i] * view->itemsize;
-        shape[i] = (Py_ssize_t) t.shape[i];
-    }
-
-    view->ndim = t.ndim;
-    view->len = len;
-    view->readonly = self->th->ro;
-    view->suboffsets = nullptr;
-    view->internal = nullptr;
-    view->strides = strides.release();
-    view->shape = shape.release();
-
-    return 0;
-}
-
-static void nb_ndarray_releasebuffer(PyObject *, Py_buffer *view) {
-    PyMem_Free(view->shape);
-    PyMem_Free(view->strides);
-}
-
-
-static PyObject *nb_ndarray_dlpack(PyObject *self, PyTypeObject *,
-                            PyObject *const *, Py_ssize_t ,
-                            PyObject *) {
-    nb_ndarray *self_nd = (nb_ndarray *) self;
-    ndarray_handle *th = self_nd->th;
-
-    PyObject *r =
-        PyCapsule_New(th->ndarray, "dltensor", ndarray_capsule_destructor);
-    if (r)
-        ndarray_inc_ref(th);
-    return r;
-}
-
-static PyObject *nb_ndarray_dlpack_device(PyObject *self, PyTypeObject *,
-                            PyObject *const *, Py_ssize_t ,
-                            PyObject *) {
-    nb_ndarray *self_nd = (nb_ndarray *) self;
-    dlpack::dltensor &t = self_nd->th->ndarray->dltensor;
-    PyObject *r = PyTuple_New(2);
-    PyObject *r0 = PyLong_FromLong(t.device.device_type);
-    PyObject *r1 = PyLong_FromLong(t.device.device_id);
-    if (!r || !r0 || !r1) {
-        Py_XDECREF(r);
-        Py_XDECREF(r0);
-        Py_XDECREF(r1);
-        return nullptr;
-    }
-    NB_TUPLE_SET_ITEM(r, 0, r0);
-    NB_TUPLE_SET_ITEM(r, 1, r1);
-    return r;
-}
-
-static PyMethodDef nb_ndarray_members[] = {
-   { "__dlpack__", (PyCFunction) (void *) nb_ndarray_dlpack, METH_FASTCALL | METH_KEYWORDS, nullptr },
-   { "__dlpack_device__", (PyCFunction) (void *) nb_ndarray_dlpack_device, METH_FASTCALL | METH_KEYWORDS, nullptr },
-   { nullptr, nullptr, 0, nullptr }
-};
-
-static PyTypeObject *nd_ndarray_tp() noexcept {
-    nb_internals *internals_ = internals;
-    PyTypeObject *tp = internals_->nb_ndarray.load_acquire();
-
-    if (NB_UNLIKELY(!tp)) {
-        lock_internals guard(internals_);
-        tp = internals_->nb_ndarray.load_relaxed();
-        if (tp)
-            return tp;
-
-        PyType_Slot slots[] = {
-            { Py_tp_dealloc, (void *) nb_ndarray_dealloc },
-            { Py_tp_methods, (void *) nb_ndarray_members },
-#if PY_VERSION_HEX >= 0x03090000
-            { Py_bf_getbuffer, (void *) nd_ndarray_tpbuffer },
-            { Py_bf_releasebuffer, (void *) nb_ndarray_releasebuffer },
-#endif
-            { 0, nullptr }
-        };
-
-        PyType_Spec spec = {
-            /* .name = */ "nanobind.nb_ndarray",
-            /* .basicsize = */ (int) sizeof(nb_ndarray),
-            /* .itemsize = */ 0,
-            /* .flags = */ Py_TPFLAGS_DEFAULT,
-            /* .slots = */ slots
-        };
-
-        tp = (PyTypeObject *) PyType_FromSpec(&spec);
-        check(tp, "nb_ndarray type creation failed!");
-
-#if PY_VERSION_HEX < 0x03090000
-        tp->tp_as_buffer->bf_getbuffer = nd_ndarray_tpbuffer;
-        tp->tp_as_buffer->bf_releasebuffer = nb_ndarray_releasebuffer;
-#endif
-
-        internals_->nb_ndarray.store_release(tp);
-    }
-
-    return tp;
-}
-
-static PyObject *dlpack_from_buffer_protocol(PyObject *o, bool ro) {
-    scoped_pymalloc<Py_buffer> view;
-    scoped_pymalloc<managed_dltensor> mt;
-
-    if (PyObject_GetBuffer(o, view.get(),
-                           ro ? PyBUF_RECORDS_RO : PyBUF_RECORDS)) {
-        PyErr_Clear();
-        return nullptr;
-    }
-
-    char format_c = 'B';
-    const char *format_str = view->format;
-    if (format_str)
-        format_c = *format_str;
-
-    bool skip_first = format_c == '@' || format_c == '=';
-
-    int32_t num = 1;
-    if(*(uint8_t *) &num == 1) {
-        if (format_c == '<')
-            skip_first = true;
-    } else {
-        if (format_c == '!' || format_c == '>')
-            skip_first = true;
-    }
-
-    if (skip_first && format_str)
-        format_c = *++format_str;
-
-    bool is_complex = format_str[0] == 'Z';
-    if (is_complex)
-        format_c = *++format_str;
-
-    dlpack::dtype dt { };
-    bool fail = format_str && format_str[1] != '\0';
-
-    if (!fail) {
-        switch (format_c) {
-            case 'c':
-            case 'b':
-            case 'h':
-            case 'i':
-            case 'l':
-            case 'q':
-            case 'n': dt.code = (uint8_t) dlpack::dtype_code::Int; break;
-
-            case 'B':
-            case 'H':
-            case 'I':
-            case 'L':
-            case 'Q':
-            case 'N': dt.code = (uint8_t) dlpack::dtype_code::UInt; break;
-
-            case 'e':
-            case 'f':
-            case 'd': dt.code = (uint8_t) dlpack::dtype_code::Float; break;
-
-            case '?': dt.code = (uint8_t) dlpack::dtype_code::Bool; break;
-
-            default:
-                fail = true;
-        }
-
-        if (is_complex) {
-            fail |= dt.code != (uint8_t) dlpack::dtype_code::Float;
-            dt.code = (uint8_t) dlpack::dtype_code::Complex;
-        }
-
-        dt.lanes = 1;
-        dt.bits = (uint8_t) (view->itemsize * 8);
-    }
-
-    if (fail) {
-        PyBuffer_Release(view.get());
-        return nullptr;
-    }
-
-    mt->deleter = [](managed_dltensor *mt2) {
-        gil_scoped_acquire guard;
-        Py_buffer *buf = (Py_buffer *) mt2->manager_ctx;
-        PyBuffer_Release(buf);
-        PyMem_Free(mt2->manager_ctx);
-        PyMem_Free(mt2->dltensor.shape);
-        PyMem_Free(mt2->dltensor.strides);
-        PyMem_Free(mt2);
-    };
-
-    /* DLPack mandates 256-byte alignment of the 'DLTensor::data' field, but
-       PyTorch unfortunately ignores the 'byte_offset' value.. :-( */
-#if 0
-    uintptr_t value_int = (uintptr_t) view->buf,
-              value_rounded = (value_int / 256) * 256;
-#else
-    uintptr_t value_int = (uintptr_t) view->buf,
-              value_rounded = value_int;
-#endif
-
-    mt->dltensor.data = (void *) value_rounded;
-    mt->dltensor.device = { device::cpu::value, 0 };
-    mt->dltensor.ndim = view->ndim;
-    mt->dltensor.dtype = dt;
-    mt->dltensor.byte_offset = value_int - value_rounded;
-
-    scoped_pymalloc<int64_t> strides((size_t) view->ndim);
-    scoped_pymalloc<int64_t> shape((size_t) view->ndim);
-    const int64_t itemsize = static_cast<int64_t>(view->itemsize);
-    for (size_t i = 0; i < (size_t) view->ndim; ++i) {
-        int64_t stride = view->strides[i] / itemsize;
-        if (stride * itemsize != view->strides[i]) {
-            PyBuffer_Release(view.get());
-            return nullptr;
-        }
-        strides[i] = stride;
-        shape[i] = (int64_t) view->shape[i];
-    }
-
-    mt->manager_ctx = view.release();
-    mt->dltensor.shape = shape.release();
-    mt->dltensor.strides = strides.release();
-
-    return PyCapsule_New(mt.release(), "dltensor", [](PyObject *o) {
-        error_scope scope; // temporarily save any existing errors
-        managed_dltensor *mt =
-            (managed_dltensor *) PyCapsule_GetPointer(o, "dltensor");
-        if (mt) {
-            if (mt->deleter)
-                mt->deleter(mt);
-        } else {
-            PyErr_Clear();
-        }
-    });
-}
-
-bool ndarray_check(PyObject *o) noexcept {
-    if (PyObject_HasAttrString(o, "__dlpack__") || PyObject_CheckBuffer(o))
-        return true;
-
-    PyTypeObject *tp = Py_TYPE(o);
-
-    if (tp == &PyCapsule_Type)
-        return true;
-
-    PyObject *name = nb_type_name((PyObject *) tp);
-    check(name, "Could not obtain type name! (1)");
-
-    const char *tp_name = PyUnicode_AsUTF8AndSize(name, nullptr);
-    check(tp_name, "Could not obtain type name! (2)");
-
-    bool result =
-        // PyTorch
-        strcmp(tp_name, "torch.Tensor") == 0 ||
-        // XLA
-        strcmp(tp_name, "jaxlib.xla_extension.ArrayImpl") == 0 ||
-        // Tensorflow
-        strcmp(tp_name, "tensorflow.python.framework.ops.EagerTensor") == 0 ||
-        // Cupy
-        strcmp(tp_name, "cupy.ndarray") == 0;
-
-    Py_DECREF(name);
-    return result;
-}
-
-
-ndarray_handle *ndarray_import(PyObject *o, const ndarray_config *c,
-                               bool convert, cleanup_list *cleanup) noexcept {
-    object capsule;
-    bool is_pycapsule = PyCapsule_CheckExact(o);
-
-    // If this is not a capsule, try calling o.__dlpack__()
-    if (!is_pycapsule) {
-        capsule = steal(PyObject_CallMethod(o, "__dlpack__", nullptr));
-
-        if (!capsule.is_valid()) {
-            PyErr_Clear();
-            PyTypeObject *tp = Py_TYPE(o);
-
-            try {
-                const char *module_name =
-                    borrow<str>(handle(tp).attr("__module__")).c_str();
-
-                object package;
-                if (strncmp(module_name, "tensorflow.", 11) == 0)
-                    package = module_::import_("tensorflow.experimental.dlpack");
-                else if (strcmp(module_name, "torch") == 0)
-                    package = module_::import_("torch.utils.dlpack");
-                else if (strncmp(module_name, "jaxlib", 6) == 0)
-                    package = module_::import_("jax.dlpack");
-
-                if (package.is_valid())
-                    capsule = package.attr("to_dlpack")(handle(o));
-            } catch (...) {
-                capsule.reset();
-            }
-        }
-
-        // Try creating an ndarray via the buffer protocol
-        if (!capsule.is_valid())
-            capsule = steal(dlpack_from_buffer_protocol(o, c->ro));
-
-        if (!capsule.is_valid())
-            return nullptr;
-    } else {
-        capsule = borrow(o);
-    }
-
-    // Extract the pointer underlying the capsule
-    void *ptr = PyCapsule_GetPointer(capsule.ptr(), "dltensor");
-    if (!ptr) {
-        PyErr_Clear();
-        return nullptr;
-    }
-
-    // Check if the ndarray satisfies the requirements
-    dlpack::dltensor &t = ((managed_dltensor *) ptr)->dltensor;
-
-    bool has_dtype = c->dtype != dlpack::dtype(),
-         has_device_type = c->device_type != 0,
-         has_shape = c->ndim != -1,
-         has_order = c->order != '\0';
-
-    bool pass_dtype = true, pass_device = true,
-         pass_shape = true, pass_order = true;
-
-    if (has_dtype)
-        pass_dtype = t.dtype == c->dtype;
-
-    if (has_device_type)
-        pass_device = t.device.device_type == c->device_type;
-
-    if (has_shape) {
-        pass_shape &= c->ndim == t.ndim;
-
-        if (pass_shape) {
-            for (int32_t i = 0; i < c->ndim; ++i) {
-                if (c->shape[i] != t.shape[i] &&
-                    c->shape[i] != -1) {
-                    pass_shape = false;
-                    break;
-                }
-            }
-        }
-    }
-
-    int64_t size = 1;
-    for (int32_t i = 0; i < t.ndim; ++i)
-        size *= t.shape[i];
-
-    // Tolerate any strides if the array has 1 or fewer elements
-    if (pass_shape && has_order && size > 1) {
-        char order = c->order;
-
-        bool c_order = order == 'C' || order == 'A',
-             f_order = order == 'F' || order == 'A';
-
-        if (!t.strides) {
-            /* When the provided tensor does not have a valid
-               strides field, it uses the C ordering convention */
-            if (c_order) {
-                pass_order = true;
-            } else {
-                int nontrivial_dims = 0;
-                for (int i = 0; i < t.ndim; ++i)
-                    nontrivial_dims += (int) (t.shape[i] > 1);
-                pass_order = nontrivial_dims <= 1;
-            }
-        } else {
-            if (c_order) {
-                for (int64_t i = t.ndim - 1, accum = 1; i >= 0; --i) {
-                    c_order &= t.shape[i] == 1 || t.strides[i] == accum;
-                    accum *= t.shape[i];
-                }
-            }
-
-            if (f_order) {
-                for (int64_t i = 0, accum = 1; i < t.ndim; ++i) {
-                    f_order &= t.shape[i] == 1 || t.strides[i] == accum;
-                    accum *= t.shape[i];
-                }
-            }
-
-            pass_order = c_order || f_order;
-        }
-    }
-
-    bool refused_conversion = t.dtype.code == (uint8_t) dlpack::dtype_code::Complex &&
-                              has_dtype &&
-                              c->dtype.code != (uint8_t) dlpack::dtype_code::Complex;
-
-    // Support implicit conversion of 'dtype' and order
-    if (pass_device && pass_shape && (!pass_dtype || !pass_order) && convert &&
-        capsule.ptr() != o && !refused_conversion) {
-        PyTypeObject *tp = Py_TYPE(o);
-        str module_name_o = borrow<str>(handle(tp).attr("__module__"));
-        const char *module_name = module_name_o.c_str();
-
-        char order = 'K'; // for NumPy. 'K' means 'keep'
-        if (c->order)
-            order = c->order;
-
-        dlpack::dtype dt = has_dtype ? c->dtype : t.dtype;
-        if (dt.lanes != 1)
-            return nullptr;
-
-        const char *prefix = nullptr;
-        char dtype[11];
-        if (dt.code == (uint8_t) dlpack::dtype_code::Bool) {
-            std::strcpy(dtype, "bool");
-        } else {
-            switch (dt.code) {
-                case (uint8_t) dlpack::dtype_code::Int: prefix = "int"; break;
-                case (uint8_t) dlpack::dtype_code::UInt: prefix = "uint"; break;
-                case (uint8_t) dlpack::dtype_code::Float: prefix = "float"; break;
-                case (uint8_t) dlpack::dtype_code::Complex: prefix = "complex"; break;
-                default:
-                    return nullptr;
-            }
-            snprintf(dtype, sizeof(dtype), "%s%u", prefix, dt.bits);
-        }
-
-        object converted;
-        try {
-            if (strcmp(module_name, "numpy") == 0 || strcmp(module_name, "cupy") == 0) {
-                converted = handle(o).attr("astype")(dtype, order);
-            } else if (strcmp(module_name, "torch") == 0) {
-                converted = handle(o).attr("to")(
-                    arg("dtype") = module_::import_("torch").attr(dtype));
-                if (c->order == 'C')
-                    converted = converted.attr("contiguous")();
-            } else if (strncmp(module_name, "tensorflow.", 11) == 0) {
-                converted = module_::import_("tensorflow")
-                                .attr("cast")(handle(o), dtype);
-            } else if (strncmp(module_name, "jaxlib", 6) == 0) {
-                converted = handle(o).attr("astype")(dtype);
-            }
-        } catch (...) { converted.reset(); }
-
-        // Potentially try again recursively
-        if (!converted.is_valid()) {
-            return nullptr;
-        } else {
-            ndarray_handle *h =
-                ndarray_import(converted.ptr(), c, false, nullptr);
-            if (h && cleanup)
-                cleanup->append(converted.release().ptr());
-            return h;
-        }
-    }
-
-    if (!pass_dtype || !pass_device || !pass_shape || !pass_order)
-        return nullptr;
-
-    // Create a reference-counted wrapper
-    scoped_pymalloc<ndarray_handle> result;
-    result->ndarray = (managed_dltensor *) ptr;
-    result->refcount = 0;
-    result->owner = nullptr;
-    result->free_shape = false;
-    result->call_deleter = true;
-    result->ro = c->ro;
-
-    if (is_pycapsule) {
-        result->self = nullptr;
-    } else {
-        result->self = o;
-        Py_INCREF(o);
-    }
-
-    // Ensure that the strides member is always initialized
-    if (t.strides) {
-        result->free_strides = false;
-    } else {
-        result->free_strides = true;
-
-        scoped_pymalloc<int64_t> strides((size_t) t.ndim);
-        for (int64_t i = t.ndim - 1, accum = 1; i >= 0; --i) {
-            strides[i] = accum;
-            accum *= t.shape[i];
-        }
-
-        t.strides = strides.release();
-    }
-
-    // Mark the dltensor capsule as "consumed"
-    if (PyCapsule_SetName(capsule.ptr(), "used_dltensor") ||
-        PyCapsule_SetDestructor(capsule.ptr(), nullptr))
-        check(false, "nanobind::detail::ndarray_import(): could not mark "
-                     "dltensor capsule as consumed!");
-
-    return result.release();
-}
-
-dlpack::dltensor *ndarray_inc_ref(ndarray_handle *th) noexcept {
-    if (!th)
-        return nullptr;
-    ++th->refcount;
-    return &th->ndarray->dltensor;
-}
-
-void ndarray_dec_ref(ndarray_handle *th) noexcept {
-    if (!th)
-        return;
-    size_t rc_value = th->refcount--;
-
-    if (rc_value == 0) {
-        check(false, "ndarray_dec_ref(): reference count became negative!");
-    } else if (rc_value == 1) {
-        gil_scoped_acquire guard;
-
-        Py_XDECREF(th->owner);
-        Py_XDECREF(th->self);
-        managed_dltensor *mt = th->ndarray;
-        if (th->free_shape) {
-            PyMem_Free(mt->dltensor.shape);
-            mt->dltensor.shape = nullptr;
-        }
-        if (th->free_strides) {
-            PyMem_Free(mt->dltensor.strides);
-            mt->dltensor.strides = nullptr;
-        }
-        if (th->call_deleter) {
-            if (mt->deleter)
-                mt->deleter(mt);
-        } else {
-            PyMem_Free(mt);
-        }
-        PyMem_Free(th);
-    }
-}
-
-ndarray_handle *ndarray_create(void *value, size_t ndim, const size_t *shape_in,
-                               PyObject *owner, const int64_t *strides_in,
-                               dlpack::dtype dtype, bool ro, int device_type,
-                               int device_id, char order) {
-    /* DLPack mandates 256-byte alignment of the 'DLTensor::data' field, but
-       PyTorch unfortunately ignores the 'byte_offset' value.. :-( */
-#if 0
-    uintptr_t value_int = (uintptr_t) value,
-              value_rounded = (value_int / 256) * 256;
-#else
-    uintptr_t value_int = (uintptr_t) value,
-              value_rounded = value_int;
-#endif
-    if (device_type == 0)
-        device_type = device::cpu::value;
-
-    scoped_pymalloc<managed_dltensor> ndarray;
-    scoped_pymalloc<ndarray_handle> result;
-    scoped_pymalloc<int64_t> shape(ndim), strides(ndim);
-
-    auto deleter = [](managed_dltensor *mt) {
-        gil_scoped_acquire guard;
-        ndarray_handle *th = (ndarray_handle *) mt->manager_ctx;
-        ndarray_dec_ref(th);
-    };
-
-    for (size_t i = 0; i < ndim; ++i)
-        shape[i] = (int64_t) shape_in[i];
-
-    if (ndim > 0) {
-        int64_t prod = 1;
-        if (strides_in) {
-            for (size_t i = 0; i < ndim; ++i)
-                strides[i] = strides_in[i];
-        } else if (order == 'F') {
-            for (size_t i = 0; i < ndim; ++i) {
-                strides[i] = prod;
-                prod *= (int64_t) shape_in[i];
-            }
-        } else if (order == '\0' || order == 'A' || order == 'C') {
-            for (ssize_t i = (ssize_t) ndim - 1; i >= 0; --i) {
-                strides[i] = prod;
-                prod *= (int64_t) shape_in[i];
-            }
-        } else {
-            check(false, "nanobind::detail::ndarray_create(): unknown "
-                         "memory order requested!");
-        }
-    }
-
-    ndarray->dltensor.data = (void *) value_rounded;
-    ndarray->dltensor.device.device_type = (int32_t) device_type;
-    ndarray->dltensor.device.device_id = (int32_t) device_id;
-    ndarray->dltensor.ndim = (int32_t) ndim;
-    ndarray->dltensor.dtype = dtype;
-    ndarray->dltensor.byte_offset = value_int - value_rounded;
-    ndarray->dltensor.shape = shape.release();
-    ndarray->dltensor.strides = strides.release();
-    ndarray->manager_ctx = result.get();
-    ndarray->deleter = deleter;
-    result->ndarray = (managed_dltensor *) ndarray.release();
-    result->refcount = 0;
-    result->owner = owner;
-    result->self = nullptr;
-    result->free_shape = true;
-    result->free_strides = true;
-    result->call_deleter = false;
-    result->ro = ro;
-    Py_XINCREF(owner);
-    return result.release();
-}
-
-PyObject *ndarray_export(ndarray_handle *th, int framework,
-                        rv_policy policy, cleanup_list *cleanup) noexcept {
-    if (!th)
-        return none().release().ptr();
-
-    bool copy;
-    switch (policy) {
-        case rv_policy::reference_internal:
-            if (cleanup && cleanup->self() != th->owner && !th->self) {
-                if (th->owner) {
-                    PyErr_SetString(PyExc_RuntimeError,
-                                    "nanobind::detail::ndarray_export(): "
-                                    "reference_internal policy cannot be "
-                                    "applied (ndarray already has an owner)");
-                    return nullptr;
-                } else {
-                    th->owner = cleanup->self();
-                    Py_INCREF(th->owner);
-                }
-            }
-            [[fallthrough]];
-
-        case rv_policy::automatic:
-        case rv_policy::automatic_reference:
-            copy = th->owner == nullptr && th->self == nullptr;
-            break;
-
-        case rv_policy::copy:
-        case rv_policy::move:
-            copy = true;
-            break;
-
-        default:
-            copy = false;
-            break;
-    }
-
-    if (!copy) {
-        if (th->self) {
-            Py_INCREF(th->self);
-            return th->self;
-        } else if (policy == rv_policy::none) {
-            return nullptr;
-        }
-    }
-
-    object o;
-    if (copy && framework == no_framework::value && th->self) {
-        o = borrow(th->self);
-    } else if (framework == numpy::value || framework == jax::value) {
-        nb_ndarray *h = PyObject_New(nb_ndarray, nd_ndarray_tp());
-        if (!h)
-            return nullptr;
-        h->th = th;
-        ndarray_inc_ref(th);
-        o = steal((PyObject *) h);
-    } else {
-        o = steal(PyCapsule_New(th->ndarray, "dltensor",
-                                ndarray_capsule_destructor));
-        ndarray_inc_ref(th);
-    }
-
-    try {
-        if (framework == numpy::value) {
-            return module_::import_("numpy")
-                .attr("array")(o, arg("copy") = copy)
-                .release()
-                .ptr();
-        } else {
-            const char *pkg_name;
-            switch (framework) {
-                case pytorch::value: pkg_name = "torch.utils.dlpack"; break;
-                case tensorflow::value: pkg_name = "tensorflow.experimental.dlpack"; break;
-                case jax::value: pkg_name = "jax.dlpack"; break;
-                case cupy::value: pkg_name = "cupy"; break;
-                default: pkg_name = nullptr;
-            }
-
-            if (pkg_name)
-                o = module_::import_(pkg_name).attr("from_dlpack")(o);
-        }
-    } catch (const std::exception &e) {
-        PyErr_Format(PyExc_RuntimeError,
-                     "nanobind::detail::ndarray_export(): could not "
-                     "import ndarray: %s",
-                     e.what());
-        return nullptr;
-    }
-
-    if (copy) {
-        const char* copy_str = "copy";
-        if (framework == pytorch::value)
-            copy_str = "clone";
-
-        try {
-            o = o.attr(copy_str)();
-        } catch (std::exception &e) {
-            PyErr_Format(PyExc_RuntimeError,
-                         "nanobind::detail::ndarray_export(): copy failed: %s",
-                         e.what());
-            return nullptr;
-        }
-    }
-
-    return o.release().ptr();
-}
-
-NAMESPACE_END(detail)
-NAMESPACE_END(NB_NAMESPACE)
diff --git a/src/nanobind/src/nb_static_property.cpp b/src/nanobind/src/nb_static_property.cpp
deleted file mode 100644
index 51be661..0000000
--- a/src/nanobind/src/nb_static_property.cpp
+++ /dev/null
@@ -1,76 +0,0 @@
-#include "nb_internals.h"
-
-NAMESPACE_BEGIN(NB_NAMESPACE)
-NAMESPACE_BEGIN(detail)
-
-/// `nb_static_property.__get__()`: Always pass the class instead of the instance.
-static PyObject *nb_static_property_descr_get(PyObject *self, PyObject *, PyObject *cls) {
-
-    // Flag to avoid infinite recursion during static attribute assignment
-    bool static_property_disabled;
-#if defined(NB_FREE_THREADED)
-    static_property_disabled = (bool) PyThread_tss_get(internals->nb_static_property_disabled);
-#else
-    static_property_disabled = internals->nb_static_property_disabled;
-#endif
-
-    if (!static_property_disabled) {
-        return NB_SLOT(PyProperty_Type, tp_descr_get)(self, cls, cls);
-    } else {
-        Py_INCREF(self);
-        return self;
-    }
-}
-
-/// `nb_static_property.__set__()`: Just like the above `__get__()`.
-static int nb_static_property_descr_set(PyObject *self, PyObject *obj, PyObject *value) {
-    PyObject *cls = PyType_Check(obj) ? obj : (PyObject *) Py_TYPE(obj);
-    return NB_SLOT(PyProperty_Type, tp_descr_set)(self, cls, value);
-}
-
-PyTypeObject *nb_static_property_tp() noexcept {
-    nb_internals *internals_ = internals;
-    PyTypeObject *tp = internals_->nb_static_property.load_acquire();
-
-    if (NB_UNLIKELY(!tp)) {
-        lock_internals guard(internals_);
-
-        tp = internals_->nb_static_property.load_relaxed();
-        if (tp)
-            return tp;
-
-        PyMemberDef *members;
-
-        #if defined(Py_LIMITED_API)
-            members = (PyMemberDef *) PyType_GetSlot(&PyProperty_Type, Py_tp_members);
-        #else
-            members = PyProperty_Type.tp_members;
-        #endif
-
-        PyType_Slot slots[] = {
-            { Py_tp_base, &PyProperty_Type },
-            { Py_tp_descr_get, (void *) nb_static_property_descr_get },
-            { Py_tp_members, members },
-            { 0, nullptr }
-        };
-
-        PyType_Spec spec = {
-            /* .name = */ "nanobind.nb_static_property",
-            /* .basicsize = */ 0,
-            /* .itemsize = */ 0,
-            /* .flags = */ Py_TPFLAGS_DEFAULT,
-            /* .slots = */ slots
-        };
-
-        tp = (PyTypeObject *) PyType_FromSpec(&spec);
-        check(tp, "nb_static_property type creation failed!");
-
-        internals_->nb_static_property_descr_set = nb_static_property_descr_set;
-        internals_->nb_static_property.store_release(tp);
-    }
-
-    return tp;
-}
-
-NAMESPACE_END(detail)
-NAMESPACE_END(NB_NAMESPACE)
diff --git a/src/nanobind/src/nb_type.cpp b/src/nanobind/src/nb_type.cpp
deleted file mode 100644
index f60083d..0000000
--- a/src/nanobind/src/nb_type.cpp
+++ /dev/null
@@ -1,2283 +0,0 @@
-/*
-    src/nb_type.cpp: libnanobind functionality for binding classes
-
-    Copyright (c) 2022 Wenzel Jakob
-
-    All rights reserved. Use of this source code is governed by a
-    BSD-style license that can be found in the LICENSE file.
-*/
-
-#include "nb_internals.h"
-#include "nb_ft.h"
-
-#if defined(_MSC_VER)
-#  pragma warning(disable: 4706) // assignment within conditional expression
-#endif
-
-#if !defined(Py_tp_vectorcall)
-#  define Py_tp_vectorcall 82
-#endif
-
-NAMESPACE_BEGIN(NB_NAMESPACE)
-NAMESPACE_BEGIN(detail)
-
-static PyObject **nb_dict_ptr(PyObject *self) {
-    PyTypeObject *tp = Py_TYPE(self);
-#if defined(Py_LIMITED_API)
-    Py_ssize_t dictoffset = nb_type_data(tp)->dictoffset;
-#else
-    Py_ssize_t dictoffset = tp->tp_dictoffset;
-#endif
-    return dictoffset ? (PyObject **) ((uint8_t *) self + dictoffset) : nullptr;
-}
-
-static PyObject **nb_weaklist_ptr(PyObject *self) {
-    PyTypeObject *tp = Py_TYPE(self);
-#if defined(Py_LIMITED_API)
-    Py_ssize_t weaklistoffset = nb_type_data(tp)->weaklistoffset;
-#else
-    Py_ssize_t weaklistoffset = tp->tp_weaklistoffset;
-#endif
-    return weaklistoffset ? (PyObject **) ((uint8_t *) self + weaklistoffset) : nullptr;
-}
-
-static PyGetSetDef inst_getset[] = {
-    { "__dict__", PyObject_GenericGetDict, PyObject_GenericSetDict, nullptr, nullptr },
-    { nullptr, nullptr, nullptr, nullptr, nullptr }
-};
-
-static int inst_clear(PyObject *self) {
-    PyObject **dict = nb_dict_ptr(self);
-    if (dict)
-        Py_CLEAR(*dict);
-    return 0;
-}
-
-static int inst_traverse(PyObject *self, visitproc visit, void *arg) {
-    PyObject **dict = nb_dict_ptr(self);
-    if (dict)
-        Py_VISIT(*dict);
-#if PY_VERSION_HEX >= 0x03090000
-    Py_VISIT(Py_TYPE(self));
-#endif
-    return 0;
-}
-
-static int inst_init(PyObject *self, PyObject *, PyObject *) {
-    const type_data *t = nb_type_data(Py_TYPE(self));
-    PyErr_Format(PyExc_TypeError, "%s: no constructor defined!", t->name);
-    return -1;
-}
-
-/// Allocate memory for a nb_type instance with internal storage
-PyObject *inst_new_int(PyTypeObject *tp, PyObject * /* args */,
-                       PyObject * /*kwd */) {
-    bool gc = PyType_HasFeature(tp, Py_TPFLAGS_HAVE_GC);
-
-    nb_inst *self;
-    if (NB_LIKELY(!gc))
-        self = PyObject_New(nb_inst, tp);
-    else
-        self = (nb_inst *) PyType_GenericAlloc(tp, 0);
-
-    if (NB_LIKELY(self)) {
-        const type_data *t = nb_type_data(tp);
-        uint32_t align = (uint32_t) t->align;
-        bool intrusive = t->flags & (uint32_t) type_flags::intrusive_ptr;
-
-        uintptr_t payload = (uintptr_t) (self + 1);
-
-        if (NB_UNLIKELY(align > sizeof(void *)))
-            payload = (payload + align - 1) / align * align;
-
-        self->offset = (int32_t) ((intptr_t) payload - (intptr_t) self);
-        self->direct = 1;
-        self->internal = 1;
-        self->state = nb_inst::state_uninitialized;
-        self->destruct = 0;
-        self->cpp_delete = 0;
-        self->clear_keep_alive = 0;
-        self->intrusive = intrusive;
-        self->unused = 0;
-
-        // Make the object compatible with nb_try_inc_ref (free-threaded builds only)
-        nb_enable_try_inc_ref((PyObject *) self);
-
-        // Update hash table that maps from C++ to Python instance
-        nb_shard &shard = internals->shard((void *) payload);
-        lock_shard guard(shard);
-        auto [it, success] = shard.inst_c2p.try_emplace((void *) payload, self);
-        check(success, "nanobind::detail::inst_new_int(): unexpected collision!");
-    }
-
-    return (PyObject *) self;
-}
-
-/// Allocate memory for a nb_type instance with external storage. In contrast to
-/// 'inst_new_int()', this does not yet register the instance in the internal
-/// data structures. The function 'inst_register()' must be used to do so.
-PyObject *inst_new_ext(PyTypeObject *tp, void *value) {
-    bool gc = PyType_HasFeature(tp, Py_TPFLAGS_HAVE_GC);
-
-    nb_inst *self;
-    if (NB_LIKELY(!gc)) {
-        self = (nb_inst *) PyObject_Malloc(sizeof(nb_inst));
-        if (!self)
-            return PyErr_NoMemory();
-        PyObject_Init((PyObject *) self, tp);
-    } else {
-        self = (nb_inst *) PyType_GenericAlloc(tp, 0);
-        if (!self)
-            return nullptr;
-    }
-
-    // Compute offset to instance value
-    // Use uint64_t because subtracting tagged pointers (e.g., with
-    // HardwareAddressSanitizer) may overflow, which is undefined behavior for
-    // signed integers.
-    int32_t offset = (int32_t) ((uintptr_t) value - (uintptr_t) self);
-
-    bool direct = (intptr_t) self + offset == (intptr_t) value;
-    if (NB_UNLIKELY(!direct)) {
-        // Location is not representable as signed 32 bit offset
-        if (!gc) {
-            /// Allocate memory for an extra pointer
-            nb_inst *self_2 =
-                (nb_inst *) PyObject_Realloc(self, sizeof(nb_inst) + sizeof(void *));
-
-            if (NB_UNLIKELY(!self_2)) {
-                PyObject_Free(self);
-                return PyErr_NoMemory();
-            }
-
-            self = self_2;
-        }
-
-        *(void **) (self + 1) = value;
-        offset = (int32_t) sizeof(nb_inst);
-    }
-
-    const type_data *t = nb_type_data(tp);
-    bool intrusive = t->flags & (uint32_t) type_flags::intrusive_ptr;
-
-    self->offset = offset;
-    self->direct = direct;
-    self->internal = 0;
-    self->state = nb_inst::state_uninitialized;
-    self->destruct = 0;
-    self->cpp_delete = 0;
-    self->clear_keep_alive = 0;
-    self->intrusive = intrusive;
-    self->unused = 0;
-
-    // Make the object compatible with nb_try_inc_ref (free-threaded builds only)
-    nb_enable_try_inc_ref((PyObject *) self);
-
-    return (PyObject *) self;
-}
-
-/// Register the object constructed by 'inst_new_ext()' in the internal data structures
-static void inst_register(PyObject *inst, void *value) noexcept {
-    nb_shard &shard = internals->shard(value);
-    lock_shard guard(shard);
-
-    // Update hash table that maps from C++ to Python instance
-    auto [it, success] = shard.inst_c2p.try_emplace(value, inst);
-
-    if (NB_UNLIKELY(!success)) {
-        void *entry = it->second;
-
-        // Potentially convert the map value into linked list format
-        if (!nb_is_seq(entry)) {
-            nb_inst_seq *first = (nb_inst_seq *) PyMem_Malloc(sizeof(nb_inst_seq));
-            check(first, "nanobind::detail::inst_new_ext(): list element "
-                         "allocation failed!");
-            first->inst = (PyObject *) entry;
-            first->next = nullptr;
-            entry = it.value() = nb_mark_seq(first);
-        }
-
-        nb_inst_seq *seq = nb_get_seq(entry);
-        while (true) {
-            // The following should never happen
-            check(inst != seq->inst, "nanobind::detail::inst_new_ext(): duplicate instance!");
-
-            if (!seq->next)
-                break;
-            seq = seq->next;
-        }
-
-        nb_inst_seq *next = (nb_inst_seq *) PyMem_Malloc(sizeof(nb_inst_seq));
-        check(next,
-              "nanobind::detail::inst_new_ext(): list element allocation failed!");
-
-        next->inst = (PyObject *) inst;
-        next->next = nullptr;
-        seq->next = next;
-    }
-}
-
-
-static void inst_dealloc(PyObject *self) {
-    PyTypeObject *tp = Py_TYPE(self);
-    const type_data *t = nb_type_data(tp);
-
-    bool gc = PyType_HasFeature(tp, Py_TPFLAGS_HAVE_GC);
-    if (NB_UNLIKELY(gc)) {
-        PyObject_GC_UnTrack(self);
-
-        if (t->flags & (uint32_t) type_flags::has_dynamic_attr) {
-            PyObject **dict = nb_dict_ptr(self);
-            if (dict)
-                Py_CLEAR(*dict);
-        }
-    }
-
-    if (t->flags & (uint32_t) type_flags::is_weak_referenceable &&
-        nb_weaklist_ptr(self) != nullptr) {
-#if defined(PYPY_VERSION)
-        PyObject **weaklist = nb_weaklist_ptr(self);
-        if (weaklist)
-            Py_CLEAR(*weaklist);
-#else
-        PyObject_ClearWeakRefs(self);
-#endif
-    }
-
-    nb_inst *inst = (nb_inst *) self;
-    void *p = inst_ptr(inst);
-
-    if (inst->destruct) {
-        check(t->flags & (uint32_t) type_flags::is_destructible,
-              "nanobind::detail::inst_dealloc(\"%s\"): attempted to call "
-              "the destructor of a non-destructible type!", t->name);
-        if (t->flags & (uint32_t) type_flags::has_destruct)
-            t->destruct(p);
-    }
-
-    if (inst->cpp_delete) {
-        if (NB_LIKELY(t->align <= (uint32_t) __STDCPP_DEFAULT_NEW_ALIGNMENT__))
-            operator delete(p);
-        else
-            operator delete(p, std::align_val_t(t->align));
-    }
-
-    nb_weakref_seq *wr_seq = nullptr;
-
-    {
-        // Enter critical section of shard
-        nb_shard &shard = internals->shard(p);
-        lock_shard guard(shard);
-
-        if (NB_UNLIKELY(inst->clear_keep_alive)) {
-            size_t self_hash = ptr_hash()(self);
-            nb_ptr_map &keep_alive = shard.keep_alive;
-            nb_ptr_map::iterator it = keep_alive.find(self, self_hash);
-            check(it != keep_alive.end(),
-                  "nanobind::detail::inst_dealloc(\"%s\"): inconsistent "
-                  "keep_alive information", t->name);
-
-            wr_seq = (nb_weakref_seq *) it->second;
-            keep_alive.erase_fast(it);
-        }
-
-        size_t p_hash = ptr_hash()(p);
-
-        // Update hash table that maps from C++ to Python instance
-        nb_ptr_map &inst_c2p = shard.inst_c2p;
-        nb_ptr_map::iterator it = inst_c2p.find(p, p_hash);
-        bool found = false;
-
-        if (NB_LIKELY(it != inst_c2p.end())) {
-            void *entry = it->second;
-            if (NB_LIKELY(entry == inst)) {
-                found = true;
-                inst_c2p.erase_fast(it);
-            } else if (nb_is_seq(entry)) {
-                // Multiple objects are associated with this address. Find the right one!
-                nb_inst_seq *seq = nb_get_seq(entry),
-                            *pred = nullptr;
-
-                do {
-                    if ((nb_inst *) seq->inst == inst) {
-                        found = true;
-
-                        if (pred) {
-                            pred->next = seq->next;
-                        } else {
-                            if (seq->next)
-                                it.value() = nb_mark_seq(seq->next);
-                            else
-                                inst_c2p.erase_fast(it);
-                        }
-
-                        PyMem_Free(seq);
-                        break;
-                    }
-
-                    pred = seq;
-                    seq = seq->next;
-                } while (seq);
-            }
-        }
-
-        check(found,
-              "nanobind::detail::inst_dealloc(\"%s\"): attempted to delete an "
-              "unknown instance (%p)!", t->name, p);
-    }
-
-    while (wr_seq) {
-        nb_weakref_seq *c = wr_seq;
-        wr_seq = c->next;
-
-        if (c->callback)
-            c->callback(c->payload);
-        else
-            Py_DECREF((PyObject *) c->payload);
-
-        PyMem_Free(c);
-    }
-
-    if (NB_UNLIKELY(gc))
-        PyObject_GC_Del(self);
-    else
-        PyObject_Free(self);
-
-    Py_DECREF(tp);
-}
-
-
-type_data *nb_type_c2p(nb_internals *internals_,
-                       const std::type_info *type) {
-#if defined(NB_FREE_THREADED)
-    thread_local nb_type_map_fast type_c2p_fast;
-#else
-    nb_type_map_fast &type_c2p_fast = internals_->type_c2p_fast;
-#endif
-
-    nb_type_map_fast::iterator it_fast = type_c2p_fast.find(type);
-    if (it_fast != type_c2p_fast.end())
-        return it_fast->second;
-
-    lock_internals guard(internals_);
-    nb_type_map_slow &type_c2p_slow = internals_->type_c2p_slow;
-    nb_type_map_slow::iterator it_slow = type_c2p_slow.find(type);
-    if (it_slow != type_c2p_slow.end()) {
-        type_data *d = it_slow->second;
-
-#if !defined(NB_FREE_THREADED)
-        // Maintain a linked list to clean up 'type_c2p_fast' when the type
-        // expires (see nb_type_unregister). In free-threaded mode, we leak
-        // these entries until the thread destructs.
-        nb_alias_chain *chain =
-            (nb_alias_chain *) PyMem_Malloc(sizeof(nb_alias_chain));
-        check(chain, "Could not allocate nb_alias_chain entry!");
-        chain->next = d->alias_chain;
-        chain->value = type;
-        d->alias_chain = chain;
-#endif
-
-        type_c2p_fast[type] = d;
-        return d;
-    }
-
-    return nullptr;
-}
-
-void nb_type_unregister(type_data *t) noexcept {
-    nb_internals *internals_ = internals;
-    nb_type_map_slow &type_c2p_slow = internals_->type_c2p_slow;
-
-    lock_internals guard(internals_);
-    size_t n_del_slow = type_c2p_slow.erase(t->type);
-
-#if defined(NB_FREE_THREADED)
-    // In free-threaded mode, stale type information remains in the
-    // 'type_c2p_fast' TLS. This data structure is eventually deallocated
-    // when the thread terminates.
-    //
-    // In principle, this is dangerous because the user could delete a type
-    // binding from a module at runtime, causing the associated
-    // Python type object to be freed. If a function then attempts to return
-    // a value with such a de-registered type, nanobind should raise an
-    // exception, which requires knowing that the entry in 'type_c2p_fast'
-    // has become invalid in the meantime.
-    //
-    // Right now, this problem is avoided because we immortalize type objects in
-    // ``nb_type_new()`` and ``enum_create()``. However, we may not always
-    // want to stick with immortalization, which is just a workaround.
-    //
-    // In the future, a global version counter modified with acquire/release
-    // semantics (see https://github.com/wjakob/nanobind/pull/695#discussion_r1761600010)
-    // might prove to be a similarly efficient but more general solution.
-    bool fail = n_del_slow != 1;
-#else
-    nb_type_map_fast &type_c2p_fast = internals_->type_c2p_fast;
-    size_t n_del_fast = type_c2p_fast.erase(t->type);
-
-    bool fail = n_del_fast != 1 || n_del_slow != 1;
-    if (!fail) {
-        nb_alias_chain *cur = t->alias_chain;
-        while (cur) {
-            nb_alias_chain *next = cur->next;
-            n_del_fast = type_c2p_fast.erase(cur->value);
-            if (n_del_fast != 1) {
-                fail = true;
-                break;
-            }
-            PyMem_Free(cur);
-            cur = next;
-        }
-    }
-#endif
-
-    check(!fail,
-          "nanobind::detail::nb_type_unregister(\"%s\"): could not "
-          "find type!", t->name);
-}
-
-static void nb_type_dealloc(PyObject *o) {
-    type_data *t = nb_type_data((PyTypeObject *) o);
-
-    if (t->type && (t->flags & (uint32_t) type_flags::is_python_type) == 0)
-        nb_type_unregister(t);
-
-    if (t->flags & (uint32_t) type_flags::has_implicit_conversions) {
-        PyMem_Free(t->implicit.cpp);
-        PyMem_Free(t->implicit.py);
-    }
-
-    free((char *) t->name);
-    NB_SLOT(PyType_Type, tp_dealloc)(o);
-}
-
-/// Called when a C++ type is extended from within Python
-static int nb_type_init(PyObject *self, PyObject *args, PyObject *kwds) {
-    if (NB_TUPLE_GET_SIZE(args) != 3) {
-        PyErr_SetString(PyExc_RuntimeError,
-                        "nb_type_init(): invalid number of arguments!");
-        return -1;
-    }
-
-    PyObject *bases = NB_TUPLE_GET_ITEM(args, 1);
-    if (!PyTuple_CheckExact(bases) || NB_TUPLE_GET_SIZE(bases) != 1) {
-        PyErr_SetString(PyExc_RuntimeError,
-                        "nb_type_init(): invalid number of bases!");
-        return -1;
-    }
-
-    PyObject *base = NB_TUPLE_GET_ITEM(bases, 0);
-    if (!PyType_Check(base)) {
-        PyErr_SetString(PyExc_RuntimeError, "nb_type_init(): expected a base type object!");
-        return -1;
-    }
-
-    type_data *t_b = nb_type_data((PyTypeObject *) base);
-    if (t_b->flags & (uint32_t) type_flags::is_final) {
-        PyErr_Format(PyExc_TypeError, "The type '%s' prohibits subclassing!",
-                     t_b->name);
-        return -1;
-    }
-
-    int rv = NB_SLOT(PyType_Type, tp_init)(self, args, kwds);
-    if (rv)
-        return rv;
-
-    type_data *t = nb_type_data((PyTypeObject *) self);
-
-    *t = *t_b;
-    t->flags |=  (uint32_t) type_flags::is_python_type;
-    t->flags &= ~((uint32_t) type_flags::has_implicit_conversions);
-
-    PyObject *name = nb_type_name(self);
-    t->name = strdup_check(PyUnicode_AsUTF8AndSize(name, nullptr));
-    Py_DECREF(name);
-    t->type_py = (PyTypeObject *) self;
-    t->implicit.cpp = nullptr;
-    t->implicit.py = nullptr;
-    t->alias_chain = nullptr;
-
-#if defined(Py_LIMITED_API)
-    t->vectorcall = nullptr;
-#else
-    ((PyTypeObject *) self)->tp_vectorcall = nullptr;
-#endif
-
-    return 0;
-}
-
-/// Special case to handle 'Class.property = value' assignments
-int nb_type_setattro(PyObject* obj, PyObject* name, PyObject* value) {
-    nb_internals *int_p = internals;
-
-    // Set a flag to avoid infinite recursion during static attribute assignment
-#if defined(NB_FREE_THREADED)
-    PyThread_tss_set(int_p->nb_static_property_disabled, (void *) 1);
-#else
-    int_p->nb_static_property_disabled = true;
-#endif
-
-    PyObject *cur = PyObject_GetAttr(obj, name);
-
-#if defined(NB_FREE_THREADED)
-    PyThread_tss_set(int_p->nb_static_property_disabled, (void *) 0);
-#else
-    int_p->nb_static_property_disabled = false;
-#endif
-
-    if (cur) {
-        PyTypeObject *tp = int_p->nb_static_property.load_acquire();
-        // For type.static_prop = value, call the setter.
-        // For type.static_prop = another_static_prop, replace the descriptor.
-        if (Py_TYPE(cur) == tp && Py_TYPE(value) != tp) {
-            int rv = int_p->nb_static_property_descr_set(cur, obj, value);
-            Py_DECREF(cur);
-            return rv;
-        }
-        Py_DECREF(cur);
-
-        const char *cname = PyUnicode_AsUTF8AndSize(name, nullptr);
-        if (!cname) {
-            PyErr_Clear(); // probably a non-string attribute name
-        } else if (cname[0] == '@') {
-            /* Prevent type attributes starting with an `@` sign from being
-               rebound or deleted. This is useful to safely stash owning
-               references. The ``nb::enum_<>`` class, e.g., uses this to ensure
-               indirect ownership of a borrowed reference in the supplemental
-               type data. */
-            PyErr_Format(PyExc_AttributeError,
-                         "internal nanobind attribute '%s' cannot be "
-                         "reassigned or deleted.", cname);
-            return -1;
-        }
-    } else {
-        PyErr_Clear();
-    }
-
-    return NB_SLOT(PyType_Type, tp_setattro)(obj, name, value);
-}
-
-#if NB_TYPE_FROM_METACLASS_IMPL || NB_TYPE_GET_SLOT_IMPL
-
-struct nb_slot {
-#if NB_TYPE_GET_SLOT_IMPL
-    uint8_t indirect_1;
-    uint8_t indirect_2;
-#endif
-    uint8_t direct;
-};
-
-template <size_t I1, size_t I2, size_t Offset1, size_t Offset2> nb_slot constexpr Ei() {
-    // Compile-time check to ensure that indices and alignment match our expectation
-    static_assert(I1 == I2 && (Offset1 % sizeof(void *)) == 0 && (Offset2 % sizeof(void *)) == 0,
-                  "nb_slot construction: internal error");
-
-#if NB_TYPE_GET_SLOT_IMPL
-    size_t o = 0;
-    switch (Offset1) {
-        case offsetof(PyHeapTypeObject, as_async):    o = offsetof(PyTypeObject, tp_as_async); break;
-        case offsetof(PyHeapTypeObject, as_number):   o = offsetof(PyTypeObject, tp_as_number); break;
-        case offsetof(PyHeapTypeObject, as_mapping):  o = offsetof(PyTypeObject, tp_as_mapping); break;
-        case offsetof(PyHeapTypeObject, as_sequence): o = offsetof(PyTypeObject, tp_as_sequence); break;
-        case offsetof(PyHeapTypeObject, as_buffer):   o = offsetof(PyTypeObject, tp_as_buffer); break;
-        default: break;
-    }
-
-    return {
-        (uint8_t) (o / sizeof(void *)),
-        (uint8_t) ((Offset2 - Offset1) / sizeof(void *)),
-        (uint8_t) (Offset2 / sizeof(void *)),
-    };
-#else
-    return { (uint8_t) (Offset2 / sizeof(void *)) };
-#endif
-}
-
-// Precomputed mapping from type slot ID to an entry in the data structure
-#define E(i1, p1, p2, name)                            \
-    Ei<i1, Py_##p2##_##name,                           \
-       offsetof(PyHeapTypeObject, p1),                 \
-       offsetof(PyHeapTypeObject, p1.p2##_##name)>()
-
-#if PY_VERSION_HEX < 0x03090000
-#  define Py_bf_getbuffer 1
-#  define Py_bf_releasebuffer 2
-#endif
-
-static constexpr nb_slot type_slots[] {
-    E(1,  as_buffer, bf, getbuffer),
-    E(2,  as_buffer, bf, releasebuffer),
-    E(3,  as_mapping, mp, ass_subscript),
-    E(4,  as_mapping, mp, length),
-    E(5,  as_mapping, mp, subscript),
-    E(6,  as_number, nb, absolute),
-    E(7,  as_number, nb, add),
-    E(8,  as_number, nb, and),
-    E(9,  as_number, nb, bool),
-    E(10, as_number, nb, divmod),
-    E(11, as_number, nb, float),
-    E(12, as_number, nb, floor_divide),
-    E(13, as_number, nb, index),
-    E(14, as_number, nb, inplace_add),
-    E(15, as_number, nb, inplace_and),
-    E(16, as_number, nb, inplace_floor_divide),
-    E(17, as_number, nb, inplace_lshift),
-    E(18, as_number, nb, inplace_multiply),
-    E(19, as_number, nb, inplace_or),
-    E(20, as_number, nb, inplace_power),
-    E(21, as_number, nb, inplace_remainder),
-    E(22, as_number, nb, inplace_rshift),
-    E(23, as_number, nb, inplace_subtract),
-    E(24, as_number, nb, inplace_true_divide),
-    E(25, as_number, nb, inplace_xor),
-    E(26, as_number, nb, int),
-    E(27, as_number, nb, invert),
-    E(28, as_number, nb, lshift),
-    E(29, as_number, nb, multiply),
-    E(30, as_number, nb, negative),
-    E(31, as_number, nb, or),
-    E(32, as_number, nb, positive),
-    E(33, as_number, nb, power),
-    E(34, as_number, nb, remainder),
-    E(35, as_number, nb, rshift),
-    E(36, as_number, nb, subtract),
-    E(37, as_number, nb, true_divide),
-    E(38, as_number, nb, xor),
-    E(39, as_sequence, sq, ass_item),
-    E(40, as_sequence, sq, concat),
-    E(41, as_sequence, sq, contains),
-    E(42, as_sequence, sq, inplace_concat),
-    E(43, as_sequence, sq, inplace_repeat),
-    E(44, as_sequence, sq, item),
-    E(45, as_sequence, sq, length),
-    E(46, as_sequence, sq, repeat),
-    E(47, ht_type, tp, alloc),
-    E(48, ht_type, tp, base),
-    E(49, ht_type, tp, bases),
-    E(50, ht_type, tp, call),
-    E(51, ht_type, tp, clear),
-    E(52, ht_type, tp, dealloc),
-    E(53, ht_type, tp, del),
-    E(54, ht_type, tp, descr_get),
-    E(55, ht_type, tp, descr_set),
-    E(56, ht_type, tp, doc),
-    E(57, ht_type, tp, getattr),
-    E(58, ht_type, tp, getattro),
-    E(59, ht_type, tp, hash),
-    E(60, ht_type, tp, init),
-    E(61, ht_type, tp, is_gc),
-    E(62, ht_type, tp, iter),
-    E(63, ht_type, tp, iternext),
-    E(64, ht_type, tp, methods),
-    E(65, ht_type, tp, new),
-    E(66, ht_type, tp, repr),
-    E(67, ht_type, tp, richcompare),
-    E(68, ht_type, tp, setattr),
-    E(69, ht_type, tp, setattro),
-    E(70, ht_type, tp, str),
-    E(71, ht_type, tp, traverse),
-    E(72, ht_type, tp, members),
-    E(73, ht_type, tp, getset),
-    E(74, ht_type, tp, free),
-    E(75, as_number, nb, matrix_multiply),
-    E(76, as_number, nb, inplace_matrix_multiply),
-    E(77, as_async, am, await),
-    E(78, as_async, am, aiter),
-    E(79, as_async, am, anext),
-    E(80, ht_type, tp, finalize),
-#if PY_VERSION_HEX >= 0x030A0000 && !defined(PYPY_VERSION)
-    E(81, as_async, am, send),
-#endif
-};
-
-#if NB_TYPE_GET_SLOT_IMPL
-void *type_get_slot(PyTypeObject *t, int slot_id) {
-    nb_slot slot = type_slots[slot_id - 1];
-
-    if (PyType_HasFeature(t, Py_TPFLAGS_HEAPTYPE)) {
-        return ((void **) t)[slot.direct];
-    } else {
-        if (slot.indirect_1)
-            return ((void ***) t)[slot.indirect_1][slot.indirect_2];
-        else
-            return ((void **) t)[slot.indirect_2];
-    }
-}
-#endif
-
-#endif
-
-static PyObject *nb_type_from_metaclass(PyTypeObject *meta, PyObject *mod,
-                                        PyType_Spec *spec) {
-#if NB_TYPE_FROM_METACLASS_IMPL == 0
-    // Life is good, PyType_FromMetaclass() is available
-    return PyType_FromMetaclass(meta, mod, spec, nullptr);
-#else
-    /* The fallback code below emulates PyType_FromMetaclass() on Python prior
-       to version 3.12. It requires access to CPython-internal structures, which
-       is why nanobind can only target the stable ABI on version 3.12+. */
-
-    const char *name = strrchr(spec->name, '.');
-    if (name)
-        name++;
-    else
-        name = spec->name;
-
-    PyObject *name_o = PyUnicode_InternFromString(name);
-    if (!name_o)
-        return nullptr;
-
-    const char *name_cstr = PyUnicode_AsUTF8AndSize(name_o, nullptr);
-    if (!name_cstr) {
-        Py_DECREF(name_o);
-        return nullptr;
-    }
-
-    PyHeapTypeObject *ht = (PyHeapTypeObject *) PyType_GenericAlloc(meta, 0);
-    if (!ht) {
-        Py_DECREF(name_o);
-        return nullptr;
-    }
-
-    ht->ht_name = name_o;
-    ht->ht_qualname = name_o;
-    Py_INCREF(name_o);
-
-#if PY_VERSION_HEX >= 0x03090000
-    if (mod) {
-        Py_INCREF(mod);
-        ht->ht_module = mod;
-    }
-#else
-    (void) mod;
-#endif
-
-    PyTypeObject *tp = &ht->ht_type;
-    tp->tp_name = name_cstr;
-    tp->tp_basicsize = spec->basicsize;
-    tp->tp_itemsize = spec->itemsize;
-    tp->tp_flags = spec->flags | Py_TPFLAGS_HEAPTYPE;
-    tp->tp_as_async = &ht->as_async;
-    tp->tp_as_number = &ht->as_number;
-    tp->tp_as_sequence = &ht->as_sequence;
-    tp->tp_as_mapping = &ht->as_mapping;
-    tp->tp_as_buffer = &ht->as_buffer;
-
-    PyType_Slot *ts = spec->slots;
-    bool fail = false;
-    while (true) {
-        int slot = ts->slot;
-
-        if (slot == 0) {
-            break;
-        } else if (slot * sizeof(nb_slot) < (int) sizeof(type_slots)) {
-            *(((void **) ht) + type_slots[slot - 1].direct) = ts->pfunc;
-        } else {
-            PyErr_Format(PyExc_RuntimeError,
-                         "nb_type_from_metaclass(): unhandled slot %i", slot);
-            fail = true;
-            break;
-        }
-        ts++;
-    }
-
-    // Bring type object into a safe state (before error handling)
-    const PyMemberDef *members = tp->tp_members;
-    const char *doc = tp->tp_doc;
-    tp->tp_members = nullptr;
-    tp->tp_doc = nullptr;
-    Py_XINCREF(tp->tp_base);
-
-    if (doc && !fail) {
-        size_t size = strlen(doc) + 1;
-        /// This code path is only used for Python 3.12, where
-        /// PyObject_Malloc is the right allocation routine for tp_doc
-        char *target = (char *) PyObject_Malloc(size);
-        if (!target) {
-            PyErr_NoMemory();
-            fail = true;
-        } else {
-            memcpy(target, doc, size);
-            tp->tp_doc = target;
-        }
-    }
-
-    if (members && !fail) {
-        while (members->name) {
-            if (members->type == T_PYSSIZET && members->flags == READONLY) {
-                if (strcmp(members->name, "__dictoffset__") == 0)
-                    tp->tp_dictoffset = members->offset;
-                else if (strcmp(members->name, "__weaklistoffset__") == 0)
-                    tp->tp_weaklistoffset = members->offset;
-                else if (strcmp(members->name, "__vectorcalloffset__") == 0)
-                    tp->tp_vectorcall_offset = members->offset;
-                else
-                    fail = true;
-            } else {
-                fail = true;
-            }
-
-            if (fail) {
-                PyErr_Format(
-                    PyExc_RuntimeError,
-                    "nb_type_from_metaclass(): unhandled tp_members entry!");
-                break;
-            }
-
-            members++;
-        }
-    }
-
-    if (fail || PyType_Ready(tp) != 0) {
-        Py_DECREF(tp);
-        return nullptr;
-    }
-
-    return (PyObject *) tp;
-#endif
-}
-
-extern int nb_type_setattro(PyObject* obj, PyObject* name, PyObject* value);
-
-static PyTypeObject *nb_type_tp(size_t supplement) noexcept {
-    object key = steal(PyLong_FromSize_t(supplement));
-    nb_internals *internals_ = internals;
-
-    PyTypeObject *tp =
-        (PyTypeObject *) dict_get_item_ref_or_fail(internals_->nb_type_dict, key.ptr());
-
-    if (NB_UNLIKELY(!tp)) {
-        // Retry in critical section to avoid races that create the same nb_type
-        lock_internals guard(internals_);
-
-        tp = (PyTypeObject *) dict_get_item_ref_or_fail(internals_->nb_type_dict, key.ptr());
-        if (tp)
-            return tp;
-
-#if defined(Py_LIMITED_API)
-        PyMemberDef members[] = {
-            { "__vectorcalloffset__", Py_T_PYSSIZET, 0, Py_READONLY, nullptr },
-            { nullptr, 0, 0, 0, nullptr }
-        };
-
-        // Workaround because __vectorcalloffset__ does not support Py_RELATIVE_OFFSET
-        members[0].offset = internals_->type_data_offset + offsetof(type_data, vectorcall);
-#endif
-
-        PyType_Slot slots[] = {
-            { Py_tp_base, &PyType_Type },
-            { Py_tp_dealloc, (void *) nb_type_dealloc },
-            { Py_tp_setattro, (void *) nb_type_setattro },
-            { Py_tp_init, (void *) nb_type_init },
-#if defined(Py_LIMITED_API)
-            { Py_tp_members, (void *) members },
-#endif
-            { 0, nullptr }
-        };
-
-#if PY_VERSION_HEX >= 0x030C0000
-        int basicsize = -(int) (sizeof(type_data) + supplement),
-            itemsize = 0;
-#else
-        int basicsize = (int) (PyType_Type.tp_basicsize + (sizeof(type_data) + supplement)),
-            itemsize = (int) PyType_Type.tp_itemsize;
-#endif
-
-        char name[17 + 20 + 1];
-        snprintf(name, sizeof(name), "nanobind.nb_type_%zu", supplement);
-
-        PyType_Spec spec = {
-            /* .name = */ name,
-            /* .basicsize = */ basicsize,
-            /* .itemsize = */ itemsize,
-            /* .flags = */ Py_TPFLAGS_DEFAULT,
-            /* .slots = */ slots
-        };
-
-#if defined(Py_LIMITED_API)
-        spec.flags |= Py_TPFLAGS_HAVE_VECTORCALL;
-#endif
-
-        tp = (PyTypeObject *) nb_type_from_metaclass(
-            internals_->nb_meta, internals_->nb_module, &spec);
-
-        make_immortal((PyObject *) tp);
-
-        handle(tp).attr("__module__") = "nanobind";
-
-        int rv = 1;
-        if (tp)
-            rv = PyDict_SetItem(internals_->nb_type_dict, key.ptr(), (PyObject *) tp);
-        check(rv == 0, "nb_type type creation failed!");
-    }
-
-    return tp;
-}
-
-// This helper function extracts the function/class name from a custom signature attribute
-NB_NOINLINE char *extract_name(const char *cmd, const char *prefix, const char *s) {
-    (void) cmd;
-
-    // Move to the last line
-    const char *p = strrchr(s, '\n');
-    p = p ? (p + 1) : s;
-
-    // Check that the last line starts with the right prefix
-    size_t prefix_len = strlen(prefix);
-    check(strncmp(p, prefix, prefix_len) == 0,
-          "%s(): last line of custom signature \"%s\" must start with \"%s\"!",
-          cmd, s, prefix);
-    p += prefix_len;
-
-    // Find the opening parenthesis or bracket
-    const char *p2 = strchr(p, '(');
-    const char *p3 = strchr(p, '[');
-    if (p2 == nullptr)
-        p2 = p3;
-    else if (p3 != nullptr)
-        p2 = p2 < p3 ? p2 : p3;
-    check(p2 != nullptr,
-          "%s(): last line of custom signature \"%s\" must contain an opening "
-          "parenthesis (\"(\") or bracket (\"[\")!", cmd, s);
-
-    // A few sanity checks
-    size_t len = strlen(p);
-    char last = p[len ? (len - 1) : 0];
-
-    check(last != ':' && last != ' ',
-          "%s(): custom signature \"%s\" should not end with \":\" or \" \"!", cmd, s);
-    check((p2 == p || (p[0] != ' ' && p2[-1] != ' ')),
-          "%s(): custom signature \"%s\" contains leading/trailing space around name!", cmd, s);
-
-    size_t size = p2 - p;
-    char *result = (char *) malloc_check(size + 1);
-    memcpy(result, p, size);
-    result[size] = '\0';
-
-    return result;
-}
-
-#if PY_VERSION_HEX >= 0x03090000
-static PyMethodDef class_getitem_method[] = {
-    { "__class_getitem__", Py_GenericAlias, METH_O | METH_CLASS, nullptr },
-    { nullptr }
-};
-#endif
-
-// Implements the vector call protocol directly on type objects to construct
-// instances more efficiently.
-static PyObject *nb_type_vectorcall(PyObject *self, PyObject *const *args_in,
-                                    size_t nargsf,
-                                    PyObject *kwargs_in) noexcept {
-    PyTypeObject *tp = (PyTypeObject *) self;
-    type_data *td = nb_type_data(tp);
-    nb_func *func = (nb_func *) td->init;
-    bool is_init = (td->flags & (uint32_t) type_flags::has_new) == 0;
-    Py_ssize_t nargs = NB_VECTORCALL_NARGS(nargsf);
-
-    if (NB_UNLIKELY(!func)) {
-        PyErr_Format(PyExc_TypeError, "%s: no constructor defined!", td->name);
-        return nullptr;
-    }
-
-    if (NB_LIKELY(is_init)) {
-        self = inst_new_int(tp, nullptr, nullptr);
-        if (!self)
-            return nullptr;
-    } else if (nargs == 0 && !kwargs_in &&
-               !(td->flags & (uint32_t) type_flags::has_nullary_new)) {
-        // When the bindings define a custom __new__ operator, nanobind always
-        // provides a no-argument dummy __new__ constructor to handle unpickling
-        // via __setstate__. This is an implementation detail that should not be
-        // exposed. Therefore, only allow argument-less calls if there is an
-        // actual __new__ overload with a compatible signature. This is
-        // detected in nb_func.cpp based on whether any __init__ overload can
-        // accept no arguments.
-
-        return func->vectorcall((PyObject *) func, nullptr, 0, nullptr);
-    }
-
-    const size_t buf_size = 5;
-    PyObject **args, *buf[buf_size], *temp = nullptr;
-    bool alloc = false;
-
-    if (NB_LIKELY(nargsf & NB_VECTORCALL_ARGUMENTS_OFFSET)) {
-        args = (PyObject **) (args_in - 1);
-        temp = args[0];
-    } else {
-        size_t size = nargs + 1;
-        if (kwargs_in)
-            size += NB_TUPLE_GET_SIZE(kwargs_in);
-
-        if (size < buf_size) {
-            args = buf;
-        } else {
-            args = (PyObject **) PyMem_Malloc(size * sizeof(PyObject *));
-            if (!args) {
-                if (is_init)
-                    Py_DECREF(self);
-                return PyErr_NoMemory();
-            }
-            alloc = true;
-        }
-
-        memcpy(args + 1, args_in, sizeof(PyObject *) * (size - 1));
-    }
-
-    args[0] = self;
-
-    PyObject *rv =
-        func->vectorcall((PyObject *) func, args, nargs + 1, kwargs_in);
-
-    args[0] = temp;
-
-    if (NB_UNLIKELY(alloc))
-        PyMem_Free(args);
-
-    if (NB_LIKELY(is_init)) {
-        if (!rv) {
-            Py_DECREF(self);
-            return nullptr;
-        }
-
-        // __init__ constructor: 'rv' is None
-        Py_DECREF(rv);
-        return self;
-    } else {
-        // __new__ constructor
-        return rv;
-    }
-}
-
-/// Called when a C++ type is bound via nb::class_<>
-PyObject *nb_type_new(const type_init_data *t) noexcept {
-    bool has_doc               = t->flags & (uint32_t) type_init_flags::has_doc,
-         has_base              = t->flags & (uint32_t) type_init_flags::has_base,
-         has_base_py           = t->flags & (uint32_t) type_init_flags::has_base_py,
-         has_type_slots        = t->flags & (uint32_t) type_init_flags::has_type_slots,
-         has_supplement        = t->flags & (uint32_t) type_init_flags::has_supplement,
-         has_dynamic_attr      = t->flags & (uint32_t) type_flags::has_dynamic_attr,
-         is_weak_referenceable = t->flags & (uint32_t) type_flags::is_weak_referenceable,
-         is_generic            = t->flags & (uint32_t) type_flags::is_generic,
-         intrusive_ptr         = t->flags & (uint32_t) type_flags::intrusive_ptr,
-         has_shared_from_this  = t->flags & (uint32_t) type_flags::has_shared_from_this,
-         has_signature         = t->flags & (uint32_t) type_flags::has_signature;
-
-    const char *t_name = t->name;
-    if (has_signature)
-        t_name =
-            extract_name("nanobind::detail::nb_type_new", "class ", t->name);
-
-    str name = steal<str>(PyUnicode_InternFromString(t_name)),
-        qualname = name;
-    object modname;
-    PyObject *mod = nullptr;
-
-    // Update hash table that maps from std::type_info to Python type
-    nb_type_map_slow::iterator it;
-    bool success;
-    nb_internals *internals_ = internals;
-
-    {
-        lock_internals guard(internals_);
-        std::tie(it, success) = internals_->type_c2p_slow.try_emplace(t->type, nullptr);
-        if (!success) {
-            PyErr_WarnFormat(PyExc_RuntimeWarning, 1,
-                             "nanobind: type '%s' was already registered!\n",
-                             t_name);
-            PyObject *tp = (PyObject *) it->second->type_py;
-            Py_INCREF(tp);
-            if (has_signature)
-                free((char *) t_name);
-            return tp;
-        }
-    }
-
-    if (t->scope != nullptr) {
-        if (PyModule_Check(t->scope)) {
-            mod = t->scope;
-            modname = getattr(t->scope, "__name__", handle());
-        } else {
-            modname = getattr(t->scope, "__module__", handle());
-
-            object scope_qualname = getattr(t->scope, "__qualname__", handle());
-            if (scope_qualname.is_valid())
-                qualname = steal<str>(
-                    PyUnicode_FromFormat("%U.%U", scope_qualname.ptr(), name.ptr()));
-        }
-    }
-
-    if (modname.is_valid())
-        name = steal<str>(
-            PyUnicode_FromFormat("%U.%U", modname.ptr(), name.ptr()));
-
-    constexpr size_t ptr_size = sizeof(void *);
-    size_t basicsize = sizeof(nb_inst) + t->size;
-    if (t->align > ptr_size)
-        basicsize += t->align - ptr_size;
-
-    PyObject *base = nullptr;
-
-#if PY_VERSION_HEX >= 0x03090000
-    bool generic_base = false;
-#endif
-
-    if (has_base_py) {
-        check(!has_base,
-              "nanobind::detail::nb_type_new(\"%s\"): multiple base types "
-              "specified!", t_name);
-        base = (PyObject *) t->base_py;
-
-        #if PY_VERSION_HEX >= 0x03090000 && !defined(PYPY_VERSION) // see https://github.com/pypy/pypy/issues/4914
-        if (Py_TYPE(base) == &Py_GenericAliasType) {
-            base = PyObject_GetAttrString(base, "__origin__");
-            check(base != nullptr,
-                  "nanobind::detail::nb_type_new(\"%s\"): could not access base of type alias!", t_name);
-            Py_DECREF(base);
-            generic_base = true;
-        }
-        #endif
-
-        check(nb_type_check(base),
-              "nanobind::detail::nb_type_new(\"%s\"): base type is not a "
-              "nanobind type!", t_name);
-    } else if (has_base) {
-        lock_internals guard(internals_);
-        nb_type_map_slow::iterator it2 = internals_->type_c2p_slow.find(t->base);
-        check(it2 != internals_->type_c2p_slow.end(),
-                  "nanobind::detail::nb_type_new(\"%s\"): base type \"%s\" not "
-                  "known to nanobind!", t_name, type_name(t->base));
-        base = (PyObject *) it2->second->type_py;
-    }
-
-    type_data *tb = nullptr;
-    if (base) {
-        // Check if the base type already has dynamic attributes
-        tb = nb_type_data((PyTypeObject *) base);
-        if (tb->flags & (uint32_t) type_flags::has_dynamic_attr)
-            has_dynamic_attr = true;
-
-        if (tb->flags & (uint32_t) type_flags::is_weak_referenceable)
-            is_weak_referenceable = true;
-
-        /* Handle a corner case (base class larger than derived class)
-           which can arise when extending trampoline base classes */
-
-        PyTypeObject *base_2 = (PyTypeObject *) base;
-        type_data *tb_2 = tb;
-
-        do {
-            size_t base_basicsize = sizeof(nb_inst) + tb_2->size;
-            if (tb_2->align > ptr_size)
-                base_basicsize += tb_2->align - ptr_size;
-            if (base_basicsize > basicsize)
-                basicsize = base_basicsize;
-
-#if !defined(Py_LIMITED_API)
-            base_2 = base_2->tp_base;
-#else
-            base_2 = (PyTypeObject *) PyType_GetSlot(base_2, Py_tp_base);
-#endif
-
-            if (!base_2 || !nb_type_check((PyObject *) base_2))
-                break;
-
-            tb_2 = nb_type_data(base_2);
-        } while (true);
-    }
-
-    bool base_intrusive_ptr =
-        tb && (tb->flags & (uint32_t) type_flags::intrusive_ptr);
-
-    // tp_basicsize must satisfy pointer alignment.
-    basicsize = (basicsize + ptr_size - 1) / ptr_size * ptr_size;
-
-    char *name_copy = strdup_check(name.c_str());
-
-    constexpr size_t nb_type_max_slots = 11,
-                     nb_extra_slots = 80,
-                     nb_total_slots = nb_type_max_slots +
-                                      nb_extra_slots + 1;
-
-    PyMemberDef members[3] { };
-    PyType_Slot slots[nb_total_slots], *s = slots;
-    PyType_Spec spec = {
-        /* .name = */ name_copy,
-        /* .basicsize = */ (int) basicsize,
-        /* .itemsize = */ 0,
-        /* .flags = */ Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
-        /* .slots = */ slots
-    };
-
-    if (base)
-        *s++ = { Py_tp_base, (void *) base };
-
-    *s++ = { Py_tp_init, (void *) inst_init };
-    *s++ = { Py_tp_new, (void *) inst_new_int };
-    *s++ = { Py_tp_dealloc, (void *) inst_dealloc };
-
-    if (has_doc)
-        *s++ = { Py_tp_doc, (void *) t->doc };
-
-    vectorcallfunc type_vectorcall = nb_type_vectorcall;
-
-    bool has_traverse = false,
-         has_getset = false,
-         has_custom_init_or_new = false,
-         has_custom_type_vectorcall = false;
-
-    if (has_type_slots) {
-        size_t num_avail = nb_extra_slots;
-        size_t i = 0;
-        while (t->type_slots[i].slot) {
-            check(i != num_avail,
-                  "nanobind::detail::nb_type_new(\"%s\"): ran out of "
-                  "type slots!", t_name);
-
-            const PyType_Slot &ts = t->type_slots[i++];
-            int slot_id = ts.slot;
-
-            has_traverse |= slot_id == Py_tp_traverse;
-            has_getset |= slot_id == Py_tp_getset;
-            has_custom_init_or_new |=
-                slot_id == Py_tp_init || slot_id == Py_tp_new;
-
-            if (slot_id == Py_tp_vectorcall) {
-                type_vectorcall = (vectorcallfunc) ts.pfunc;
-                has_custom_type_vectorcall = true;
-                continue;
-            }
-
-            *s++ = ts;
-        }
-    }
-
-    if (has_custom_init_or_new && !has_custom_type_vectorcall)
-        type_vectorcall = nullptr;
-
-    Py_ssize_t dictoffset = 0, weaklistoffset = 0;
-    int num_members = 0;
-
-    // realign to sizeof(void*) if needed
-    if (has_dynamic_attr || is_weak_referenceable)
-        basicsize = (basicsize + ptr_size - 1) / ptr_size * ptr_size;
-
-    if (has_dynamic_attr) {
-        dictoffset = (Py_ssize_t) basicsize;
-        basicsize += ptr_size;
-
-        members[num_members] = PyMemberDef{ "__dictoffset__", T_PYSSIZET,
-                                            dictoffset, READONLY, nullptr };
-        ++num_members;
-
-        // Install GC traverse and clear routines if not inherited/overridden
-        if (!has_traverse) {
-            *s++ = { Py_tp_traverse, (void *) inst_traverse };
-            *s++ = { Py_tp_clear, (void *) inst_clear };
-            has_traverse = true;
-        }
-        spec.basicsize = (int) basicsize;
-
-        if (!has_getset)
-            *s++ = { Py_tp_getset, (void *) inst_getset };
-    }
-
-    if (is_weak_referenceable) {
-        weaklistoffset = (Py_ssize_t) basicsize;
-        basicsize += ptr_size;
-
-        members[num_members] = PyMemberDef{ "__weaklistoffset__", T_PYSSIZET,
-                                            weaklistoffset, READONLY, nullptr };
-        ++num_members;
-
-        // Install GC traverse and clear routines if not inherited/overridden
-        if (!has_traverse) {
-            *s++ = { Py_tp_traverse, (void *) inst_traverse };
-            *s++ = { Py_tp_clear, (void *) inst_clear };
-            has_traverse = true;
-        }
-        spec.basicsize = (int) basicsize;
-    }
-
-    if (num_members > 0)
-        *s++ = { Py_tp_members, (void*) members };
-
-#if PY_VERSION_HEX < 0x03090000
-    // Features that are unsupported in Python 3.8
-    (void) is_generic;
-    type_vectorcall = nullptr;
-#else
-    if (is_generic)
-        *s++ = { Py_tp_methods, (void*) class_getitem_method };
-#endif
-
-    if (has_traverse)
-        spec.flags |= Py_TPFLAGS_HAVE_GC;
-
-    *s++ = { 0, nullptr };
-
-    PyTypeObject *metaclass = nb_type_tp(has_supplement ? t->supplement : 0);
-
-    PyObject *result = nb_type_from_metaclass(metaclass, mod, &spec);
-    if (!result) {
-        python_error err;
-        check(false,
-              "nanobind::detail::nb_type_new(\"%s\"): type construction "
-              "failed: %s!", t_name, err.what());
-    }
-
-    Py_DECREF(metaclass);
-
-    make_immortal(result);
-
-    type_data *to = nb_type_data((PyTypeObject *) result);
-
-    *to = *t; // note: slices off _init parts
-    to->flags &= ~(uint32_t) type_init_flags::all_init_flags;
-
-    if (!intrusive_ptr && base_intrusive_ptr) {
-        to->flags |= (uint32_t) type_flags::intrusive_ptr;
-        to->set_self_py = tb->set_self_py;
-    }
-
-    if (!has_shared_from_this && tb &&
-        (tb->flags & (uint32_t) type_flags::has_shared_from_this)) {
-        to->flags |= (uint32_t) type_flags::has_shared_from_this;
-        to->keep_shared_from_this_alive = tb->keep_shared_from_this_alive;
-    }
-
-    #if defined(Py_LIMITED_API)
-        to->vectorcall = type_vectorcall;
-    #else
-        ((PyTypeObject *) result)->tp_vectorcall = type_vectorcall;
-    #endif
-
-    to->name = name_copy;
-    to->type_py = (PyTypeObject *) result;
-    to->alias_chain = nullptr;
-    to->init = nullptr;
-
-    if (has_dynamic_attr)
-        to->flags |= (uint32_t) type_flags::has_dynamic_attr;
-    if (is_weak_referenceable)
-        to->flags |= (uint32_t) type_flags::is_weak_referenceable;
-
-    #if defined(Py_LIMITED_API)
-        /* These must be set unconditionally so that nb_dict_ptr() /
-           nb_weaklist_ptr() return null (rather than garbage) on
-           objects whose types don't use the corresponding feature. */
-        to->dictoffset = (uint32_t) dictoffset;
-        to->weaklistoffset = (uint32_t) weaklistoffset;
-    #endif
-
-    if (t->scope != nullptr)
-        setattr(t->scope, t_name, result);
-
-    setattr(result, "__qualname__", qualname.ptr());
-
-    if (modname.is_valid())
-        setattr(result, "__module__", modname.ptr());
-
-    {
-        lock_internals guard(internals_);
-        internals_->type_c2p_slow[t->type] = to;
-
-        #if !defined(NB_FREE_THREADED)
-            internals_->type_c2p_fast[t->type] = to;
-        #endif
-    }
-
-    if (has_signature) {
-        setattr(result, "__nb_signature__", str(t->name));
-        free((char *) t_name);
-    }
-
-#if PY_VERSION_HEX >= 0x03090000
-    if (generic_base)
-        setattr(result, "__orig_bases__", make_tuple(handle(t->base_py)));
-#endif
-
-    return result;
-}
-
-
-PyObject *call_one_arg(PyObject *fn, PyObject *arg) noexcept {
-    PyObject *result;
-#if PY_VERSION_HEX < 0x03090000
-    PyObject *args = PyTuple_New(1);
-    if (!args)
-        return nullptr;
-    Py_INCREF(arg);
-    NB_TUPLE_SET_ITEM(args, 0, arg);
-    result = PyObject_CallObject(fn, args);
-    Py_DECREF(args);
-#else
-    PyObject *args[2] = { nullptr, arg };
-    result = PyObject_Vectorcall(fn, args + 1,
-                                 NB_VECTORCALL_ARGUMENTS_OFFSET + 1, nullptr);
-#endif
-    return result;
-}
-
-/// Encapsulates the implicit conversion part of nb_type_get()
-static NB_NOINLINE bool nb_type_get_implicit(PyObject *src,
-                                             const std::type_info *cpp_type_src,
-                                             const type_data *dst_type,
-                                             nb_internals *internals_,
-                                             cleanup_list *cleanup, void **out) noexcept {
-    if (dst_type->implicit.cpp && cpp_type_src) {
-        const std::type_info **it = dst_type->implicit.cpp;
-        const std::type_info *v;
-
-        while ((v = *it++)) {
-            if (v == cpp_type_src || *v == *cpp_type_src)
-                goto found;
-        }
-
-        it = dst_type->implicit.cpp;
-        while ((v = *it++)) {
-            const type_data *d = nb_type_c2p(internals_, v);
-            if (d && PyType_IsSubtype(Py_TYPE(src), d->type_py))
-                goto found;
-        }
-    }
-
-    if (dst_type->implicit.py) {
-        bool (**it)(PyTypeObject *, PyObject *, cleanup_list *) noexcept =
-            dst_type->implicit.py;
-        bool (*v2)(PyTypeObject *, PyObject *, cleanup_list *) noexcept;
-
-        while ((v2 = *it++)) {
-            if (v2(dst_type->type_py, src, cleanup))
-                goto found;
-        }
-    }
-
-    return false;
-
-found:
-    PyObject *result = call_one_arg((PyObject *) dst_type->type_py, src);
-
-    if (result) {
-        cleanup->append(result);
-        *out = inst_ptr((nb_inst *) result);
-        return true;
-    } else {
-        PyErr_Clear();
-
-        if (internals->print_implicit_cast_warnings) {
-#if !defined(Py_LIMITED_API)
-            const char *name = Py_TYPE(src)->tp_name;
-#else
-            PyObject *name_py = nb_inst_name(src);
-            const char *name = PyUnicode_AsUTF8AndSize(name_py, nullptr);
-#endif
-            // Can't use PyErr_Warn*() if conversion failed due to a stack overflow
-            fprintf(stderr,
-                    "nanobind: implicit conversion from type '%s' to type '%s' "
-                    "failed!\n", name, dst_type->name);
-
-#if defined(Py_LIMITED_API)
-            Py_DECREF(name_py);
-#endif
-        }
-
-        return false;
-    }
-}
-
-// Attempt to retrieve a pointer to a C++ instance
-bool nb_type_get(const std::type_info *cpp_type, PyObject *src, uint8_t flags,
-                 cleanup_list *cleanup, void **out) noexcept {
-    // Convert None -> nullptr
-    if (src == Py_None) {
-        *out = nullptr;
-        return true;
-    }
-
-    PyTypeObject *src_type = Py_TYPE(src);
-    const std::type_info *cpp_type_src = nullptr;
-    const bool src_is_nb_type = nb_type_check((PyObject *) src_type);
-
-    type_data *dst_type = nullptr;
-    nb_internals *internals_ = internals;
-
-    // If 'src' is a nanobind-bound type
-    if (NB_LIKELY(src_is_nb_type)) {
-        type_data *t = nb_type_data(src_type);
-        cpp_type_src = t->type;
-
-        // Check if the source / destination typeid are an exact match
-        bool valid = cpp_type == cpp_type_src || *cpp_type == *cpp_type_src;
-
-        // If not, look up the Python type and check the inheritance chain
-        if (NB_UNLIKELY(!valid)) {
-            dst_type = nb_type_c2p(internals_, cpp_type);
-            if (dst_type)
-                valid = PyType_IsSubtype(src_type, dst_type->type_py);
-        }
-
-        // Success, return the pointer if the instance is correctly initialized
-        if (NB_LIKELY(valid)) {
-            nb_inst *inst = (nb_inst *) src;
-
-            static_assert(cast_flags::construct == nb_inst::state_ready,
-                          "this function is optimized assuming that "
-                          "cast_flags::construct == nb_inst::state_ready");
-
-            // (flags & construct)       state  xor-result  should accept?
-            //          [normal] 0  [uninit] 0  0           no
-            //          [normal] 0  [relinq] 1  1           no
-            //          [normal] 0   [ready] 2  2           yes
-            //       [construct] 2  [uninit] 0  2           yes
-            //       [construct] 2  [relinq] 1  3           no
-            //       [construct] 2   [ready] 2  0           no
-
-            if (NB_UNLIKELY(((flags & (uint8_t) cast_flags::construct) ^
-                             inst->state) != nb_inst::state_ready)) {
-                constexpr const char* errors[4] = {
-                    /* 0 = uninit  */ "attempted to access an uninitialized instance",
-                    /* 1 = relinq  */ "attempted to access a relinquished instance",
-                    /* 2 = ready   */ "attempted to initialize an already-initialized instance",
-                    /* 3 = invalid */ "instance state has become corrupted",
-                };
-                PyErr_WarnFormat(
-                    PyExc_RuntimeWarning, 1, "nanobind: %s of type '%s'!\n",
-                    errors[inst->state], t->name);
-                return false;
-            }
-
-            *out = inst_ptr(inst);
-
-            return true;
-        }
-    }
-
-    // Try an implicit conversion as last resort (if possible & requested)
-    if ((flags & (uint16_t) cast_flags::convert) && cleanup) {
-        if (!src_is_nb_type)
-            dst_type = nb_type_c2p(internals_, cpp_type);
-
-        if (dst_type &&
-            (dst_type->flags & (uint32_t) type_flags::has_implicit_conversions))
-            return nb_type_get_implicit(src, cpp_type_src, dst_type, internals_,
-                                        cleanup, out);
-    }
-
-    return false;
-}
-
-static PyObject *keep_alive_callback(PyObject *self, PyObject *const *args,
-                                     Py_ssize_t nargs) {
-    check(nargs == 1 && PyWeakref_CheckRefExact(args[0]),
-          "nanobind::detail::keep_alive_callback(): invalid input!");
-    Py_DECREF(args[0]); // self
-    Py_DECREF(self); // patient
-    Py_INCREF(Py_None);
-    return Py_None;
-}
-
-static PyMethodDef keep_alive_callback_def = {
-    "keep_alive_callback", (PyCFunction) (void *) keep_alive_callback,
-    METH_FASTCALL, nullptr
-};
-
-void keep_alive(PyObject *nurse, PyObject *patient) {
-    if (!patient || !nurse || nurse == Py_None || patient == Py_None)
-        return;
-
-    if (nb_type_check((PyObject *) Py_TYPE(nurse))) {
-#if defined(NB_FREE_THREADED)
-        nb_shard &shard = internals->shard(inst_ptr((nb_inst *) nurse));
-        lock_shard guard(shard);
-#else
-        nb_shard &shard = internals->shards[0];
-#endif
-
-        nb_weakref_seq **pp = (nb_weakref_seq **) &shard.keep_alive[nurse];
-        do {
-            nb_weakref_seq *p = *pp;
-            if (!p)
-                break;
-            else if (p->payload == patient && !p->callback)
-                return;
-            pp = &p->next;
-        } while (true);
-
-        nb_weakref_seq *s =
-            (nb_weakref_seq *) PyMem_Malloc(sizeof(nb_weakref_seq));
-        check(s, "nanobind::detail::keep_alive(): out of memory!");
-
-        s->payload = patient;
-        s->callback = nullptr;
-        s->next = nullptr;
-        *pp = s;
-
-        Py_INCREF(patient);
-        ((nb_inst *) nurse)->clear_keep_alive = true;
-    } else {
-        PyObject *callback =
-            PyCFunction_New(&keep_alive_callback_def, patient);
-
-        PyObject *weakref = PyWeakref_NewRef(nurse, callback);
-        if (!weakref) {
-            Py_DECREF(callback);
-            PyErr_Clear();
-            raise("nanobind::detail::keep_alive(): could not create a weak "
-                  "reference! Likely, the 'nurse' argument you specified is not "
-                  "a weak-referenceable type!");
-        }
-        check(callback,
-              "nanobind::detail::keep_alive(): callback creation failed!");
-
-        // Increase patient reference count, leak weak reference
-        Py_INCREF(patient);
-        Py_DECREF(callback);
-    }
-}
-
-void keep_alive(PyObject *nurse, void *payload,
-                void (*callback)(void *) noexcept) noexcept {
-    check(nurse, "nanobind::detail::keep_alive(): 'nurse' is undefined!");
-
-    if (nb_type_check((PyObject *) Py_TYPE(nurse))) {
-#if defined(NB_FREE_THREADED)
-        nb_shard &shard = internals->shard(inst_ptr((nb_inst *) nurse));
-        lock_shard guard(shard);
-#else
-        nb_shard &shard = internals->shards[0];
-#endif
-
-        nb_weakref_seq
-            **pp = (nb_weakref_seq **) &shard.keep_alive[nurse],
-            *s   = (nb_weakref_seq *) PyMem_Malloc(sizeof(nb_weakref_seq));
-        check(s, "nanobind::detail::keep_alive(): out of memory!");
-
-        s->payload = payload;
-        s->callback = callback;
-        s->next = *pp;
-        *pp = s;
-
-        ((nb_inst *) nurse)->clear_keep_alive = true;
-    } else {
-        PyObject *patient = capsule_new(payload, nullptr, callback);
-        keep_alive(nurse, patient);
-        Py_DECREF(patient);
-    }
-}
-
-static PyObject *nb_type_put_common(void *value, type_data *t, rv_policy rvp,
-                                    cleanup_list *cleanup,
-                                    bool *is_new) noexcept {
-    // The reference_internals RVP needs a self pointer, give up if unavailable
-    if (rvp == rv_policy::reference_internal && (!cleanup || !cleanup->self()))
-        return nullptr;
-
-    const bool intrusive = t->flags & (uint32_t) type_flags::intrusive_ptr;
-    if (intrusive)
-        rvp = rv_policy::take_ownership;
-
-    const bool create_new = rvp == rv_policy::copy || rvp == rv_policy::move;
-
-    nb_inst *inst;
-    if (create_new)
-        inst = (nb_inst *) inst_new_int(t->type_py, nullptr, nullptr);
-    else
-        inst = (nb_inst *) inst_new_ext(t->type_py, value);
-
-    if (!inst)
-        return nullptr;
-
-    void *new_value = inst_ptr(inst);
-    if (rvp == rv_policy::move) {
-        if (t->flags & (uint32_t) type_flags::is_move_constructible) {
-            if (t->flags & (uint32_t) type_flags::has_move) {
-                try {
-                    t->move(new_value, value);
-                } catch (...) {
-                    Py_DECREF(inst);
-                    return nullptr;
-                }
-            } else {
-                memcpy(new_value, value, t->size);
-                memset(value, 0, t->size);
-            }
-        } else {
-            check(t->flags & (uint32_t) type_flags::is_copy_constructible,
-                  "nanobind::detail::nb_type_put(\"%s\"): attempted to move "
-                  "an instance that is neither copy- nor move-constructible!",
-                  t->name);
-
-            rvp = rv_policy::copy;
-        }
-    }
-
-    if (rvp == rv_policy::copy) {
-        check(t->flags & (uint32_t) type_flags::is_copy_constructible,
-              "nanobind::detail::nb_type_put(\"%s\"): attempted to copy "
-              "an instance that is not copy-constructible!", t->name);
-
-        if (t->flags & (uint32_t) type_flags::has_copy) {
-            try {
-                t->copy(new_value, value);
-            } catch (...) {
-                Py_DECREF(inst);
-                return nullptr;
-            }
-        } else {
-            memcpy(new_value, value, t->size);
-        }
-    }
-
-    // If we can find an existing C++ shared_ptr for this object, and
-    // the instance we're creating just holds a pointer, then take out
-    // another C++ shared_ptr that shares ownership with the existing
-    // one, and tie its lifetime to the Python object. This is the
-    // same thing done by the <nanobind/stl/shared_ptr.h> caster when
-    // returning shared_ptr<T> to Python explicitly.
-    if ((t->flags & (uint32_t) type_flags::has_shared_from_this) &&
-        !create_new && t->keep_shared_from_this_alive((PyObject *) inst))
-        rvp = rv_policy::reference;
-    else if (is_new)
-        *is_new = true;
-
-    inst->destruct = rvp != rv_policy::reference && rvp != rv_policy::reference_internal;
-    inst->cpp_delete = rvp == rv_policy::take_ownership;
-    inst->state = nb_inst::state_ready;
-
-    if (rvp == rv_policy::reference_internal)
-        keep_alive((PyObject *) inst, cleanup->self());
-
-    if (intrusive)
-        t->set_self_py(new_value, (PyObject *) inst);
-
-    if (!create_new)
-        inst_register((PyObject *) inst, value);
-
-    return (PyObject *) inst;
-}
-
-PyObject *nb_type_put(const std::type_info *cpp_type,
-                      void *value, rv_policy rvp,
-                      cleanup_list *cleanup,
-                      bool *is_new) noexcept {
-    // Convert nullptr -> None
-    if (!value) {
-        Py_INCREF(Py_None);
-        return Py_None;
-    }
-
-    nb_internals *internals_ = internals;
-    type_data *td = nullptr;
-
-    auto lookup_type = [cpp_type, internals_, &td]() -> bool {
-        if (!td) {
-            type_data *d = nb_type_c2p(internals_, cpp_type);
-            if (!d)
-                return false;
-            td = d;
-        }
-        return true;
-    };
-
-    if (rvp != rv_policy::copy) {
-        nb_shard &shard = internals_->shard(value);
-        lock_shard guard(shard);
-
-        // Check if the instance is already registered with nanobind
-        nb_ptr_map &inst_c2p = shard.inst_c2p;
-        nb_ptr_map::iterator it = inst_c2p.find(value);
-
-        if (it != inst_c2p.end()) {
-            void *entry = it->second;
-            nb_inst_seq seq;
-
-            if (NB_UNLIKELY(nb_is_seq(entry))) {
-                seq = *nb_get_seq(entry);
-            } else {
-                seq.inst = (PyObject *) entry;
-                seq.next = nullptr;
-            }
-
-            while (true) {
-                PyTypeObject *tp = Py_TYPE(seq.inst);
-
-                if (nb_type_data(tp)->type == cpp_type) {
-                    if (nb_try_inc_ref(seq.inst))
-                        return seq.inst;
-                }
-
-                if (!lookup_type())
-                    return nullptr;
-
-                if (PyType_IsSubtype(tp, td->type_py)) {
-                    if (nb_try_inc_ref(seq.inst))
-                        return seq.inst;
-                }
-
-                if (seq.next == nullptr)
-                    break;
-
-                seq = *seq.next;
-            }
-        } else if (rvp == rv_policy::none) {
-            return nullptr;
-        }
-    }
-
-    // Look up the corresponding Python type if not already done
-    if (!lookup_type())
-        return nullptr;
-
-    return nb_type_put_common(value, td, rvp, cleanup, is_new);
-}
-
-PyObject *nb_type_put_p(const std::type_info *cpp_type,
-                        const std::type_info *cpp_type_p,
-                        void *value, rv_policy rvp,
-                        cleanup_list *cleanup,
-                        bool *is_new) noexcept {
-    // Convert nullptr -> None
-    if (!value) {
-        Py_INCREF(Py_None);
-        return Py_None;
-    }
-
-    // Check if the instance is already registered with nanobind
-    nb_internals *internals_ = internals;
-
-    // Look up the corresponding Python type
-    type_data *td = nullptr,
-              *td_p = nullptr;
-
-    auto lookup_type = [cpp_type, cpp_type_p, internals_, &td, &td_p]() -> bool {
-        if (!td) {
-            type_data *d = nb_type_c2p(internals_, cpp_type);
-            if (!d)
-                return false;
-            td = d;
-
-            if (cpp_type_p && cpp_type_p != cpp_type)
-                td_p = nb_type_c2p(internals_, cpp_type_p);
-        }
-
-        return true;
-    };
-
-    if (rvp != rv_policy::copy) {
-        nb_shard &shard = internals_->shard(value);
-        lock_shard guard(shard);
-
-        // Check if the instance is already registered with nanobind
-        nb_ptr_map &inst_c2p = shard.inst_c2p;
-        nb_ptr_map::iterator it = inst_c2p.find(value);
-
-        if (it != inst_c2p.end()) {
-            void *entry = it->second;
-            nb_inst_seq seq;
-
-            if (NB_UNLIKELY(nb_is_seq(entry))) {
-                seq = *nb_get_seq(entry);
-            } else {
-                seq.inst = (PyObject *) entry;
-                seq.next = nullptr;
-            }
-
-            while (true) {
-                PyTypeObject *tp = Py_TYPE(seq.inst);
-
-                const std::type_info *p = nb_type_data(tp)->type;
-
-                if (p == cpp_type || p == cpp_type_p) {
-                    if (nb_try_inc_ref(seq.inst))
-                        return seq.inst;
-                }
-
-                if (!lookup_type())
-                    return nullptr;
-
-                if (PyType_IsSubtype(tp, td->type_py) ||
-                    (td_p && PyType_IsSubtype(tp, td_p->type_py))) {
-                    if (nb_try_inc_ref(seq.inst))
-                        return seq.inst;
-                }
-
-                if (seq.next == nullptr)
-                    break;
-
-                seq = *seq.next;
-            }
-        } else if (rvp == rv_policy::none) {
-            return nullptr;
-        }
-    }
-
-    // Look up the corresponding Python type if not already done
-    if (!lookup_type())
-        return nullptr;
-
-    return nb_type_put_common(value, td_p ? td_p : td, rvp, cleanup, is_new);
-}
-
-static void nb_type_put_unique_finalize(PyObject *o,
-                                        const std::type_info *cpp_type,
-                                        bool cpp_delete, bool is_new) {
-    (void) cpp_type;
-    check(cpp_delete || !is_new,
-          "nanobind::detail::nb_type_put_unique(type='%s', cpp_delete=%i): "
-          "ownership status has become corrupted.",
-          type_name(cpp_type), cpp_delete);
-
-    nb_inst *inst = (nb_inst *) o;
-
-    if (cpp_delete) {
-        check(inst->state == (is_new ? nb_inst::state_ready
-                                     : nb_inst::state_relinquished) &&
-                  (bool) inst->destruct == is_new &&
-                  (bool) inst->cpp_delete == is_new,
-              "nanobind::detail::nb_type_put_unique(type='%s', cpp_delete=%i): "
-              "unexpected status flags! (state=%i, destruct=%i, cpp_delete=%i)",
-              type_name(cpp_type), cpp_delete, inst->state, inst->destruct,
-              inst->cpp_delete);
-
-        inst->state = nb_inst::state_ready;
-        inst->destruct = inst->cpp_delete = true;
-    } else {
-        check(inst->state == nb_inst::state_relinquished,
-                  "nanobind::detail::nb_type_put_unique('%s'): ownership "
-                  "status has become corrupted.", type_name(cpp_type));
-
-        inst->state = nb_inst::state_ready;
-    }
-}
-
-PyObject *nb_type_put_unique(const std::type_info *cpp_type,
-                             void *value,
-                             cleanup_list *cleanup, bool cpp_delete) noexcept {
-    rv_policy policy = cpp_delete ? rv_policy::take_ownership : rv_policy::none;
-
-    bool is_new = false;
-    PyObject *o = nb_type_put(cpp_type, value, policy, cleanup, &is_new);
-
-    if (o)
-        nb_type_put_unique_finalize(o, cpp_type, cpp_delete, is_new);
-
-    return o;
-}
-
-PyObject *nb_type_put_unique_p(const std::type_info *cpp_type,
-                               const std::type_info *cpp_type_p,
-                               void *value,
-                               cleanup_list *cleanup, bool cpp_delete) noexcept {
-    rv_policy policy = cpp_delete ? rv_policy::take_ownership : rv_policy::none;
-
-    bool is_new = false;
-    PyObject *o =
-        nb_type_put_p(cpp_type, cpp_type_p, value, policy, cleanup, &is_new);
-
-    if (o)
-        nb_type_put_unique_finalize(o, cpp_type, cpp_delete, is_new);
-
-    return o;
-}
-
-static void warn_relinquish_failed(const char *why, PyObject *o) noexcept {
-    PyObject *name = nb_inst_name(o);
-    int rc = PyErr_WarnFormat(
-        PyExc_RuntimeWarning, 1,
-        "nanobind::detail::nb_relinquish_ownership(): could not "
-        "transfer ownership of a Python instance of type '%U' to C++. %s",
-        name, why);
-    if (rc != 0) // user has configured warnings-as-errors
-        PyErr_WriteUnraisable(o);
-    Py_DECREF(name);
-}
-
-bool nb_type_relinquish_ownership(PyObject *o, bool cpp_delete) noexcept {
-    nb_inst *inst = (nb_inst *) o;
-
-    /* This function is called after nb_type_get() succeeds, so the instance
-       should be ready; but the !ready case is possible if an attempt is made to
-       transfer ownership of the same object to C++ multiple times as part of
-       the same data structure. For example, converting Python (foo, foo) to C++
-       std::pair<std::unique_ptr<T>, std::unique_ptr<T>>. */
-
-    if (inst->state != nb_inst::state_ready) {
-        warn_relinquish_failed(
-            "The resulting data structure would have multiple "
-            "std::unique_ptrs, each thinking that they own the same instance, "
-            "which is not allowed.", o);
-        return false;
-    }
-
-    if (cpp_delete) {
-        if (!inst->cpp_delete || !inst->destruct || inst->internal) {
-            warn_relinquish_failed(
-                "This is only possible when the instance was previously "
-                "constructed on the C++ side and is now owned by Python, which "
-                "was not the case here. You could change the unique pointer "
-                "signature to std::unique_ptr<T, nb::deleter<T>> to work "
-                "around this issue.", o);
-            return false;
-        }
-
-        inst->cpp_delete = false;
-        inst->destruct = false;
-    }
-
-    inst->state = nb_inst::state_relinquished;
-    return true;
-}
-
-void nb_type_restore_ownership(PyObject *o, bool cpp_delete) noexcept {
-    nb_inst *inst = (nb_inst *) o;
-
-    check(inst->state == nb_inst::state_relinquished,
-          "nanobind::detail::nb_type_restore_ownership('%s'): ownership "
-          "status has become corrupted.",
-          PyUnicode_AsUTF8AndSize(nb_inst_name(o), nullptr));
-
-    inst->state = nb_inst::state_ready;
-    if (cpp_delete) {
-        inst->cpp_delete = true;
-        inst->destruct = true;
-    }
-}
-
-bool nb_type_isinstance(PyObject *o, const std::type_info *t) noexcept {
-    type_data *d = nb_type_c2p(internals, t);
-    if (d)
-        return PyType_IsSubtype(Py_TYPE(o), d->type_py);
-    else
-        return false;
-}
-
-PyObject *nb_type_lookup(const std::type_info *t) noexcept {
-    type_data *d = nb_type_c2p(internals, t);
-    if (d)
-        return (PyObject *) d->type_py;
-    else
-        return nullptr;
-}
-
-bool nb_type_check(PyObject *t) noexcept {
-    PyTypeObject *meta  = Py_TYPE(t),
-                 *meta2 = Py_TYPE((PyObject *) meta);
-
-    return meta2 == nb_meta_cache;
-}
-
-size_t nb_type_size(PyObject *t) noexcept {
-    return nb_type_data((PyTypeObject *) t)->size;
-}
-
-size_t nb_type_align(PyObject *t) noexcept {
-    return nb_type_data((PyTypeObject *) t)->align;
-}
-
-const std::type_info *nb_type_info(PyObject *t) noexcept {
-    return nb_type_data((PyTypeObject *) t)->type;
-}
-
-void *nb_type_supplement(PyObject *t) noexcept {
-    return nb_type_data((PyTypeObject *) t) + 1;
-}
-
-PyObject *nb_inst_alloc(PyTypeObject *t) {
-    PyObject *result = inst_new_int(t, nullptr, nullptr);
-    if (!result)
-        raise_python_error();
-    return result;
-}
-
-PyObject *nb_inst_reference(PyTypeObject *t, void *ptr, PyObject *parent) {
-    PyObject *result = inst_new_ext(t, ptr);
-    if (!result)
-        raise_python_error();
-    nb_inst *nbi = (nb_inst *) result;
-    nbi->destruct = nbi->cpp_delete = false;
-    nbi->state = nb_inst::state_ready;
-    if (parent)
-        keep_alive(result, parent);
-    inst_register(result, ptr);
-    return result;
-}
-
-PyObject *nb_inst_take_ownership(PyTypeObject *t, void *ptr) {
-    PyObject *result = inst_new_ext(t, ptr);
-    if (!result)
-        raise_python_error();
-    nb_inst *nbi = (nb_inst *) result;
-    nbi->destruct = nbi->cpp_delete = true;
-    nbi->state = nb_inst::state_ready;
-    inst_register(result, ptr);
-    return result;
-}
-
-void *nb_inst_ptr(PyObject *o) noexcept {
-    return inst_ptr((nb_inst *) o);
-}
-
-void nb_inst_zero(PyObject *o) noexcept {
-    nb_inst *nbi = (nb_inst *) o;
-    type_data *td = nb_type_data(Py_TYPE(o));
-    memset(inst_ptr(nbi), 0, td->size);
-    nbi->state = nb_inst::state_ready;
-    nbi->destruct = true;
-}
-
-PyObject *nb_inst_alloc_zero(PyTypeObject *t) {
-    PyObject *result = inst_new_int(t, nullptr, nullptr);
-    if (!result)
-        raise_python_error();
-    nb_inst *nbi = (nb_inst *) result;
-    type_data *td = nb_type_data(t);
-    memset(inst_ptr(nbi), 0, td->size);
-    nbi->state = nb_inst::state_ready;
-    nbi->destruct = true;
-    return result;
-}
-
-void nb_inst_set_state(PyObject *o, bool ready, bool destruct) noexcept {
-    nb_inst *nbi = (nb_inst *) o;
-    nbi->state = ready ? nb_inst::state_ready : nb_inst::state_uninitialized;
-    nbi->destruct = destruct;
-    nbi->cpp_delete = destruct && !nbi->internal;
-}
-
-std::pair<bool, bool> nb_inst_state(PyObject *o) noexcept {
-    nb_inst *nbi = (nb_inst *) o;
-    return { nbi->state == nb_inst::state_ready, (bool) nbi->destruct };
-}
-
-void nb_inst_destruct(PyObject *o) noexcept {
-    nb_inst *nbi = (nb_inst *) o;
-    type_data *t = nb_type_data(Py_TYPE(o));
-
-    check(nbi->state != nb_inst::state_relinquished,
-          "nanobind::detail::nb_inst_destruct(\"%s\"): attempted to destroy "
-          "an object whose ownership had been transferred away!",
-          t->name);
-
-    if (nbi->destruct) {
-        check(t->flags & (uint32_t) type_flags::is_destructible,
-              "nanobind::detail::nb_inst_destruct(\"%s\"): attempted to call "
-              "the destructor of a non-destructible type!",
-              t->name);
-        if (t->flags & (uint32_t) type_flags::has_destruct)
-            t->destruct(inst_ptr(nbi));
-        nbi->destruct = false;
-    }
-
-    nbi->state = nb_inst::state_uninitialized;
-}
-
-void nb_inst_copy(PyObject *dst, const PyObject *src) noexcept {
-    if (src == dst)
-        return;
-
-    PyTypeObject *tp = Py_TYPE((PyObject *) src);
-    type_data *t = nb_type_data(tp);
-
-    check(tp == Py_TYPE(dst) &&
-              (t->flags & (uint32_t) type_flags::is_copy_constructible),
-          "nanobind::detail::nb_inst_copy(): invalid arguments!");
-
-    nb_inst *nbi = (nb_inst *) dst;
-    const void *src_data = inst_ptr((nb_inst *) src);
-    void *dst_data = inst_ptr(nbi);
-
-    if (t->flags & (uint32_t) type_flags::has_copy)
-        t->copy(dst_data, src_data);
-    else
-        memcpy(dst_data, src_data, t->size);
-
-    nbi->state = nb_inst::state_ready;
-    nbi->destruct = true;
-}
-
-void nb_inst_move(PyObject *dst, const PyObject *src) noexcept {
-    if (src == dst)
-        return;
-
-    PyTypeObject *tp = Py_TYPE((PyObject *) src);
-    type_data *t = nb_type_data(tp);
-
-    check(tp == Py_TYPE(dst) &&
-              (t->flags & (uint32_t) type_flags::is_move_constructible),
-          "nanobind::detail::nb_inst_move(): invalid arguments!");
-
-    nb_inst *nbi = (nb_inst *) dst;
-    void *src_data = inst_ptr((nb_inst *) src);
-    void *dst_data = inst_ptr(nbi);
-
-    if (t->flags & (uint32_t) type_flags::has_move) {
-        t->move(dst_data, src_data);
-    } else {
-        memcpy(dst_data, src_data, t->size);
-        memset(src_data, 0, t->size);
-    }
-
-    nbi->state = nb_inst::state_ready;
-    nbi->destruct = true;
-}
-
-void nb_inst_replace_move(PyObject *dst, const PyObject *src) noexcept {
-    if (src == dst)
-        return;
-    nb_inst *nbi = (nb_inst *) dst;
-    bool destruct = nbi->destruct;
-    nbi->destruct = true;
-    nb_inst_destruct(dst);
-    nb_inst_move(dst, src);
-    nbi->destruct = destruct;
-}
-
-void nb_inst_replace_copy(PyObject *dst, const PyObject *src) noexcept {
-    if (src == dst)
-        return;
-    nb_inst *nbi = (nb_inst *) dst;
-    bool destruct = nbi->destruct;
-    nbi->destruct = true;
-    nb_inst_destruct(dst);
-    nb_inst_copy(dst, src);
-    nbi->destruct = destruct;
-}
-
-#if defined(Py_LIMITED_API)
-type_data *nb_type_data_static(PyTypeObject *o) noexcept {
-    return (type_data *) PyObject_GetTypeData((PyObject *) o, Py_TYPE((PyObject *) o));
-}
-#endif
-
-PyObject *nb_type_name(PyObject *t) noexcept {
-    error_scope s;
-
-#if PY_VERSION_HEX >= 0x030B0000
-    PyObject *result = PyType_GetName((PyTypeObject *) t);
-#else
-    PyObject *result = PyObject_GetAttrString(t, "__name__");
-#endif
-
-    if (PyType_HasFeature((PyTypeObject *) t, Py_TPFLAGS_HEAPTYPE)) {
-        PyObject *mod = PyObject_GetAttrString(t, "__module__");
-        PyObject *combined = PyUnicode_FromFormat("%U.%U", mod, result);
-        Py_DECREF(mod);
-        Py_DECREF(result);
-        result = combined;
-    }
-
-    return result;
-}
-
-PyObject *nb_inst_name(PyObject *o) noexcept {
-        return nb_type_name((PyObject *) Py_TYPE(o));
-}
-
-bool nb_inst_python_derived(PyObject *o) noexcept {
-    return nb_type_data(Py_TYPE(o))->flags &
-           (uint32_t) type_flags::is_python_type;
-}
-
-NAMESPACE_END(detail)
-NAMESPACE_END(NB_NAMESPACE)
diff --git a/src/nanobind/src/stubgen.py b/src/nanobind/src/stubgen.py
deleted file mode 100644
index 5bb9bf3..0000000
--- a/src/nanobind/src/stubgen.py
+++ /dev/null
@@ -1,1444 +0,0 @@
-#!/usr/bin/env python3
-# pyright: strict
-
-"""
-stubgen.py: nanobind stub generation tool
-
-This file provides both an API (``nanobind.stubgen.StubGen``) and a command
-line interface to generate stubs for nanobind extensions.
-
-To generate stubs on the command line, invoke the stub generator with a module
-name, which will place the newly generated ``.pyi`` file directly into the
-module folder.
-
-```
-python -m nanobind.stubgen <module name>
-```
-
-Specify ``-o <filename>`` or ``-O <path>`` to redirect the output somewhere
-else in case this is not desired.
-
-To programmatically generate stubs, construct an instance of the ``StubGen``
-class and repeatedly call ``.put()`` to register modules or contents within the
-modules (specific methods, classes, etc.). Afterwards, the ``.get()`` method
-returns a string containing the stub declarations.
-
-```
-from nanobind.stubgen import StubGen
-import my_module
-
-sg = StubGen()
-sg.put(my_module)
-print(sg.get())
-```
-
-Internals:
-----------
-
-The implementation of stubgen performs a DFS traversal of the loaded module and
-directly generates the stub in lockstep. There are no ASTs or other
-intermediate data structures to keep things as simple as possible. Every kind
-of object that could be encountered (functions, properties, values, types) has
-a corresponding ``put_..`` method, along with the main ``put()`` entry point
-that dispatches to the others as appropriate.
-
-Internally, stub generation involves two potentially complex steps: converting
-nanobind overload chains into '@overload' declarations that can be understood
-by the 'typing' module, and turning default values back into Python
-expressions. To make both steps well-defined, the implementation relies on an
-internal ``__nb_signature__`` property that nanobind functions expose
-specifically to simplify stub generation.
-
-(Note that for now, the StubGen API is considered experimental and not subject
- to the semantic versioning policy used by the nanobind project.)
-"""
-
-import argparse
-import builtins
-import enum
-from inspect import Signature, Parameter, signature, ismodule
-import textwrap
-import importlib
-import importlib.machinery
-import importlib.util
-import types
-import typing
-from dataclasses import dataclass
-from typing import Dict, Sequence, List, Optional, Tuple, cast, Generator, Any, Callable, Union, Protocol, Literal
-from pathlib import Path
-import re
-import sys
-
-if sys.version_info < (3, 9):
-    from typing import Match, Pattern
-else:
-    from re import Match, Pattern
-
-if sys.version_info < (3, 11):
-    try:
-        import typing_extensions
-    except ImportError:
-        raise RuntimeError(
-            "stubgen.py requires the 'typing_extensions' package on Python <3.11"
-        )
-else:
-    typing_extensions = None
-
-# Exclude various standard elements found in modules, classes, etc.
-SKIP_LIST = [
-    "__doc__", "__module__", "__name__", "__new__", "__builtins__",
-    "__cached__", "__path__", "__version__", "__spec__", "__loader__",
-    "__package__", "__nb_signature__", "__class_getitem__", "__orig_bases__",
-    "__file__", "__dict__", "__weakref__", "__format__", "__nb_enum__",
-    "__firstlineno__", "__static_attributes__", "__annotations__", "__annotate__",
-    "__annotate_func__"
-]
-# fmt: on
-
-# This type is used to track per-module imports (``import name as desired_name``)
-# during stub generation. The actual name in the stub is given by the value element.
-# (name, desired_as_name) -> actual_as_name
-ImportDict = Dict[Tuple[Optional[str], Optional[str]], Optional[str]]
-
-# This type maps a module name to an `ImportDict` tuple that tracks the
-# import declarations from that module.
-# package_name -> ((name, desired_as_name) -> actual_as_name)
-PackagesDict = Dict[str, ImportDict]
-
-# Type of an entry of the ``__nb_signature__`` tuple of nanobind functions.
-# It stores a function signature string, docstring, and a tuple of default function values.
-# (signature_str, doc_str, (default_arg_1, default_arg_2, ...))
-NbSignature = Tuple[Optional[str], Optional[str]]
-
-# Type of an entry of the ``__nb_signature__`` tuple of nanobind functions.
-NbFunctionSignature = Tuple[Optional[str], Optional[str], Optional[Tuple[Any, ...]]]
-
-# Type of an entry of the ``__nb_signature__`` tuple of nanobind getters and setters.
-NbGetterSetterSignature = Tuple[str, str]
-
-class NamedObject(Protocol):
-    """
-    Typing protocol representing an object with __name__ and __module__ members
-    """
-    __module__: str
-    __name__: str
-
-class NbFunction(Protocol):
-    """
-    Typing protocol representing a nanobind function with its __nb_signature__ property
-    """
-    __module__: Literal["nanobind"]
-    __name__: Literal["nb_func", "nb_method"]
-    __nb_signature__: Tuple[NbFunctionSignature, ...]
-    __call__: Callable[..., Any]
-
-
-@typing.runtime_checkable
-class NbGetterSetter(Protocol):
-    __nb_signature__: Tuple[NbGetterSetterSignature, ...]
-
-
-class NbStaticProperty(Protocol):
-    """Typing protocol representing a nanobind static property"""
-    __module__: Literal["nanobind"]
-    __name__: Literal["nb_static_property"]
-    fget: NbGetterSetter
-    fset: NbGetterSetter
-
-
-class NbType(Protocol):
-    """typing protocol representing a nanobind type object"""
-    __module__: Literal["nanobind"]
-    __name__: Literal["nb_type"]
-    __nb_signature__: str
-    __bases__: Tuple[Any, ...]
-
-
-@dataclass
-class ReplacePattern:
-    """
-    A compiled query (regular expression) and replacement pattern. Patterns can
-    be loaded using the ``load_pattern_file()`` function defined below
-    """
-
-    # A replacement patterns as produced by ``load_pattern_file()`` below
-    query: Pattern[str]
-    lines: List[str]
-    matches: int
-
-
-class StubGen:
-    def __init__(
-        self,
-        module: types.ModuleType,
-        recursive: bool = False,
-        include_docstrings: bool = True,
-        include_private: bool = False,
-        include_internal_imports: bool = True,
-        include_external_imports: bool = False,
-        max_expr_length: int = 50,
-        patterns: List[ReplacePattern] = [],
-        quiet: bool = True,
-        output_file: Optional[Path] = None
-    ) -> None:
-        # Module to check for name conflicts when adding helper imports
-        self.module = module
-
-        # Include docstrings in the generated stub?
-        self.include_docstrings = include_docstrings
-
-        # Recurse into submodules?
-        self.recursive = recursive
-
-        # Include private members that start or end with a single underscore?
-        self.include_private = include_private
-
-        # Include types and functions imported from the same package (but a different module)
-        self.include_internal_imports = include_internal_imports
-
-        # Include types and functions imported from external packages?
-        self.include_external_imports = include_external_imports
-
-        # Maximal length (in characters) before an expression gets abbreviated as '...'
-        self.max_expr_length = max_expr_length
-
-        # Replacement patterns as produced by ``load_pattern_file()`` below
-        self.patterns = patterns
-
-        # Set this to ``True`` if output to stdout is unacceptable
-        self.quiet = quiet
-
-        # Target filename, only needed for recursive stub generation
-        self.output_file = output_file
-
-        # ---------- Internal fields ----------
-
-        # Current depth / indentation level
-        self.depth = 0
-
-        # Output will be appended to this string
-        self.output = ""
-
-        # A stack to avoid infinite recursion
-        self.stack: List[object] = []
-
-        # An identifier associated with the top element of the stack
-        self.prefix = module.__name__
-
-        # Dictionary to keep track of import directives added by the stub generator
-        # Maps package_name -> ((name, desired_as_name) -> actual_as_name)
-        self.imports: PackagesDict = {}
-
-        # ---------- Regular expressions ----------
-
-        # Negative lookbehind matching word boundaries except '.'
-        sep_before = r"(?<![\\B\.])"
-
-        # Negative lookforward matching word boundaries except '.'
-        sep_after = r"(?![\\B\.])"
-
-        # Regexp matching a Python identifier
-        identifier = r"[^\d\W]\w*"
-
-        # Precompile RE a sequence of identifiers separated by periods
-        self.id_seq = re.compile(
-            sep_before
-            + "((?:"
-            + identifier
-            + r"\.)+)("
-            + identifier
-            + r")\b"
-            + sep_after
-        )
-
-        # Precompile RE to extract nanobind nd-arrays
-        self.ndarray_re = re.compile(
-            sep_before + r"(numpy\.ndarray|ndarray|torch\.Tensor)\[([^\]]*)\]"
-        )
-
-        # Types which moved from typing.* to collections.abc in Python 3.9
-        self.abc_re = re.compile(
-            'typing.(AsyncGenerator|AsyncIterable|AsyncIterator|Awaitable|Callable|'
-            'Collection|Container|Coroutine|Generator|Hashable|ItemsView|'
-            'Iterable|Iterator|KeysView|Mapping|MappingView|MutableMapping|'
-            'MutableSequence|MutableSet|Sequence|ValuesView)'
-        )
-
-    def write(self, s: str) -> None:
-        """Append raw characters to the output"""
-        self.output += s
-
-    def write_ln(self, line: str) -> None:
-        """Append an indented line"""
-        if len(line) != 0 and not line.isspace():
-            self.output += "    " * self.depth + line
-        self.output += "\n"
-
-    def write_par(self, line: str) -> None:
-        """Append an indented paragraph"""
-        self.output += textwrap.indent(line, "    " * self.depth)
-
-    def put_docstr(self, docstr: str) -> None:
-        """Append an indented single or multi-line docstring"""
-        docstr = textwrap.dedent(docstr).strip()
-        raw_str = ""
-        if "''" in docstr or "\\" in docstr:
-            # Escape all double quotes so that no unquoted triple quote can exist
-            docstr = docstr.replace("''", "\\'\\'")
-            raw_str = "r"
-        if len(docstr) > 70 or "\n" in docstr:
-            docstr = "\n" + docstr + "\n"
-        docstr = f'{raw_str}"""{docstr}"""\n'
-        self.write_par(docstr)
-
-    def put_nb_overload(self, fn: NbFunction, sig: NbFunctionSignature, name: Optional[str] = None) -> None:
-        """
-        The ``put_nb_func()`` repeatedly calls this method to render the
-        individual method overloads.
-        """
-        sig_str, docstr, start = cast(str, sig[0]), cast(str, sig[1]), 0
-
-        # Label anonymous functions
-        if sig_str.startswith("def (") and name is not None:
-            sig_str = "def " + name + sig_str[4:]
-
-        # Simplify type names present in the signature
-        paren = sig_str.find("(")
-        sig_str = sig_str[:paren] + self.simplify_types(sig_str[paren:])
-
-        # Substitute in string versions of the default arguments
-        default_args = sig[2]
-        if default_args:
-            for index, arg in enumerate(default_args):
-                pos = -1
-                pattern = None
-                arg_str = None
-
-                # First, handle the case where the user overrode the default value signature
-                if isinstance(arg, str):
-                    pattern = f"\\={index}"
-                    pos = sig_str.find(pattern, start)
-                    if pos >= 0:
-                        arg_str = arg
-
-                # General case
-                if pos < 0:
-                    pattern = f"\\{index}"
-                    pos = sig_str.find(pattern, start)
-
-                if pos < 0:
-                    raise Exception(
-                        "Could not locate default argument in function signature"
-                    )
-
-                if not arg_str:
-                    # Call expr_str to convert the default value to a string.
-                    # Abbreviate with '...' if it is too long.
-                    expr = self.expr_str(arg, abbrev=True)
-                    arg_str = expr if expr else "..."
-
-                assert (
-                    "\n" not in arg_str
-                ), "Default argument string may not contain newlines."
-
-                assert pattern is not None
-                sig_str = sig_str[:pos] + arg_str + sig_str[pos + len(pattern) :]
-                start = pos + len(arg_str)
-
-        if type(fn).__name__ == "nb_func" and self.depth > 0:
-            self.write_ln("@staticmethod")
-
-        if not docstr or not self.include_docstrings:
-            for s in sig_str.split("\n"):
-                self.write_ln(s)
-            self.output = self.output[:-1] + ": ...\n"
-        else:
-            docstr = textwrap.dedent(docstr)
-            for s in sig_str.split("\n"):
-                self.write_ln(s)
-            self.output = self.output[:-1] + ":\n"
-            self.depth += 1
-            self.put_docstr(docstr)
-            self.depth -= 1
-        self.write("\n")
-
-    def put_nb_func(self, fn: NbFunction, name: Optional[str] = None) -> None:
-        """Append a nanobind function binding to the stub"""
-        sigs = fn.__nb_signature__
-        count = len(sigs)
-        assert count > 0
-        if count == 1:
-            # No overloads write directly
-            self.put_nb_overload(fn, sigs[0], name)
-        else:
-            # Render an @overload-decorated chain
-            overload = self.import_object("typing", "overload")
-            for s in sigs:
-                self.write_ln(f"@{overload}")
-                self.put_nb_overload(fn, s, name)
-
-    def put_function(self, fn: Callable[..., Any], name: Optional[str] = None, parent: Optional[object] = None):
-        """Append a function of an arbitrary type to the stub"""
-        # Don't generate a constructor for nanobind classes that aren't constructible
-        if name == "__init__" and type(parent).__name__.startswith("nb_type"):
-            return
-
-        fn_module = getattr(fn, "__module__", None)
-        fn_name = getattr(fn, "__name__", None)
-
-        # Check if this function is an alias from *another* module
-        if name and fn_module and fn_module != self.module.__name__:
-            self.put_value(fn, name)
-            return
-
-        # Check if this function is an alias from the *same* module
-        if name and fn_name and name != fn_name:
-            self.write_ln(f"{name} = {fn_name}\n")
-            return
-
-        # Special handling for nanobind functions with overloads
-        if type(fn).__module__ == "nanobind":
-            fn = cast(NbFunction, fn)
-            self.put_nb_func(fn, name)
-            return
-
-        if isinstance(fn, staticmethod):
-            self.write_ln("@staticmethod")
-            fn = fn.__func__
-        elif isinstance(fn, classmethod):
-            self.write_ln("@classmethod")
-            fn = fn.__func__
-
-        if name is None:
-            name = fn.__name__
-            assert name
-
-        overloads: Sequence[Callable[..., Any]] = []
-        if hasattr(fn, "__module__"):
-            if typing_extensions:
-                overloads = typing_extensions.get_overloads(fn)
-            else:
-                overloads = typing.get_overloads(fn)
-
-        if not overloads:
-            overloads = [fn]
-
-        for i, fno in enumerate(overloads):
-            if len(overloads) > 1:
-                overload = self.import_object("typing", "overload")
-                self.write_ln(f"@{overload}")
-
-            sig_str = f"{name}{self.signature_str(signature(fno))}"
-
-            # Potentially copy docstring from the implementation function
-            docstr = fno.__doc__
-            if i == 0 and not docstr and fn.__doc__:
-                docstr = fn.__doc__
-
-            if not docstr or not self.include_docstrings:
-                self.write_ln("def " + sig_str + ": ...")
-            else:
-                self.write_ln("def " + sig_str + ":")
-                self.depth += 1
-                self.put_docstr(docstr)
-                self.depth -= 1
-            self.write("\n")
-
-    def put_property(self, prop: property, name: Optional[str]):
-        """Append a Python 'property' object"""
-        fget, fset = prop.fget, prop.fset
-        self.write_ln("@property")
-        self.put(fget, name=name)
-        if fset:
-            self.write_ln(f"@{name}.setter")
-            docstrings_backup = self.include_docstrings
-            if isinstance(fget, NbGetterSetter) and isinstance(fset, NbGetterSetter):
-                doc1 = fget.__nb_signature__[0][1]
-                doc2 = fset.__nb_signature__[0][1]
-                if doc1 and doc2 and doc1 == doc2:
-                    self.include_docstrings = False
-            self.put(prop.fset, name=name)
-            self.include_docstrings = docstrings_backup
-
-    def put_nb_static_property(self, name: Optional[str], prop: NbStaticProperty):
-        """Append a 'nb_static_property' object"""
-        getter_sig = prop.fget.__nb_signature__[0][0]
-        pos = getter_sig.find("/) -> ")
-        if pos == -1:
-            raise RuntimeError(f"Static property '{name}' ({getter_sig}) has an invalid signature!")
-        getter_sig = getter_sig[pos + 6 :]
-        self.write_ln(f"{name}: {getter_sig} = ...")
-        if prop.__doc__ and self.include_docstrings:
-            self.put_docstr(prop.__doc__)
-        self.write("\n")
-
-    def put_type(self, tp: NbType, name: Optional[str]):
-        """Append a 'nb_type' type object"""
-        tp_name, tp_mod_name = tp.__name__, tp.__module__
-        mod_name = self.module.__name__
-
-        if name and (name != tp_name or mod_name != tp_mod_name):
-            same_module = tp_mod_name == mod_name
-            same_toplevel_module = tp_mod_name.split(".")[0] == mod_name.split(".")[0]
-
-            if same_module:
-                # This is an alias of a type in the same module or same top-level module
-                if sys.version_info >= (3, 10, 0):
-                    alias_tp = self.import_object("typing", "TypeAlias")
-                else:
-                    alias_tp = self.import_object("typing_extensions", "TypeAlias")
-                self.write_ln(f"{name}: {alias_tp} = {tp.__qualname__}\n")
-            elif self.include_external_imports or (same_toplevel_module and self.include_internal_imports):
-                # Import from a different module
-                self.put_value(tp, name)
-        else:
-            docstr = tp.__doc__
-            tp_dict = dict(tp.__dict__)
-            tp_bases: Union[List[str], Tuple[Any, ...], None] = None
-
-            if "__nb_signature__" in tp.__dict__:
-                # Types with a custom signature override
-                for s in tp.__nb_signature__.split("\n"):
-                    self.write_ln(self.simplify_types(s))
-                self.output = self.output[:-1] + ":\n"
-            else:
-                self.write_ln(f"class {tp_name}:")
-                if tp_bases is None:
-                    tp_bases = getattr(tp, "__orig_bases__", None)
-                    if tp_bases is None:
-                        tp_bases = tp.__bases__
-                    tp_bases = [self.type_str(base) for base in tp_bases]
-
-                if tp_bases != ["object"]:
-                    self.output = self.output[:-2] + "("
-                    for i, base in enumerate(tp_bases):
-                        if i:
-                            self.write(", ")
-                        self.write(base)
-                    self.write("):\n")
-
-            self.depth += 1
-            output_len = len(self.output)
-            if docstr and self.include_docstrings:
-                self.put_docstr(docstr)
-                if len(tp_dict):
-                    self.write("\n")
-            for k, v in tp_dict.items():
-                self.put(v, k, tp)
-            if output_len == len(self.output):
-                self.write_ln("pass\n")
-            self.depth -= 1
-
-    def is_function(self, tp: type) -> bool:
-        """
-        Test if this is one of the many types of built-in functions supported
-        by Python, or if it is a nanobind ``nb_func``.
-        """
-        return (
-            issubclass(tp, types.FunctionType)
-            or issubclass(tp, types.BuiltinFunctionType)
-            or issubclass(tp, types.BuiltinMethodType)
-            or issubclass(tp, types.WrapperDescriptorType)
-            or issubclass(tp, staticmethod)
-            or issubclass(tp, classmethod)
-            or (tp.__module__ == "nanobind" and tp.__name__ == "nb_func")
-        )
-
-    def put_value(self, value: object, name: str, parent: Optional[object] = None, abbrev: bool = True) -> None:
-        """
-        Render a ``name: type = value`` assignment at the module, class, or
-        enum scope.
-
-        The parameter ``abbrev`` indicates if it is acceptable to reduce very
-        long expressions to ``...``.
-        """
-        tp = type(value)
-
-        # Ignore module imports of non-type values like 'from typing import Optional'
-        if (
-            not self.include_external_imports
-            and tp.__module__ == "typing"
-            and str(value) == f"typing.{name}"
-        ):
-            return
-
-        if tp.__module__ == '__future__':
-            return
-
-        if isinstance(parent, type) and issubclass(tp, parent):
-            # This is an entry of an enumeration
-            self.write_ln(f"{name} = {typing.cast(enum.Enum, value).value}")
-            if value.__doc__ and self.include_docstrings:
-                self.put_docstr(value.__doc__)
-            self.write("\n")
-        elif self.is_function(tp) or isinstance(value, type):
-            named_value = cast(NamedObject, value)
-            same_toplevel_module = named_value.__module__.split(".")[0] == self.module.__name__.split(".")[0]
-
-            if self.include_external_imports or (same_toplevel_module and self.include_internal_imports):
-                # This is a function or a type, import it from its actual source
-                self.import_object(named_value.__module__, named_value.__name__, name)
-        else:
-            value_str = self.expr_str(value, abbrev)
-
-            if value_str is None:
-                value_str = "..."
-
-            # Catch a few different typing.* constructs
-            if self.is_type_var(tp):
-                types = ""
-            elif typing.get_origin(value):
-                if sys.version_info >= (3, 10, 0):
-                    types = ": " + self.import_object("typing", "TypeAlias")
-                else:
-                    types = ": " + self.import_object("typing_extensions", "TypeAlias")
-            else:
-                types = f": {self.type_str(tp)}"
-
-            self.write_ln(f"{name}{types} = {value_str}\n")
-
-    def is_type_var(self, tp: type) -> bool:
-        return (issubclass(tp, typing.TypeVar)
-            or (sys.version_info >= (3, 11) and issubclass(tp, typing.TypeVarTuple))
-            or (typing_extensions is not None
-            and (
-                issubclass(tp, typing_extensions.TypeVar)
-                or issubclass(tp, typing_extensions.TypeVarTuple))))
-
-    def simplify_types(self, s: str) -> str:
-        """
-        Process types that occur within a signature string ``s`` and simplify
-        them. This function applies the following rules:
-
-        - "local_module.X" -> "X"
-
-        - "other_module.X" -> "other_module.XX"
-          (with "import other_module" added at top)
-
-        - "builtins.X" -> "X"
-
-        - "NoneType" -> "None"
-
-        - "ndarray[...]" -> "Annotated[ArrayLike, dict(...)]"
-
-        - "collections.abc.X" -> "X"
-          (with "from collections.abc import X" added at top)
-
-        - "typing.X" -> "X"
-          (with "from typing import X" added at top, potentially
-           changed to 'collections.abc' on newer Python versions)
-        """
-
-        # Process nd-array type annotations so that MyPy accepts them
-        def process_ndarray(m: Match[str]) -> str:
-            s = m.group(2)
-
-            ndarray = self.import_object("numpy.typing", "ArrayLike")
-            assert ndarray
-            s = re.sub(r"dtype=([\w]*)\b", r"dtype='\g<1>'", s)
-            s = s.replace("*", "None")
-
-            if s:
-                annotated = self.import_object("typing", "Annotated")
-                return f"{annotated}[{ndarray}, dict({s})]"
-            else:
-                return ndarray
-
-        s = self.ndarray_re.sub(process_ndarray, s)
-
-        if sys.version_info >= (3, 9, 0):
-            s = self.abc_re.sub(r'collections.abc.\1', s)
-
-        # Process other type names and add suitable import statements
-        def process_general(m: Match[str]) -> str:
-            def is_valid_module(module_name: str) -> bool:
-                try:
-                    importlib.util.find_spec(module_name)
-                    # If we get here, the module exists and has a valid spec.
-                    return True
-                except ValueError:
-                    # The module exists but has no spec, `find_spec` raises a
-                    # `ValueError`, so if we get here, the module does exist.
-                    return True
-                except ModuleNotFoundError:
-                    return False
-
-            full_name, mod_name, cls_name = m.group(0), m.group(1)[:-1], m.group(2)
-
-            if mod_name == "builtins":
-                # Simplify builtins
-                return cls_name if cls_name != "NoneType" else "None"
-            if full_name.startswith(self.module.__name__):
-                # Strip away the module prefix for local classes
-                return full_name[len(self.module.__name__) + 1 :]
-            elif mod_name == "typing" or mod_name == "collections.abc":
-                # Import frequently-occurring typing classes and ABCs directly
-                return self.import_object(mod_name, cls_name)
-            else:
-                # Handle nested names. While mod_name isn't a valid module, then
-                # move the last segment of the name from mod_name to cls_name
-                # and try again until we have the right partition.
-                search_mod_name = mod_name
-                search_cls_name = cls_name
-                while search_mod_name:
-                    if is_valid_module(search_mod_name):
-                        mod_name = search_mod_name
-                        cls_name = search_cls_name
-                        break
-                    search_mod_name, _, symbol = search_mod_name.rpartition(".")
-                    search_cls_name = f"{symbol}.{search_cls_name}"
-
-                # Import the module and reference the contained class by name
-                self.import_object(mod_name, None)
-                return full_name
-
-        s = self.id_seq.sub(process_general, s)
-
-        return s
-
-    def apply_pattern(self, query: str, value: object) -> bool:
-        """
-        Check if ``value`` matches an entry of a pattern file. Applies the
-        pattern and returns ``True`` in that case, otherwise returns ``False``.
-        """
-
-        match: Optional[Match[str]] = None
-        pattern: Optional[ReplacePattern] = None
-
-        for pattern in self.patterns:
-            match = pattern.query.search(query)
-            if match:
-                break
-
-        if not match or not pattern:
-            return False
-
-        for line in pattern.lines:
-            ls = line.strip()
-            if ls == "\\doc":
-                # Docstring reference
-                tp = type(value)
-                doc: Optional[str] = None
-                if tp.__module__ == "nanobind" and tp.__name__ in (
-                    "nb_func",
-                    "nb_method",
-                ):
-                    value = cast(NbFunction, value)
-                    for tp_i in value.__nb_signature__:
-                        doc = tp_i[1]
-                        if doc:
-                            break
-                else:
-                    doc = getattr(value, "__doc__", None)
-                self.depth += 1
-                if doc and self.include_docstrings:
-                    self.put_docstr(doc)
-                else:
-                    self.write_ln("pass")
-                self.depth -= 1
-                continue
-            elif ls.startswith("\\from "):
-                items = ls[5:].split(" import ")
-                if len(items) != 2:
-                    raise RuntimeError(f"Could not parse import declaration {ls}")
-                for item in items[1].strip("()").split(","):
-                    item_list = item.split(" as ")
-                    import_module, import_name = (
-                        items[0].strip(),
-                        item_list[0].strip(),
-                    )
-                    import_as = item_list[1].strip() if len(item_list) > 1 else None
-                    self.import_object(import_module, import_name, import_as)
-                continue
-
-            groups = match.groups()
-            for i in reversed(range(len(groups))):
-                line = line.replace(f"\\{i+1}", groups[i])
-            for k, v in match.groupdict().items():
-                line = line.replace(f"\\{k}", v)
-            self.write_ln(line)
-
-        # Success, pattern was applied
-        return True
-
-    def put(self, value: object, name: Optional[str] = None, parent: Optional[object] = None) -> None:
-        old_prefix = self.prefix
-
-        if value in self.stack:
-            # Avoid infinite recursion due to cycles
-            return
-
-        try:
-            self.stack.append(value)
-            self.prefix = self.prefix + (("." + name) if name else "")
-
-            # Check if an entry in a provided pattern file matches
-            if self.apply_pattern(self.prefix, value):
-                return
-
-            # Exclude various standard elements found in modules, classes, etc.
-            if name in SKIP_LIST:
-                return
-
-            is_type_alias = typing.get_origin(value) or (
-                isinstance(value, type)
-                and (value.__name__ != name or value.__module__ != self.module.__name__)
-            )
-
-            # Ignore private members unless the user requests their inclusion
-            if (
-                not self.include_private
-                and name
-                and not is_type_alias
-                and len(name) > 2
-                and (
-                    (name[0] == "_" and name[1] != "_")
-                    or (name[-1] == "_" and name[-2] != "_")
-                )
-            ):
-                return
-
-            tp = type(value)
-            tp_mod, tp_name = tp.__module__, tp.__name__
-
-            if ismodule(value):
-                if len(self.stack) != 1:
-                    value_name_s = value.__name__.split(".")
-                    module_name_s = self.module.__name__.split(".")
-                    is_external = value_name_s[0] != module_name_s[0]
-                    if not self.include_external_imports and is_external:
-                        return
-
-                    # Do not include submodules in the same stub, but include a directive to import them
-                    self.import_object(value.__name__, name=None, as_name=name)
-
-                    # If the user requested this, generate a separate stub recursively
-                    if self.recursive and value_name_s[:-1] == module_name_s and self.output_file:
-                        module_file = getattr(value, '__file__', None)
-
-                        if not module_file or module_file.endswith('__init__.py'):
-                            dir_name = self.output_file.parents[0] / value_name_s[-1]
-                            dir_name.mkdir(parents=False, exist_ok=True)
-                            output_file = dir_name / '__init__.pyi'
-                        else:
-                            output_file = self.output_file.parents[0] / (value_name_s[-1] + '.py')
-
-                        sg = StubGen(
-                            module=value,
-                            recursive=self.recursive,
-                            include_docstrings=self.include_docstrings,
-                            include_private=self.include_private,
-                            include_external_imports=self.include_external_imports,
-                            include_internal_imports=self.include_internal_imports,
-                            max_expr_length=self.max_expr_length,
-                            patterns=self.patterns,
-                            output_file=output_file,
-                            quiet=self.quiet
-                        )
-
-                        sg.put(value)
-
-                        if not self.quiet:
-                            print(f'  - writing stub "{output_file}" ..')
-
-                        with open(output_file, "w", encoding='utf-8') as f:
-                            f.write(sg.get())
-                    return
-                else:
-                    self.apply_pattern(self.prefix + ".__prefix__", None)
-                    # using value.__dict__ rather than inspect.getmembers
-                    # to preserve insertion order
-                    for name, child in value.__dict__.items():
-                        self.put(child, name=name, parent=value)
-                    self.apply_pattern(self.prefix + ".__suffix__", None)
-            elif self.is_function(tp):
-                value = cast(NbFunction, value)
-                self.put_function(value, name, parent)
-            elif issubclass(tp, type):
-                value = cast(NbType, value)
-                self.put_type(value, name)
-            elif tp_mod == "nanobind":
-                if tp_name == "nb_method":
-                    value = cast(NbFunction, value)
-                    self.put_function(value, name)
-                elif tp_name == "nb_static_property":
-                    value = cast(NbStaticProperty, value)
-                    self.put_nb_static_property(name, value)
-            elif tp_mod == "builtins":
-                if tp is property:
-                    value = cast(property, value)
-                    self.put_property(value, name)
-                else:
-                    assert name is not None
-                    abbrev = name != "__all__"
-                    self.put_value(value, name, parent, abbrev=abbrev)
-            else:
-                assert name is not None
-                self.put_value(value, name, parent)
-        finally:
-            self.stack.pop()
-            self.prefix = old_prefix
-
-    def import_object(
-        self, module: str, name: Optional[str], as_name: Optional[str] = None
-    ) -> str:
-        """
-        Import a type (e.g. typing.Optional) used within the stub, ensuring
-        that this does not cause conflicts. Specify ``as_name`` to ensure that
-        the import is bound to a specified name.
-
-        When ``name`` is None, the entire module is imported.
-        """
-        if module == "builtins" and name and (not as_name or name == as_name):
-            return name
-
-        # Rewrite module name if this is relative import from a submodule
-        if module.startswith(self.module.__name__) and module != self.module.__name__:
-            module_short = module[len(self.module.__name__) :]
-            if not name and as_name and module_short[0] == ".":
-                name = as_name = module_short[1:]
-                module_short = "."
-        else:
-            module_short = module
-
-        # Query a cache of previously imported objects
-        imports_module: Optional[ImportDict] = self.imports.get(module_short, None)
-        if not imports_module:
-            imports_module = {}
-            self.imports[module_short] = imports_module
-
-        key = (name, as_name)
-        final_name = imports_module.get(key, None)
-        if final_name:
-            return final_name
-
-        # Cache miss, import the object
-        final_name = as_name if as_name else name
-
-        # If no as_name constraint was set, potentially adjust the name to
-        # avoid conflicts with an existing object of the same name
-        if name and not as_name:
-            test_name = name
-            while True:
-                # Accept the name if there are no conflicts
-                if not hasattr(self.module, test_name):
-                    break
-                value = getattr(self.module, test_name)
-                try:
-                    if module == ".":
-                        mod_o = self.module
-                    else:
-                        mod_o = importlib.import_module(module)
-
-                    # If there is a conflict, accept it if it refers to the same object
-                    if getattr(mod_o, name) is value:
-                        break
-                except ImportError:
-                    pass
-
-                # Prefix with an underscore
-                test_name = "_" + test_name
-            final_name = test_name
-
-        imports_module[key] = final_name
-        return final_name if final_name else ""
-
-    def expr_str(self, e: Any, abbrev: bool = True) -> Optional[str]:
-        """
-        Attempt to convert a value into valid Python syntax that regenerates
-        that value. When ``abbrev`` is True, the implementation gives up and
-        returns ``None`` when the expression is considered to be too
-        complicated.
-        """
-        tp = type(e)
-        for t in [bool, int, type(None), type(builtins.Ellipsis)]:
-            if issubclass(tp, t):
-                return repr(e)
-        if issubclass(tp, float):
-            s = repr(e)
-            if "inf" in s or "nan" in s:
-                return f"float('{s}')"
-            else:
-                return s
-        elif issubclass(tp, type) or typing.get_origin(e):
-            return self.type_str(e)
-        elif issubclass(tp, typing.ForwardRef):
-            return f'"{e.__forward_arg__}"'
-        elif issubclass(tp, enum.Enum):
-            return self.type_str(tp) + '.' + e.name
-        elif (sys.version_info >= (3, 11) and issubclass(tp, typing.TypeVarTuple)) \
-            or (typing_extensions is not None and issubclass(tp, typing_extensions.TypeVarTuple)):
-            tv = self.import_object(tp.__module__, "TypeVarTuple")
-            return f'{tv}("{e.__name__}")'
-        elif issubclass(tp, typing.TypeVar):
-            tv = self.import_object("typing", "TypeVar")
-            s = f'{tv}("{e.__name__}"'
-            for v in getattr(e, "__constraints__", ()):
-                v = self.expr_str(v)
-                assert v
-                s += ", " + v
-            for k in ["contravariant", "covariant", "bound", "infer_variance"]:
-                v = getattr(e, f"__{k}__", None)
-                if v:
-                    v = self.expr_str(v)
-                    if v is None:
-                        return None
-                    s += f", {k}=" + v
-            s += ")"
-            return s
-        elif issubclass(tp, str):
-            s = repr(e)
-            if len(s) < self.max_expr_length or not abbrev:
-                return s
-        elif issubclass(tp, list) or issubclass(tp, tuple):
-            e = [self.expr_str(v, abbrev) for v in e]
-            if None in e:
-                return None
-            if issubclass(tp, list):
-                s = "[" + ", ".join(e) + "]"
-            else:
-                s = "(" + ", ".join(e) + ")"
-            if len(s) < self.max_expr_length or not abbrev:
-                return s
-        elif issubclass(tp, dict):
-            e = [
-                (self.expr_str(k, abbrev), self.expr_str(v, abbrev))
-                for k, v in e.items()
-            ]
-            s = "{"
-            for i, (k, v) in enumerate(e):
-                if k is None or v is None:
-                    return None
-                s += k + " : " + v
-                if i + 1 < len(e):
-                    s += ", "
-            s += "}"
-            if len(s) < self.max_expr_length or not abbrev:
-                return s
-            pass
-        return None
-
-    def signature_str(self, s: Signature) -> str:
-        """Convert an inspect.Signature to into valid Python syntax"""
-        posonly_sep, kwonly_sep = False, True
-        params: List[str] = []
-
-        # Logic for placing '*' and '/' based on the
-        # signature.Signature implementation
-        for param in s.parameters.values():
-            kind = param.kind
-
-            if kind == Parameter.POSITIONAL_ONLY:
-                posonly_sep = True
-            elif posonly_sep:
-                params.append("/")
-                posonly_sep = False
-
-            if kind == Parameter.VAR_POSITIONAL:
-                kwonly_sep = False
-            elif kind == Parameter.KEYWORD_ONLY and kwonly_sep:
-                params.append("*")
-                kwonly_sep = False
-            params.append(self.param_str(param))
-
-        if posonly_sep:
-            params.append("/")
-
-        result = f"({', '.join(params)})"
-        if s.return_annotation != Signature.empty:
-            result += " -> " + self.type_str(s.return_annotation)
-        return result
-
-    def param_str(self, p: Parameter) -> str:
-        result = ""
-        if p.kind == Parameter.VAR_POSITIONAL:
-            result += "*"
-        elif p.kind == Parameter.VAR_KEYWORD:
-            result += "**"
-        result += p.name
-        has_type = p.annotation != Parameter.empty
-        has_def = p.default != Parameter.empty
-
-        if has_type:
-            result += ": " + self.type_str(p.annotation)
-        if has_def:
-            result += " = " if has_type else "="
-            p_default_str = self.expr_str(p.default)
-            if p_default_str is None:
-                # self.expr_str(p.default) could return None in some rare cases, 
-                # e.g. p.default is a nanobind object. If so, use ellipsis as a placeholder.
-                p_default_str = "..."
-            assert p_default_str
-            result += p_default_str
-        return result
-
-    def type_str(self, tp: Union[List[Any], Tuple[Any, ...], Dict[Any, Any], Any]) -> str:
-        """Attempt to convert a type into a Python expression which reproduces it"""
-        origin, args = typing.get_origin(tp), typing.get_args(tp)
-
-        if isinstance(tp, str):
-            result = tp
-        elif isinstance(tp, typing.TypeVar):
-            return tp.__name__
-        elif isinstance(tp, typing.ForwardRef):
-            return repr(tp.__forward_arg__)
-        elif isinstance(tp, list):
-            list_gen: Generator[str, None, None] = (self.type_str(a) for a in tp)
-            return "[" + ", ".join(list_gen) + "]"
-        elif isinstance(tp, tuple):
-            tuple_gen: Generator[str, None, None] = (self.type_str(a) for a in tp)
-            return "(" + ", ".join(tuple_gen) + ")"
-        elif isinstance(tp, dict):
-            dict_gen: Generator[str, None, None] = (repr(k) + ": " + self.type_str(v) for k, v in tp.items())
-            return (
-                "{"
-                + ", ".join(dict_gen)
-                + "}"
-            )
-        elif origin and args:
-            args_gen: Generator[str, None, None] = (self.type_str(a) for a in args)
-            result = (
-                self.type_str(origin)
-                + "["
-                + ", ".join(args_gen)
-                + "]"
-            )
-        elif tp is types.ModuleType:
-            result = "types.ModuleType"
-        elif isinstance(tp, type):
-            result = tp.__module__ + "." + tp.__qualname__
-        else:
-            result = repr(tp)
-        return self.simplify_types(result)
-
-    def check_party(self, module: str) -> Literal[0, 1, 2]:
-        """
-        Check source of module
-        0 = From stdlib
-        1 = From 3rd party package
-        2 = From the package being built
-        """
-        if module.startswith(".") or module.split('.')[0] == self.module.__name__.split('.')[0]:
-            return 2
-
-        try:
-            spec = importlib.util.find_spec(module)
-        except (ModuleNotFoundError, ValueError):
-            return 1
-
-        if spec:
-            if spec.origin and ("site-packages" in spec.origin or "dist-packages" in spec.origin):
-                return 1
-            else:
-                return 0
-        else:
-            return 1
-
-    def get(self) -> str:
-        """Generate the final stub output"""
-        s = ""
-        last_party = None
-
-        for module in sorted(self.imports, key=lambda i: str(self.check_party(i)) + i):
-            imports = self.imports[module]
-            items: List[str] = []
-            party = self.check_party(module)
-
-            if party != last_party:
-                if last_party is not None:
-                    s += "\n"
-                last_party = party
-
-            for (k, v1), v2 in imports.items():
-                if k is None:
-                    if v1 and v1 != module:
-                        s += f"import {module} as {v1}\n"
-                    elif v1 is None or (k, None) not in imports:
-                        s += f"import {module}\n"
-                else:
-                    if k != v2 or v1:
-                        items.append(f"{k} as {v2}")
-                    else:
-                        items.append(k)
-
-            items = sorted(items)
-            if items:
-                items_v0 = ", ".join(items)
-                items_v0 = f"from {module} import {items_v0}\n"
-                items_v1 = "(\n    " + ",\n    ".join(items) + "\n)"
-                items_v1 = f"from {module} import {items_v1}\n"
-                s += items_v0 if len(items_v0) <= 70 else items_v1
-
-        s += "\n\n"
-
-        # Append the main generated stub
-        s += self.output
-
-        return s.rstrip() + "\n"
-
-def parse_options(args: List[str]) -> argparse.Namespace:
-    parser = argparse.ArgumentParser(
-        prog="python -m nanobind.stubgen",
-        description="Generate stubs for nanobind-based extensions.",
-    )
-
-    parser.add_argument(
-        "-o",
-        "--output-file",
-        metavar="FILE",
-        dest="output_file",
-        default=None,
-        help="write generated stubs to the specified file",
-    )
-
-    parser.add_argument(
-        "-O",
-        "--output-dir",
-        metavar="PATH",
-        dest="output_dir",
-        default=None,
-        help="write generated stubs to the specified directory",
-    )
-
-    parser.add_argument(
-        "-i",
-        "--import",
-        action="append",
-        metavar="PATH",
-        dest="imports",
-        default=[],
-        help="add the directory to the Python import path (can specify multiple times)",
-    )
-
-    parser.add_argument(
-        "-m",
-        "--module",
-        action="append",
-        metavar="MODULE",
-        dest="modules",
-        default=[],
-        help="generate a stub for the specified module (can specify multiple times)",
-    )
-
-    parser.add_argument(
-        "-r",
-        "--recursive",
-        default=False,
-        action="store_true",
-        dest="recursive",
-        help="recursively process submodules",
-    )
-
-    parser.add_argument(
-        "-M",
-        "--marker-file",
-        metavar="FILE",
-        dest="marker_file",
-        default=None,
-        help="generate a marker file (usually named 'py.typed')",
-    )
-
-    parser.add_argument(
-        "-p",
-        "--pattern-file",
-        metavar="FILE",
-        dest="pattern_file",
-        default=None,
-        help="apply the given patterns to the generated stub (see the docs for syntax)",
-    )
-
-    parser.add_argument(
-        "-P",
-        "--include-private",
-        dest="include_private",
-        default=False,
-        action="store_true",
-        help="include private members (with single leading or trailing underscore)",
-    )
-
-    parser.add_argument(
-        "-D",
-        "--exclude-docstrings",
-        dest="include_docstrings",
-        default=True,
-        action="store_false",
-        help="exclude docstrings from the generated stub",
-    )
-
-    parser.add_argument(
-        "-q",
-        "--quiet",
-        default=False,
-        action="store_true",
-        help="do not generate any output in the absence of failures",
-    )
-
-    opt = parser.parse_args(args)
-    if len(opt.modules) == 0:
-        parser.error("At least one module must be specified.")
-    if len(opt.modules) > 1 and opt.output_file:
-        parser.error(
-            "The -o option can only be specified when a single module is being processed."
-        )
-    if opt.recursive and opt.output_file:
-        parser.error(
-            "The -o option is not compatible with recursive stub generation (-r)."
-        )
-    return opt
-
-
-def load_pattern_file(fname: str) -> List[ReplacePattern]:
-    """
-    Load a pattern file from disk and return a list of pattern instances that
-    includes precompiled versions of all of the contained regular expressions.
-    """
-
-    with open(fname, "r", encoding='utf-8') as f:
-        f_lines = f.readlines()
-
-    patterns: List[ReplacePattern] = []
-
-    def add_pattern(query: str, lines: List[str]):
-        # Exactly 1 empty line at the end
-        while lines and (lines[-1].isspace() or len(lines[-1]) == 0):
-            lines.pop()
-        lines.append("")
-
-        # Identify deletions (replacement by only whitespace)
-        if all((p.isspace() or len(p) == 0 for p in lines)):
-            lines = []
-        patterns.append(ReplacePattern(re.compile(query[:-1]), lines, 0))
-
-    lines: List[str]
-    lines, query, dedent = [], None, 0
-    for i, line in enumerate(f_lines):
-        line = line.rstrip()
-
-        if line.startswith("#"):
-            continue
-
-        if len(line) == 0 or line[0].isspace():
-            if not lines:
-                stripped = line.lstrip()
-                dedent = len(line) - len(stripped)
-                lines.append(stripped)
-            else:
-                s1, s2 = line.lstrip(), line[dedent:]
-                lines.append(s2 if len(s2) > len(s1) else s1)
-        else:
-            if not line.endswith(":"):
-                raise Exception(f'Cannot parse line {i+1} of pattern file "{fname}"')
-
-            if query:
-                add_pattern(query, lines)
-            query = line
-            lines = []
-
-    if query:
-        add_pattern(query, lines)
-
-    return patterns
-
-
-def main(args: Optional[List[str]] = None) -> None:
-    import sys
-
-    # Ensure that the current directory is on the path
-    if "" not in sys.path and "." not in sys.path:
-        sys.path.insert(0, "")
-
-    opt = parse_options(sys.argv[1:] if args is None else args)
-
-    patterns: List[ReplacePattern]
-    if opt.pattern_file:
-        if not opt.quiet:
-            print('Using pattern file "%s" ..' % opt.pattern_file)
-        patterns = load_pattern_file(opt.pattern_file)
-        if not opt.quiet:
-            print("  - loaded %i patterns.\n" % len(patterns))
-    else:
-        patterns = []
-
-    for i in opt.imports:
-        sys.path.insert(0, i)
-
-    for i, mod in enumerate(opt.modules):
-        if not opt.quiet:
-            if i > 0:
-                print("\n")
-            print('Module "%s" ..' % mod)
-            print("  - importing ..")
-        mod_imported = importlib.import_module(mod)
-
-        if opt.output_file:
-            file = Path(opt.output_file)
-        else:
-            file_s = getattr(mod_imported, "__file__", None)
-            if file_s is None:
-                raise Exception(
-                    'the module lacks a "__file__" attribute, hence '
-                    "stubgen cannot infer where to place the generated "
-                    "stub. You must specify the -o parameter to provide "
-                    "the name of an output file."
-                )
-            file = Path(str(file_s))
-
-            ext_loader = importlib.machinery.ExtensionFileLoader
-            if isinstance(mod_imported.__loader__, ext_loader):
-                # Splitting on "." (module nesting qualifier) handles the case
-                # of invoking stubgen on a module that's not in the current
-                # working directory - in that case, we still only want the Python
-                # module name as the stub file name, not the whole source tree
-                # hierarchy.
-                modname = mod_imported.__name__.split(".")[-1]
-                file = file.with_name(modname)
-            file = file.with_suffix(".pyi")
-
-            if opt.output_dir:
-                file = Path(opt.output_dir, file.name)
-
-        file.parents[0].mkdir(parents=True, exist_ok=True)
-
-        sg = StubGen(
-            module=mod_imported,
-            quiet=opt.quiet,
-            recursive=opt.recursive,
-            include_docstrings=opt.include_docstrings,
-            include_private=opt.include_private,
-            patterns=patterns,
-            output_file=file
-        )
-
-        if not opt.quiet:
-            print("  - analyzing ..")
-
-        sg.put(mod_imported)
-
-        if patterns:
-            total_matches = 0
-            for p in patterns:
-                if p.matches != 0:
-                    total_matches += p.matches
-                    continue
-                rule_str = str(p.query)
-                if "re.compile" in rule_str:
-                    rule_str = rule_str.replace("re.compile(", "")[:-1]
-                if not opt.quiet:
-                    print(f"  - warning: rule {rule_str} did not match any elements.")
-            if not opt.quiet:
-                print(f"  - applied {total_matches} patterns.")
-
-        if not opt.quiet:
-            print(f'  - writing stub "{file}" ..')
-
-        with open(file, "w", encoding='utf-8') as f:
-            f.write(sg.get())
-
-    if opt.marker_file:
-        if not opt.quiet:
-            print(f'  - writing marker file "{opt.marker_file}" ..')
-        Path(opt.marker_file).touch()
-
-
-if __name__ == "__main__":
-    main()
diff --git a/src/nanobind/src/trampoline.cpp b/src/nanobind/src/trampoline.cpp
deleted file mode 100644
index 9671efd..0000000
--- a/src/nanobind/src/trampoline.cpp
+++ /dev/null
@@ -1,188 +0,0 @@
-/*
-    src/trampoline.cpp: support for overriding virtual functions in Python
-
-    Copyright (c) 2022 Wenzel Jakob
-
-    All rights reserved. Use of this source code is governed by a
-    BSD-style license that can be found in the LICENSE file.
-*/
-
-#include <nanobind/trampoline.h>
-#include "nb_internals.h"
-
-NAMESPACE_BEGIN(NB_NAMESPACE)
-NAMESPACE_BEGIN(detail)
-
-void trampoline_new(void **data, size_t size, void *ptr) noexcept {
-    // GIL is held when the trampoline constructor runs. Lock the
-    // associated instance shard in GIL-less Python.
-
-    nb_shard &shard = internals->shard(ptr);
-    lock_shard lock(shard);
-
-    nb_ptr_map &inst_c2p = shard.inst_c2p;
-    nb_ptr_map::iterator it = inst_c2p.find(ptr);
-    check(it != inst_c2p.end() && (((uintptr_t) it->second) & 1) == 0,
-          "nanobind::detail::trampoline_new(): unique instance not found!");
-
-    data[0] = it->second;
-    memset(data + 1, 0, sizeof(void *) * 2 * size);
-}
-
-void trampoline_release(void **data, size_t size) noexcept {
-    // GIL is held when the trampoline destructor runs
-    for (size_t i = 0; i < size; ++i)
-        Py_XDECREF((PyObject *) data[i*2 + 2]);
-}
-
-static void trampoline_enter_internal(void **data, size_t size,
-                                      const char *name, bool pure, ticket *t) {
-    const PyObject *None = Py_None;
-    PyGILState_STATE state{ };
-    const char *error = nullptr;
-    PyObject *key = nullptr, *value = nullptr;
-    PyObject *self = (PyObject *) data[0];
-    PyTypeObject *value_tp = nullptr;
-    size_t offset = 0;
-
-    // First, perform a quick sweep without lock
-    for (size_t i = 0; i < size; i++) {
-        void *d_name  = data[2*i + 1],
-             *d_value = data[2*i + 2];
-        if (name == d_name && d_value) {
-            if (d_value != None) {
-                t->state = PyGILState_Ensure();
-                t->key = (PyObject *) d_value;
-                return;
-            } else {
-                if (pure) {
-                    error = "tried to call a pure virtual function";
-                    break;
-                } else {
-                    return;
-                }
-            }
-        }
-    }
-
-    // Nothing found -- retry, now with lock held
-    state = PyGILState_Ensure();
-    ft_object_guard guard(self);
-
-    if (error)
-        goto fail;
-
-    for (size_t i = 0; i < size; i++) {
-        void *d_name  = data[2*i + 1],
-             *d_value = data[2*i + 2];
-        if (name == d_name && d_value) {
-            if (d_value != None) {
-                t->state = state;
-                t->key = (PyObject *) d_value;
-                return;
-            } else {
-                if (pure) {
-                    error = "tried to call a pure virtual function";
-                    goto fail;
-                } else {
-                    PyGILState_Release(state);
-                    return;
-                }
-            }
-        }
-    }
-
-    // Sill no luck -- perform a lookup and populate the trampoline
-    for (; offset < size; offset++) {
-        if (data[2 * offset + 1] == nullptr &&
-            data[2 * offset + 2] == nullptr)
-            break;
-    }
-
-    if (offset == size) {
-        error = "the trampoline ran out of slots (you will need to increase "
-                "the value provided to the NB_TRAMPOLINE() macro)";
-        goto fail;
-    }
-
-    key = PyUnicode_InternFromString(name);
-    if (!key) {
-        error = "could not intern string";
-        goto fail;
-    }
-
-    value = PyObject_GetAttr(self, key);
-    if (!value) {
-        error = "lookup failed";
-        goto fail;
-    }
-
-    value_tp = Py_TYPE(value);
-    Py_CLEAR(value);
-
-    if (value_tp == internals->nb_func || value_tp == internals->nb_method ||
-        value_tp == internals->nb_bound_method) {
-        Py_DECREF(key);
-
-        if (pure) {
-            error = "tried to call a pure virtual function";
-            goto fail;
-        }
-
-        Py_INCREF(Py_None);
-        key = Py_None;
-    }
-
-    data[2 * offset + 1] = (void *) name;
-    data[2 * offset + 2] = key;
-
-    if (key != None) {
-        t->state = state;
-        t->key = key;
-        return;
-    } else {
-        PyGILState_Release(state);
-        return;
-    }
-
-fail:
-    type_data *td = nb_type_data(Py_TYPE(self));
-    PyGILState_Release(state);
-
-    raise("nanobind::detail::get_trampoline('%s::%s()'): %s!",
-          td->name, name, error);
-}
-
-static NB_THREAD_LOCAL ticket *current_ticket = nullptr;
-
-void trampoline_enter(void **data, size_t size, const char *name, bool pure, ticket *t) {
-    trampoline_enter_internal(data, size, name, pure, t);
-
-    if (t->key) {
-        t->self = (PyObject *) data[0];
-        t->prev = current_ticket;
-
-        if (t->prev && t->prev->self.is(t->self) && t->prev->key.is(t->key)) {
-            t->self = handle();
-            t->key = handle();
-            t->prev = nullptr;
-            PyGILState_Release(t->state);
-            if (pure)
-                raise("nanobind::detail::get_trampoline('%s()'): tried to call "
-                      "a pure virtual function!", name);
-            return;
-        }
-
-        current_ticket = t;
-    }
-}
-
-void trampoline_leave(ticket *t) noexcept {
-    if (!t->key)
-        return;
-    current_ticket = t->prev;
-    PyGILState_Release(t->state);
-}
-
-NAMESPACE_END(detail)
-NAMESPACE_END(NB_NAMESPACE)
diff --git a/src/nanobind/src/version.py b/src/nanobind/src/version.py
deleted file mode 100644
index 55e1895..0000000
--- a/src/nanobind/src/version.py
+++ /dev/null
@@ -1,110 +0,0 @@
-#!/usr/bin/env python3
-
-# With no command line flag, this prints the nanobind version.
-# With flags -w semver, this writes the new version to where it's needed.
-
-import os
-import re
-import sys
-
-# Parse the header file <nanobind/nanobind.h> and print the version.
-def get_version(root):
-    major = ''
-    minor = ''
-    patch = ''
-    dev = ''
-    with open(os.path.join(root, "include/nanobind/nanobind.h"), 'r') as f:
-        for line in f:
-            if m := re.match(r'#define NB_VERSION_(.+)', line):
-                if m_major := re.match(r'MAJOR\s+([0-9]+)', m.group(1)):
-                    major = m_major.group(1)
-                if m_minor := re.match(r'MINOR\s+([0-9]+)', m.group(1)):
-                    minor = m_minor.group(1)
-                if m_patch := re.match(r'PATCH\s+([0-9]+)', m.group(1)):
-                    patch = m_patch.group(1)
-                if m_dev := re.match(r'DEV\s+([0-9]+)', m.group(1)):
-                    dev = m_dev.group(1)
-
-    version_core = '.'.join([major, minor, patch])
-    if int(dev) > 0:
-        print(version_core, '-dev', dev, sep='')
-    else:
-        print(version_core)
-
-# Write the semantic version to nanobind.h, pyproject.toml, and __init__.py.
-# The semver string must be either 'X.Y.Z' or 'X.Y.Z-devN', where X, Y, Z are
-# non-negative integers and N is a positive integer.
-def write_version(root, semver):
-    major = 0
-    minor = 0
-    patch = 0
-    dev = 0
-    try:
-        beginning, middle, end = semver.split('.', maxsplit=2)
-        major = int(beginning)
-        minor = int(middle)
-        if m := re.match(r'([0-9]+)-dev([1-9][0-9]*)', end):
-            patch = int(m.group(1))
-            dev = int(m.group(2))
-        else:
-            patch = int(end)
-    except:
-        print("Invalid version: '", semver, "'", sep='', file=sys.stderr)
-        print("Valid examples: '1.2.3' or '1.2.3-dev4'", file=sys.stderr)
-        return
-
-    # Write to nanobind.h
-    with open(os.path.join(root, "include/nanobind/nanobind.h"), "r+") as f:
-        contents = f.read()
-        contents = re.sub(r'#define NB_VERSION_MAJOR\s+[0-9]+',
-                          r'#define NB_VERSION_MAJOR ' + str(major),
-                          contents, count=1)
-        contents = re.sub(r'#define NB_VERSION_MINOR\s+[0-9]+',
-                          r'#define NB_VERSION_MINOR ' + str(minor),
-                          contents, count=1)
-        contents = re.sub(r'#define NB_VERSION_PATCH\s+[0-9]+',
-                          r'#define NB_VERSION_PATCH ' + str(patch),
-                          contents, count=1)
-        contents = re.sub(r'#define NB_VERSION_DEV\s+[0-9]+',
-                          r'#define NB_VERSION_DEV   ' + str(dev),
-                          contents, count=1)
-        f.seek(0)
-        f.truncate()
-        f.write(contents)
-
-    # Write to pyproject.toml
-    with open(os.path.join(root, "pyproject.toml"), "r+") as f:
-        contents = f.read()
-        contents = re.sub(r'version\s+=\s+"[^"]+"',
-                          r'version = "' + semver + '"',
-                          contents, count=1)
-        f.seek(0)
-        f.truncate()
-        f.write(contents)
-
-    # Write to __init__.py
-    with open(os.path.join(root, "src/__init__.py"), "r+") as f:
-        contents = f.read()
-        contents = re.sub(r'__version__\s+=\s+"[^"]+"',
-                          r'__version__ = "' + semver + '"',
-                          contents, count=1)
-        f.seek(0)
-        f.truncate()
-        f.write(contents)
-
-
-def main():
-    root = os.path.dirname(os.path.dirname(os.path.realpath(__file__)))
-    if len(sys.argv) == 1:
-        get_version(root)
-    elif len(sys.argv) == 3 and sys.argv[1] == '-w':
-        write_version(root, sys.argv[2])
-    else:
-        print("Usage: ", sys.argv[0], file=sys.stderr)
-        print("   or: ", sys.argv[0], "-w X.Y.Z", file=sys.stderr)
-        print("   or: ", sys.argv[0], "-w X.Y.Z-devN", file=sys.stderr)
-
-
-if __name__ == '__main__':
-    main()
-
diff --git a/src/nanobind/tests/CMakeLists.txt b/src/nanobind/tests/CMakeLists.txt
deleted file mode 100644
index 3bd5478..0000000
--- a/src/nanobind/tests/CMakeLists.txt
+++ /dev/null
@@ -1,209 +0,0 @@
-# If leaks are found, abort() during interpreter shutdown to catch this in the CI
-add_definitions(-DNB_ABORT_ON_LEAK)
-
-if (NB_TEST_STABLE_ABI)
-  set(NB_EXTRA_ARGS ${NB_EXTRA_ARGS} STABLE_ABI)
-endif()
-
-if (NB_TEST_FREE_THREADED)
-  set(NB_EXTRA_ARGS ${NB_EXTRA_ARGS} FREE_THREADED)
-endif()
-
-if (NB_TEST_SHARED_BUILD)
-  set(NB_EXTRA_ARGS ${NB_EXTRA_ARGS} NB_SHARED)
-endif()
-
-# ---------------------------------------------------------------------------
-# Compile with a few more compiler warnings turned on
-# ---------------------------------------------------------------------------
-
-if (MSVC)
-  if (CMAKE_CXX_FLAGS MATCHES "/W[0-4]")
-    string(REGEX REPLACE "/W[0-4]" "/W4" CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}")
-  elseif (NOT NB_TEST_CUDA)
-    add_compile_options(/W4)
-  endif()
-elseif (CMAKE_CXX_COMPILER_ID MATCHES "Clang|GNU")
-  add_compile_options(-Wall -Wextra -Wno-unused-local-typedefs)
-endif()
-
-if (UNIX AND (CMAKE_SIZEOF_VOID_P EQUAL 4) AND (CMAKE_SYSTEM_PROCESSOR STREQUAL i686))
-  # Don't use the legacy 387 math coprocessor in 32 bit builds, this causes tests to fail
-  add_compile_options(-mfpmath=sse -msse2)
-endif()
-
-# Enforce the use of the CUDA NVCC compiler if requested
-if (NB_TEST_CUDA)
-  enable_language(CUDA)
-  set(CMAKE_CUDA_STANDARD 17)
-  set(CMAKE_CUDA_STANDARD_REQUIRED ON)
-endif()
-
-set(NB_TEST_SANITIZER "")
-
-if (NB_TEST_SANITIZERS_ASAN)
-  list(APPEND NB_TEST_SANITIZERS address)
-endif()
-
-if (NB_TEST_SANITIZERS_UBSAN)
-  list(APPEND NB_TEST_SANITIZERS undefined)
-endif()
-
-if (NB_TEST_SANITIZERS_TSAN)
-  list(APPEND NB_TEST_SANITIZERS thread)
-endif()
-
-
-if (NB_TEST_SANITIZERS)
-  string(REPLACE ";" "," NB_TEST_SANITIZERS "${NB_TEST_SANITIZERS}")
-  add_compile_options(-fsanitize=${NB_TEST_SANITIZERS})
-  add_link_options(-fsanitize=${NB_TEST_SANITIZERS})
-endif()
-
-set(TEST_NAMES
-  functions
-  callbacks
-  classes
-  holders
-  stl
-  stl_bind_map
-  stl_bind_vector
-  chrono
-  enum
-  eval
-  ndarray
-  jax
-  tensorflow
-  exception
-  make_iterator
-  typing
-  issue
-  intrusive
-  thread
-)
-
-foreach (NAME ${TEST_NAMES})
-  nanobind_add_module(test_${NAME}_ext test_${NAME}.cpp ${NB_EXTRA_ARGS})
-
-  if (NB_TEST_CUDA)
-    set_property(SOURCE test_${NAME}.cpp PROPERTY LANGUAGE CUDA)
-  endif()
-endforeach()
-
-target_sources(test_intrusive_ext PRIVATE test_intrusive_impl.cpp)
-
-if (CMAKE_CONFIGURATION_TYPES)
-  set(OUT_DIR ${CMAKE_CURRENT_BINARY_DIR}/$<CONFIG>)
-else()
-  set(OUT_DIR ${CMAKE_CURRENT_BINARY_DIR})
-endif()
-
-foreach (NAME functions classes ndarray jax tensorflow stl enum typing make_iterator)
-  if (NAME STREQUAL typing)
-    set(EXTRA
-      MARKER_FILE py.typed
-      PATTERN_FILE "${CMAKE_CURRENT_SOURCE_DIR}/pattern_file.nb"
-    )
-    set(EXTRA_DEPENDS "${OUT_DIR}/py_stub_test.py")
-  else()
-    set(EXTRA "")
-    set(EXTRA_DEPENDS "")
-  endif()
-
-  if (CMAKE_CONFIGURATION_TYPES)
-    # On multi-config generators like Visual Studio, put stubs in the 'Debug' / 'Release' /.. folders
-    set(PYI_PREFIX $<CONFIG>/)
-  endif()
-
-  nanobind_add_stub(
-    ${NAME}_ext_stub
-    MODULE test_${NAME}_ext
-    OUTPUT ${PYI_PREFIX}test_${NAME}_ext.pyi
-    PYTHON_PATH $<TARGET_FILE_DIR:test_${NAME}_ext>
-    DEPENDS test_${NAME}_ext ${EXTRA_DEPENDS}
-    ${EXTRA})
-endforeach()
-
-find_package (Eigen3 3.3.1 NO_MODULE)
-if (TARGET Eigen3::Eigen)
-  nanobind_add_module(test_eigen_ext test_eigen.cpp ${NB_EXTRA_ARGS})
-  target_link_libraries(test_eigen_ext PRIVATE Eigen3::Eigen)
-endif()
-
-add_library(
-  inter_module
-  SHARED
-  inter_module.h
-  inter_module.cpp
-)
-
-target_compile_definitions(inter_module PRIVATE -DSHARED_BUILD)
-target_compile_features(inter_module PRIVATE cxx_std_17)
-target_include_directories(inter_module PRIVATE ${NB_DIR}/include)
-
-nanobind_add_module(test_inter_module_1_ext NB_DOMAIN mydomain test_inter_module_1.cpp ${NB_EXTRA_ARGS})
-nanobind_add_module(test_inter_module_2_ext NB_DOMAIN mydomain test_inter_module_2.cpp ${NB_EXTRA_ARGS})
-target_link_libraries(test_inter_module_1_ext PRIVATE inter_module)
-target_link_libraries(test_inter_module_2_ext PRIVATE inter_module)
-
-set(TEST_FILES
-  common.py
-  conftest.py
-  test_callbacks.py
-  test_classes.py
-  test_eigen.py
-  test_enum.py
-  test_eval.py
-  test_exception.py
-  test_functions.py
-  test_holders.py
-  test_inter_module.py
-  test_intrusive.py
-  test_make_iterator.py
-  test_stl.py
-  test_stl_bind_map.py
-  test_stl_bind_vector.py
-  test_chrono.py
-  test_ndarray.py
-  test_jax.py
-  test_tensorflow.py
-  test_stubs.py
-  test_typing.py
-  test_thread.py
-
-  # Stub reference files
-  test_classes_ext.pyi.ref
-  test_functions_ext.pyi.ref
-  test_make_iterator_ext.pyi.ref
-  test_ndarray_ext.pyi.ref
-  test_jax_ext.pyi.ref
-  test_tensorflow_ext.pyi.ref
-  test_stl_ext.pyi.ref
-  test_enum_ext.pyi.ref
-  test_typing_ext.pyi.ref
-  py_stub_test.py
-  py_stub_test.pyi.ref
-)
-
-set (PY_STUB_TEST py_stub_test.py)
-if (NOT (CMAKE_CURRENT_SOURCE_DIR STREQUAL CMAKE_CURRENT_BINARY_DIR) OR MSVC)
-  foreach(TEST_FILE IN LISTS TEST_FILES)
-    set(IN_FILE ${CMAKE_CURRENT_SOURCE_DIR}/${TEST_FILE})
-    set(OUT_FILE ${OUT_DIR}/${TEST_FILE})
-    set(TEST_FILES_OUT ${TEST_FILES_OUT} ${OUT_FILE})
-    add_custom_command(
-      DEPENDS ${IN_FILE} OUTPUT ${OUT_FILE}
-      COMMAND ${CMAKE_COMMAND} -E copy_if_different ${IN_FILE} ${OUT_DIR})
-  endforeach()
-
-  add_custom_target(copy-tests ALL DEPENDS ${TEST_FILES_OUT})
-  set(PY_STUB_TEST ${OUT_DIR}/py_stub_test.py)
-endif()
-
-nanobind_add_stub(
-  py_stub
-  MODULE py_stub_test
-  OUTPUT ${PYI_PREFIX}py_stub_test.pyi
-  PYTHON_PATH $<TARGET_FILE_DIR:test_stl_ext>
-  DEPENDS ${PY_STUB_TEST}
-)
diff --git a/src/nanobind/tests/common.py b/src/nanobind/tests/common.py
deleted file mode 100644
index a38b9f8..0000000
--- a/src/nanobind/tests/common.py
+++ /dev/null
@@ -1,42 +0,0 @@
-import platform
-import gc
-import pytest
-import threading
-
-is_pypy = platform.python_implementation() == 'PyPy'
-is_darwin = platform.system() == 'Darwin'
-
-def collect() -> None:
-    if is_pypy:
-        for _ in range(3):
-            gc.collect()
-    else:
-        gc.collect()
-
-skip_on_pypy = pytest.mark.skipif(
-    is_pypy, reason="This test currently fails/crashes PyPy")
-
-xfail_on_pypy_darwin = pytest.mark.xfail(
-    is_pypy and is_darwin, reason="This test for some reason fails on PyPy/Darwin")
-
-
-# Helper function to parallelize execution of a function. We intentionally
-# don't use the Python threads pools here to have threads shut down / start
-# between test cases.
-def parallelize(func, n_threads):
-    barrier = threading.Barrier(n_threads)
-    result = [None]*n_threads
-
-    def wrapper(i):
-        barrier.wait()
-        result[i] = func()
-
-    workers = []
-    for i in range(n_threads):
-        t = threading.Thread(target=wrapper, args=(i,))
-        t.start()
-        workers.append(t)
-
-    for worker in workers:
-        worker.join()
-    return result
\ No newline at end of file
diff --git a/src/nanobind/tests/conftest.py b/src/nanobind/tests/conftest.py
deleted file mode 100644
index a4e9ccf..0000000
--- a/src/nanobind/tests/conftest.py
+++ /dev/null
@@ -1,6 +0,0 @@
-def pytest_addoption(parser):
-    parser.addoption('--enable-slow-tests',
-                     action='store_true',
-                     dest="enable-slow-tests",
-                     default=False,
-                     help="enable longrundecorated tests")
diff --git a/src/nanobind/tests/inter_module.cpp b/src/nanobind/tests/inter_module.cpp
deleted file mode 100644
index 20a1c68..0000000
--- a/src/nanobind/tests/inter_module.cpp
+++ /dev/null
@@ -1,9 +0,0 @@
-#include "inter_module.h"
-
-Shared create_shared() {
-    return { 123 };
-}
-
-bool check_shared(const Shared &shared) {
-    return shared.value == 123;
-}
diff --git a/src/nanobind/tests/inter_module.h b/src/nanobind/tests/inter_module.h
deleted file mode 100644
index c78498a..0000000
--- a/src/nanobind/tests/inter_module.h
+++ /dev/null
@@ -1,14 +0,0 @@
-#include <nanobind/nb_defs.h>
-
-#if defined(SHARED_BUILD)
-#  define EXPORT_SHARED NB_EXPORT
-#else
-#  define EXPORT_SHARED NB_IMPORT
-#endif
-
-struct EXPORT_SHARED Shared {
-    int value;
-};
-
-extern EXPORT_SHARED Shared create_shared();
-extern EXPORT_SHARED bool check_shared(const Shared &shared);
diff --git a/src/nanobind/tests/object_py.h b/src/nanobind/tests/object_py.h
deleted file mode 100644
index f1e027c..0000000
--- a/src/nanobind/tests/object_py.h
+++ /dev/null
@@ -1,28 +0,0 @@
-#include <nanobind/nanobind.h>
-
-NAMESPACE_BEGIN(nanobind)
-NAMESPACE_BEGIN(detail)
-
-template <typename T> struct type_caster<ref<T>> {
-    using Caster = make_caster<T>;
-    static constexpr bool IsClass = true;
-    NB_TYPE_CASTER(ref<T>, Caster::Name)
-
-    bool from_python(handle src, uint8_t flags,
-                     cleanup_list *cleanup) noexcept {
-        Caster caster;
-        if (!caster.from_python(src, flags, cleanup))
-            return false;
-
-        value = Value(caster.operator T *());
-        return true;
-    }
-
-    static handle from_cpp(const ref<T> &value, rv_policy policy,
-                           cleanup_list *cleanup) noexcept {
-        return Caster::from_cpp(value.get(), policy, cleanup);
-    }
-};
-
-NAMESPACE_END(detail)
-NAMESPACE_END(nanobind)
diff --git a/src/nanobind/tests/pattern_file.nb b/src/nanobind/tests/pattern_file.nb
deleted file mode 100644
index 8b9939f..0000000
--- a/src/nanobind/tests/pattern_file.nb
+++ /dev/null
@@ -1,19 +0,0 @@
-# This is a pattern file used to rewrite generated stubs
-
-# Remove an entry
-remove_me:
-
-# Change a function signature, keep the documentation
-tweak_me:
-    def tweak_me(arg: int):
-        \doc
-
-# Apply a pattern to multiple places
-__(lt|gt)__:
-    def __\1__(self, arg: int, /) -> bool: ...
-
-test_typing_ext.__prefix__:
-    # a prefix
-
-test_typing_ext.__suffix__:
-    # a suffix
diff --git a/src/nanobind/tests/py_stub_test.py b/src/nanobind/tests/py_stub_test.py
deleted file mode 100644
index c0251ba..0000000
--- a/src/nanobind/tests/py_stub_test.py
+++ /dev/null
@@ -1,68 +0,0 @@
-import sys
-
-if sys.version_info < (3, 11, 0):
-    # Work around limitations in typing.overload in Python<3.11
-    import typing_extensions as typing
-else:
-    import typing
-
-# Ignore a type and a function from elsewhere. These shouldn't be included in
-# the stub by default
-from os import PathLike, getcwd
-
-del sys
-
-C = 123
-T = typing.TypeVar("T")
-
-def f1(a, b, c, /):
-    """docstring"""
-
-def f2(a=(3,(4,5)), /, b=(1,2), *, c=4):
-    """docstring 2"""
-
-def f3(*args, **kwargs):
-    pass
-
-def f4() -> typing.Callable[[T], T]:
-    return lambda x: x
-
-class AClass:
-    STATIC_VAR: int = 5
-
-    class NestedClass:
-        pass
-
-    def __init__(self, x):
-        pass
-
-    def method(self, x: str):
-        pass
-
-    @staticmethod
-    def static_method(x):
-        pass
-
-    @classmethod
-    def class_method(cls, x):
-        pass
-
-    @typing.overload
-    def overloaded(self, x: int) -> None:
-        """docstr 1"""
-
-    @typing.overload
-    def overloaded(self, x: str) -> None:
-        """docstr 2"""
-
-    def overloaded(self, x):
-        pass
-
-    @typing.overload
-    def overloaded_2(self, x: int) -> None: ...
-
-    @typing.overload
-    def overloaded_2(self, x: str) -> None: ...
-
-    def overloaded_2(self, x):
-        "docstr 3"
diff --git a/src/nanobind/tests/py_stub_test.pyi.ref b/src/nanobind/tests/py_stub_test.pyi.ref
deleted file mode 100644
index a520499..0000000
--- a/src/nanobind/tests/py_stub_test.pyi.ref
+++ /dev/null
@@ -1,48 +0,0 @@
-from collections.abc import Callable
-from typing import TypeVar, overload
-
-
-C: int = 123
-
-T = TypeVar("T")
-
-def f1(a, b, c, /):
-    """docstring"""
-
-def f2(a=(3, (4, 5)), /, b=(1, 2), *, c=4):
-    """docstring 2"""
-
-def f3(*args, **kwargs): ...
-
-def f4() -> Callable[[T], T]: ...
-
-class AClass:
-    STATIC_VAR: int = 5
-
-    class NestedClass:
-        pass
-
-    def __init__(self, x): ...
-
-    def method(self, x: str): ...
-
-    @staticmethod
-    def static_method(x): ...
-
-    @classmethod
-    def class_method(cls, x): ...
-
-    @overload
-    def overloaded(self, x: int) -> None:
-        """docstr 1"""
-
-    @overload
-    def overloaded(self, x: str) -> None:
-        """docstr 2"""
-
-    @overload
-    def overloaded_2(self, x: int) -> None:
-        """docstr 3"""
-
-    @overload
-    def overloaded_2(self, x: str) -> None: ...
diff --git a/src/nanobind/tests/test_callbacks.cpp b/src/nanobind/tests/test_callbacks.cpp
deleted file mode 100644
index f178bae..0000000
--- a/src/nanobind/tests/test_callbacks.cpp
+++ /dev/null
@@ -1,137 +0,0 @@
-// This is an example of using nb::call_policy to support binding an
-// object that takes non-owning callbacks. Since the callbacks can't
-// directly keep a Python object alive (they're trivially copyable), we
-// maintain a sideband structure to manage the lifetimes.
-
-#include <algorithm>
-#include <unordered_set>
-#include <vector>
-
-#include <nanobind/nanobind.h>
-#include <nanobind/stl/unordered_set.h>
-
-namespace nb = nanobind;
-
-// The callback type accepted by the object, which we assume we can't change.
-// It's trivially copyable, so it can't directly keep a Python object alive.
-struct callback {
-    void *context;
-    void (*func)(void *context, int arg);
-
-    void operator()(int arg) const { (*func)(context, arg); }
-    bool operator==(const callback& other) const {
-        return context == other.context && func == other.func;
-    }
-};
-
-// An object that uses these callbacks, which we want to write bindings for
-class publisher {
-  public:
-    void subscribe(callback cb) { cbs.push_back(cb); }
-    void unsubscribe(callback cb) {
-        cbs.erase(std::remove(cbs.begin(), cbs.end(), cb), cbs.end());
-    }
-    void emit(int arg) const { for (auto cb : cbs) cb(arg); }
-  private:
-    std::vector<callback> cbs;
-};
-
-template <> struct nanobind::detail::type_caster<callback> {
-    static void wrap_call(void *context, int arg) {
-        borrow<callable>((PyObject *) context)(arg);
-    }
-    bool from_python(handle src, uint8_t, cleanup_list*) noexcept {
-        if (!isinstance<callable>(src)) return false;
-        value = {(void *) src.ptr(), &wrap_call};
-        return true;
-    }
-    static handle from_cpp(callback cb, rv_policy policy, cleanup_list*) noexcept {
-        if (cb.func == &wrap_call)
-            return handle((PyObject *) cb.context).inc_ref();
-        if (policy == rv_policy::none)
-            return handle();
-        return cpp_function(cb, policy).release();
-    }
-    NB_TYPE_CASTER(callback, const_name("Callable[[int], None]"))
-};
-
-nb::dict cb_registry() {
-    return nb::cast<nb::dict>(
-            nb::module_::import_("test_callbacks_ext").attr("registry"));
-}
-
-struct callback_data {
-    struct py_hash {
-        size_t operator()(const nb::object& obj) const { return nb::hash(obj); }
-    };
-    struct py_eq {
-        bool operator()(const nb::object& a, const nb::object& b) const {
-            return a.equal(b);
-        }
-    };
-    std::unordered_set<nb::object, py_hash, py_eq> subscribers;
-};
-
-callback_data& callbacks_for(nb::handle publisher) {
-    auto registry = cb_registry();
-    nb::weakref key(publisher, registry.attr("__delitem__"));
-    if (nb::handle value = PyDict_GetItem(registry.ptr(), key.ptr())) {
-        return nb::cast<callback_data&>(value);
-    }
-    nb::object new_data = nb::cast(callback_data{});
-    registry[key] = new_data;
-    return nb::cast<callback_data&>(new_data);
-}
-
-struct cb_policy_common {
-    using TwoArgs = std::integral_constant<size_t, 2>;
-    static void precall(PyObject **args, TwoArgs,
-                        nb::detail::cleanup_list *cleanup) {
-        nb::handle self = args[0], cb = args[1];
-        auto& cbs = callbacks_for(self);
-        auto it = cbs.subscribers.find(nb::borrow(cb));
-        if (it != cbs.subscribers.end() && !it->is(cb)) {
-            // A callback is already subscribed that is
-            // equal-but-not-identical to the one passed in.
-            // Adjust args to refer to that one, to work around
-            // the fact that the C++ object does not understand py-equality.
-            args[1] = it->ptr();
-
-            // This ensures that the normalized callback won't be
-            // immediately destroyed if it's removed from the registry
-            // in the unsubscribe postcall hook. Such destruction could
-            // result in a use-after-free if you have other postcall hooks
-            // or keep_alives that try to inspect the function args.
-            // It's not strictly necessary if each arg is inspected by
-            // only one call policy or keep_alive.
-            cleanup->append(it->inc_ref().ptr());
-        }
-    }
-};
-
-struct subscribe_policy : cb_policy_common {
-    static void postcall(PyObject **args, TwoArgs, nb::handle) {
-        nb::handle self = args[0], cb = args[1];
-        callbacks_for(self).subscribers.insert(nb::borrow(cb));
-    }
-};
-
-struct unsubscribe_policy : cb_policy_common {
-    static void postcall(PyObject **args, TwoArgs, nb::handle) {
-        nb::handle self = args[0], cb = args[1];
-        callbacks_for(self).subscribers.erase(nb::borrow(cb));
-    }
-};
-
-NB_MODULE(test_callbacks_ext, m) {
-    m.attr("registry") = nb::dict();
-    nb::class_<callback_data>(m, "callback_data")
-        .def_ro("subscribers", &callback_data::subscribers);
-    nb::class_<publisher>(m, "publisher", nb::is_weak_referenceable())
-        .def(nb::init<>())
-        .def("subscribe", &publisher::subscribe,
-             nb::call_policy<subscribe_policy>())
-        .def("unsubscribe", &publisher::unsubscribe,
-             nb::call_policy<unsubscribe_policy>())
-        .def("emit", &publisher::emit);
-}
diff --git a/src/nanobind/tests/test_callbacks.py b/src/nanobind/tests/test_callbacks.py
deleted file mode 100644
index 5f6796c..0000000
--- a/src/nanobind/tests/test_callbacks.py
+++ /dev/null
@@ -1,58 +0,0 @@
-import test_callbacks_ext as t
-import gc
-
-
-def test_callbacks():
-    pub1 = t.publisher()
-    pub2 = t.publisher()
-    record = []
-
-    def sub1(x):
-        record.append(x + 10)
-
-    def sub2(x):
-        record.append(x + 20)
-
-    pub1.subscribe(sub1)
-    pub2.subscribe(sub2)
-    for pub in (pub1, pub2):
-        pub.subscribe(record.append)
-
-    pub1.emit(1)
-    assert record == [11, 1]
-    del record[:]
-
-    pub2.emit(2)
-    assert record == [22, 2]
-    del record[:]
-
-    pub1_w, pub2_w = t.registry.keys()  # weakrefs to pub1, pub2
-    assert pub1_w() is pub1
-    assert pub2_w() is pub2
-    assert t.registry[pub1_w].subscribers == {sub1, record.append}
-    assert t.registry[pub2_w].subscribers == {sub2, record.append}
-
-    # NB: this `record.append` is a different object than the one we subscribed
-    # above, so we're testing the normalization logic in unsubscribe_policy
-    pub1.unsubscribe(record.append)
-    assert t.registry[pub1_w].subscribers == {sub1}
-    pub1.emit(3)
-    assert record == [13]
-    del record[:]
-
-    del pub, pub1
-    gc.collect()
-    gc.collect()
-    assert pub1_w() is None
-    assert pub2_w() is pub2
-    assert t.registry.keys() == {pub2_w}
-
-    pub2.emit(4)
-    assert record == [24, 4]
-    del record[:]
-
-    del pub2
-    gc.collect()
-    gc.collect()
-    assert pub2_w() is None
-    assert not t.registry
diff --git a/src/nanobind/tests/test_chrono.cpp b/src/nanobind/tests/test_chrono.cpp
deleted file mode 100644
index d1ff68a..0000000
--- a/src/nanobind/tests/test_chrono.cpp
+++ /dev/null
@@ -1,93 +0,0 @@
-/*
-    tests/test_chrono.cpp -- test conversions to/from std::chrono types
-    Ported from pybind11/tests/test_chrono.cpp
-
-    Copyright (c) 2016 Trent Houliston <trent@houliston.me> and
-                       Wenzel Jakob <wenzel.jakob@epfl.ch>
-
-    All rights reserved. Use of this source code is governed by a
-    BSD-style license that can be found in the LICENSE file.
-*/
-
-#include <nanobind/stl/chrono.h>
-
-struct different_resolutions {
-    using time_point_h = std::chrono::time_point<std::chrono::system_clock,
-                                                 std::chrono::hours>;
-    using time_point_m = std::chrono::time_point<std::chrono::system_clock,
-                                                 std::chrono::minutes>;
-    using time_point_s = std::chrono::time_point<std::chrono::system_clock,
-                                                 std::chrono::seconds>;
-    using time_point_ms = std::chrono::time_point<std::chrono::system_clock,
-                                                  std::chrono::milliseconds>;
-    using time_point_us = std::chrono::time_point<std::chrono::system_clock,
-                                                  std::chrono::microseconds>;
-    time_point_h timestamp_h;
-    time_point_m timestamp_m;
-    time_point_s timestamp_s;
-    time_point_ms timestamp_ms;
-    time_point_us timestamp_us;
-};
-
-NB_MODULE(test_chrono_ext, m) {
-    using system_time = std::chrono::system_clock::time_point;
-    using steady_time = std::chrono::steady_clock::time_point;
-
-    using timespan = std::chrono::duration<int64_t, std::nano>;
-    using timestamp = std::chrono::time_point<std::chrono::system_clock, timespan>;
-
-    // test_chrono_system_clock
-    // Return the current time off the wall clock
-    m.def("test_chrono1", []() { return std::chrono::system_clock::now(); });
-
-    // test_chrono_system_clock_roundtrip
-    // Round trip the passed in system clock time
-    m.def("test_chrono2", [](system_time t) { return t; });
-
-    // test_chrono_duration_roundtrip
-    // Round trip the passed in duration
-    m.def("test_chrono3", [](std::chrono::system_clock::duration d) { return d; });
-
-    // test_chrono_duration_subtraction_equivalence
-    // Difference between two passed in time_points
-    m.def("test_chrono4", [](system_time a, system_time b) { return a - b; });
-
-    // test_chrono_steady_clock
-    // Return the current time off the steady_clock
-    m.def("test_chrono5", []() { return std::chrono::steady_clock::now(); });
-
-    // test_chrono_steady_clock_roundtrip
-    // Round trip a steady clock timepoint
-    m.def("test_chrono6", [](steady_time t) { return t; });
-
-    // test_floating_point_duration
-    // Roundtrip a duration in microseconds from a float argument
-    m.def("test_chrono7", [](std::chrono::microseconds t) { return t; });
-    // Float durations (pybind11 issue #719)
-    m.def("test_chrono_float_diff",
-          [](std::chrono::duration<float> a, std::chrono::duration<float> b) { return a - b; });
-
-    m.def("test_nano_timepoint",
-          [](timestamp start, timespan delta) -> timestamp { return start + delta; });
-
-    m.def("test_nano_timepoint_roundtrip",
-          [](timestamp start) { return start; });
-
-    m.def("test_nano_timepoint_diff",
-          [](timestamp start, timestamp end) -> timespan { return start - end; });
-
-    // Test different resolutions
-    nanobind::class_<different_resolutions>(m, "different_resolutions")
-        .def(nanobind::init<>())
-        .def_rw("timestamp_h", &different_resolutions::timestamp_h)
-        .def_rw("timestamp_m", &different_resolutions::timestamp_m)
-        .def_rw("timestamp_s", &different_resolutions::timestamp_s)
-        .def_rw("timestamp_ms", &different_resolutions::timestamp_ms)
-        .def_rw("timestamp_us", &different_resolutions::timestamp_us);
-
-#if defined(Py_LIMITED_API) || defined(PYPY_VERSION)
-    m.attr("access_via_python") = true;
-#else
-    m.attr("access_via_python") = false;
-#endif
-}
diff --git a/src/nanobind/tests/test_chrono.py b/src/nanobind/tests/test_chrono.py
deleted file mode 100644
index fac98e4..0000000
--- a/src/nanobind/tests/test_chrono.py
+++ /dev/null
@@ -1,340 +0,0 @@
-# Ported from pybind11/tests/test_chrono.py
-
-import test_chrono_ext as m
-
-import time
-import datetime
-import sys
-
-import pytest
-
-
-def test_chrono_system_clock():
-    # Get the time from both c++ and datetime
-    date0 = datetime.datetime.today()
-    date1 = m.test_chrono1()
-    date2 = datetime.datetime.today()
-
-    # The returned value should be a datetime
-    assert isinstance(date1, datetime.datetime)
-
-    # The numbers should vary by a very small amount (time it took to execute)
-    diff_python = abs(date2 - date0)
-    diff = abs(date1 - date2)
-
-    # There should never be a days difference
-    assert diff.days == 0
-
-    # Since datetime.datetime.today() calls time.time(), and on some platforms
-    # that has 1 second accuracy, we compare this way
-    assert diff.seconds <= diff_python.seconds
-
-
-def test_chrono_system_clock_roundtrip():
-    date1 = datetime.datetime.today()
-
-    # Roundtrip the time
-    date2 = m.test_chrono2(date1)
-
-    # The returned value should be a datetime
-    assert isinstance(date2, datetime.datetime)
-
-    # They should be identical (no information lost on roundtrip)
-    diff = abs(date1 - date2)
-    assert diff == datetime.timedelta(0)
-
-
-def test_chrono_system_clock_roundtrip_date():
-    date1 = datetime.date.today()
-
-    # Roundtrip the time
-    datetime2 = m.test_chrono2(date1)
-    date2 = datetime2.date()
-    time2 = datetime2.time()
-
-    # The returned value should be a datetime
-    assert isinstance(datetime2, datetime.datetime)
-    assert isinstance(date2, datetime.date)
-    assert isinstance(time2, datetime.time)
-
-    # They should be identical (no information lost on roundtrip)
-    diff = abs(date1 - date2)
-    assert diff.days == 0
-    assert diff.seconds == 0
-    assert diff.microseconds == 0
-
-    # Year, Month & Day should be the same after the round trip
-    assert date1 == date2
-
-    # There should be no time information
-    assert time2.hour == 0
-    assert time2.minute == 0
-    assert time2.second == 0
-    assert time2.microsecond == 0
-
-
-SKIP_TZ_ENV_ON_WIN = pytest.mark.skipif(
-    "sys.platform == 'win32'",
-    reason="TZ environment variable only supported on POSIX"
-)
-
-
-@pytest.mark.parametrize(
-    "time1",
-    [
-        datetime.datetime.today().time(),
-        datetime.time(0, 0, 0),
-        datetime.time(0, 0, 0, 1),
-        datetime.time(0, 28, 45, 109827),
-        datetime.time(0, 59, 59, 999999),
-        datetime.time(1, 0, 0),
-        datetime.time(5, 59, 59, 0),
-        datetime.time(5, 59, 59, 1),
-    ],
-)
-@pytest.mark.parametrize(
-    "tz",
-    [
-        None,
-        pytest.param("Europe/Brussels", marks=SKIP_TZ_ENV_ON_WIN),
-        pytest.param("Asia/Pyongyang", marks=SKIP_TZ_ENV_ON_WIN),
-        pytest.param("America/New_York", marks=SKIP_TZ_ENV_ON_WIN),
-    ],
-)
-def test_chrono_system_clock_roundtrip_time(time1, tz, monkeypatch):
-    if tz is not None:
-        monkeypatch.setenv("TZ", f"/usr/share/zoneinfo/{tz}")
-
-    # Roundtrip the time
-    datetime2 = m.test_chrono2(time1)
-    date2 = datetime2.date()
-    time2 = datetime2.time()
-
-    # The returned value should be a datetime
-    assert isinstance(datetime2, datetime.datetime)
-    assert isinstance(date2, datetime.date)
-    assert isinstance(time2, datetime.time)
-
-    # Hour, Minute, Second & Microsecond should be the same after the round trip
-    assert time1 == time2
-
-    # There should be no date information (i.e. date = python base date)
-    assert date2.year == 1970
-    assert date2.month == 1
-    assert date2.day == 1
-
-
-def test_chrono_duration_roundtrip():
-    # Get the difference between two times (a timedelta)
-    date1 = datetime.datetime.today()
-    date2 = datetime.datetime.today()
-    diff = date2 - date1
-
-    # Make sure this is a timedelta
-    assert isinstance(diff, datetime.timedelta)
-
-    cpp_diff = m.test_chrono3(diff)
-
-    assert cpp_diff == diff
-
-    # Negative timedelta roundtrip
-    diff = datetime.timedelta(microseconds=-1)
-    cpp_diff = m.test_chrono3(diff)
-
-    assert cpp_diff == diff
-
-
-def test_chrono_duration_subtraction_equivalence():
-    date1 = datetime.datetime.today()
-    date2 = datetime.datetime.today()
-
-    diff = date2 - date1
-    cpp_diff = m.test_chrono4(date2, date1)
-
-    assert cpp_diff == diff
-
-
-def test_chrono_duration_subtraction_equivalence_date():
-    date1 = datetime.date.today()
-    date2 = datetime.date.today()
-
-    diff = date2 - date1
-    cpp_diff = m.test_chrono4(date2, date1)
-
-    assert cpp_diff == diff
-
-
-def test_chrono_steady_clock():
-    time1 = m.test_chrono5()
-    assert isinstance(time1, datetime.timedelta)
-
-
-def test_chrono_steady_clock_roundtrip():
-    time1 = datetime.timedelta(days=10, seconds=10, microseconds=100)
-    time2 = m.test_chrono6(time1)
-
-    assert isinstance(time2, datetime.timedelta)
-
-    # They should be identical (no information lost on roundtrip)
-    assert time1 == time2
-
-    # Floating point conversion also works
-    assert m.test_chrono6(time1.total_seconds()) == time1
-
-
-def test_floating_point_duration():
-    # Test using a floating point number in seconds
-    time = m.test_chrono7(35.525123)
-
-    assert isinstance(time, datetime.timedelta)
-
-    assert time.seconds == 35
-    assert 525122 <= time.microseconds <= 525123
-
-    diff = m.test_chrono_float_diff(43.789012, 1.123456)
-    assert diff.seconds == 42
-    assert 665556 <= diff.microseconds <= 665557
-
-
-def test_nano_timepoint():
-    time = datetime.datetime.now()
-    time1 = m.test_nano_timepoint(time, datetime.timedelta(seconds=60))
-    assert time1 == time + datetime.timedelta(seconds=60)
-
-
-def test_chrono_different_resolutions():
-    resolutions = m.different_resolutions()
-    time = datetime.datetime.now()
-    resolutions.timestamp_h = time
-    resolutions.timestamp_m = time
-    resolutions.timestamp_s = time
-    resolutions.timestamp_ms = time
-    resolutions.timestamp_us = time
-
-    assert time == resolutions.timestamp_us
-    time = time.replace(microsecond=(time.microsecond // 1000) * 1000)
-    assert time == resolutions.timestamp_ms
-    time = time.replace(microsecond=0)
-    assert time == resolutions.timestamp_s
-    time = time.replace(second=0)
-    assert time == resolutions.timestamp_m
-    time = time.replace(minute=0)
-    assert time == resolutions.timestamp_h
-
-
-# Tests below this point are new in nanobind
-
-
-def test_chrono_misc():
-    from datetime import datetime, timedelta
-
-    advance_datetime = m.test_nano_timepoint
-    difference_between_datetimes = m.test_nano_timepoint_diff
-    roundtrip_datetime = m.test_nano_timepoint_roundtrip
-
-    d1 = datetime(2023, 4, 5, 12, 0, 0, 0)
-    d2 = datetime(2023, 4, 5, 12, 30, 0, 123)
-    # datetime -> time_point and duration -> timedelta conversion
-    assert difference_between_datetimes(d1, d2) == d1 - d2
-    assert difference_between_datetimes(d2, d1) == d2 - d1
-    # date -> time_point conversion
-    assert difference_between_datetimes(d2, d1.date()) == timedelta(
-        hours=12, minutes=30, microseconds=123
-    )
-    # time -> time_point conversion
-    assert difference_between_datetimes(d2.time(), d1.time()) == timedelta(
-        minutes=30, microseconds=123
-    )
-    assert roundtrip_datetime(d1.time()) == datetime(1970, 1, 1, 12, 0, 0)
-    for td in (
-        timedelta(seconds=5),
-        timedelta(microseconds=123),
-        timedelta(days=1, seconds=10),
-        timedelta(seconds=-5),
-        timedelta(microseconds=-123),
-        timedelta(days=-1, seconds=-10),
-    ):
-        # timedelta -> duration conversion
-        assert advance_datetime(d1, td) == d1 + td
-        # float -> duration conversion
-        assert advance_datetime(d1, td.total_seconds()) == d1 + td
-    # time_point -> datetime conversion
-    assert roundtrip_datetime(d1) == d1
-    assert roundtrip_datetime(d2) == d2
-
-
-@pytest.mark.parametrize(
-    "test_type,roundtrip_name",
-    [
-        (datetime.timedelta, 'test_chrono7'),
-        (datetime.datetime, 'test_nano_timepoint_roundtrip'),
-    ]
-)
-def test_chrono_invalid(test_type, roundtrip_name):
-    roundtrip = getattr(m, roundtrip_name)
-
-    # Can't pass None or an integer where a duration or timepoint is expected
-    with pytest.raises(TypeError, match="incompatible function arguments"):
-        roundtrip(None)
-    with pytest.raises(TypeError, match="incompatible function arguments"):
-        roundtrip(42)
-
-    # Can't pass a duration where a timepoint is expected, or vice versa
-    with pytest.raises(TypeError, match="incompatible function arguments"):
-        if test_type is datetime.datetime:
-            roundtrip(datetime.timedelta(seconds=5))
-        else:
-            roundtrip(datetime.datetime.now())
-
-    # On the limited API we access timedelta/datetime objects via
-    # regular attribute access; test that invalid results are handled
-    # reasonably. On the full API we use Python's <datetime.h> header
-    # so we'll always access the true C-level datetime slot and can't
-    # be fooled by tricks like this. PyPy uses normal attribute access
-    # and works like the limited API in this respect.
-
-    class fake_type(test_type):
-        @property
-        def seconds(self):
-            return self.override_value
-
-        @property
-        def second(self):
-            return self.override_value
-
-    if test_type is datetime.datetime:
-        fake_val = fake_type.fromtimestamp(time.time())
-        replace_overridden = lambda s: fake_val.replace(second=s)
-    else:
-        fake_val = fake_type(days=1, seconds=10, microseconds=123456)
-        replace_overridden = lambda s: fake_type(
-            days=1, seconds=s, microseconds=123456
-        )
-
-    for fake_result, errtype in (
-        ("hi", "TypeError"),
-        (0, None),
-        (2**64, "Python int too large to convert to C long"),
-        (2**32, "OverflowError"),
-    ):
-        fake_val.override_value = fake_result
-        if not m.access_via_python:
-            assert roundtrip(fake_val) == fake_val
-        elif errtype is None:
-            assert roundtrip(fake_val) == replace_overridden(fake_result)
-        elif test_type is datetime.timedelta and sys.implementation.name == "pypy":
-            # pypy's cpyext module converts timedelta to a C structure
-            # before the nanobind function even gets called, producing
-            # a different exception than the one we're testing below.
-            # datetime still works as it doesn't have its attributes
-            # converted but instead is implemented with Python
-            # attribute accesses.
-            pass
-        else:
-            from test.support import catch_unraisable_exception
-
-            with catch_unraisable_exception() as cm:
-                with pytest.raises(TypeError, match="incompatible function arguments"):
-                    roundtrip(fake_val)
-                assert cm.unraisable is not None
-                assert errtype in repr(cm.unraisable.exc_value)
diff --git a/src/nanobind/tests/test_classes.cpp b/src/nanobind/tests/test_classes.cpp
deleted file mode 100644
index caaa9ec..0000000
--- a/src/nanobind/tests/test_classes.cpp
+++ /dev/null
@@ -1,734 +0,0 @@
-#include <nanobind/nanobind.h>
-#include <nanobind/trampoline.h>
-#include <nanobind/operators.h>
-#include <nanobind/stl/optional.h>
-#include <nanobind/stl/string.h>
-#include <nanobind/stl/pair.h>
-#include <nanobind/stl/shared_ptr.h>
-#include <nanobind/stl/tuple.h>
-#include <nanobind/stl/unique_ptr.h>
-#include <map>
-#include <memory>
-#include <cstring>
-#include <vector>
-#include <nanobind/stl/detail/traits.h>
-#include "inter_module.h"
-
-namespace nb = nanobind;
-using namespace nb::literals;
-
-static int default_constructed = 0, value_constructed = 0, copy_constructed = 0,
-           move_constructed = 0, copy_assigned = 0, move_assigned = 0,
-           destructed = 0, pickled = 0, unpickled = 0;
-
-struct Struct;
-std::unique_ptr<Struct> struct_tmp;
-static std::vector<int> struct_destructed;
-
-struct Struct {
-    int i = 5;
-
-    Struct() { default_constructed++; }
-    Struct(int i) : i(i) { value_constructed++; }
-    Struct(const Struct &s) : i(s.i) { copy_constructed++; }
-    Struct(Struct &&s) noexcept : i(s.i) { s.i = 0; move_constructed++; }
-    Struct &operator=(const Struct &s) { i = s.i; copy_assigned++; return *this; }
-    Struct &operator=(Struct &&s) noexcept { i = s.i; s.i = 0; move_assigned++; return *this; }
-    ~Struct() { destructed++; if (nb::is_alive()) struct_destructed.push_back(i); }
-
-    int value() const { return i; }
-    int getstate() const { ++pickled; return i; }
-    void set_value(int value) { i = value; }
-    void setstate(int value) { unpickled++; i = value; }
-
-    static int static_test(int) { return 1; }
-    static int static_test(float) { return 2; }
-
-    static Struct* create_take() { return new Struct(10); }
-    static Struct  create_move() { return Struct(11); }
-    static Struct* create_copy() { return struct_tmp.get(); }
-    static Struct* create_reference() { return struct_tmp.get(); }
-    Struct &self() { return *this; }
-};
-
-struct PairStruct {
-    Struct s1;
-    Struct s2;
-};
-
-struct Big {
-    char data[1024];
-    Big() { memset(data, 0xff, 1024); }
-};
-
-struct alignas(128) BigAligned {
-    char data[128];
-    BigAligned() {
-        if (((uintptr_t) data) % 128)
-            throw std::runtime_error("data is not aligned!");
-        memset(data, 0xff, 128);
-    }
-};
-
-struct Animal {
-    virtual ~Animal() = default;
-    virtual std::string name() const { return "Animal"; }
-    virtual std::string what() const = 0;
-    virtual void void_ret() { }
-};
-
-struct StaticProperties {
-    static int value;
-};
-
-struct StaticProperties2 : StaticProperties { };
-
-int StaticProperties::value = 23;
-
-static Py_ssize_t sq_length_dummy(PyObject *) {
-    return 123;
-}
-
-struct Wrapper {
-    std::shared_ptr<Wrapper> value;
-};
-
-struct StructWithWeakrefs : Struct { };
-
-struct StructWithWeakrefsAndDynamicAttrs : Struct { };
-
-struct UniqueInt {
-    static std::map<int, std::weak_ptr<UniqueInt>> instances;
-
-    static std::shared_ptr<UniqueInt> make(int val) {
-        std::weak_ptr<UniqueInt>& entry = instances[val];
-        std::shared_ptr<UniqueInt> ret = entry.lock();
-        if (!ret) {
-            entry = ret = std::shared_ptr<UniqueInt>(new UniqueInt(val));
-        }
-        ++ret->nlook;
-        return ret;
-    }
-    int value() const { return val; }
-    int lookups() const { return nlook; }
-
-  private:
-    UniqueInt(int v) : val(v) {}
-    int val;
-    int nlook = 0;
-};
-std::map<int, std::weak_ptr<UniqueInt>> UniqueInt::instances;
-
-int wrapper_tp_traverse(PyObject *self, visitproc visit, void *arg) {
-    // On Python 3.9+, we must traverse the implicit dependency
-    // of an object on its associated type object.
-    #if PY_VERSION_HEX >= 0x03090000
-        Py_VISIT(Py_TYPE(self));
-    #endif
-
-    // The tp_traverse method may be called after __new__ but before or during
-    // __init__, before the C++ constructor has been called. We must not inspect
-    // the C++ state before the constructor completes.
-    if (!nb::inst_ready(self)) {
-        return 0;
-    }
-
-    Wrapper *w = nb::inst_ptr<Wrapper>(self);
-
-    // If c->value corresponds to an associated CPython object, return it
-    nb::handle value = nb::find(w->value);
-
-    // Inform the Python GC about it
-    Py_VISIT(value.ptr());
-
-    return 0;
-}
-
-int wrapper_tp_clear(PyObject *self) {
-    Wrapper *w = nb::inst_ptr<Wrapper>(self);
-    w->value.reset();
-    return 0;
-}
-
-PyType_Slot wrapper_slots[] = {
-    { Py_tp_traverse, (void *) wrapper_tp_traverse },
-    { Py_tp_clear, (void *) wrapper_tp_clear },
-    { 0, 0 }
-};
-
-NB_MODULE(test_classes_ext, m) {
-    struct_tmp = std::make_unique<Struct>(12);
-
-    auto cls = nb::class_<Struct>(m, "Struct", "Some documentation")
-        .def(nb::init<>())
-        .def(nb::init<int>())
-        .def("value", &Struct::value)
-        .def("set_value", &Struct::set_value, "value"_a)
-        .def("self", &Struct::self, nb::rv_policy::none)
-        .def("none", [](Struct &) -> const Struct * { return nullptr; })
-        .def("__getstate__", &Struct::getstate)
-        .def("__setstate__", &Struct::setstate)
-        .def_static("static_test", nb::overload_cast<int>(&Struct::static_test))
-        .def_static("static_test", nb::overload_cast<float>(&Struct::static_test))
-        .def_static("create_move", &Struct::create_move)
-        .def_static("create_reference", &Struct::create_reference,
-                    nb::rv_policy::reference)
-        .def_static("create_copy", &Struct::create_copy,
-                    nb::rv_policy::copy)
-        .def_static("create_take", &Struct::create_take);
-
-    if (!nb::type<Struct>().is(cls))
-        nb::detail::raise("type lookup failed!");
-
-    nb::class_<PairStruct>(m, "PairStruct")
-        .def(nb::init<>())
-        .def_rw("s1", &PairStruct::s1, "A documented property")
-        .def_rw("s2", &PairStruct::s2);
-
-    m.def("stats", []{
-        nb::dict d;
-        d["default_constructed"] = default_constructed;
-        d["value_constructed"] = value_constructed;
-        d["copy_constructed"] = copy_constructed;
-        d["move_constructed"] = move_constructed;
-        d["copy_assigned"] = copy_assigned;
-        d["move_assigned"] = move_assigned;
-        d["destructed"] = destructed;
-        d["pickled"] = pickled;
-        d["unpickled"] = unpickled;
-        return d;
-    });
-
-    m.def("reset", []() {
-        default_constructed = 0;
-        value_constructed = 0;
-        copy_constructed = 0;
-        move_constructed = 0;
-        copy_assigned = 0;
-        move_assigned = 0;
-        destructed = 0;
-        pickled = 0;
-        unpickled = 0;
-    });
-
-    // test06_big
-
-    nb::class_<Big>(m, "Big", "A class\nwith a multi-line\ndocstring..")
-        .def(nb::init<>());
-
-    nb::class_<BigAligned>(m, "BigAligned")
-        .def(nb::init<>());
-
-    // test09_trampoline
-    // test10_trampoline_failures
-
-    struct PyAnimal : Animal {
-        NB_TRAMPOLINE(Animal, 3);
-
-        PyAnimal() {
-            default_constructed++;
-        }
-
-        ~PyAnimal() override {
-            destructed++;
-        }
-
-        std::string name() const override {
-            NB_OVERRIDE(name);
-        }
-
-        std::string what() const override {
-            NB_OVERRIDE_PURE(what);
-        }
-
-        void void_ret() override {
-            NB_OVERRIDE(void_ret);
-        }
-    };
-
-    struct Dog : Animal {
-        Dog(const std::string &s) : s(s) { }
-        std::string name() const override { return "Dog"; }
-        std::string what() const override { return s; }
-        std::string s;
-    };
-
-    struct PyDog : Dog {
-        NB_TRAMPOLINE(Dog, 2);
-
-        PyDog(const std::string &s) : Dog(s) { }
-
-        std::string name() const override {
-            NB_OVERRIDE(name);
-        }
-
-        std::string what() const override {
-            NB_OVERRIDE(what);
-        }
-    };
-
-    struct Cat : Animal {
-        Cat(const std::string &s) : s(s) { }
-        std::string name() const override { return "Cat"; }
-        std::string what() const override { return s; }
-        std::string s;
-    };
-
-    struct SiameseCat : Cat { };
-
-    struct Foo { };
-
-    auto animal = nb::class_<Animal, PyAnimal>(m, "Animal")
-        .def(nb::init<>(), "A constructor")
-        .def("name", &Animal::name, "A method")
-        .def("what", &Animal::what);
-
-    nb::class_<Dog, Animal, PyDog>(m, "Dog")
-        .def(nb::init<const std::string &>());
-
-    nb::class_<Cat>(m, "Cat", animal)
-        .def(nb::init<const std::string &>());
-
-    nb::class_<SiameseCat, Cat> sc(m, "SiameseCat");
-    (void) sc;
-
-    m.def("go", [](Animal *a) {
-        return a->name() + " says " + a->what();
-    });
-
-    m.def("animal_passthrough", [](Animal *a) { return a; }, nb::rv_policy::none);
-    m.def("dog_passthrough", [](Dog *d) { return d; }, nb::rv_policy::none);
-
-    m.def("void_ret", [](Animal *a) { a->void_ret(); });
-
-    m.def("call_function", [](nb::handle h) {
-        return h(1, 2, "hello", true, 4);
-    });
-
-    m.def("call_method", [](nb::handle h) {
-        return h.attr("f")(1, 2, "hello", true, 4);
-    });
-
-    // test11_large_pointers
-    nb::class_<Foo>(m, "Foo");
-    m.def("i2p", [](uintptr_t x) { return (Foo *) x; }, nb::rv_policy::reference);
-    m.def("p2i", [](Foo *x) { return (uintptr_t) x; }, "x"_a = nullptr);
-
-    // test12_implicitly_convertible
-    struct A { int a; };
-    struct B { int b; };
-    struct B2 : B { B2(int i) : B{i} { } };
-    struct C { int c; };
-
-    struct D {
-        D(const A &a) : value(a.a + 10) { }
-        D(const B *b) : value(b->b + 100) { }
-        D(C c) : value(c.c + 1000) { }
-        D(int d) : value(d + 10000) { }
-        D(float) : value(0) { throw std::runtime_error("Fail!"); }
-        D(std::nullptr_t) : value(0) {}
-        // notice dangling access:
-        ~D() { static_cast<volatile int&>(value) = -100; }
-        int value;
-    };
-
-    nb::class_<A>(m, "A")
-        .def(nb::init<int>());
-
-    nb::class_<B>(m, "B")
-        .def(nb::init<int>());
-
-    nb::class_<B2, B>(m, "B2")
-        .def(nb::init<int>());
-
-    nb::class_<C>(m, "C")
-        .def(nb::init<int>());
-
-    nb::class_<D>(m, "D")
-        .def(nb::init_implicit<const A &>())
-        .def(nb::init_implicit<const B *>())
-        .def(nb::init_implicit<int>())
-        .def(nb::init_implicit<float>())
-        .def_rw("value", &D::value);
-
-    m.def("get_d", [](const D &d) { return d.value; });
-    m.def("get_optional_d", [](std::optional<const D*> arg) {
-        return arg ? arg.value()->value : -1;
-    }, nb::arg().none());
-    m.def("get_d_via_cast", [](nb::object obj) {
-        int by_val = -1, by_ptr = -1, by_opt_val = -1, by_opt_ptr = -1;
-        try {
-            by_val = nb::cast<D>(obj).value;
-        } catch (const nb::cast_error&) {}
-        try {
-            by_ptr = nb::cast<D*>(obj)->value;
-        } catch (const nb::cast_error&) {}
-        try {
-            by_opt_val = nb::cast<std::optional<D>>(obj)->value;
-        } catch (const nb::cast_error&) {}
-        try {
-            by_opt_ptr = nb::cast<std::optional<D*>>(obj).value()->value;
-        } catch (const nb::cast_error&) {}
-        return nb::make_tuple(by_val, by_ptr, by_opt_val, by_opt_ptr);
-    });
-    m.def("get_d_via_try_cast", [](nb::object obj) {
-        int by_val = -1, by_ptr = -1, by_opt_val = -1, by_opt_ptr = -1;
-        if (D val(nullptr); nb::try_cast(obj, val))
-            by_val = val.value;
-        if (D* ptr; nb::try_cast(obj, ptr))
-            by_ptr = ptr->value;
-        if (std::optional<D> opt_val; nb::try_cast(obj, opt_val))
-            by_opt_val = opt_val->value;
-        if (std::optional<D*> opt_ptr; nb::try_cast(obj, opt_ptr))
-            by_opt_ptr = opt_ptr.value()->value;
-        return nb::make_tuple(by_val, by_ptr, by_opt_val, by_opt_ptr);
-    });
-
-    struct Int {
-        int i;
-        Int operator+(Int o) const { return {i + o.i}; }
-        Int operator-(float j) const { return {int(i - j)}; }
-        bool operator==(Int o) const { return i == o.i; }
-        Int &operator+=(Int o) {
-            i += o.i;
-            return *this;
-        }
-    };
-
-    // test13_operators
-    nb::class_<Int>(m, "Int")
-        .def(nb::init<int>())
-        .def(nb::self + nb::self)
-        .def(nb::self += nb::self)
-        .def(nb::self - float())
-        .def("__repr__", [](const Int &i) { return std::to_string(i.i); });
-
-
-    // test15: Test nb::keep_alive feature
-    m.def(
-        "keep_alive_arg", [](nb::handle, nb::handle ret) { return ret; },
-        nb::keep_alive<0, 1>());
-
-    m.def(
-        "keep_alive_ret", [](nb::handle, nb::handle ret) { return ret; },
-        nb::keep_alive<1, 0>());
-
-    // test17_name_qualname_module()
-    m.def("f", []{});
-    struct MyClass { struct NestedClass { }; };
-    nb::class_<MyClass> mcls(m, "MyClass");
-    nb::class_<MyClass::NestedClass> ncls(mcls, "NestedClass");
-    mcls.def(nb::init<>());
-    mcls.def("f", [](MyClass&){});
-    ncls.def("f", [](MyClass::NestedClass&){});
-
-    // test18_static_properties
-    nb::class_<StaticProperties>(m, "StaticProperties")
-        .def_rw_static("value", &StaticProperties::value, "Static property docstring")
-        .def_static("get", []{ return StaticProperties::value; } );
-
-    nb::class_<StaticProperties2, StaticProperties>(m, "StaticProperties2");
-
-    // test19_supplement
-    struct ClassWithSupplement { };
-    struct Supplement {
-        uint8_t data[0xFF];
-    };
-
-    auto scls = nb::class_<ClassWithSupplement>(m, "ClassWithSupplement", nb::supplement<Supplement>())
-        .def(nb::init<>());
-
-    Supplement &supplement = nb::type_supplement<Supplement>(scls);
-    for (uint8_t i = 0; i < 0xFF; ++i)
-        supplement.data[i] = i;
-
-    m.def("check_supplement", [](nb::handle h) {
-        if (nb::isinstance<ClassWithSupplement>(h)) {
-            Supplement &s2 = nb::type_supplement<Supplement>(h.type());
-            for (uint16_t i = 0; i < 0xFF; ++i) {
-                if (s2.data[i] != i)
-                    return false;
-            }
-            return true;
-        }
-        return false;
-    });
-
-    // test20_type_callback
-    PyType_Slot slots[] {
-        { Py_sq_length, (void *) sq_length_dummy },
-        { 0, nullptr }
-    };
-
-    struct ClassWithLen { };
-    nb::class_<ClassWithLen>(m, "ClassWithLen", nb::type_slots(slots))
-        .def(nb::init<>());
-
-    // test21_low_level
-    m.def("test_lowlevel", []() {
-        nb::handle py_type = nb::type<Struct>();
-        if (!(nb::type_check(py_type) &&
-              nb::type_size(py_type) == sizeof(Struct) &&
-              nb::type_align(py_type) == alignof(Struct) &&
-              nb::type_info(py_type) == typeid(Struct)))
-            throw std::runtime_error("Internal error!");
-
-        nb::object py_inst = nb::inst_alloc(py_type);
-        if (!(nb::inst_check(py_inst) && py_inst.type().is(py_type) &&
-              !nb::inst_ready(py_inst)))
-            throw std::runtime_error("Internal error! (2)");
-
-        // Get a C++ pointer to the uninitialized instance data
-        Struct *ptr = nb::inst_ptr<Struct>(py_inst);
-
-        // Perform an in-place construction of the C++ object
-        new (ptr) Struct(123);
-
-        nb::inst_mark_ready(py_inst);
-        if (!nb::inst_ready(py_inst))
-            throw std::runtime_error("Internal error! (3)");
-
-        nb::object py_inst_2 = nb::inst_alloc(py_type);
-        if (nb::inst_ready(py_inst_2))
-            throw std::runtime_error("Internal error! (4)");
-
-        nb::inst_copy(py_inst_2, py_inst);
-        if (!nb::inst_ready(py_inst_2))
-            throw std::runtime_error("Internal error! (5)");
-
-        nb::inst_destruct(py_inst);
-        if (nb::inst_ready(py_inst))
-            throw std::runtime_error("Internal error! (6)");
-
-        nb::inst_move(py_inst, py_inst_2);
-        if (!nb::inst_ready(py_inst))
-            throw std::runtime_error("Internal error! (7)");
-
-        nb::handle py_type_pair = nb::type<PairStruct>();
-        PairStruct *ps = new PairStruct{Struct(123), Struct(456)};
-        nb::object py_inst_3 = nb::inst_take_ownership(py_type_pair, ps);
-        if (!(nb::inst_check(py_inst_3) && py_inst_3.type().is(py_type_pair) &&
-              nb::inst_state(py_inst_3) == std::make_pair(true, true)))
-            throw std::runtime_error("Internal error! (8)");
-
-        nb::object py_inst_4 = nb::inst_reference(py_type, &ps->s1, py_inst_3);
-        if (!(nb::inst_check(py_inst_4) && py_inst_4.type().is(py_type) &&
-              nb::inst_state(py_inst_4) == std::make_pair(true, false)))
-            throw std::runtime_error("Internal error! (9)");
-
-        return nb::make_tuple(py_inst, py_inst_2, py_inst_3, py_inst_4);
-    });
-
-    // test22_handle_t
-    m.def("test_handle_t", [](nb::handle_t<Struct> h) { return borrow(h); });
-
-    // test23_type_object_t
-    m.def("test_type_object_t", [](nb::type_object_t<Struct> h) -> nb::object { return h; });
-
-    // test24_none_arg
-    m.def("none_0", [](Struct *s) { return s == nullptr; });
-    m.def("none_1", [](Struct *s) { return s == nullptr; }, nb::arg());
-    m.def("none_2", [](Struct *s) { return s == nullptr; }, nb::arg("arg"));
-    m.def("none_3", [](Struct *s) { return s == nullptr; }, nb::arg().none());
-    m.def("none_4", [](Struct *s) { return s == nullptr; }, nb::arg("arg").none());
-
-    // test25_is_final
-    struct FinalType { };
-    nb::class_<FinalType>(m, "FinalType", nb::is_final())
-        .def(nb::init<>());
-
-    // test26_dynamic_attr
-    struct StructWithAttr : Struct { };
-    nb::class_<StructWithAttr, Struct>(m, "StructWithAttr", nb::dynamic_attr())
-        .def(nb::init<int>());
-
-    nb::class_<Wrapper>(m, "Wrapper", nb::type_slots(wrapper_slots))
-        .def(nb::init<>())
-        .def_rw("value", &Wrapper::value);
-
-    // The following isn't tested on the Python side, we just want to make sure it compiles
-    struct NonCopyable {
-        NonCopyable() = default;
-        NonCopyable(const NonCopyable&) = delete;
-    };
-
-    using NonCopyableVec = std::vector<NonCopyable>;
-    nb::class_<NonCopyableVec>(m, "NonCopyableVec");
-
-    m.def("is_int_1", [](nb::handle h) { return nb::isinstance<int>(h); });
-    m.def("is_int_2", [](nb::handle h) { return nb::isinstance<nb::int_>(h); });
-    m.def("is_struct", [](nb::handle h) { return nb::isinstance<Struct>(h); });
-
-    struct Base { ~Base() = default; };
-    struct PolymorphicBase { virtual ~PolymorphicBase() = default; };
-    struct Subclass : Base { };
-    struct PolymorphicSubclass : PolymorphicBase { };
-    struct AnotherSubclass : Base { };
-    struct AnotherPolymorphicSubclass : PolymorphicBase { };
-
-    nb::class_<Base> (m, "Base");
-    nb::class_<Subclass> (m, "Subclass");
-    nb::class_<PolymorphicBase> (m, "PolymorphicBase");
-    nb::class_<PolymorphicSubclass> (m, "PolymorphicSubclass");
-
-    m.def("polymorphic_factory", []() { return (PolymorphicBase *) new PolymorphicSubclass(); });
-    m.def("polymorphic_factory_2", []() { return (PolymorphicBase *) new AnotherPolymorphicSubclass(); });
-    m.def("factory", []() { return (Base *) new Subclass(); });
-    m.def("factory_2", []() { return (Base *) new AnotherSubclass(); });
-
-    m.def("check_shared", [](Shared *) { });
-
-    m.def("try_cast_1", [](nb::handle h) {
-        Struct s;
-        bool rv = nb::try_cast<Struct>(h, s);
-        return std::make_pair(rv, std::move(s));
-    }, nb::arg().none());
-
-    m.def("try_cast_2", [](nb::handle h) {
-        Struct s;
-        Struct &s2 = s;
-        bool rv = nb::try_cast<Struct &>(h, s2);
-        return std::make_pair(rv, std::move(s2));
-    }, nb::arg().none());
-
-    m.def("try_cast_3", [](nb::handle h) {
-        Struct *sp = nullptr;
-        bool rv = nb::try_cast<Struct *>(h, sp);
-        return std::make_pair(rv, sp);
-    }, nb::arg().none(), nb::rv_policy::none);
-
-    m.def("try_cast_4", [](nb::handle h) {
-        int i = 0;
-        bool rv = nb::try_cast<int>(h, i);
-        return std::make_pair(rv, i);
-    });
-
-#if !defined(Py_LIMITED_API)
-    m.def("test_slots", []() {
-        nb::object wrapper_tp = nb::module_::import_("test_classes_ext").attr("Wrapper");
-        return nb::make_tuple(
-            nb::type_get_slot(wrapper_tp, Py_tp_traverse) == (void *) wrapper_tp_traverse,
-            nb::type_get_slot(&PyLong_Type, Py_tp_init) == (void *) PyLong_Type.tp_init,
-            nb::type_get_slot(&PyLong_Type, Py_nb_add) == (void *) PyLong_Type.tp_as_number->nb_add
-        );
-    });
-#endif
-
-    // Used by test41_implicit_conversion_keep_alive
-    struct IncrementingStruct : Struct {
-        IncrementingStruct(const Struct &s) : Struct(s) {
-            i++;
-        }
-    };
-
-    nb::class_<IncrementingStruct, Struct>(m, "IncrementingStruct")
-        .def(nb::init_implicit<const Struct &>());
-
-    m.def("get_destructed", []() {
-        nb::list out;
-        for (int i : struct_destructed)
-            out.append(i);
-        struct_destructed.clear();
-        return out;
-    });
-
-    m.def(
-        "get_incrementing_struct_value",
-        [](IncrementingStruct &s) { return new Struct(s.i + 100); },
-        nb::keep_alive<0, 1>());
-
-    nb::class_<StructWithWeakrefs, Struct>(m, "StructWithWeakrefs", nb::is_weak_referenceable())
-        .def(nb::init<int>());
-
-    nb::class_<StructWithWeakrefsAndDynamicAttrs, Struct>(m, "StructWithWeakrefsAndDynamicAttrs",
-               nb::is_weak_referenceable(), nb::dynamic_attr())
-        .def(nb::init<int>());
-
-    union Union {
-        int i;
-        float f;
-    };
-    nb::class_<Union>(m, "Union")
-        .def(nb::init<>())
-        .def_rw("i", &Union::i)
-        .def_rw("f", &Union::f);
-
-    struct HiddenBase {
-        int value = 10;
-        int vget() const { return value; }
-        void vset(int v) { value = v; }
-        int get_answer() const { return value * 10; }
-    };
-    struct BoundDerived : HiddenBase {
-        virtual int polymorphic() { return value; }
-    };
-    nb::class_<BoundDerived>(m, "BoundDerived")
-        .def(nb::init<>())
-        .def_rw("value", &BoundDerived::value)
-        .def_prop_rw("prop", &BoundDerived::vget, &BoundDerived::vset)
-        .def("get_answer", &BoundDerived::get_answer)
-        .def("polymorphic", &BoundDerived::polymorphic);
-
-    nb::class_<UniqueInt>(m, "UniqueInt")
-        .def(nb::new_(&UniqueInt::make))
-        .def(nb::new_([](std::string s) {
-            return UniqueInt::make(std::atoi(s.c_str()));
-        }), "s"_a)
-        .def("value", &UniqueInt::value)
-        .def("lookups", &UniqueInt::lookups);
-
-    // issue #786
-    struct NewNone {};
-    struct NewDflt { int value; };
-    struct NewStar { size_t value; };
-    nb::class_<NewNone>(m, "NewNone")
-        .def(nb::new_([]() { return NewNone(); }));
-    nb::class_<NewDflt>(m, "NewDflt")
-        .def(nb::new_([](int value) { return NewDflt{value}; }),
-             "value"_a = 42)
-        .def_ro("value", &NewDflt::value);
-    nb::class_<NewStar>(m, "NewStar")
-        .def(nb::new_([](nb::args a, int value, nb::kwargs k) {
-            return NewStar{nb::len(a) + value + 10 * nb::len(k)};
-        }),
-            "args"_a, "value"_a = 42, "kwargs"_a)
-        .def_ro("value", &NewStar::value);
-
-    // issue #750
-    PyCFunctionWithKeywords dummy_init = [](PyObject *, PyObject *,
-                                            PyObject *) -> PyObject * {
-        PyErr_SetString(PyExc_RuntimeError, "This should never be called!");
-        return nullptr;
-    };
-
-    PyType_Slot init_slots[] {
-        // the presence of this slot enables normal object construction via __init__ and __new__
-        // instead of an optimized codepath within nanobind that skips these. That in turn
-        // makes it possible to intercept calls and implement custom logic.
-        { Py_tp_init, (void *) dummy_init },
-        { 0, nullptr }
-    };
-
-    struct MonkeyPatchable {
-        int value = 123;
-    };
-
-    nb::class_<MonkeyPatchable>(m, "MonkeyPatchable", nb::type_slots(init_slots))
-        .def(nb::init<>())
-        .def_static("custom_init", [](nb::handle_t<MonkeyPatchable> h) {
-            if (nb::inst_ready(h))
-                nb::raise_type_error("Input is already initialized!");
-            MonkeyPatchable *p = nb::inst_ptr<MonkeyPatchable>(h);
-            new (p) MonkeyPatchable{456};
-            nb::inst_mark_ready(h);
-        })
-        .def_rw("value", &MonkeyPatchable::value);
-
-    struct StaticPropertyOverride {};
-    struct StaticPropertyOverride2 : public StaticPropertyOverride {};
-
-    nb::class_<StaticPropertyOverride>(m, "StaticPropertyOverride")
-        .def_prop_ro_static("x", [](nb::handle /*unused*/) { return 42; });
-    nb::class_<StaticPropertyOverride2, StaticPropertyOverride>(m, "StaticPropertyOverride2")
-        .def_prop_ro_static("x", [](nb::handle /*unused*/) { return 43; });
-}
diff --git a/src/nanobind/tests/test_classes.py b/src/nanobind/tests/test_classes.py
deleted file mode 100644
index a34fa65..0000000
--- a/src/nanobind/tests/test_classes.py
+++ /dev/null
@@ -1,943 +0,0 @@
-import sys
-import test_classes_ext as t
-import pytest
-from common import skip_on_pypy, collect
-
-# Some helper declaration to check types across different Python versions
-if sys.version_info < (3, 9):
-    TYPING_TYPE = "typing.Type"
-else:
-    TYPING_TYPE = "type"
-
-
-def optional(arg: str, /) -> str:
-    if sys.version_info < (3, 10):
-        return "typing.Optional[" + arg + "]"
-    else:
-        return arg + " | " + "None"
-
-
-@pytest.fixture
-def clean():
-    collect()
-    t.reset()
-
-
-def assert_stats(**kwargs):
-    collect()
-    for k, v in t.stats().items():
-        fail = False
-        if k in kwargs:
-            if v != kwargs[k]:
-                fail = True
-        elif v != 0:
-            fail = True
-        if fail:
-            raise Exception(f"Mismatch for key {k}: {t.stats()}")
-
-
-def test01_signature():
-    assert t.Struct.__init__.__doc__ == (
-        "__init__(self) -> None\n" "__init__(self, arg: int, /) -> None"
-    )
-
-    assert t.Struct.value.__doc__ == "value(self) -> int"
-    assert t.Struct.create_move.__doc__ == "create_move() -> test_classes_ext.Struct"
-    assert t.Struct.set_value.__doc__ == "set_value(self, value: int) -> None"
-    assert t.Struct().set_value.__doc__ == "set_value(self, value: int) -> None"
-    assert t.Struct.__doc__ == "Some documentation"
-    assert t.Struct.static_test.__doc__ == (
-        "static_test(arg: int, /) -> int\n" "static_test(arg: float, /) -> int"
-    )
-
-
-def test02_static_overload():
-    assert t.Struct.static_test(1) == 1
-    assert t.Struct.static_test(1.0) == 2
-
-
-def test03_instantiate(clean):
-    s1: t.Struct = t.Struct()
-    assert s1.value() == 5
-    s2 = t.Struct(10)
-    assert s2.value() == 10
-    del s1
-    del s2
-    assert_stats(default_constructed=1, value_constructed=1, destructed=2)
-
-
-def test04_double_init():
-    s = t.Struct()
-    with pytest.warns(
-        RuntimeWarning,
-        match="nanobind: attempted to initialize an already-initialized instance of type",
-    ):
-        with pytest.raises(TypeError):
-            s.__init__(3)
-
-
-def test05_rv_policy(clean):
-    s = t.Struct()
-    assert s.self() is s
-    assert s.none() is None
-    del s
-    assert_stats(default_constructed=1, destructed=1)
-
-    # ------
-
-    t.reset()
-    assert t.Struct.create_take().value() == 10
-    assert_stats(value_constructed=1, destructed=1)
-
-    # ------
-
-    t.reset()
-    assert t.Struct.create_move().value() == 11
-    assert_stats(value_constructed=1, move_constructed=1, destructed=2)
-
-    # ------
-
-    t.reset()
-    assert t.Struct.create_reference().value() == 12
-    assert_stats()
-
-    # ------
-
-    t.reset()
-    assert t.Struct.create_copy().value() == 12
-    assert_stats(copy_constructed=1, destructed=1)
-
-
-def test06_reference_internal(clean):
-    s = t.PairStruct()
-    s1 = s.s1
-    s2 = s.s2
-    del s
-    assert_stats(default_constructed=2)
-    assert s2.value() == 5
-    del s2
-
-    assert_stats(default_constructed=2)
-
-    assert s1.value() == 5
-    del s1
-    assert_stats(default_constructed=2, destructed=2)
-
-    # ----
-
-    s = t.PairStruct()
-    s1 = s.s1
-    del s1
-    del s
-
-
-def test07_big():
-    x = [t.Big() for i in range(1024)]
-    x2 = [t.BigAligned() for i in range(1024)]
-
-
-def test08_inheritance():
-    dog = t.Dog("woof")
-    cat = t.Cat("meow")
-    assert dog.name() == "Dog"
-    assert cat.name() == "Cat"
-    assert dog.what() == "woof"
-    assert cat.what() == "meow"
-    assert isinstance(dog, t.Animal) and isinstance(dog, t.Dog)
-    assert isinstance(cat, t.Animal) and isinstance(cat, t.Cat)
-    assert t.go(dog) == "Dog says woof"
-    assert t.go(cat) == "Cat says meow"
-
-    assert t.animal_passthrough(dog) is dog
-    assert t.animal_passthrough(cat) is cat
-    assert t.dog_passthrough(dog) is dog
-
-    with pytest.raises(TypeError):
-        t.dog_passthrough(cat)
-
-
-def test09_method_vectorcall():
-    out = []
-
-    def f(a, b, c, d, e):
-        out.append((a, b, c, d, e))
-
-    class MyClass:
-        def f(self, a, b, c, d, e):
-            self.out = (a, b, c, d, e)
-
-    t.call_function(f)
-
-    i = MyClass()
-    t.call_method(i)
-    assert out == [(1, 2, "hello", True, 4)]
-    assert i.out == (1, 2, "hello", True, 4)
-
-
-def test10_trampoline(clean):
-    for _ in range(10):
-
-        class Dachshund(t.Animal):
-            def __init__(self):
-                super().__init__()
-
-            def name(self):
-                return "Dachshund"
-
-            def what(self):
-                return "yap"
-
-        d = Dachshund()
-        for _ in range(10):
-            assert t.go(d) == "Dachshund says yap"
-
-        assert t.animal_passthrough(d) is d
-
-    a = 0
-
-    class GenericAnimal(t.Animal):
-        def what(self):
-            return "goo"
-
-        def void_ret(self):
-            nonlocal a
-            a += 1
-
-        def name(self):
-            return "Generic" + super().name()
-
-    ga = GenericAnimal()
-    assert t.go(ga) == "GenericAnimal says goo"
-    assert t.void_ret(ga) is None
-    assert a == 1
-    assert t.animal_passthrough(ga) is ga
-
-    del ga
-    del d
-
-    assert_stats(default_constructed=11, destructed=11)
-
-    class GenericDog(t.Dog):
-        pass
-
-    d = GenericDog("GenericDog")
-    assert t.dog_passthrough(d) is d
-    assert t.animal_passthrough(d) is d
-
-
-def test11_trampoline_failures():
-    class Incomplete(t.Animal):
-        def __init__(self):
-            super().__init__()
-
-        def void_ret(self):
-            raise TypeError("propagating an exception")
-
-    d = Incomplete()
-    with pytest.raises(RuntimeError) as excinfo:
-        t.go(d)
-    assert (
-        "test_classes.Incomplete::what()'): tried to call a pure virtual function!"
-        in str(excinfo.value)
-    )
-
-    with pytest.raises(TypeError) as excinfo:
-        t.void_ret(d)
-    assert "propagating an exception" in str(excinfo.value)
-
-    class Incomplete2(t.Animal):
-        def __init__(self):
-            pass  # Missing call to super().__init__()
-
-        def name(self):
-            return "a"
-
-        def what(self):
-            return "b"
-
-    with pytest.warns(
-        RuntimeWarning,
-        match="nanobind: attempted to access an uninitialized instance of type",
-    ):
-        with pytest.raises(TypeError) as excinfo:
-            t.go(Incomplete2())
-    assert "incompatible function arguments" in str(excinfo.value)
-
-
-def test12_large_pointers():
-    import struct
-
-    for i in range(1, 10):
-        c = t.i2p(i)
-        assert isinstance(c, t.Foo)
-        assert t.p2i(c) == i
-
-    large = (1 << (struct.calcsize("P") * 8)) - 1
-    for i in range(large - 10, large):
-        c = t.i2p(i)
-        assert isinstance(c, t.Foo)
-        assert t.p2i(c) == i
-
-
-def test13_implicitly_convertible():
-    assert t.get_d.__doc__ == "get_d(arg: test_classes_ext.D, /) -> int"
-    a = t.A(1)
-    b = t.B(2)
-    b2 = t.B2(3)
-    c = t.C(4)
-    i = 5
-
-    with pytest.raises(TypeError) as excinfo:
-        t.get_d(c)
-    assert str(excinfo.value) == (
-        "get_d(): incompatible function arguments. The following argument types are supported:\n"
-        "    1. get_d(arg: test_classes_ext.D, /) -> int\n"
-        "\n"
-        "Invoked with types: test_classes_ext.C"
-    )
-    with pytest.raises(TypeError):
-        t.get_optional_d(c)
-
-    for obj, expected in ((a, 11), (b, 102), (b2, 103), (i, 10005)):
-        assert t.get_d(obj) == expected
-        assert t.get_optional_d(obj) == expected
-        # The -1's here are because nb::cast() won't implicit-convert to a
-        # pointer because it would dangle
-        assert t.get_d_via_cast(obj) == (expected, -1, expected, -1)
-        assert t.get_d_via_try_cast(obj) == (expected, -1, expected, -1)
-
-    d = t.D(5)
-    assert t.get_d(d) == 10005
-    assert t.get_optional_d(d) == 10005
-    assert t.get_d_via_cast(d) == (10005, 10005, 10005, 10005)
-    assert t.get_d_via_try_cast(d) == (10005, 10005, 10005, 10005)
-
-    assert t.get_optional_d(None) == -1
-    assert t.get_d_via_cast(c) == (-1, -1, -1, -1)
-    assert t.get_d_via_try_cast(c) == (-1, -1, -1, -1)
-
-
-def test14_operators():
-    a = t.Int(1)
-    b = t.Int(2)
-    assert repr(a + b) == "3"
-    with pytest.raises(TypeError) as excinfo:
-        assert repr(a - b) == "3"
-    assert "unsupported operand type" in str(excinfo.value)
-    assert repr(a - 2) == "-1"
-    a_before = id(a)
-    a += b
-    assert id(a) == a_before
-    assert repr(a) == "3"
-    assert repr(b) == "2"
-
-    assert a.__add__("test") is NotImplemented
-
-
-def test15_keep_alive_nbtype(clean):
-    t.reset()
-    s = t.Struct()
-    a = t.Dog("Rufus")
-    assert t.keep_alive_arg(s, a) is a
-    assert t.keep_alive_arg(s, a) is a
-    del s
-    assert_stats(default_constructed=1)
-    del a
-    assert_stats(default_constructed=1, destructed=1)
-
-    t.reset()
-    s = t.Struct()
-    a = t.Dog("Rufus")
-    assert t.keep_alive_ret(a, s) is s
-    assert t.keep_alive_ret(a, s) is s
-    del a
-    assert_stats(default_constructed=1)
-    del s
-    assert_stats(default_constructed=1, destructed=1)
-
-
-def test16_keep_alive_custom(clean):
-    constructed = 0
-    destructed = 0
-
-    class Struct:
-        def __init__(self):
-            nonlocal constructed
-            constructed += 1
-
-        def __del__(self):
-            nonlocal destructed
-            destructed += 1
-
-    class Struct2:
-        def __init__(self):
-            pass
-
-    s = Struct()
-    a = Struct2()
-    assert t.keep_alive_arg(s, a) is a
-    del s
-    collect()
-    assert constructed == 1 and destructed == 0
-    del a
-    collect()
-    assert constructed == 1 and destructed == 1
-
-    s = Struct()
-    a = Struct2()
-    assert t.keep_alive_ret(a, s) is s
-    del a
-    collect()
-    assert constructed == 2 and destructed == 1
-    del s
-    collect()
-    assert constructed == 2 and destructed == 2
-
-    with pytest.raises(RuntimeError) as excinfo:
-        s = Struct()
-        x = 5
-        t.keep_alive_ret(x, s)
-
-    assert "nanobind::detail::keep_alive(): could not create a weak reference!" in str(
-        excinfo.value
-    )
-
-
-def f():
-    pass
-
-
-class MyClass:
-    def f(self):
-        pass
-
-    class NestedClass:
-        def f(self):
-            pass
-
-
-def test17_name_qualname_module():
-    # First, check what CPython does
-    assert f.__module__ == "test_classes"
-    assert f.__name__ == "f"
-    assert f.__qualname__ == "f"
-    assert MyClass.__name__ == "MyClass"
-    assert MyClass.__qualname__ == "MyClass"
-    assert MyClass.__module__ == "test_classes"
-    assert MyClass.f.__name__ == "f"
-    assert MyClass.f.__qualname__ == "MyClass.f"
-    assert MyClass.f.__module__ == "test_classes"
-    assert MyClass().f.__name__ == "f"
-    assert MyClass().f.__qualname__ == "MyClass.f"
-    assert MyClass().f.__module__ == "test_classes"
-    assert MyClass.NestedClass.__name__ == "NestedClass"
-    assert MyClass.NestedClass.__qualname__ == "MyClass.NestedClass"
-    assert MyClass.NestedClass.__module__ == "test_classes"
-    assert MyClass.NestedClass.f.__name__ == "f"
-    assert MyClass.NestedClass.f.__qualname__ == "MyClass.NestedClass.f"
-    assert MyClass.NestedClass.f.__module__ == "test_classes"
-
-    # Now, check the extension module
-    assert t.f.__module__ == "test_classes_ext"
-    assert t.f.__name__ == "f"
-    assert t.f.__qualname__ == "f"
-    assert type(t.f).__module__ == "nanobind"
-    assert type(t.f).__name__ == "nb_func"
-    assert type(t.f).__qualname__ == "nb_func"
-    assert t.MyClass.__name__ == "MyClass"
-    assert t.MyClass.__qualname__ == "MyClass"
-    assert t.MyClass.__module__ == "test_classes_ext"
-    assert t.MyClass.f.__name__ == "f"
-    assert t.MyClass.f.__qualname__ == "MyClass.f"
-    assert t.MyClass.f.__module__ == "test_classes_ext"
-    assert t.MyClass().f.__name__ == "f"
-    assert t.MyClass().f.__qualname__ == "MyClass.f"
-    assert t.MyClass().f.__module__ == "test_classes_ext"
-    assert type(t.MyClass.f).__module__ == "nanobind"
-    assert type(t.MyClass.f).__name__ == "nb_method"
-    assert type(t.MyClass.f).__qualname__ == "nb_method"
-    assert t.MyClass.NestedClass.__name__ == "NestedClass"
-    assert t.MyClass.NestedClass.__qualname__ == "MyClass.NestedClass"
-    assert t.MyClass.NestedClass.__module__ == "test_classes_ext"
-    assert t.MyClass.NestedClass.f.__name__ == "f"
-    assert t.MyClass.NestedClass.f.__qualname__ == "MyClass.NestedClass.f"
-    assert t.MyClass.NestedClass.f.__module__ == "test_classes_ext"
-
-
-def test18_static_properties():
-    assert t.StaticProperties.value == 23
-    t.StaticProperties.value += 1
-    assert t.StaticProperties.value == 24
-    assert t.StaticProperties.get() == 24
-    assert t.StaticProperties2.get() == 24
-    t.StaticProperties2.value = 50
-    assert t.StaticProperties2.get() == 50
-    assert t.StaticProperties.get() == 50
-
-
-@skip_on_pypy
-def test19_static_properties_doc():
-    import pydoc
-
-    assert "Static property docstring" in pydoc.render_doc(t.StaticProperties2)
-
-
-def test20_supplement():
-    c = t.ClassWithSupplement()
-    assert t.check_supplement(c)
-    assert not t.check_supplement(t.Struct())
-
-
-def test21_type_callback():
-    o = t.ClassWithLen()
-    assert len(o) == 123
-
-
-def test22_low_level(clean):
-    s1, s2, s3, s4 = t.test_lowlevel()
-    assert s1.value() == 123 and s2.value() == 0 and s4.value() == 123
-    assert s3.s1.value() == 123 and s3.s2.value() == 456
-    assert s3.s1 is s4
-    del s1
-    del s2
-    del s3
-    collect()
-    assert s4.value() == 123
-    del s4
-    assert_stats(
-        value_constructed=3, copy_constructed=1, move_constructed=1, destructed=5
-    )
-
-
-def test23_handle_t(clean):
-    assert (
-        t.test_handle_t.__doc__
-        == "test_handle_t(arg: test_classes_ext.Struct, /) -> object"
-    )
-    s = t.test_handle_t(t.Struct(5))
-    assert s.value() == 5
-    del s
-
-    with pytest.raises(TypeError) as excinfo:
-        t.test_handle_t("test")
-    assert "incompatible function argument" in str(excinfo.value)
-    assert_stats(value_constructed=1, destructed=1)
-
-
-def test24_type_object_t(clean):
-    assert (
-        t.test_type_object_t.__doc__
-        == f"test_type_object_t(arg: {TYPING_TYPE}[test_classes_ext.Struct], /) -> object"
-    )
-
-    assert t.test_type_object_t(t.Struct) is t.Struct
-
-    with pytest.raises(TypeError):
-        t.test_type_object_t(t.Struct())
-
-    with pytest.raises(TypeError):
-        t.test_type_object_t(int)
-
-
-def test25_none_arg():
-    with pytest.raises(TypeError):
-        t.none_0(None)
-    with pytest.raises(TypeError):
-        t.none_1(None)
-    with pytest.raises(TypeError):
-        t.none_2(arg=None)
-    assert t.none_3(None) is True
-    assert t.none_4(arg=None) is True
-    assert t.none_0.__doc__ == "none_0(arg: test_classes_ext.Struct, /) -> bool"
-    assert t.none_1.__doc__ == "none_1(arg: test_classes_ext.Struct) -> bool"
-    assert t.none_2.__doc__ == "none_2(arg: test_classes_ext.Struct) -> bool"
-    opt_struct = optional("test_classes_ext.Struct")
-    assert t.none_3.__doc__ == f"none_3(arg: {opt_struct}) -> bool"
-    assert t.none_4.__doc__ == f"none_4(arg: {opt_struct}) -> bool"
-
-
-def test26_is_final():
-    with pytest.raises(TypeError) as excinfo:
-
-        class MyType(t.FinalType):
-            pass
-
-    assert "The type 'test_classes_ext.FinalType' prohibits subclassing!" in str(
-        excinfo.value
-    )
-
-
-def test27_dynamic_attr(clean):
-    l = [None] * 100
-    for i in range(100):
-        l[i] = t.StructWithAttr(i)
-
-    # Create a big reference cycle..
-    for i in range(100):
-        l[i].prev = l[i - 1]
-        l[i].next = l[i + 1 if i < 99 else 0]
-        l[i].t = t.StructWithAttr
-        l[i].self = l[i]
-
-    for i in range(100):
-        assert l[i].value() == i
-        assert l[i].self.value() == i
-        assert l[i].prev.value() == (i - 1 if i > 0 else 99)
-        assert l[i].next.value() == (i + 1 if i < 99 else 0)
-
-    del l
-
-    assert_stats(value_constructed=100, destructed=100)
-
-
-def test28_copy_rvp():
-    a = t.Struct.create_reference()
-    b = t.Struct.create_copy()
-    assert a is not b
-
-
-def test29_pydoc():
-    import pydoc
-
-    assert "Some documentation" in pydoc.render_doc(t)
-
-
-def test30_property_assignment_instance():
-    s = t.PairStruct()
-    s1 = t.Struct(123)
-    s2 = t.Struct(456)
-    s.s1 = s1
-    s.s2 = s2
-    assert s2 is not s.s2 and s1 is not s.s1
-    assert s.s1.value() == 123
-    assert s.s2.value() == 456
-    assert s1.value() == 123
-    assert s2.value() == 456
-
-
-# cpyext reference cycles are not supported, see https://foss.heptapod.net/pypy/pypy/-/issues/3849
-@skip_on_pypy()
-def test31_cycle():
-    a = t.Wrapper()
-    a.value = a
-    del a
-    collect()
-
-
-def test32_type_checks():
-    v1 = 5
-    v2 = t.Struct()
-
-    assert t.is_int_1(v1) and not t.is_int_1(v2)
-    assert t.is_int_2(v1) and not t.is_int_2(v2)
-    assert not t.is_struct(v1) and t.is_struct(v2)
-
-
-def test33_polymorphic_downcast():
-    assert isinstance(t.factory(), t.Base)
-    assert isinstance(t.factory_2(), t.Base)
-    assert isinstance(t.polymorphic_factory(), t.PolymorphicSubclass)
-    assert isinstance(t.polymorphic_factory_2(), t.PolymorphicBase)
-
-
-def test34_trampoline_optimization():
-    class Rufus(t.Dog):
-        def __init__(self):
-            super().__init__("woof")
-
-        def name(self):
-            return "Rufus"
-
-    for i in range(2):
-        d1 = t.Dog("woof")
-        d2 = Rufus()
-
-        if i == 0:
-            assert t.go(d1) == "Dog says woof"
-            assert t.go(d2) == "Rufus says woof"
-
-        old = t.Dog.name
-        try:
-            t.Dog.name = lambda self: "Max"
-
-            assert t.go(d1) == "Dog says woof"
-            assert t.go(d2) == "Rufus says woof"
-        finally:
-            t.Dog.name = old
-
-
-def test35_method_introspection():
-    obj = t.Struct(5)
-    m = obj.value
-    assert m() == m.__call__() == 5
-    assert hash(m) == m.__hash__()
-    assert repr(m) == m.__repr__()
-    assert "bound_method" in repr(m)
-    assert m.__self__ is obj
-    assert m.__func__ is t.Struct.value
-    # attributes not defined by nb_bound_method are forwarded to nb_method:
-    assert m.__name__ == "value"
-    assert m.__qualname__ == "Struct.value"
-    assert m.__module__ == t.__name__
-    assert m.__doc__ == t.Struct.value.__doc__ == "value(self) -> int"
-
-
-def test38_pickle(clean):
-    import pickle
-
-    s = t.Struct(123)
-    s2 = pickle.dumps(s, protocol=pickle.HIGHEST_PROTOCOL)
-    s3 = pickle.loads(s2)
-    assert s.value() == s3.value()
-    del s, s3
-
-    assert_stats(value_constructed=1, pickled=1, unpickled=1, destructed=2)
-
-
-def test39_try_cast(clean):
-    s = t.Struct(123)
-
-    assert_stats(value_constructed=1)
-    t.reset()
-
-    rv, s2 = t.try_cast_1(s)
-    assert rv is True and s2 is not s and s.value() == 123 and s2.value() == 123
-    del s2
-    assert_stats(
-        default_constructed=1, move_constructed=2, copy_assigned=1, destructed=3
-    )
-    t.reset()
-
-    rv, s2 = t.try_cast_1(None)
-    assert rv is False and s2 is not s and s2.value() == 5
-    del s2
-    assert_stats(
-        default_constructed=1, move_constructed=2, copy_assigned=0, destructed=3
-    )
-    t.reset()
-
-    rv, s2 = t.try_cast_2(s)
-    assert rv is True and s2 is not s and s.value() == 123 and s2.value() == 123
-    del s2
-    assert_stats(
-        default_constructed=1, move_constructed=2, copy_assigned=1, destructed=3
-    )
-    t.reset()
-
-    rv, s2 = t.try_cast_2(None)
-    assert rv is False and s2 is not s and s2.value() == 5
-    del s2
-    assert_stats(
-        default_constructed=1, move_constructed=2, copy_assigned=0, destructed=3
-    )
-    t.reset()
-
-    rv, s2 = t.try_cast_3(s)
-    assert rv is True and s2 is s and s.value() == 123
-    del s2
-    assert_stats()
-    t.reset()
-
-    rv, s2 = t.try_cast_3(None)
-    assert rv is True and s2 is None
-    del s2
-    assert_stats(
-        default_constructed=0, move_constructed=0, copy_assigned=0, destructed=0
-    )
-    t.reset()
-
-    rv, s2 = t.try_cast_2(1)
-    assert rv is False
-    del s2
-    assert_stats(default_constructed=1, move_constructed=2, destructed=3)
-    t.reset()
-
-    rv, s2 = t.try_cast_3(1)
-    assert rv is False and s2 is None
-    del s2
-    assert_stats()
-    t.reset()
-
-    rv, s2 = t.try_cast_4(s)
-    assert rv is False and s2 == 0
-    rv, s2 = t.try_cast_4(123)
-    assert rv is True and s2 == 123
-    del s, s2
-
-    assert_stats(destructed=1)
-
-
-def test40_slots():
-    if not hasattr(t, "test_slots"):
-        pytest.skip()
-    assert t.test_slots() == (True, True, True)
-
-
-def test41_implicit_conversion_keep_alive():
-    # Check that keep_alive references implicitly constructed arguments
-    # as opposed to the original function arguments
-    collect()
-    t.get_destructed()
-
-    a = t.Struct(5)
-    b = t.get_incrementing_struct_value(a)
-    d1 = t.get_destructed()
-    assert b.value() == 106
-    del a
-    collect()
-    d2 = t.get_destructed()
-    collect()
-    del b
-    collect()
-    d3 = t.get_destructed()
-    assert d1 == []
-    assert d2 == [5]
-    assert d3 == [106, 6]
-
-
-def test42_weak_references():
-    import weakref
-    import gc
-    import time
-
-    o = t.StructWithWeakrefs(42)
-    w = weakref.ref(o)
-    assert w() is o
-    del o
-    gc.collect()
-    gc.collect()
-    assert w() is None
-
-    p = t.StructWithWeakrefsAndDynamicAttrs(43)
-    p.a_dynamic_attr = 101
-    w = weakref.ref(p)
-    assert w() is p
-    assert w().a_dynamic_attr == 101
-    del p
-    gc.collect()
-    gc.collect()
-    assert w() is None
-
-
-def test43_union():
-    u = t.Union()
-    u.i = 42
-    assert u.i == 42
-
-    u.f = 2.125
-    assert u.f == 2.125
-
-
-def test44_dynamic_attr_has_dict():
-    s = t.StructWithAttr(5)
-    assert s.__dict__ == {}
-    s.a_dynamic_attr = 101
-    assert s.__dict__ == {"a_dynamic_attr": 101}
-
-
-def test45_hidden_base():
-    s = t.BoundDerived()
-    assert s.value == 10
-    s.value = 5
-    assert s.prop == 5
-    s.prop = 20
-    assert s.value == 20
-    assert s.get_answer() == 200
-    assert s.polymorphic() == 20
-
-
-def test46_custom_new():
-    import gc
-
-    u1 = t.UniqueInt(10)
-    assert u1.value() == 10 and u1.lookups() == 1
-
-    u2 = t.UniqueInt(10)
-    assert u1 is u2
-    assert u1.lookups() == 2
-
-    # test alternate constructor
-    assert t.UniqueInt("10") is u1
-    assert t.UniqueInt(s="10") is u1
-    assert u1.lookups() == 4
-
-    u3 = t.UniqueInt(20)
-    assert u1 is not u3
-    assert u3.value() == 20 and u3.lookups() == 1
-
-    del u1
-    assert u2.lookups() == 4
-    assert u2 is t.UniqueInt(10)
-    assert u2.lookups() == 5
-
-    del u2
-    gc.collect()
-    gc.collect()
-
-    u4 = t.UniqueInt(10)
-    assert u4.value() == 10 and u4.lookups() == 1
-
-    # As if unpickling:
-    empty = t.UniqueInt.__new__(t.UniqueInt)
-    with pytest.warns(RuntimeWarning, match="access an uninitialized instance"):
-        with pytest.raises(TypeError):
-            empty.value()
-
-    # Make sure pickle support doesn't allow no-args construction by mistake
-    with pytest.raises(TypeError):
-        t.UniqueInt()
-
-    with pytest.raises(RuntimeError):
-        t.UniqueInt.__new__(int)
-
-    # Make sure we do allow no-args construction for types that declare
-    # such a __new__
-    t.NewNone()
-    assert t.NewDflt().value == 42
-    assert t.NewDflt(10).value == 10
-    assert t.NewStar().value == 42
-    assert t.NewStar("hi").value == 43
-    assert t.NewStar(value=10).value == 10
-    assert t.NewStar("hi", "lo", value=10).value == 12
-    assert t.NewStar(value=10, other="blah").value == 20
-
-    # Make sure a Python class that derives from a C++ class that uses
-    # nb::new_() can be instantiated producing the correct Python type
-    class FancyInt(t.UniqueInt):
-        @staticmethod
-        def the_answer():
-            return 42
-
-        @property
-        def value_as_string(self):
-            return str(self.value())
-
-    f1 = FancyInt(10)
-    f2 = FancyInt(20)
-    # The derived-type wrapping doesn't preserve Python identity...
-    assert f1 is not FancyInt(10)
-    # ... but does preserve C++ identity
-    assert f1.lookups() == u4.lookups() == 3  # u4, f1, and anonymous
-    assert f1.the_answer() == f2.the_answer() == 42
-    assert f1.value_as_string == "10"
-    assert f2.value_as_string == "20"
-
-def test47_inconstructible():
-    with pytest.raises(TypeError, match="no constructor defined"):
-        t.Foo()
-
-def test48_monekypatchable():
-    # issue 750: how to monkeypatch __init__
-    q = t.MonkeyPatchable()
-    assert q.value == 123
-
-    def my_init(self):
-        t.MonkeyPatchable.custom_init(self)
-
-    t.MonkeyPatchable.__init__ = my_init
-    q = t.MonkeyPatchable()
-    assert q.value == 456
-
-def test49_static_property_override():
-    assert t.StaticPropertyOverride.x == 42
-    assert t.StaticPropertyOverride2.x == 43
diff --git a/src/nanobind/tests/test_classes_ext.pyi.ref b/src/nanobind/tests/test_classes_ext.pyi.ref
deleted file mode 100644
index d9b8593..0000000
--- a/src/nanobind/tests/test_classes_ext.pyi.ref
+++ /dev/null
@@ -1,362 +0,0 @@
-from typing import overload
-
-
-class Struct:
-    """Some documentation"""
-
-    @overload
-    def __init__(self) -> None: ...
-
-    @overload
-    def __init__(self, arg: int, /) -> None: ...
-
-    def value(self) -> int: ...
-
-    def set_value(self, value: int) -> None: ...
-
-    def self(self) -> Struct: ...
-
-    def none(self) -> Struct: ...
-
-    def __getstate__(self) -> int: ...
-
-    def __setstate__(self, arg: int, /) -> None: ...
-
-    @overload
-    @staticmethod
-    def static_test(arg: int, /) -> int: ...
-
-    @overload
-    @staticmethod
-    def static_test(arg: float, /) -> int: ...
-
-    @staticmethod
-    def create_move() -> Struct: ...
-
-    @staticmethod
-    def create_reference() -> Struct: ...
-
-    @staticmethod
-    def create_copy() -> Struct: ...
-
-    @staticmethod
-    def create_take() -> Struct: ...
-
-class PairStruct:
-    def __init__(self) -> None: ...
-
-    @property
-    def s1(self) -> Struct:
-        """A documented property"""
-
-    @s1.setter
-    def s1(self, arg: Struct, /) -> None: ...
-
-    @property
-    def s2(self) -> Struct: ...
-
-    @s2.setter
-    def s2(self, arg: Struct, /) -> None: ...
-
-def stats() -> dict: ...
-
-def reset() -> None: ...
-
-class Big:
-    """
-    A class
-    with a multi-line
-    docstring..
-    """
-
-    def __init__(self) -> None: ...
-
-class BigAligned:
-    def __init__(self) -> None: ...
-
-class Animal:
-    def __init__(self) -> None:
-        """A constructor"""
-
-    def name(self) -> str:
-        """A method"""
-
-    def what(self) -> str: ...
-
-class Dog(Animal):
-    def __init__(self, arg: str, /) -> None: ...
-
-class Cat(Animal):
-    def __init__(self, arg: str, /) -> None: ...
-
-class SiameseCat(Cat):
-    pass
-
-def go(arg: Animal, /) -> str: ...
-
-def animal_passthrough(arg: Animal, /) -> Animal: ...
-
-def dog_passthrough(arg: Dog, /) -> Dog: ...
-
-def void_ret(arg: Animal, /) -> None: ...
-
-def call_function(arg: object, /) -> object: ...
-
-def call_method(arg: object, /) -> object: ...
-
-class Foo:
-    pass
-
-def i2p(arg: int, /) -> Foo: ...
-
-def p2i(x: Foo | None = None) -> int: ...
-
-class A:
-    def __init__(self, arg: int, /) -> None: ...
-
-class B:
-    def __init__(self, arg: int, /) -> None: ...
-
-class B2(B):
-    def __init__(self, arg: int, /) -> None: ...
-
-class C:
-    def __init__(self, arg: int, /) -> None: ...
-
-class D:
-    @overload
-    def __init__(self, arg: A, /) -> None: ...
-
-    @overload
-    def __init__(self, arg: B, /) -> None: ...
-
-    @overload
-    def __init__(self, arg: int, /) -> None: ...
-
-    @overload
-    def __init__(self, arg: float, /) -> None: ...
-
-    @property
-    def value(self) -> int: ...
-
-    @value.setter
-    def value(self, arg: int, /) -> None: ...
-
-def get_d(arg: D, /) -> int: ...
-
-def get_optional_d(arg: D | None) -> int: ...
-
-def get_d_via_cast(arg: object, /) -> tuple: ...
-
-def get_d_via_try_cast(arg: object, /) -> tuple: ...
-
-class Int:
-    def __init__(self, arg: int, /) -> None: ...
-
-    def __add__(self, arg: Int, /) -> Int: ...
-
-    def __iadd__(self, arg: Int, /) -> Int: ...
-
-    def __sub__(self, arg: float, /) -> Int: ...
-
-    def __repr__(self) -> str: ...
-
-def keep_alive_arg(arg0: object, arg1: object, /) -> object: ...
-
-def keep_alive_ret(arg0: object, arg1: object, /) -> object: ...
-
-def f() -> None: ...
-
-class MyClass:
-    def __init__(self) -> None: ...
-
-    class NestedClass:
-        def f(self) -> None: ...
-
-    def f(self) -> None: ...
-
-class StaticProperties:
-    value: int = ...
-    """Static property docstring"""
-
-    @staticmethod
-    def get() -> int: ...
-
-class StaticProperties2(StaticProperties):
-    pass
-
-class ClassWithSupplement:
-    def __init__(self) -> None: ...
-
-def check_supplement(arg: object, /) -> bool: ...
-
-class ClassWithLen:
-    def __init__(self) -> None: ...
-
-    def __len__(self, /):
-        """Return len(self)."""
-
-def test_lowlevel() -> tuple: ...
-
-def test_handle_t(arg: Struct, /) -> object: ...
-
-def test_type_object_t(arg: type[Struct], /) -> object: ...
-
-def none_0(arg: Struct, /) -> bool: ...
-
-def none_1(arg: Struct) -> bool: ...
-
-def none_2(arg: Struct) -> bool: ...
-
-def none_3(arg: Struct | None) -> bool: ...
-
-def none_4(arg: Struct | None) -> bool: ...
-
-class FinalType:
-    def __init__(self) -> None: ...
-
-class StructWithAttr(Struct):
-    def __init__(self, arg: int, /) -> None: ...
-
-class Wrapper:
-    def __init__(self) -> None: ...
-
-    @property
-    def value(self) -> Wrapper: ...
-
-    @value.setter
-    def value(self, arg: Wrapper, /) -> None: ...
-
-class NonCopyableVec:
-    pass
-
-def is_int_1(arg: object, /) -> bool: ...
-
-def is_int_2(arg: object, /) -> bool: ...
-
-def is_struct(arg: object, /) -> bool: ...
-
-class Base:
-    pass
-
-class Subclass:
-    pass
-
-class PolymorphicBase:
-    pass
-
-class PolymorphicSubclass:
-    pass
-
-def polymorphic_factory() -> PolymorphicBase: ...
-
-def polymorphic_factory_2() -> PolymorphicBase: ...
-
-def factory() -> Base: ...
-
-def factory_2() -> Base: ...
-
-def check_shared(arg: "Shared", /) -> None: ...
-
-def try_cast_1(arg: object | None) -> tuple[bool, Struct]: ...
-
-def try_cast_2(arg: object | None) -> tuple[bool, Struct]: ...
-
-def try_cast_3(arg: object | None) -> tuple[bool, Struct]: ...
-
-def try_cast_4(arg: object, /) -> tuple[bool, int]: ...
-
-def test_slots() -> tuple: ...
-
-class IncrementingStruct(Struct):
-    def __init__(self, arg: Struct, /) -> None: ...
-
-def get_destructed() -> list: ...
-
-def get_incrementing_struct_value(arg: IncrementingStruct, /) -> Struct: ...
-
-class StructWithWeakrefs(Struct):
-    def __init__(self, arg: int, /) -> None: ...
-
-class StructWithWeakrefsAndDynamicAttrs(Struct):
-    def __init__(self, arg: int, /) -> None: ...
-
-class Union:
-    def __init__(self) -> None: ...
-
-    @property
-    def i(self) -> int: ...
-
-    @i.setter
-    def i(self, arg: int, /) -> None: ...
-
-    @property
-    def f(self) -> float: ...
-
-    @f.setter
-    def f(self, arg: float, /) -> None: ...
-
-class BoundDerived:
-    def __init__(self) -> None: ...
-
-    @property
-    def value(self) -> int: ...
-
-    @value.setter
-    def value(self, arg: int, /) -> None: ...
-
-    @property
-    def prop(self) -> int: ...
-
-    @prop.setter
-    def prop(self, arg: int, /) -> None: ...
-
-    def get_answer(self) -> int: ...
-
-    def polymorphic(self) -> int: ...
-
-class UniqueInt:
-    @overload
-    def __init__(self, arg: int, /) -> None: ...
-
-    @overload
-    def __init__(self, s: str) -> None: ...
-
-    def value(self) -> int: ...
-
-    def lookups(self) -> int: ...
-
-class NewNone:
-    def __init__(self) -> None: ...
-
-class NewDflt:
-    def __init__(self, value: int = 42) -> None: ...
-
-    @property
-    def value(self) -> int: ...
-
-class NewStar:
-    def __init__(self, *args, value: int = 42, **kwargs) -> None: ...
-
-    @property
-    def value(self) -> int: ...
-
-class MonkeyPatchable:
-    def __init__(self) -> None: ...
-
-    @staticmethod
-    def custom_init(arg: MonkeyPatchable, /) -> None: ...
-
-    @property
-    def value(self) -> int: ...
-
-    @value.setter
-    def value(self, arg: int, /) -> None: ...
-
-class StaticPropertyOverride:
-    x: int = ...
-    """(arg: object, /) -> int"""
-
-class StaticPropertyOverride2(StaticPropertyOverride):
-    x: int = ...
-    """(arg: object, /) -> int"""
diff --git a/src/nanobind/tests/test_eigen.cpp b/src/nanobind/tests/test_eigen.cpp
deleted file mode 100644
index 904e115..0000000
--- a/src/nanobind/tests/test_eigen.cpp
+++ /dev/null
@@ -1,281 +0,0 @@
-#include <nanobind/stl/complex.h>
-#include <nanobind/eigen/dense.h>
-#include <nanobind/eigen/sparse.h>
-#include <nanobind/trampoline.h>
-#include <iostream>
-
-namespace nb = nanobind;
-
-using namespace nb::literals;
-
-NB_MODULE(test_eigen_ext, m) {
-    m.def("addV3i",
-          [](const Eigen::Vector3i &a,
-             const Eigen::Vector3i &b) -> Eigen::Vector3i { return a + b; },
-          "a"_a, "b"_a.noconvert());
-
-    m.def("addR3i",
-          [](const Eigen::RowVector3i &a,
-             const Eigen::RowVector3i &b) -> Eigen::RowVector3i { return a + b; },
-          "a"_a, "b"_a.noconvert());
-
-    m.def("addRefCnstV3i",
-          [](const Eigen::Ref<const Eigen::Vector3i> &a,
-             const Eigen::Ref<const Eigen::Vector3i> &b) -> Eigen::Vector3i { return a + b; },
-          "a"_a, "b"_a.noconvert());
-
-    m.def("addRefCnstR3i",
-          [](const Eigen::Ref<const Eigen::RowVector3i>& a,
-             const Eigen::Ref<const Eigen::RowVector3i>& b) -> Eigen::RowVector3i { return a + b; },
-          "a"_a, "b"_a.noconvert());
-
-    m.def("addA3i",
-          [](const Eigen::Array3i &a,
-             const Eigen::Array3i &b) -> Eigen::Array3i { return a + b; },
-          "a"_a, "b"_a.noconvert());
-
-    m.def("addA3i_retExpr",
-          [](const Eigen::Array3i &a,
-             const Eigen::Array3i &b) { return a + b; },
-          "a"_a, "b"_a.noconvert());
-
-    m.def("addVXi",
-          [](const Eigen::VectorXi &a,
-             const Eigen::VectorXi &b) -> Eigen::VectorXi { return a + b; });
-
-    using Matrix4uC = Eigen::Matrix<uint32_t, 4, 4, Eigen::ColMajor>;
-    using Matrix4uR = Eigen::Matrix<uint32_t, 4, 4, Eigen::RowMajor>;
-    using MatrixXuC = Eigen::Matrix<uint32_t, Eigen::Dynamic, Eigen::Dynamic, Eigen::ColMajor>;
-    using MatrixXuR = Eigen::Matrix<uint32_t, Eigen::Dynamic, Eigen::Dynamic, Eigen::RowMajor>;
-
-    m.def("addM4uCC",
-          [](const Matrix4uC &a,
-             const Matrix4uC &b) -> Matrix4uC { return a + b; });
-    m.def("addMXuCC",
-          [](const MatrixXuC &a,
-             const MatrixXuC &b) -> MatrixXuC { return a + b; });
-    m.def("addMXuCC_nc",
-          [](const MatrixXuC &a,
-             const MatrixXuC &b) -> MatrixXuC { return a + b; },
-          "a"_a.noconvert(), "b"_a.noconvert());
-
-
-    m.def("addM4uRR",
-          [](const Matrix4uR &a,
-             const Matrix4uR &b) -> Matrix4uR { return a + b; });
-    m.def("addMXuRR",
-          [](const MatrixXuR &a,
-             const MatrixXuR &b) -> MatrixXuR { return a + b; });
-    m.def("addMXuRR_nc",
-          [](const MatrixXuR &a,
-             const MatrixXuR &b) -> MatrixXuR { return a + b; },
-          "a"_a.noconvert(), "b"_a.noconvert());
-
-    m.def("addM4uCR",
-          [](const Matrix4uC &a,
-             const Matrix4uR &b) -> Matrix4uC { return a + b; });
-    m.def("addMXuCR",
-          [](const MatrixXuC &a,
-             const MatrixXuR &b) -> MatrixXuC { return a + b; });
-
-    m.def("addM4uRC",
-          [](const Matrix4uR &a,
-             const Matrix4uC &b) -> Matrix4uR { return a + b; });
-    m.def("addMXuRC",
-          [](const MatrixXuR &a,
-             const MatrixXuC &b) -> MatrixXuR { return a + b; });
-
-    m.def("addMapMXuCC",
-          [](const Eigen::Map<MatrixXuC>& a,
-             const Eigen::Map<MatrixXuC>& b) -> MatrixXuC { return a + b; });
-
-    m.def("addMapCnstMXuCC",
-          [](const Eigen::Map<const MatrixXuC>& a,
-             const Eigen::Map<const MatrixXuC>& b) -> MatrixXuC { return a + b; });
-
-    m.def("addMapMXuRR",
-          [](const Eigen::Map<MatrixXuR>& a,
-             const Eigen::Map<MatrixXuR>& b) -> MatrixXuC { return a + b; });
-
-    m.def("addMapCnstMXuRR",
-          [](const Eigen::Map<const MatrixXuR>& a,
-             const Eigen::Map<const MatrixXuR>& b) -> MatrixXuC { return a + b; });
-
-    m.def("addRefMXuCC",
-          [](const Eigen::Ref<MatrixXuC>& a,
-             const Eigen::Ref<MatrixXuC>& b) -> MatrixXuC { return a + b; });
-
-    m.def("addRefCnstMXuCC",
-          [](const Eigen::Ref<const MatrixXuC>& a,
-             const Eigen::Ref<const MatrixXuC>& b) -> MatrixXuC { return a + b; });
-
-    m.def("addRefCnstMXuCC_nc",
-          [](const Eigen::Ref<const MatrixXuC>& a,
-             const Eigen::Ref<const MatrixXuC>& b) -> MatrixXuC { return a + b; },
-          "a"_a.noconvert(), "b"_a.noconvert());
-
-    m.def("addRefMXuRR",
-          [](const Eigen::Ref<MatrixXuR>& a,
-             const Eigen::Ref<MatrixXuR>& b) -> MatrixXuC { return a + b; });
-
-    m.def("addRefCnstMXuRR",
-          [](const Eigen::Ref<const MatrixXuR>& a,
-             const Eigen::Ref<const MatrixXuR>& b) -> MatrixXuC { return a + b; });
-
-    m.def("addRefCnstMXuRR_nc",
-          [](const Eigen::Ref<const MatrixXuR>& a,
-             const Eigen::Ref<const MatrixXuR>& b) -> MatrixXuC { return a + b; },
-          "a"_a.noconvert(), "b"_a.noconvert());
-
-    m.def("addDRefMXuCC_nc",
-          [](const nb::DRef<MatrixXuC> &a,
-             const nb::DRef<MatrixXuC> &b) -> MatrixXuC { return a + b; },
-          "a"_a.noconvert(), "b"_a.noconvert());
-
-    m.def("addDRefMXuRR_nc",
-          [](const nb::DRef<MatrixXuR>& a,
-             const nb::DRef<MatrixXuR>& b) -> MatrixXuC { return a + b; },
-          "a"_a.noconvert(), "b"_a.noconvert());
-
-    m.def("mutate_DRefMXuC", [](nb::DRef<MatrixXuC> a) { a *= 2; }, nb::arg().noconvert());
-
-    m.def("updateRefV3i", [](Eigen::Ref<Eigen::Vector3i> a) { a[2] = 123; });
-    m.def("updateRefV3i_nc", [](Eigen::Ref<Eigen::Vector3i> a) { a[2] = 123; }, nb::arg().noconvert());
-    m.def("updateRefVXi", [](Eigen::Ref<Eigen::VectorXi> a) { a[2] = 123; });
-    m.def("updateRefVXi_nc", [](Eigen::Ref<Eigen::VectorXi> a) { a[2] = 123; }, nb::arg().noconvert());
-
-    using SparseMatrixR = Eigen::SparseMatrix<float, Eigen::RowMajor>;
-    using SparseMatrixC = Eigen::SparseMatrix<float>;
-    Eigen::MatrixXf mat(5, 6);
-    mat <<
-	     0, 3,  0, 0,  0, 11,
-	    22, 0,  0, 0, 17, 11,
-	     7, 5,  0, 1,  0, 11,
-	     0, 0,  0, 0,  0, 11,
-	     0, 0, 14, 0,  8, 11;
-    m.def("sparse_r", [mat]() -> SparseMatrixR {
-        return Eigen::SparseView<Eigen::MatrixXf>(mat);
-    });
-    m.def("sparse_c", [mat]() -> SparseMatrixC {
-        return Eigen::SparseView<Eigen::MatrixXf>(mat);
-    });
-    m.def("sparse_copy_r", [](const SparseMatrixR &m) -> SparseMatrixR { return m; });
-    m.def("sparse_copy_c", [](const SparseMatrixC &m) -> SparseMatrixC { return m; });
-    m.def("sparse_r_uncompressed", []() -> SparseMatrixR {
-        SparseMatrixR m(2,2);
-        m.coeffRef(0,0) = 1.0f;
-        assert(!m.isCompressed());
-        return m.markAsRValue();
-    });
-    // This function doesn't appear to be called in tests/test_eigen.py
-    m.def("sparse_complex", [](Eigen::SparseMatrix<std::complex<double>> x) -> Eigen::SparseMatrix<std::complex<double>> { return x; });
-    m.def("sparse_complex_map_c", [](Eigen::Map<Eigen::SparseMatrix<std::complex<double>>> x) { return x; });
-
-    m.def("sparse_map_c", [](const Eigen::Map<const SparseMatrixC> &c) { return c; }, nb::rv_policy::reference);
-    m.def("sparse_map_r", [](const Eigen::Map<const SparseMatrixR> &r) { return r; }, nb::rv_policy::reference);
-
-    m.def("sparse_update_map_to_zero_c", [](nb::object obj) {
-        Eigen::Map<SparseMatrixC> c = nb::cast<Eigen::Map<SparseMatrixC>>(obj);
-        for (int i = 0; i < c.nonZeros(); ++i) { c.valuePtr()[i] = 0; }
-    });
-    m.def("sparse_update_map_to_zero_r", [](nb::object obj) {
-        Eigen::Map<SparseMatrixR> r = nb::cast<Eigen::Map<SparseMatrixR>>(obj);
-        for (int i = 0; i < r.nonZeros(); ++i) { r.valuePtr()[i] = 0; }
-    });
-
-    /// issue #166
-    using Matrix1d = Eigen::Matrix<double,1,1>;
-    try {
-        m.def(
-            "default_arg", [](Matrix1d a, Matrix1d b) -> Matrix1d { return a + b; },
-            "a"_a = Matrix1d::Zero(), "b"_a = Matrix1d::Zero());
-    } catch (...) {
-        // Ignore (NumPy not installed, etc.)
-    }
-
-    struct Buffer {
-        uint32_t x[30] { };
-
-        using Map = Eigen::Map<Eigen::Array<uint32_t, 10, 3>>;
-        using DMap = Eigen::Map<Eigen::Array<uint32_t, Eigen::Dynamic, Eigen::Dynamic>>;
-
-        Map map() { return Map(x); }
-        DMap dmap() { return DMap(x, 10, 3); }
-    };
-
-    nb::class_<Buffer>(m, "Buffer")
-        .def(nb::init<>())
-        .def("map", &Buffer::map, nb::rv_policy::reference_internal)
-        .def("dmap", &Buffer::dmap, nb::rv_policy::reference_internal);
-
-
-    struct ClassWithEigenMember {
-        Eigen::MatrixXd member = Eigen::Matrix2d::Ones();
-        const Eigen::MatrixXd &get_member_ref() { return member; }
-        const Eigen::MatrixXd get_member_copy() { return member; }
-    };
-
-    nb::class_<ClassWithEigenMember>(m, "ClassWithEigenMember")
-        .def(nb::init<>())
-        .def_prop_ro("member_ro_ref", &ClassWithEigenMember::get_member_ref)
-        .def_prop_ro("member_ro_copy", &ClassWithEigenMember::get_member_copy)
-        .def_rw("member", &ClassWithEigenMember::member);
-
-    m.def("castToMapVXi", [](nb::object obj) {
-        return nb::cast<Eigen::Map<Eigen::VectorXi>>(obj);
-    });
-    m.def("castToMapCnstVXi", [](nb::object obj) {
-      return nb::cast<Eigen::Map<const Eigen::VectorXi>>(obj);
-      });
-    m.def("castToRefVXi", [](nb::object obj) -> Eigen::VectorXi {
-        return nb::cast<Eigen::Ref<Eigen::VectorXi>>(obj);
-    });
-    m.def("castToRefCnstVXi", [](nb::object obj) -> Eigen::VectorXi {
-        return nb::cast<Eigen::Ref<const Eigen::VectorXi>>(obj);
-    });
-    m.def("castToDRefCnstVXi", [](nb::object obj) -> Eigen::VectorXi {
-        return nb::cast<nb::DRef<const Eigen::VectorXi>>(obj);
-    });
-    m.def("castToRef03CnstVXi", [](nb::object obj) -> Eigen::VectorXi {
-        return nb::cast<Eigen::Ref<const Eigen::VectorXi, Eigen::Unaligned, Eigen::InnerStride<3>>>(obj);
-    });
-
-    struct Base {
-        virtual ~Base() = default;
-        virtual void modRefData(Eigen::Ref<Eigen::VectorXd>) {}
-        virtual void modRefDataConst(Eigen::Ref<const Eigen::VectorXd>) {}
-        virtual Eigen::VectorXd returnVecXd() { return { 1, 2 }; }
-    };
-
-    struct PyBase : Base {
-        NB_TRAMPOLINE(Base, 3);
-        void modRefData(Eigen::Ref<Eigen::VectorXd> a) override {
-            NB_OVERRIDE_PURE(modRefData, a);
-        }
-        void modRefDataConst(Eigen::Ref<const Eigen::VectorXd> a) override {
-            NB_OVERRIDE_PURE(modRefDataConst, a);
-        }
-        Eigen::VectorXd returnVecXd() override {
-            NB_OVERRIDE_PURE(returnVecXd);
-        }
-    };
-
-    nb::class_<Base, PyBase>(m, "Base")
-        .def(nb::init<>())
-        .def("modRefData", &Base::modRefData)
-        .def("modRefDataConst", &Base::modRefDataConst);
-
-    m.def("modifyRef", [](Base* base) {
-        Eigen::Vector2d input(1.0, 2.0);
-        base->modRefData(input);
-        return input;
-    });
-    m.def("modifyRefConst", [](Base* base) {
-        Eigen::Vector2d input(1.0, 2.0);
-        base->modRefDataConst(input);
-        return input;
-    });
-    m.def("returnVecXd", [](Base* base) {
-        return base->returnVecXd();
-    });
-}
diff --git a/src/nanobind/tests/test_eigen.py b/src/nanobind/tests/test_eigen.py
deleted file mode 100644
index f8d5ac0..0000000
--- a/src/nanobind/tests/test_eigen.py
+++ /dev/null
@@ -1,468 +0,0 @@
-import pytest
-import gc
-import itertools
-import re
-import sys
-
-try:
-    import numpy as np
-    from numpy.testing import assert_array_equal
-    import test_eigen_ext as t
-    def needs_numpy_and_eigen(x):
-        return x
-except:
-    needs_numpy_and_eigen = pytest.mark.skip(reason="NumPy and Eigen are required")
-
-
-@needs_numpy_and_eigen
-def test01_vector_fixed():
-    a  = np.array([1, 2, 3],    dtype=np.int32)
-    b  = np.array([0, 1, 2],    dtype=np.int32)
-    c  = np.array([1, 3, 5],    dtype=np.int32)
-    x  = np.array([1, 3, 5, 6], dtype=np.int32)
-    af = np.float32(a)
-    bf = np.float32(b)
-
-    assert_array_equal(t.addV3i(a, b), c)
-    assert_array_equal(t.addR3i(a, b), c)
-    assert_array_equal(t.addRefCnstV3i(a, b), c)
-    assert_array_equal(t.addRefCnstR3i(a, b), c)
-    assert_array_equal(t.addA3i(a, b), c)
-    assert_array_equal(t.addA3i_retExpr(a, b), c)
-
-    # Implicit conversion supported for first argument
-    assert_array_equal(t.addV3i(af, b), c)
-    assert_array_equal(t.addR3i(af, b), c)
-    assert_array_equal(t.addRefCnstV3i(af, b), c)
-    assert_array_equal(t.addRefCnstR3i(af, b), c)
-    assert_array_equal(t.addA3i(af, b), c)
-
-    # But not the second one
-    with pytest.raises(TypeError, match='incompatible function arguments'):
-        t.addV3i(a, bf)
-    with pytest.raises(TypeError, match='incompatible function arguments'):
-        t.addR3i(a, bf)
-    with pytest.raises(TypeError, match='incompatible function arguments'):
-        t.addRefCnstV3i(a, bf)
-    with pytest.raises(TypeError, match='incompatible function arguments'):
-        t.addRefCnstR3i(a, bf)
-    with pytest.raises(TypeError, match='incompatible function arguments'):
-        t.addA3i(a, bf)
-
-    # Catch size errors
-    with pytest.raises(TypeError, match='incompatible function arguments'):
-        t.addV3i(x, b)
-    with pytest.raises(TypeError, match='incompatible function arguments'):
-        t.addR3i(x, b)
-    with pytest.raises(TypeError, match='incompatible function arguments'):
-        t.addRefCnstV3i(x, b)
-    with pytest.raises(TypeError, match='incompatible function arguments'):
-        t.addA3i(x, b)
-
-
-@needs_numpy_and_eigen
-def test02_vector_dynamic():
-    a  = np.array([1, 2, 3], dtype=np.int32)
-    b  = np.array([0, 1, 2], dtype=np.int32)
-    c  = np.array([1, 3, 5], dtype=np.int32)
-    x  = np.arange(10000, dtype=np.int32)
-    af = np.float32(a)
-
-    # Check call with dynamically sized arrays
-    assert_array_equal(t.addVXi(a, b), c)
-
-    # Implicit conversion
-    assert_array_equal(t.addVXi(af, b), c)
-
-    # Try with a big array. This will move the result to avoid a copy
-    assert_array_equal(t.addVXi(x, x), 2*x)
-
-
-@needs_numpy_and_eigen
-def test03_update_map():
-    a = np.array([1, 2, 3], dtype=np.int32)
-    b = np.array([1, 2, 123], dtype=np.int32)
-    c = a.copy()
-    t.updateRefV3i(c)
-    assert_array_equal(c, b)
-
-    c = a.copy()
-    t.updateRefV3i_nc(c)
-    assert_array_equal(c, b)
-
-    c = a.copy()
-    t.updateRefVXi(c)
-    assert_array_equal(c, b)
-
-    c = a.copy()
-    t.updateRefVXi_nc(c)
-    assert_array_equal(c, b)
-
-    c = np.float32(a)
-    with pytest.raises(TypeError, match='incompatible function arguments'):
-        t.updateRefV3i(c)
-
-    c = np.float32(a)
-    with pytest.raises(TypeError, match='incompatible function arguments'):
-        t.updateRefV3i_nc(c)
-
-    c = np.float32(a)
-    with pytest.raises(TypeError, match='incompatible function arguments'):
-        t.updateRefVXi(c)
-
-    c = np.float32(a)
-    with pytest.raises(TypeError, match='incompatible function arguments'):
-        t.updateRefVXi_nc(c)
-
-
-
-@needs_numpy_and_eigen
-def test04_matrix():
-    A = np.vander((1, 2, 3, 4,))
-    At = A.T
-    assert A.flags['C_CONTIGUOUS']
-    assert At.flags['F_CONTIGUOUS']
-    base = np.zeros((A.shape[0] * 2, A.shape[1] * 2), A.dtype)
-    base[::2, ::2] = A
-    Av = base[-2::-2, -2::-2]
-    assert Av.base is base
-    Avt = Av.T
-    assert Avt.base is base
-    matrices = A, At, Av, Avt
-    for addM in (t.addM4uCC, t.addM4uRR, t.addM4uCR, t.addM4uRC,
-                 t.addMXuCC, t.addMXuRR, t.addMXuCR, t.addMXuRC):
-        for left, right in itertools.product(matrices, matrices):
-            assert_array_equal(addM(left, right), left + right)
-
-
-@needs_numpy_and_eigen
-@pytest.mark.parametrize("rowStart", (0, 1))
-@pytest.mark.parametrize("colStart", (0, 2))
-@pytest.mark.parametrize("rowStep", (1, 2, -2))
-@pytest.mark.parametrize("colStep", (1, 3, -3))
-@pytest.mark.parametrize("transpose", (False, True))
-def test05_matrix_large_nonsymm(rowStart, colStart, rowStep, colStep, transpose):
-    A = np.uint32(np.vander(np.arange(80)))
-    if rowStep < 0:
-        rowStart = -rowStart - 1
-    if colStep < 0:
-        colStart = -colStart - 1
-    A = A[rowStart::rowStep, colStart::colStep]
-    if transpose:
-        A = A.T
-    A2 = A + A
-    assert_array_equal(t.addMXuCC(A, A), A2)
-    assert_array_equal(t.addMXuRR(A, A), A2)
-    assert_array_equal(t.addMXuCR(A, A), A2)
-    assert_array_equal(t.addMXuRC(A, A), A2)
-    assert_array_equal(t.addDRefMXuCC_nc(A, A), A2)
-    assert_array_equal(t.addDRefMXuRR_nc(A, A), A2)
-    if A.flags['C_CONTIGUOUS']:
-        assert_array_equal(t.addMapMXuRR(A, A), A2)
-        assert_array_equal(t.addMapCnstMXuRR(A, A), A2)
-    else:
-        with pytest.raises(TypeError, match="incompatible function arguments"):
-            t.addMapMXuRR(A, A)
-        with pytest.raises(TypeError, match="incompatible function arguments"):
-            t.addMapCnstMXuRR(A, A)
-
-    assert_array_equal(t.addRefCnstMXuRR(A, A), A2)
-    assert_array_equal(t.addRefCnstMXuRR(A.view(np.int32), A), A2)
-    assert_array_equal(t.addRefCnstMXuRR_nc(A, A), A2)
-    with pytest.raises(TypeError, match="incompatible function arguments"):
-        t.addRefCnstMXuRR_nc(A.view(np.int32), A)
-    if A.strides[1] == A.itemsize:
-        assert_array_equal(t.addRefMXuRR(A, A), A2)
-    else:
-        with pytest.raises(TypeError, match="incompatible function arguments"):
-            t.addRefMXuRR(A, A)
-    if A.flags['F_CONTIGUOUS']:
-        assert_array_equal(t.addMapMXuCC(A, A), A2)
-        assert_array_equal(t.addMapCnstMXuCC(A, A), A2)
-    else:
-        with pytest.raises(TypeError, match="incompatible function arguments"):
-            t.addMapMXuCC(A, A)
-        with pytest.raises(TypeError, match="incompatible function arguments"):
-            t.addMapCnstMXuCC(A, A)
-
-    assert_array_equal(t.addRefCnstMXuCC(A, A), A2)
-    assert_array_equal(t.addRefCnstMXuCC(A.view(np.int32), A), A2)
-    assert_array_equal(t.addRefCnstMXuCC_nc(A, A), A2)
-    with pytest.raises(TypeError, match="incompatible function arguments"):
-        t.addRefCnstMXuCC_nc(A.view(np.int32), A)
-    if A.strides[0] == A.itemsize:
-        assert_array_equal(t.addRefMXuCC(A, A), A2)
-    else:
-        with pytest.raises(TypeError, match="incompatible function arguments"):
-            t.addRefMXuCC(A, A)
-    A = np.ascontiguousarray(A)
-    assert A.flags['C_CONTIGUOUS']
-    assert_array_equal(t.addMXuRR_nc(A, A), A2)
-    A = np.asfortranarray(A)
-    assert A.flags['F_CONTIGUOUS']
-    assert_array_equal(t.addMXuCC_nc(A, A), A2)
-
-
-@needs_numpy_and_eigen
-def test06_map():
-    b = t.Buffer()
-    m = b.map()
-    dm = b.dmap()
-    for i in range(10):
-        for j in range(3):
-            m[i, j] = i*3+j
-    for i in range(10):
-        for j in range(3):
-            assert dm[i, j] == i*3+j
-    del dm
-    del b
-    gc.collect()
-    gc.collect()
-    for i in range(10):
-        for j in range(3):
-            assert m[i, j] == i*3+j
-
-
-@needs_numpy_and_eigen
-def test07_mutate_arg():
-    A = np.uint32(np.vander(np.arange(10)))
-    A2 = A.copy()
-    t.mutate_DRefMXuC(A)
-    assert_array_equal(A, 2*A2)
-
-
-def create_spmat_unsorted():
-    import scipy.sparse as sparse
-    # Create a small matrix with explicit indices and indptr
-    data = np.array([1.0, 2.0, 3.0, 4.0, 5.0])
-
-    # Deliberately unsorted indices within columns
-    # For a properly sorted CSC matrix, indices should be sorted within each column
-    indices = np.array([0, 2, 1, 4, 3])  # Unsorted (should be [0, 1, 2, 3, 4])
-
-    # indptr points to where each column starts in the indices/data arrays
-    indptr = np.array([0, 2, 3, 5])
-
-    # Create a 5x3 matrix with unsorted indices
-    unsorted_csc = sparse.csc_matrix((data, indices, indptr), shape=(5, 3))
-
-    # Verify that indices are unsorted
-    assert not unsorted_csc.has_sorted_indices
-    return unsorted_csc
-
-
-@needs_numpy_and_eigen
-def test08_sparse():
-    pytest.importorskip("scipy")
-    import scipy.sparse
-
-    # no isinstance here because we want strict type equivalence
-    assert type(t.sparse_r()) is scipy.sparse.csr_matrix
-    assert type(t.sparse_c()) is scipy.sparse.csc_matrix
-    assert type(t.sparse_copy_r(t.sparse_r())) is scipy.sparse.csr_matrix
-    assert type(t.sparse_copy_c(t.sparse_c())) is scipy.sparse.csc_matrix
-    assert type(t.sparse_copy_r(t.sparse_c())) is scipy.sparse.csr_matrix
-    assert type(t.sparse_copy_c(t.sparse_r())) is scipy.sparse.csc_matrix
-
-
-    def assert_sparse_equal_ref(sparse_mat):
-        ref = np.array(
-            [
-                [0.0, 3, 0, 0, 0, 11],
-                [22, 0, 0, 0, 17, 11],
-                [7, 5, 0, 1, 0, 11],
-                [0, 0, 0, 0, 0, 11],
-                [0, 0, 14, 0, 8, 11],
-            ]
-        )
-        assert_array_equal(sparse_mat.toarray(), ref)
-
-    assert_sparse_equal_ref(t.sparse_r())
-    assert_sparse_equal_ref(t.sparse_c())
-    assert_sparse_equal_ref(t.sparse_copy_r(t.sparse_r()))
-    assert_sparse_equal_ref(t.sparse_copy_c(t.sparse_c()))
-    assert_sparse_equal_ref(t.sparse_copy_r(t.sparse_c()))
-    assert_sparse_equal_ref(t.sparse_copy_c(t.sparse_r()))
-
-    # construct scipy matrix with unsorted indices
-    assert type(t.sparse_copy_c(create_spmat_unsorted())) is scipy.sparse.csc_matrix
-    mat_unsort = create_spmat_unsorted()
-    assert_array_equal(t.sparse_copy_c(mat_unsort).toarray(), create_spmat_unsorted().toarray())
-
-
-@needs_numpy_and_eigen
-def test09_sparse_failures():
-    sp = pytest.importorskip("scipy.sparse")
-
-    with pytest.raises(
-        ValueError,
-        match=re.escape(
-            "nanobind: unable to return an Eigen sparse matrix that is not in a compressed format. Please call `.makeCompressed()` before returning the value on the C++ end."
-        ),
-    ):
-        t.sparse_r_uncompressed()
-
-    csr_matrix = sp.csr_matrix
-    sp.csr_matrix = None
-    with pytest.raises(TypeError, match=re.escape("'NoneType' object is not callable")):
-        t.sparse_r()
-
-    del sp.csr_matrix
-    with pytest.raises(
-        AttributeError,
-        match=re.escape("'scipy.sparse' has no attribute 'csr_matrix'"),
-    ):
-        t.sparse_r()
-
-    sys_path = sys.path
-    sys.path = []
-    del sys.modules["scipy"]
-    with pytest.raises(ModuleNotFoundError, match=re.escape("No module named 'scipy'")):
-        t.sparse_r()
-
-    # undo sabotage of the module
-    sys.path = sys_path
-    sp.csr_matrix = csr_matrix
-
-@needs_numpy_and_eigen
-def test10_eigen_scalar_default():
-    x = t.default_arg()
-    assert x==0
-
-@needs_numpy_and_eigen
-def test11_prop():
-    for j in range(3):
-        c = t.ClassWithEigenMember()
-        ref = np.ones((2, 2))
-        if j == 0:
-            c.member = ref
-
-        for i in range(2):
-            member = c.member
-            if j == 2 and i == 0:
-                member[0, 0] = 10
-                ref[0, 0] = 10
-            assert_array_equal(member, ref)
-            del member
-            gc.collect()
-            gc.collect()
-
-        member = c.member
-        assert_array_equal(c.member_ro_ref, ref)
-        assert_array_equal(c.member_ro_copy, ref)
-        del c
-        gc.collect()
-        gc.collect()
-        assert_array_equal(member, ref)
-
-@needs_numpy_and_eigen
-def test12_cast():
-    vec = np.arange(1000, dtype=np.int32)
-    vec2 = vec[::2]
-    vecf = np.float32(vec)
-    assert_array_equal(t.castToMapVXi(vec), vec)
-    assert_array_equal(t.castToMapCnstVXi(vec), vec)
-    assert_array_equal(t.castToRefVXi(vec), vec)
-    assert_array_equal(t.castToRefCnstVXi(vec), vec)
-    assert t.castToMapVXi(vec).flags.writeable
-    assert not t.castToMapCnstVXi(vec).flags.writeable
-    assert_array_equal(t.castToDRefCnstVXi(vec), vec)
-    for v in vec2, vecf:
-        with pytest.raises(RuntimeError, match="bad[_ ]cast"):
-            t.castToMapVXi(v)
-        with pytest.raises(RuntimeError, match="bad[_ ]cast"):
-            t.castToRefVXi(v)
-        assert_array_equal(t.castToRefCnstVXi(v), v)
-    assert_array_equal(t.castToDRefCnstVXi(vec2), vec2)
-    with pytest.raises(RuntimeError, match="bad[_ ]cast"):
-        t.castToDRefCnstVXi(vecf)
-    for v in vec, vec2, vecf:
-        with pytest.raises(RuntimeError, match='bad[_ ]cast'):
-            t.castToRef03CnstVXi(v)
-
-@needs_numpy_and_eigen
-def test13_mutate_python():
-    class Derived(t.Base):
-        def modRefData(self, input):
-            input[0] = 3.0
-
-        def modRefDataConst(self, input):
-            input[0] = 3.0
-
-        def returnVecXd(self):
-            pass
-
-    vecRef = np.array([3.0, 2.0])
-    der = Derived()
-    assert_array_equal(t.modifyRef(der), vecRef)
-    with pytest.raises(ValueError):
-        t.modifyRefConst(der)
-    with pytest.raises(RuntimeError, match="bad[_ ]cast"):
-        t.returnVecXd(der)
-
-@needs_numpy_and_eigen
-def test14_single_element():
-    a = np.array([[1]], dtype=np.uint32)
-    assert a.ndim == 2 and a.shape == (1, 1)
-    t.addMXuCC(a, a)
-
-@needs_numpy_and_eigen
-def test15_sparse_map():
-    scipy = pytest.importorskip("scipy")
-
-    def assert_same_array(a, b):
-        assert a.shape == b.shape
-        assert a.__array_interface__['data'] == b.__array_interface__['data']
-
-    def assert_same_sparse_array(a, b):
-        assert_same_array(a.data, b.data)
-        assert_same_array(a.indices, b.indices)
-        assert_same_array(a.indptr, b.indptr)
-
-    c1 = scipy.sparse.csc_matrix([[1, 0], [0, 1]], dtype=np.float32)
-    c2 = t.sparse_map_c(c1)
-    assert_same_sparse_array(c1, c2)
-
-    r1 = scipy.sparse.csr_matrix([[1, 0], [0, 1]], dtype=np.float32)
-    r2 = t.sparse_map_r(r1)
-    assert_same_sparse_array(r1, r2)
-
-    # Implicit CSR <-> CSC conversion is not permitted by the map type caster
-    with pytest.raises(TypeError):
-        t.sparse_map_c(r1)
-
-    with pytest.raises(TypeError):
-        t.sparse_map_r(c1)
-
-    assert c1.sum() != 0
-    t.sparse_update_map_to_zero_c(c1);
-    assert c1.sum() == 0
-
-    assert r1.sum() != 0
-    t.sparse_update_map_to_zero_r(r1);
-    assert r1.sum() == 0
-
-    # Implicit type conversion is not permitted by the map type caster
-    c1 = scipy.sparse.csc_matrix([[1, 0], [0, 1]], dtype=np.float64)
-    r1 = scipy.sparse.csr_matrix([[1, 0], [0, 1]], dtype=np.float64)
-    with pytest.raises(TypeError):
-        t.sparse_map_c(c1)
-
-    with pytest.raises(TypeError):
-        t.sparse_map_r(r1)
-
-@needs_numpy_and_eigen
-def test16_sparse_complex():
-    scipy = pytest.importorskip("scipy")
-
-    c1 = scipy.sparse.csc_matrix([[1j+2, 0], [-3j, 1]], dtype=np.complex128)
-    c2 = t.sparse_complex(c1)
-    assert np.array_equal(c1.todense(), c2.todense())
-
-@needs_numpy_and_eigen
-def test17_sparse_map_complex():
-    scipy = pytest.importorskip("scipy")
-
-    c1 = scipy.sparse.csc_matrix([[1j+2, 0], [-3j, 1]], dtype=np.complex128)
-    c2 = t.sparse_complex_map_c(c1)
-    assert np.array_equal(c1.todense(), c2.todense())
diff --git a/src/nanobind/tests/test_enum.cpp b/src/nanobind/tests/test_enum.cpp
deleted file mode 100644
index dfafb95..0000000
--- a/src/nanobind/tests/test_enum.cpp
+++ /dev/null
@@ -1,70 +0,0 @@
-#include <nanobind/nanobind.h>
-
-namespace nb = nanobind;
-
-enum class Enum  : uint32_t { A, B, C = (uint32_t) -1 };
-enum class Flag  : uint32_t { A = 1, B = 2, C = 4};
-enum class UnsignedFlag : uint64_t {
-     A = 1 << 0,
-     B = 1 << 1,
-     All = (uint64_t) -1,
-};
-enum class SEnum : int32_t { A, B, C = (int32_t) -1 };
-enum ClassicEnum { Item1, Item2 };
-
-struct EnumProperty { Enum get_enum() { return Enum::A; } };
-
-NB_MODULE(test_enum_ext, m) {
-    nb::enum_<Enum>(m, "Enum", "enum-level docstring")
-        .value("A", Enum::A, "Value A")
-        .value("B", Enum::B, "Value B")
-        .value("C", Enum::C, "Value C");
-
-    nb::enum_<Flag>(m, "Flag", "enum-level docstring", nb::is_flag())
-            .value("A", Flag::A, "Value A")
-            .value("B", Flag::B, "Value B")
-            .value("C", Flag::C, "Value C")
-            .export_values();
-
-    nb::enum_<UnsignedFlag>(m, "UnsignedFlag", nb::is_flag())
-                .value("A", UnsignedFlag::A, "Value A")
-                .value("B", UnsignedFlag::B, "Value B")
-                .value("All", UnsignedFlag::All, "All values");
-
-    nb::enum_<SEnum>(m, "SEnum", nb::is_arithmetic())
-        .value("A", SEnum::A)
-        .value("B", SEnum::B)
-        .value("C", SEnum::C);
-
-    auto ce = nb::enum_<ClassicEnum>(m, "ClassicEnum")
-        .value("Item1", ClassicEnum::Item1)
-        .value("Item2", ClassicEnum::Item2)
-        .export_values();
-
-    ce.def("get_value", [](ClassicEnum &x) { return (int) x; })
-      .def_prop_ro("my_value", [](ClassicEnum &x) { return (int) x; })
-      .def("foo", [](ClassicEnum x) { return x; })
-      .def_static("bar", [](ClassicEnum x) { return x; });
-
-    m.def("from_enum", [](Enum value) { return (uint32_t) value; }, nb::arg().noconvert());
-    m.def("to_enum", [](uint32_t value) { return (Enum) value; });
-    m.def("from_enum", [](Flag value) { return (uint32_t) value; }, nb::arg().noconvert());
-    m.def("to_flag", [](uint32_t value) { return (Flag) value; });
-    m.def("from_enum", [](SEnum value) { return (int32_t) value; }, nb::arg().noconvert());
-    m.def("to_unsigned_flag", [](uint64_t value) { return (UnsignedFlag) value; });
-    m.def("from_enum", [](UnsignedFlag value) { return (uint64_t) value; }, nb::arg().noconvert());
-    m.def("from_enum_implicit", [](Enum value) { return (uint32_t) value; });
-
-    m.def("from_enum_default_0", [](Enum value) { return (uint32_t) value; }, nb::arg("value") = Enum::A);
-
-    m.def("from_enum_implicit", [](Flag value) { return (uint32_t) value; });
-
-    m.def("from_enum_default_0", [](Flag value) { return (uint32_t) value; }, nb::arg("value") = Enum::A);
-
-    m.def("from_enum_default_1", [](SEnum value) { return (uint32_t) value; }, nb::arg("value") = SEnum::A);
-
-    // test for issue #39
-    nb::class_<EnumProperty>(m, "EnumProperty")
-        .def(nb::init<>())
-        .def_prop_ro("read_enum", &EnumProperty::get_enum);
-}
diff --git a/src/nanobind/tests/test_enum.py b/src/nanobind/tests/test_enum.py
deleted file mode 100644
index e1736ea..0000000
--- a/src/nanobind/tests/test_enum.py
+++ /dev/null
@@ -1,186 +0,0 @@
-import test_enum_ext as t
-import pytest
-
-def test01_unsigned_enum():
-    assert repr(t.Enum.A) == 'Enum.A'
-    assert str(t.Enum.A) == 'Enum.A'
-    assert repr(t.Enum.B) == 'Enum.B'
-    assert str(t.Enum.B) == 'Enum.B'
-    assert repr(t.Enum.C) == 'Enum.C'
-    assert str(t.Enum.C) == 'Enum.C'
-    assert t.Enum.A.name == 'A'
-    assert t.Enum.B.name == 'B'
-    assert t.Enum.C.name == 'C'
-    assert t.Enum.A.__name__ == 'A'
-    assert t.Enum.B.__name__ == 'B'
-    assert t.Enum.C.__name__ == 'C'
-
-    assert t.Enum.__doc__ == 'enum-level docstring'
-
-    assert t.Enum.A.__doc__ == 'Value A'
-    assert t.Enum.B.__doc__ == 'Value B'
-    assert t.Enum.C.__doc__ == 'Value C'
-    assert t.Enum.A.value == 0
-    assert t.Enum.B.value == 1
-    assert t.Enum.C.value == 0xffffffff
-    assert t.Enum(0) is t.Enum.A
-    assert t.Enum(1) is t.Enum.B
-    assert t.Enum(0xffffffff) is t.Enum.C
-    assert t.Enum(t.Enum.A) is t.Enum.A
-    assert t.Enum(t.Enum.B) is t.Enum.B
-    assert t.Enum(t.Enum.C) == t.Enum.C
-    assert t.from_enum(t.Enum.A) == 0
-    assert t.from_enum(t.Enum.B) == 1
-    assert t.from_enum(t.Enum.C) == 0xffffffff
-    assert t.to_enum(0).__name__ == 'A'
-    assert t.to_enum(0) == t.Enum.A
-    assert t.to_enum(1) == t.Enum.B
-    assert t.to_enum(0xffffffff) == t.Enum.C
-
-    with pytest.raises(ValueError) as excinfo:
-        t.to_enum(5)
-    assert '5 is not a valid Enum' in str(excinfo.value)
-
-    with pytest.raises(ValueError) as excinfo:
-        t.Enum(123)
-    assert '123 is not a valid Enum' in str(excinfo.value)
-
-    assert t.from_enum_implicit(0) == 0
-
-    with pytest.raises(TypeError):
-        t.from_enum_implicit(123)
-
-
-def test02_signed_enum():
-    assert repr(t.SEnum.A) == 'SEnum.A'
-    assert repr(t.SEnum.B) == 'SEnum.B'
-    assert repr(t.SEnum.C) == 'SEnum.C'
-    assert str(t.SEnum.A) == 'SEnum.A'
-    assert str(t.SEnum.B) == 'SEnum.B'
-    assert str(t.SEnum.C) == 'SEnum.C'
-    assert int(t.SEnum.A) == 0
-    assert int(t.SEnum.B) == 1
-    assert int(t.SEnum.C) == -1
-    assert t.SEnum.A.value == 0
-    assert t.SEnum.B.value == 1
-    assert t.SEnum.C.value == -1
-    assert t.SEnum(0) is t.SEnum.A
-    assert t.SEnum(1) is t.SEnum.B
-    assert t.SEnum(-1) is t.SEnum.C
-    assert t.from_enum(t.SEnum.A) == 0
-    assert t.from_enum(t.SEnum.B) == 1
-    assert t.from_enum(t.SEnum.C) == -1
-
-
-def test03_enum_arithmetic():
-    assert t.SEnum.B + 2 == 3
-    assert t.SEnum.B + 2.5 == 3.5
-    assert 2 + t.SEnum.B == 3
-    assert 2.5 + t.SEnum.B == 3.5
-    assert t.SEnum.B >> t.SEnum.B == 0
-    assert t.SEnum.B << t.SEnum.B == 2
-    assert -t.SEnum.B == -1 and -t.SEnum.C == 1
-    assert t.SEnum.B & t.SEnum.B == 1
-    assert t.SEnum.B & ~t.SEnum.B == 0
-
-    with pytest.raises(TypeError, match="unsupported operand type"):
-        t.Enum.B + 2
-    with pytest.raises(TypeError, match="unsupported operand type"):
-        t.SEnum.B - "1"
-    with pytest.raises(TypeError, match="unsupported operand type"):
-        t.SEnum.B >> 1.0
-
-
-def test04_enum_export():
-    assert t.Item1 is t.ClassicEnum.Item1 and t.Item1.value == 0
-    assert t.Item2 is t.ClassicEnum.Item2 and t.Item2.value == 1
-
-# test for issue #39
-def test05_enum_property():
-    w = t.EnumProperty()
-    assert w.read_enum == t.Enum.A
-    assert str(w.read_enum) == 'Enum.A'
-
-def test08_enum_comparisons():
-    assert int(t.SEnum.B) == 1
-    for enum in (t.SEnum,):
-        value = getattr(enum, "B")
-        assert value != str(int(value))
-        assert value != int(value) + 0.4
-        assert value < int(value) + 0.4
-        for i in (0, 0.5, 1, 1.5, 2):
-            assert (value == i) == (int(value) == i)
-            assert (value != i) == (int(value) != i)
-            assert (value < i) == (int(value) < i)
-            assert (value <= i) == (int(value) <= i)
-            assert (value >= i) == (int(value) >= i)
-            assert (value > i) == (int(value) > i)
-
-            assert (i == value) == (i == int(value))
-            assert (i != value) == (i != int(value))
-            assert (i < value) == (i < int(value))
-            assert (i <= value) == (i <= int(value))
-            assert (i >= value) == (i >= int(value))
-            assert (i > value) == (i > int(value))
-
-        for unrelated in (None, "hello", "1"):
-            assert value != unrelated and unrelated != value
-            assert not (value == unrelated) and not (unrelated == value)
-            with pytest.raises(TypeError):
-                value < unrelated
-            with pytest.raises(TypeError):
-                unrelated < value
-
-    # different enum types never compare equal ...
-    assert t.Enum.B != t.SEnum.B and t.SEnum.B != t.Enum.B
-    assert not (t.Enum.B == t.SEnum.B) and not (t.SEnum.B == t.Enum.B)
-    assert t.Enum.B != t.SEnum.C and t.SEnum.C != t.Enum.B
-
-def test06_enum_flag():
-    # repr / str tests
-    assert repr(t.Flag.A) == 'Flag.A'
-    assert str(t.Flag.A) == 'Flag.A'
-    assert repr(t.Flag.B) == 'Flag.B'
-    assert str(t.Flag.B) == 'Flag.B'
-    assert repr(t.Flag.C) == 'Flag.C'
-    assert str(t.Flag.C) == 'Flag.C'
-    assert repr(t.Flag.A | t.Flag.B) in ['Flag.A|B', 'Flag.B|A']
-    assert str(t.Flag.A | t.Flag.B) in ['Flag.A|B', 'Flag.B|A']
-    assert repr(t.Flag.A | t.Flag.B | t.Flag.C) in ['Flag.A|B|C', 'Flag.C|B|A']
-    assert str(t.Flag.A | t.Flag.B | t.Flag.C) in ['Flag.A|B|C', 'Flag.C|B|A']
-
-    # Flag membership tests
-    assert (t.Flag(1) | t.Flag(2)).value == 3
-    assert (t.Flag(3) & t.Flag(1)).value == 1
-    assert (t.Flag(3) ^ t.Flag(1)).value == 2
-    assert (t.Flag(3) ==  (t.Flag.A | t.Flag.B))
-
-    # ensure the flag mask is set correctly by enum_append in Python 3.11+
-    if hasattr(t.Flag, "_flag_mask_"):
-        assert t.Flag._flag_mask_ == 7
-    assert (t.from_enum(t.Flag.A | t.Flag.C) == 5)
-    assert (t.from_enum_implicit(t.Flag(1) | t.Flag(4)) == 5)
-
-    # unsigned flag tests to verify correct type casting behavior
-    # (in particular, overflow protection in enum_from_python.)
-    assert (t.UnsignedFlag(1) | t.UnsignedFlag(2)).value == 3
-    assert t.UnsignedFlag.A.value == 1
-    assert t.UnsignedFlag.B.value == 2
-    assert t.UnsignedFlag.All.value == 0xffffffffffffffff
-    assert t.UnsignedFlag(t.UnsignedFlag.A) is t.UnsignedFlag.A
-    assert t.UnsignedFlag(t.UnsignedFlag.B) is t.UnsignedFlag.B
-    assert t.UnsignedFlag(t.UnsignedFlag.All) is t.UnsignedFlag.All
-    assert t.from_enum(t.UnsignedFlag.A) == 1
-    assert t.from_enum(t.UnsignedFlag.B) == 2
-    assert t.from_enum(t.UnsignedFlag.All) == 0xffffffffffffffff
-
-    assert t.to_flag(1) == t.Flag.A
-    assert t.to_flag(2) == t.Flag.B
-    assert t.to_flag(4) == t.Flag.C
-    assert t.to_flag(5) == (t.Flag.A | t.Flag.C)
-
-def test09_enum_methods():
-    assert t.Item1.my_value == 0 and t.Item2.my_value == 1
-    assert t.Item1.get_value() == 0 and t.Item2.get_value() == 1
-    assert t.Item1.foo() == t.Item1
-    assert t.ClassicEnum.bar(t.Item1) == t.Item1
diff --git a/src/nanobind/tests/test_enum_ext.pyi.ref b/src/nanobind/tests/test_enum_ext.pyi.ref
deleted file mode 100644
index 85825fe..0000000
--- a/src/nanobind/tests/test_enum_ext.pyi.ref
+++ /dev/null
@@ -1,107 +0,0 @@
-import enum
-from typing import overload
-
-
-class Enum(enum.Enum):
-    """enum-level docstring"""
-
-    A = 0
-    """Value A"""
-
-    B = 1
-    """Value B"""
-
-    C = 4294967295
-    """Value C"""
-
-class Flag(enum.Flag):
-    """enum-level docstring"""
-
-    A = 1
-    """Value A"""
-
-    B = 2
-    """Value B"""
-
-    C = 4
-    """Value C"""
-
-A: Flag = Flag.A
-
-B: Flag = Flag.B
-
-C: Flag = Flag.C
-
-class UnsignedFlag(enum.Flag):
-    A = 1
-    """Value A"""
-
-    B = 2
-    """Value B"""
-
-    All = 18446744073709551615
-    """All values"""
-
-class SEnum(enum.IntEnum):
-    A = 0
-
-    B = 1
-
-    C = -1
-
-class ClassicEnum(enum.Enum):
-    Item1 = 0
-
-    Item2 = 1
-
-    def get_value(self) -> int: ...
-
-    @property
-    def my_value(self) -> int: ...
-
-    def foo(self) -> ClassicEnum: ...
-
-    @staticmethod
-    def bar(arg: ClassicEnum, /) -> ClassicEnum: ...
-
-Item1: ClassicEnum = ClassicEnum.Item1
-
-Item2: ClassicEnum = ClassicEnum.Item2
-
-@overload
-def from_enum(arg: Enum) -> int: ...
-
-@overload
-def from_enum(arg: Flag) -> int: ...
-
-@overload
-def from_enum(arg: SEnum) -> int: ...
-
-@overload
-def from_enum(arg: UnsignedFlag) -> int: ...
-
-def to_enum(arg: int, /) -> Enum: ...
-
-def to_flag(arg: int, /) -> Flag: ...
-
-def to_unsigned_flag(arg: int, /) -> UnsignedFlag: ...
-
-@overload
-def from_enum_implicit(arg: Enum, /) -> int: ...
-
-@overload
-def from_enum_implicit(arg: Flag, /) -> int: ...
-
-@overload
-def from_enum_default_0(value: Enum = Enum.A) -> int: ...
-
-@overload
-def from_enum_default_0(value: Flag = Enum.A) -> int: ...
-
-def from_enum_default_1(value: SEnum = SEnum.A) -> int: ...
-
-class EnumProperty:
-    def __init__(self) -> None: ...
-
-    @property
-    def read_enum(self) -> Enum: ...
diff --git a/src/nanobind/tests/test_eval.cpp b/src/nanobind/tests/test_eval.cpp
deleted file mode 100644
index 599e6fe..0000000
--- a/src/nanobind/tests/test_eval.cpp
+++ /dev/null
@@ -1,87 +0,0 @@
-#include <nanobind/nanobind.h>
-#include <nanobind/eval.h>
-#include <nanobind/stl/pair.h>
-
-namespace nb = nanobind;
-
-NB_MODULE(test_eval_ext, m) {
-    auto global = nb::dict(nb::module_::import_("__main__").attr("__dict__"));
-
-    m.def("test_eval_statements", [global]() {
-        auto local = nb::dict();
-        local["call_test"] = nb::cpp_function([&]() -> int { return 42; });
-
-        // Regular string literal
-        nb::exec("message = 'Hello World!'\n"
-                 "x = call_test()",
-                 global,
-                 local);
-
-        // Multi-line raw string literal
-        nb::exec(R"(
-            if x == 42:
-                print(message)
-            else:
-                raise RuntimeError
-            )",
-                 global,
-                 local);
-        auto x = nb::cast<int>(local["x"]);
-        return x == 42;
-    });
-
-    m.def("test_eval", [global]() {
-        auto local = nb::dict();
-        local["x"] = nb::int_(42);
-        auto x = nb::eval("x", global, local);
-        return nb::cast<int>(x) == 42;
-    });
-
-    m.def("test_eval_single_statement", []() {
-        auto local = nb::dict();
-        local["call_test"] = nb::cpp_function([&]() -> int { return 42; });
-
-        auto result = nb::eval<nb::eval_single_statement>("x = call_test()", nb::dict(), local);
-        auto x = nb::cast<int>(local["x"]);
-        return result.is_none() && x == 42;
-    });
-
-    m.def("test_eval_failure", []() {
-        try {
-            nb::eval("nonsense code ...");
-        } catch (nb::python_error &) {
-            return true;
-        }
-        return false;
-    });
-
-    // test_eval_closure
-    m.def("test_eval_closure", []() {
-        nb::dict global;
-        global["closure_value"] = 42;
-        nb::dict local;
-        local["closure_value"] = 0;
-        nb::exec(R"(
-            local_value = closure_value
-
-            def func_global():
-                return closure_value
-
-            def func_local():
-                return local_value
-            )",
-                 global,
-                 local);
-        return std::make_pair(global, local);
-    });
-
-    m.def("globals_contains_a", []() {
-        return nb::globals().contains("a");
-    });
-
-    m.def("globals_add_b", []() {
-        auto globals = nb::globals();
-        globals["b"] = 123;
-        return globals;
-    });
-}
diff --git a/src/nanobind/tests/test_eval.py b/src/nanobind/tests/test_eval.py
deleted file mode 100644
index 7c669a0..0000000
--- a/src/nanobind/tests/test_eval.py
+++ /dev/null
@@ -1,44 +0,0 @@
-import os
-
-import pytest
-
-import test_eval_ext as m
-
-
-def test_evals(capsys):
-    assert m.test_eval_statements()
-    captured = capsys.readouterr()
-    assert captured.out == "Hello World!\n"
-
-    assert m.test_eval()
-    assert m.test_eval_single_statement()
-
-    assert m.test_eval_failure()
-
-
-def test_eval_closure():
-    global_, local = m.test_eval_closure()
-
-    assert global_["closure_value"] == 42
-    assert local["closure_value"] == 0
-
-    assert "local_value" not in global_
-    assert local["local_value"] == 0
-
-    assert "func_global" not in global_
-    assert local["func_global"]() == 42
-
-    assert "func_local" not in global_
-    with pytest.raises(NameError):
-        local["func_local"]()
-
-a = 1
-
-def test_read_globals():
-    assert m.globals_contains_a()
-
-
-def test_write_globals():
-    assert "b" not in globals()
-    m.globals_add_b()
-    assert globals()["b"] == 123
diff --git a/src/nanobind/tests/test_exception.cpp b/src/nanobind/tests/test_exception.cpp
deleted file mode 100644
index bd80890..0000000
--- a/src/nanobind/tests/test_exception.cpp
+++ /dev/null
@@ -1,62 +0,0 @@
-#include <nanobind/nanobind.h>
-
-namespace nb = nanobind;
-
-class MyError1 : public std::exception {
-public:
-    virtual const char *what() const noexcept { return "MyError1"; }
-};
-
-class MyError2 : public std::exception {
-public:
-    virtual const char *what() const noexcept { return "MyError2"; }
-};
-
-class MyError3 : public std::exception {
-public:
-    virtual const char *what() const noexcept { return "MyError3"; }
-};
-
-NB_MODULE(test_exception_ext, m) {
-    m.def("raise_generic", [] { throw std::exception(); });
-    m.def("raise_bad_alloc", [] { throw std::bad_alloc(); });
-    m.def("raise_runtime_error", [] { throw std::runtime_error("a runtime error"); });
-    m.def("raise_domain_error", [] { throw std::domain_error("a domain error"); });
-    m.def("raise_invalid_argument", [] { throw std::invalid_argument("an invalid argument error"); });
-    m.def("raise_length_error", [] { throw std::length_error("a length error"); });
-    m.def("raise_out_of_range", [] { throw std::out_of_range("an out of range error"); });
-    m.def("raise_range_error", [] { throw std::range_error("a range error"); });
-    m.def("raise_overflow_error", [] { throw std::overflow_error("an overflow error"); });
-    m.def("raise_index_error", [] { throw nb::index_error("an index error"); });
-    m.def("raise_key_error", [] { throw nb::key_error("a key error"); });
-    m.def("raise_value_error", [] { throw nb::value_error("a value error"); });
-    m.def("raise_type_error", [] { throw nb::type_error("a type error"); });
-    m.def("raise_import_error", [] { throw nb::import_error("an import error"); });
-    m.def("raise_attribute_error", [] { throw nb::attribute_error("an attribute error"); });
-    m.def("raise_stop_iteration", [] { throw nb::stop_iteration("a stop iteration error"); });
-
-    m.def("raise_my_error_1", [] { throw MyError1(); });
-
-    nb::register_exception_translator(
-        [](const std::exception_ptr &p, void * /* unused */) {
-            try {
-                std::rethrow_exception(p);
-            } catch (const MyError2 &e) {
-                PyErr_SetString(PyExc_IndexError, e.what());
-            }
-        });
-    m.def("raise_my_error_2", [] { throw MyError2(); });
-
-    nb::exception<MyError3>(m, "MyError3");
-    m.def("raise_my_error_3", [] { throw MyError3(); });
-
-    m.def("raise_nested", [](nb::callable c) {
-            int arg = 123;
-            try {
-                c(arg);
-            } catch (nb::python_error &e) {
-                nb::raise_from(e, PyExc_RuntimeError, "Call with value %i failed", arg);
-            }
-        }
-    );
-}
diff --git a/src/nanobind/tests/test_exception.py b/src/nanobind/tests/test_exception.py
deleted file mode 100644
index fb195a7..0000000
--- a/src/nanobind/tests/test_exception.py
+++ /dev/null
@@ -1,104 +0,0 @@
-import test_exception_ext as t
-import pytest
-
-def test01_base():
-    with pytest.raises(RuntimeError):
-        assert t.raise_generic()
-
-def test02_bad_alloc():
-    with pytest.raises(MemoryError):
-        assert t.raise_bad_alloc()
-
-def test03_runtime_error():
-    with pytest.raises(RuntimeError) as excinfo:
-        assert t.raise_runtime_error()
-    assert str(excinfo.value) == 'a runtime error'
-
-def test04_domain_error():
-    with pytest.raises(ValueError) as excinfo:
-        assert t.raise_domain_error()
-    assert str(excinfo.value) == 'a domain error'
-
-def test05_invalid_argument():
-    with pytest.raises(ValueError) as excinfo:
-        assert t.raise_invalid_argument()
-    assert str(excinfo.value) == 'an invalid argument error'
-
-def test06_length():
-    with pytest.raises(ValueError) as excinfo:
-        assert t.raise_length_error()
-    assert str(excinfo.value) == 'a length error'
-
-def test07_out_of_range():
-    with pytest.raises(IndexError) as excinfo:
-        assert t.raise_out_of_range()
-    assert str(excinfo.value) == 'an out of range error'
-
-def test08_range_error():
-    with pytest.raises(ValueError) as excinfo:
-        assert t.raise_range_error()
-    assert str(excinfo.value) == 'a range error'
-
-def test09_overflow_error():
-    with pytest.raises(OverflowError) as excinfo:
-        assert t.raise_overflow_error()
-    assert str(excinfo.value) == 'an overflow error'
-
-def test10_index_error():
-    with pytest.raises(IndexError) as excinfo:
-        assert t.raise_index_error()
-    assert str(excinfo.value) == 'an index error'
-
-def test11_key_error():
-    with pytest.raises(KeyError) as excinfo:
-        assert t.raise_key_error()
-    assert str(excinfo.value) == "'a key error'"
-
-def test12_value_error():
-    with pytest.raises(ValueError) as excinfo:
-        assert t.raise_value_error()
-    assert str(excinfo.value) == 'a value error'
-
-def test13_type_error():
-    with pytest.raises(TypeError) as excinfo:
-        assert t.raise_type_error()
-    assert str(excinfo.value) == 'a type error'
-
-def test14_import_error():
-    with pytest.raises(ImportError) as excinfo:
-        assert t.raise_import_error()
-    assert str(excinfo.value) == 'an import error'
-
-def test15_attribute_error():
-    with pytest.raises(AttributeError) as excinfo:
-        assert t.raise_attribute_error()
-    assert str(excinfo.value) == 'an attribute error'
-
-def test16_stop_iteration():
-    with pytest.raises(StopIteration) as excinfo:
-        assert t.raise_stop_iteration()
-    assert str(excinfo.value) == 'a stop iteration error'
-
-def test17_raise_my_error_1():
-    with pytest.raises(RuntimeError) as excinfo:
-        assert t.raise_my_error_1()
-    assert str(excinfo.value) == 'MyError1'
-
-def test18_raise_my_error_2():
-    with pytest.raises(IndexError) as excinfo:
-        assert t.raise_my_error_2()
-    assert str(excinfo.value) == 'MyError2'
-
-def test19_raise_my_error_3():
-    with pytest.raises(t.MyError3) as excinfo:
-        assert t.raise_my_error_3()
-    assert str(excinfo.value) == 'MyError3'
-
-def test20_nested():
-    def foo(arg):
-        return arg / 0
-    with pytest.raises(RuntimeError) as excinfo:
-        t.raise_nested(foo)
-    assert str(excinfo.value) == 'Call with value 123 failed'
-    assert str(excinfo.value.__cause__) == 'division by zero'
-
diff --git a/src/nanobind/tests/test_functions.cpp b/src/nanobind/tests/test_functions.cpp
deleted file mode 100644
index ffde612..0000000
--- a/src/nanobind/tests/test_functions.cpp
+++ /dev/null
@@ -1,507 +0,0 @@
-#include <string.h>
-
-#include <nanobind/nanobind.h>
-#include <nanobind/stl/function.h>
-#include <nanobind/stl/pair.h>
-#include <nanobind/stl/string.h>
-#include <nanobind/stl/vector.h>
-
-namespace nb = nanobind;
-using namespace nb::literals;
-
-int call_guard_value = 0;
-
-struct my_call_guard {
-    my_call_guard() { call_guard_value = 1; }
-    ~my_call_guard() { call_guard_value = 2; }
-};
-
-// Example call policy for use with nb::call_policy<>. Each call will add
-// an entry to `calls` containing the arguments tuple and return value.
-// The return value will be recorded as "<unfinished>" if the function
-// did not return (still executing or threw an exception) and as
-// "<return conversion failed>" if the function returned something that we
-// couldn't convert to a Python object.
-// Additional features to test particular interactions:
-// - the precall hook will throw if any arguments are not strings
-// - any argument equal to "swapfrom" will be replaced by a temporary
-//   string object equal to "swapto", which will be destroyed at end of call
-// - the postcall hook will throw if any argument equals "postthrow"
-struct example_policy {
-    static inline std::vector<std::pair<nb::tuple, nb::object>> calls;
-    static void precall(PyObject **args, size_t nargs,
-                        nb::detail::cleanup_list *cleanup) {
-        PyObject* tup = PyTuple_New(nargs);
-        for (size_t i = 0; i < nargs; ++i) {
-            if (!PyUnicode_CheckExact(args[i])) {
-                Py_DECREF(tup);
-                throw std::runtime_error("expected only strings");
-            }
-            if (0 == PyUnicode_CompareWithASCIIString(args[i], "swapfrom")) {
-                nb::object replacement = nb::cast("swapto");
-                args[i] = replacement.ptr();
-                cleanup->append(replacement.release().ptr());
-            }
-            Py_INCREF(args[i]);
-            PyTuple_SetItem(tup, i, args[i]);
-        }
-        calls.emplace_back(nb::steal<nb::tuple>(tup), nb::cast("<unfinished>"));
-    }
-    static void postcall(PyObject **args, size_t nargs, nb::handle ret) {
-        if (!ret.is_valid()) {
-            calls.back().second = nb::cast("<return conversion failed>");
-        } else {
-            calls.back().second = nb::borrow(ret);
-        }
-        for (size_t i = 0; i < nargs; ++i) {
-            if (0 == PyUnicode_CompareWithASCIIString(args[i], "postthrow")) {
-                throw std::runtime_error("postcall exception");
-            }
-        }
-    }
-};
-
-struct numeric_string {
-    unsigned long number;
-};
-
-template <> struct nb::detail::type_caster<numeric_string> {
-    NB_TYPE_CASTER(numeric_string, const_name("str"))
-
-    bool from_python(handle h, uint8_t flags, cleanup_list* cleanup) noexcept {
-        make_caster<const char*> str_caster;
-        if (!str_caster.from_python(h, flags, cleanup))
-            return false;
-        const char* str = str_caster.operator cast_t<const char*>();
-        if (!str)
-            return false;
-        char* endp;
-        value.number = strtoul(str, &endp, 10);
-        return *str && !*endp;
-    }
-    static handle from_cpp(numeric_string, rv_policy, handle) noexcept {
-        return nullptr;
-    }
-};
-
-int test_31(int i) noexcept { return i; }
-
-NB_MODULE(test_functions_ext, m) {
-    m.doc() = "function testcase";
-
-    // Function without inputs/outputs
-    m.def("test_01", []() { });
-
-    // Simple binary function (via function pointer)
-    auto test_02 = [](int up, int down) -> int { return up - down; };
-    m.def("test_02", (int (*)(int, int)) test_02, "up"_a = 8, "down"_a = 1);
-
-    // Simple binary function with capture object
-    int i = 42;
-    m.def("test_03", [i](int j, int k) -> int { return i + j - k; });
-
-    // Large capture object requiring separate storage
-    uint64_t k = 10, l = 11, m_ = 12, n = 13, o = 14;
-    m.def("test_04", [k, l, m_, n, o]() -> int { return (int) (k + l + m_ + n + o); });
-
-    // Overload chain with two docstrings
-    m.def("test_05", [](int) -> int { return 1; }, "doc_1");
-    nb::object first_overload = m.attr("test_05");
-    m.def("test_05", [](float) -> int { return 2; }, "doc_2");
-#if !defined(PYPY_VERSION) && !defined(Py_GIL_DISABLED)
-    // Make sure we don't leak the previous member of the overload chain
-    // (pypy's refcounts are bogus and will not help us with this check)
-    if (first_overload.ptr()->ob_refcnt != 1) {
-        throw std::runtime_error("Overload was leaked!");
-    }
-#endif
-    first_overload.reset();
-
-    // Test an overload chain that always repeats the same docstring
-    m.def("test_05b", [](int) -> int { return 1; }, "doc_1");
-    m.def("test_05b", [](float) -> int { return 2; }, "doc_1");
-
-    // Test an overload chain with an empty docstring
-    m.def("test_05c", [](int) -> int { return 1; }, "doc_1");
-    m.def("test_05c", [](float) -> int { return 2; }, "");
-
-    /// Function raising an exception
-    m.def("test_06", []() { throw std::runtime_error("oops!"); });
-
-    /// Function taking some positional/keyword args and nb::[kw]args
-    m.def("test_07", [](int, int, nb::args args, nb::kwargs kwargs) {
-        return std::make_pair(args.size(), kwargs.size());
-    });
-
-    /// As above, but with nb::arg annotations
-    m.def("test_07", [](int, int, nb::args args, nb::kwargs kwargs) {
-        return std::make_pair(args.size(), kwargs.size());
-    }, "a"_a, "b"_a, "myargs"_a, "mykwargs"_a);
-
-    /// Test successful/unsuccessful tuple conversion, with rich output types
-    m.def("test_tuple", []() -> nb::typed<nb::tuple, std::string, int> {
-        return nb::make_tuple("Hello", 123); });
-    m.def("test_bad_tuple", []() -> nb::typed<nb::object, std::pair<std::string, nb::object>> {
-        struct Foo{}; return nb::make_tuple("Hello", Foo()); });
-
-    /// Perform a Python function call from C++
-    m.def("test_call_1", [](nb::typed<nb::object, std::function<int(int)>> o) {
-        return o(1);
-    });
-    m.def("test_call_2", [](nb::typed<nb::callable, void(int, int)> o) {
-        return o(1, 2);
-    });
-
-    /// Test expansion of args/kwargs-style arguments
-    m.def("test_call_extra", [](nb::typed<nb::callable, void(...)> o,
-                                nb::args args, nb::kwargs kwargs) {
-        return o(1, 2, *args, **kwargs, "extra"_a = 5);
-    });
-
-    /// Test list manipulation
-    m.def("test_list", [](nb::list l) {
-        int result = 0;
-        for (size_t i = 0; i < l.size(); ++i)
-            result += nb::cast<int>(l[i]);
-        l[2] = 123;
-        l.append(result);
-    });
-
-    /// Test tuple manipulation
-    m.def("test_tuple", [](nb::typed<nb::tuple, int, nb::ellipsis> l) {
-        int result = 0;
-        for (size_t i = 0; i < l.size(); ++i)
-            result += nb::cast<int>(l[i]);
-        return result;
-    });
-
-    /// Test call_guard feature
-    m.def("test_call_guard_wrapper_rvalue_ref", [](int&& i) { return i; },
-          nb::call_guard<my_call_guard>());
-
-    m.def("test_call_guard", []() {
-        return call_guard_value;
-    }, nb::call_guard<my_call_guard>());
-
-    m.def("call_guard_value", []() { return call_guard_value; });
-
-    m.def("test_release_gil", []() -> bool {
-#if defined(Py_LIMITED_API)
-        return false;
-#else
-        return PyGILState_Check();
-#endif
-    }, nb::call_guard<nb::gil_scoped_release>());
-
-    m.def("test_print", []{
-        nb::print("Test 1");
-        nb::print("Test 2"_s);
-    });
-
-    m.def("test_iter", [](nb::object in) {
-        nb::list l;
-        for (nb::handle h : in)
-            l.append(h);
-        return l;
-    });
-
-    m.def("test_iter_tuple", [](nb::tuple in) {
-        nb::list l;
-        for (nb::handle h : in)
-            l.append(h);
-        return l;
-    });
-
-    m.def("test_iter_list", [](nb::list in) {
-        nb::list l;
-        for (nb::handle h : in)
-            l.append(h);
-        return l;
-    });
-
-    // Overload chain with a raw docstring that has precedence
-    m.def("test_08", [](int) -> int { return 1; }, "first docstring");
-    m.def("test_08", [](float) -> int { return 2; },
-          nb::sig("def test_08(x: typing.Annotated[float, 'foo']) -> int"),
-          "another docstring");
-
-    // Manual type check
-    m.def("test_09", [](nb::type_object t) -> bool { return t.is(&PyBool_Type); });
-
-    // nb::dict iterator
-    m.def("test_10", [](nb::dict d) {
-        nb::dict result;
-        for (auto [k, v] : d)
-            result[k] = v;
-        return result;
-    });
-
-    m.def("test_10_contains", [](nb::dict d) {
-        return d.contains("foo"_s);
-    });
-
-    // Test implicit conversion of various types
-    m.def("test_11_sl",  [](signed long x)        { return x; });
-    m.def("test_11_ul",  [](unsigned long x)      { return x; });
-    m.def("test_11_sll", [](signed long long x)   { return x; });
-    m.def("test_11_ull", [](unsigned long long x) { return x; });
-
-    // Test string caster
-    m.def("test_12", [](const char *c) { return nb::str(c); });
-    m.def("test_13", []() -> const char * { return "test"; });
-    m.def("test_14", [](nb::object o) -> const char * { return nb::cast<const char *>(o); });
-
-    // Test bytes type
-    m.def("test_15",   [](nb::bytes o) -> const char * { return o.c_str(); });
-    m.def("test_15_d", [](nb::bytes o) { return nb::bytes(o.data(), o.size()); });
-    m.def("test_16",   [](const char *c) { return nb::bytes(c); });
-    m.def("test_17",   [](nb::bytes c) { return c.size(); });
-    m.def("test_18",   [](const char *c, int size) { return nb::bytes(c, size); });
-
-    // Test int type
-    m.def("test_19", [](nb::int_ i) { return i + nb::int_(123); });
-    m.def("test_20", [](nb::str s) { return nb::int_(s) + nb::int_(123); });
-    m.def("test_21", [](nb::int_ i) { return (int) i; });
-    m.def("test_21_f", [](nb::float_ f) { return nb::int_(f); });
-    m.def("test_21_g", []() { return nb::int_(1.5); });
-    m.def("test_21_h", []() { return nb::int_(1e50); });
-
-    // Test floating-point
-    m.def("test_21_dnc", [](double d) { return d + 1.0; }, nb::arg().noconvert());
-    m.def("test_21_fnc", [](float f) { return f + 1.0f; }, nb::arg().noconvert());
-
-    // Test capsule wrapper
-    m.def("test_22", []() -> void * { return (void*) 1; });
-    m.def("test_23", []() -> void * { return nullptr; });
-    m.def("test_24", [](void *p) { return (uintptr_t) p; }, "p"_a.none());
-
-    // Test slice
-    m.def("test_25", [](nb::slice s) { return s; });
-    m.def("test_26", []() { return nb::slice(4); });
-    m.def("test_27", []() { return nb::slice(1, 10); });
-    m.def("test_28", []() { return nb::slice(5, -5, -2); });
-
-    // Test ellipsis
-    m.def("test_29", [](nb::ellipsis) { return nb::ellipsis(); });
-
-    // Traceback test
-    m.def("test_30", [](nb::callable f) -> std::string {
-        nb::gil_scoped_release g;
-        try {
-            nb::gil_scoped_acquire g2;
-            f();
-        } catch (const nb::python_error &e) {
-            return e.what();
-        }
-        return "Unknown";
-    });
-
-    m.def("test_31", &test_31);
-    m.def("test_32", [](int i) noexcept { return i; });
-
-    m.def("identity_i8", [](int8_t  i) { return i; });
-    m.def("identity_u8", [](uint8_t i) { return i; });
-    m.def("identity_i16", [](int16_t  i) { return i; });
-    m.def("identity_u16", [](uint16_t i) { return i; });
-    m.def("identity_i32", [](int32_t  i) { return i; });
-    m.def("identity_u32", [](uint32_t i) { return i; });
-    m.def("identity_i64", [](int64_t  i) { return i; });
-    m.def("identity_u64", [](uint64_t i) { return i; });
-
-    m.attr("test_33") = nb::cpp_function([](nb::object self, int y) {
-        return nb::cast<int>(self.attr("x")) + y;
-    }, nb::is_method());
-
-    m.attr("test_34") = nb::cpp_function([](nb::object self, int y) {
-        return nb::cast<int>(self.attr("x")) * y;
-    }, nb::arg("y"), nb::is_method());
-
-    m.def("test_35", []() {
-        const char *name = "Foo";
-
-        auto callback = [=]() {
-            return "Test {}"_s.format(name);
-        };
-
-        return nb::cpp_function(callback);
-    });
-
-    m.def("test_cast_char", [](nb::handle h) {
-        return nb::cast<char>(h);
-    });
-
-    m.def("test_cast_str", [](nb::handle h) {
-        return nb::cast<const char *>(h);
-    });
-
-    m.def("test_set", []() {
-        nb::set s;
-        s.add("123");
-        s.add(123);
-        return s;
-    });
-
-    m.def("test_set_contains", [](nb::set s, nb::handle h) { return s.contains(h); });
-
-    m.def("test_frozenset", []() {
-        return nb::frozenset(nb::make_tuple("123", 123));
-    });
-
-    m.def("test_frozenset_contains", [](nb::frozenset s, nb::handle h) {
-        return s.contains(h);
-    });
-
-
-    m.def("test_del_list", [](nb::list l) { nb::del(l[2]); });
-    m.def("test_del_dict", [](nb::dict l) { nb::del(l["a"]); });
-
-    static int imut = 10;
-    static const int iconst = 100;
-    m.def("test_ptr_return", []() { return std::make_pair(&imut, &iconst); });
-
-    // These are caught at compile time, uncomment and rebuild to verify:
-
-    // No nb::arg annotations:
-    //m.def("bad_args1", [](nb::args, int) {});
-
-    // kw_only in wrong place (1):
-    //m.def("bad_args2", [](nb::args, int) {}, nb::kw_only(), "args"_a, "i"_a);
-
-    // kw_only in wrong place (2):
-    //m.def("bad_args3", [](nb::args, int) {}, "args"_a, "i"_a, nb::kw_only());
-
-    // kw_only in wrong place (3):
-    //m.def("bad_args4", [](int, nb::kwargs) {}, "i"_a, "kwargs"_a, nb::kw_only());
-
-    // kw_only specified twice:
-    //m.def("bad_args5", [](int, int) {}, nb::kw_only(), "i"_a, nb::kw_only(), "j"_a);
-
-    m.def("test_args_kwonly",
-          [](int i, double j, nb::args args, int z) {
-              return nb::make_tuple(i, j, args, z);
-          }, "i"_a, "j"_a, "args"_a, "z"_a);
-    m.def("test_args_kwonly_kwargs",
-          [](int i, double j, nb::args args, int z, nb::kwargs kwargs) {
-              return nb::make_tuple(i, j, args, z, kwargs);
-          }, "i"_a, "j"_a, "args"_a, nb::kw_only(), "z"_a, "kwargs"_a);
-    m.def("test_kwonly_kwargs",
-          [](int i, double j, nb::kwargs kwargs) {
-              return nb::make_tuple(i, j, kwargs);
-          }, "i"_a, nb::kw_only(), "j"_a, "kwargs"_a);
-
-    m.def("test_kw_only_all",
-          [](int i, int j) { return nb::make_tuple(i, j); },
-          nb::kw_only(), "i"_a, "j"_a);
-    m.def("test_kw_only_some",
-          [](int i, int j, int k) { return nb::make_tuple(i, j, k); },
-          nb::arg(), nb::kw_only(), "j"_a, "k"_a);
-    m.def("test_kw_only_with_defaults",
-          [](int i, int j, int k, int z) { return nb::make_tuple(i, j, k, z); },
-          nb::arg() = 3, "j"_a = 4, nb::kw_only(), "k"_a = 5, "z"_a);
-    m.def("test_kw_only_mixed",
-          [](int i, int j) { return nb::make_tuple(i, j); },
-          "i"_a, nb::kw_only(), "j"_a);
-
-    struct kw_only_methods {
-        kw_only_methods(int _v) : v(_v) {}
-        int v;
-    };
-
-    nb::class_<kw_only_methods>(m, "kw_only_methods")
-        .def(nb::init<int>(), nb::kw_only(), "v"_a)
-        .def_rw("v", &kw_only_methods::v)
-        .def("method_2k",
-             [](kw_only_methods&, int i, int j) { return nb::make_tuple(i, j); },
-             nb::kw_only(), "i"_a = 1, "j"_a = 2)
-        .def("method_1p1k",
-             [](kw_only_methods&, int i, int j) { return nb::make_tuple(i, j); },
-             "i"_a = 1, nb::kw_only(), "j"_a = 2);
-
-    m.def("test_any", [](nb::any a) { return a; } );
-
-    m.def("test_wrappers_list", []{
-        nb::list l1, l2;
-        l1.append(1);
-        l2.append(2);
-        l1.extend(l2);
-
-        bool b = nb::len(l1) == 2 && nb::len(l2) == 1 &&
-            l1[0].equal(nb::int_(1)) && l1[1].equal(nb::int_(2));
-
-        l1.clear();
-        return b && nb::len(l1) == 0;
-    });
-
-    m.def("test_wrappers_dict", []{
-        nb::dict d1, d2;
-        d1["a"] = 1;
-        d2["b"] = 2;
-        d1.update(d2);
-
-        bool b = nb::len(d1) == 2 && nb::len(d2) == 1 &&
-            d1["a"].equal(nb::int_(1)) &&
-            d1["b"].equal(nb::int_(2));
-
-        d1.clear();
-        return b && nb::len(d1) == 0;
-    });
-
-    m.def("test_wrappers_set", []{
-        nb::set s;
-        s.add("a");
-        s.add("b");
-
-        bool b = nb::len(s) == 2 && s.contains("a") && s.contains("b");
-
-        b &= s.discard("a");
-        b &= !s.discard("q");
-
-        b &= !s.contains("a") && s.contains("b");
-        s.clear();
-        b &= s.size() == 0;
-
-        return b;
-    });
-
-    m.def("hash_it", [](nb::handle h) { return nb::hash(h); });
-    m.def("isinstance_", [](nb::handle inst, nb::handle cls) {
-        return nb::isinstance(inst, cls);
-    });
-
-    // Test bytearray type
-    m.def("test_bytearray_new",     []() { return nb::bytearray(); });
-    m.def("test_bytearray_new",     [](const char *c, int size) { return nb::bytearray(c, size); });
-    m.def("test_bytearray_copy",    [](nb::bytearray o) { return nb::bytearray(o.c_str(), o.size()); });
-    m.def("test_bytearray_c_str",   [](nb::bytearray o) -> const char * { return o.c_str(); });
-    m.def("test_bytearray_size",    [](nb::bytearray o) { return o.size(); });
-    m.def("test_bytearray_resize",  [](nb::bytearray c, int size) { return c.resize(size); });
-
-    // Test call_policy feature
-    m.def("test_call_policy",
-          [](const char* s, numeric_string n) -> const char* {
-              if (0 == strcmp(s, "returnfail")) {
-                  return "not utf8 \xff";
-              }
-              if (n.number > strlen(s)) {
-                  throw std::runtime_error("offset too large");
-              }
-              return s + n.number;
-          },
-          nb::call_policy<example_policy>());
-
-    m.def("call_policy_record",
-          []() {
-              auto ret = std::move(example_policy::calls);
-              return ret;
-          });
-
-    m.def("abi_tag", [](){ return nb::detail::abi_tag(); });
-
-    // Test the nb::fallback type
-    m.def("test_fallback_1", [](double){ return 0; });
-    m.def("test_fallback_1", [](nb::handle){ return 1; });
-    m.def("test_fallback_2", [](double) { return 0; });
-    m.def("test_fallback_2", [](nb::fallback){ return 1; });
-
-    m.def("test_get_dict_default", [](nb::dict l) { return l.get("key", nb::int_(123)); });
-}
diff --git a/src/nanobind/tests/test_functions.py b/src/nanobind/tests/test_functions.py
deleted file mode 100644
index cc6e997..0000000
--- a/src/nanobind/tests/test_functions.py
+++ /dev/null
@@ -1,791 +0,0 @@
-import test_functions_ext as t
-import pytest
-import sys
-import re
-
-# Some helper declaration to check types across different Python versions
-if sys.version_info < (3, 9):
-    TYPING_TUPLE = "typing.Tuple"
-else:
-    TYPING_TUPLE = "tuple"
-
-# Reference counting behavior changed on 3.14a7+
-py_3_14a7_or_newer = sys.version_info >= (3, 14, 0, 'alpha', 7)
-
-def fail_fn():  # used in test_30
-    raise RuntimeError("Foo")
-
-
-def test01_capture():
-    # Functions with and without capture object of different sizes
-    assert t.test_01() is None
-    assert t.test_02(5, 3) == 2
-    assert t.test_03(5, 3) == 44
-    assert t.test_04() == 60
-
-
-def test02_default_args():
-    # Default arguments
-    assert t.test_02() == 7
-    assert t.test_02(7) == 6
-
-
-def test03_kwargs():
-    # Basic use of keyword arguments
-    assert t.test_02(3, 5) == -2
-    assert t.test_02(3, down=5) == -2
-    assert t.test_02(down=5, up=3) == -2
-
-    # Make sure non-interned keyword names work also
-    i_cant_believe_its_not_down = "".join("down")
-    assert i_cant_believe_its_not_down is not "down"
-    assert t.test_02(**{i_cant_believe_its_not_down: 5, "up": 3}) == -2
-    assert t.test_02(**{i_cant_believe_its_not_down: 5}) == 3
-    with pytest.raises(TypeError):
-        t.test_02(unexpected=27)
-    with pytest.raises(TypeError):
-        t.test_02(**{i_cant_believe_its_not_down: None})
-
-
-def test04_overloads():
-    assert t.test_05(0) == 1
-    assert t.test_05(0.0) == 2
-
-
-def test05_signature():
-    assert t.test_01.__doc__ == "test_01() -> None"
-    assert t.test_02.__doc__ == "test_02(up: int = 8, down: int = 1) -> int"
-    assert t.test_05.__doc__ == (
-        "test_05(arg: int, /) -> int\n"
-        "test_05(arg: float, /) -> int\n"
-        "\n"
-        "Overloaded function.\n"
-        "\n"
-        "1. ``test_05(arg: int, /) -> int``\n"
-        "\n"
-        "doc_1\n"
-        "\n"
-        "2. ``test_05(arg: float, /) -> int``\n"
-        "\n"
-        "doc_2"
-    )
-
-    assert t.test_05b.__doc__ == (
-        "test_05b(arg: int, /) -> int\n"
-        "test_05b(arg: float, /) -> int\n"
-        "\n"
-        "doc_1"
-    )
-
-    assert t.test_05c.__doc__ == (
-        "test_05c(arg: int, /) -> int\n"
-        "test_05c(arg: float, /) -> int\n"
-        "\n"
-        "Overloaded function.\n"
-        "\n"
-        "1. ``test_05c(arg: int, /) -> int``\n"
-        "\n"
-        "doc_1\n"
-        "\n"
-        "2. ``test_05c(arg: float, /) -> int``\n"
-    )
-
-    assert t.test_07.__doc__ == (
-        f"test_07(arg0: int, arg1: int, /, *args, **kwargs) -> {TYPING_TUPLE}[int, int]\n"
-        f"test_07(a: int, b: int, *myargs, **mykwargs) -> {TYPING_TUPLE}[int, int]"
-    )
-
-
-def test06_signature_error():
-    with pytest.raises(TypeError) as excinfo:
-        t.test_05("x", y=4)
-    assert str(excinfo.value) == (
-        "test_05(): incompatible function arguments. The "
-        "following argument types are supported:\n"
-        "    1. test_05(arg: int, /) -> int\n"
-        "    2. test_05(arg: float, /) -> int\n\n"
-        "Invoked with types: str, kwargs = { y: int }"
-    )
-
-
-def test07_raises():
-    with pytest.raises(RuntimeError) as excinfo:
-        t.test_06()
-    assert str(excinfo.value) == "oops!"
-
-
-def test08_args_kwargs():
-    assert t.test_07(1, 2) == (0, 0)
-    assert t.test_07(a=1, b=2) == (0, 0)
-    assert t.test_07(a=1, b=2, c=3) == (0, 1)
-    assert t.test_07(1, 2, 3, c=4) == (1, 1)
-    assert t.test_07(1, 2, 3, 4, c=5, d=5) == (2, 2)
-
-
-def test09_maketuple():
-    assert t.test_tuple() == ("Hello", 123)
-    with pytest.raises(RuntimeError) as excinfo:
-        assert t.test_bad_tuple()
-    value = str(excinfo.value)
-    assert value == "std::bad_cast" or value == "bad cast"
-
-
-def test10_cpp_call_simple():
-    result = []
-
-    def my_callable(a, b):
-        result.append((a, b))
-
-    t.test_call_2(my_callable)
-    assert result == [(1, 2)]
-
-    with pytest.raises(TypeError) as excinfo:
-        t.test_call_1(my_callable)
-    assert "my_callable() missing 1 required positional argument: 'b'" in str(
-        excinfo.value
-    )
-    assert result == [(1, 2)]
-
-
-def test11_call_complex():
-    result = []
-
-    def my_callable(*args, **kwargs):
-        result.append((args, kwargs))
-
-    t.test_call_extra(my_callable)
-    assert result == [((1, 2), {"extra": 5})]
-
-    result.clear()
-    t.test_call_extra(my_callable, 5, 6, hello="world")
-    assert result == [((1, 2, 5, 6), {"extra": 5, "hello": "world"})]
-
-
-def test12_list_tuple_manipulation():
-    li = [1, 5, 6, 7]
-    t.test_list(li)
-    assert li == [1, 5, 123, 7, 19]
-
-    tu = (1, 5, 6, 7)
-    assert t.test_tuple(tu) == 19
-    assert tu == (1, 5, 6, 7)
-
-
-def test13_call_guard():
-    assert t.call_guard_value() == 0
-    assert t.test_call_guard() == 1
-    assert t.call_guard_value() == 2
-    assert t.test_call_guard_wrapper_rvalue_ref(1) == 1
-    assert not t.test_release_gil()
-
-
-def test14_print(capsys):
-    t.test_print()
-    captured = capsys.readouterr()
-    assert captured.out == "Test 1\nTest 2\n"
-
-
-def test15_iter():
-    assert t.test_iter(()) == []
-    assert t.test_iter((1,)) == [1]
-    assert t.test_iter((1, 2)) == [1, 2]
-    assert t.test_iter((1, 2, 3)) == [1, 2, 3]
-
-
-def test16_iter_tuple():
-    assert t.test_iter_tuple(()) == []
-    assert t.test_iter_tuple((1,)) == [1]
-    assert t.test_iter_tuple((1, 2)) == [1, 2]
-    assert t.test_iter_tuple((1, 2, 3)) == [1, 2, 3]
-
-
-def test17_iter_tuple():
-    assert t.test_iter_list([]) == []
-    assert t.test_iter_list([1]) == [1]
-    assert t.test_iter_list([1, 2]) == [1, 2]
-    assert t.test_iter_list([1, 2, 3]) == [1, 2, 3]
-
-
-def test18_raw_doc():
-    assert (
-        t.test_08.__doc__
-        == """test_08(arg: int, /) -> int
-test_08(x: typing.Annotated[float, 'foo']) -> int
-
-Overloaded function.
-
-1. ``test_08(arg: int, /) -> int``
-
-first docstring
-
-2. ``test_08(x: typing.Annotated[float, 'foo']) -> int``
-
-another docstring"""
-    )
-
-
-def test19_type_check_manual():
-    assert t.test_09.__doc__ == "test_09(arg: type, /) -> bool"
-
-    assert t.test_09(bool) is True
-    assert t.test_09(int) is False
-    with pytest.raises(TypeError) as excinfo:
-        assert t.test_09(True)
-    assert "incompatible function arguments" in str(excinfo.value)
-
-
-def test20_dict_iterator():
-    assert t.test_10({}) == {}
-    assert t.test_10({1: 2}) == {1: 2}
-    assert t.test_10({1: 2, 3: 4}) == {1: 2, 3: 4}
-    assert t.test_10({1: 2, 3: 4, "a": "b"}) == {1: 2, 3: 4, "a": "b"}
-
-
-def test21_numpy_overloads():
-    try:
-        import numpy as np
-    except ImportError:
-        pytest.skip("numpy is missing")
-
-    assert t.test_05(np.int32(0)) == 1
-    assert t.test_05(np.float64(0.1)) == 2
-    assert t.test_05(np.float64(0.0)) == 2
-    assert t.test_11_sl(np.int32(5)) == 5
-    assert t.test_11_ul(np.int32(5)) == 5
-    assert t.test_11_sll(np.int32(5)) == 5
-    assert t.test_11_ull(np.int32(5)) == 5
-
-    with pytest.raises(TypeError) as excinfo:
-        t.test_21_dnc(np.float64(21.0))  # Python type is not exactly float
-    assert "incompatible function arguments" in str(excinfo.value)
-    assert t.test_21_dnc(float(np.float64(21.0))) == 22.0
-    assert t.test_21_dnc(float(np.float32(21.0))) == 22.0
-
-    assert t.test_21_fnc(float(np.float32(21.0))) == 22.0
-    with pytest.raises(TypeError) as excinfo:
-        t.test_21_fnc(float(np.float64(21.1)))  # Inexact narrowing to float32
-    assert "incompatible function arguments" in str(excinfo.value)
-    assert t.test_21_fnc(float(np.float32(21.1))) == np.float32(22.1)
-
-
-def test22_string_return():
-    assert t.test_12("hello") == "hello"
-    assert t.test_13() == "test"
-    assert t.test_14("abc") == "abc"
-
-
-def test23_byte_return():
-    assert t.test_15(b"abc") == "abc"
-    assert t.test_15_d(b"abc\x00def\x00ghi") == b"abc\x00def\x00ghi"
-    assert t.test_16("hello") == b"hello"
-    assert t.test_17(b"four") == 4
-    assert t.test_17(b"\x00\x00\x00\x00") == 4
-    assert t.test_18("hello world", 5) == b"hello"
-
-
-@pytest.mark.skipif(sys.version_info < (3, 9), reason="requires python3.9 or higher")
-def test24_pydoc():
-    import pydoc
-
-    assert "test_05(arg: int, /)" in pydoc.render_doc(t)
-
-
-def test25_int():
-    assert t.test_19(5) == 128
-    assert t.test_20("5") == 128
-    assert t.test_21(5) == 5
-    assert t.test_21_f(5.1) == int(5.1)
-    assert t.test_21_f(1e50) == int(1e50)
-    assert type(t.test_21_f(0.5)) is int
-    assert t.test_21_g() == int(1.5)
-    assert type(t.test_21_g()) is int
-    assert t.test_21_h() == int(1e50)
-    assert type(t.test_21_h()) is int
-    assert t.test_19.__doc__ == "test_19(arg: int, /) -> object"
-
-
-def test26_capsule():
-    p = t.test_22()
-    assert "capsule" in str(p) and "nb_handle" in str(p)
-    assert t.test_24(p) == 1
-    p = t.test_23()
-    assert p is None
-    assert t.test_24(p) == 0
-
-
-def test27_slice():
-    s = slice(1, 10, 2)
-    assert t.test_25(s) is s
-    assert t.test_25.__doc__ == "test_25(arg: slice, /) -> slice"
-    assert t.test_26() == slice(4)
-    assert t.test_27() == slice(1, 10)
-    assert t.test_28() == slice(5, -5, -2)
-
-
-def test28_ellipsis():
-    assert t.test_29(...) is ...
-    assert (
-        t.test_29.__doc__ == "test_29(arg: types.EllipsisType, /) -> types.EllipsisType"
-    )
-
-
-def test29_traceback():
-    result = t.test_30(fail_fn)
-    regexp = r'Traceback \(most recent call last\):\n.*\n  File "[^"]*", line [0-9]*, in fail_fn\n.*RuntimeError: Foo'
-    matches = re.findall(regexp, result, re.MULTILINE | re.DOTALL)
-    assert len(matches) == 1
-
-
-def test30_noexcept():
-    assert t.test_31(123) == 123
-    assert t.test_32(123) == 123
-
-
-@pytest.mark.parametrize(
-    "func_name",
-    [
-        "identity_i8",
-        "identity_u8",
-        "identity_i16",
-        "identity_u16",
-        "identity_i32",
-        "identity_u32",
-        "identity_i64",
-        "identity_u64",
-    ],
-)
-def test31_range(func_name):
-    func = getattr(t, func_name)
-
-    values = [
-        0,
-        -1,
-        1,
-        2**7,
-        2**7 - 1,
-        2**8,
-        2**8 - 1,
-        2**15,
-        2**15 - 1,
-        2**16,
-        2**16 - 1,
-        2**29,
-        2**29 - 1,
-        2**30,
-        2**30 - 1,
-        2**31,
-        2**31 - 1,
-        2**32,
-        2**32 - 1,
-        2**63,
-        2**63 - 1,
-        2**64,
-        2**64 - 1,
-        2**127,
-        2**127 - 1,
-        2**128,
-        2**128 - 1,
-    ]
-    values += [-value for value in values]
-    suffix = func.__name__[9:]
-
-    if suffix[0] == "u":
-        range_min = 0
-        range_max = 2 ** int(suffix[1:]) - 1
-    else:
-        range_min = -(2 ** (int(suffix[1:]) - 1))
-        range_max = -range_min - 1
-
-    for value in values:
-        if value < range_min or value > range_max:
-            with pytest.raises(TypeError):
-                value_out = func(value)
-        else:
-            value_out = func(value)
-            assert value_out == value
-
-
-def test33_method_on_non_nanobind_class():
-    class AClass:
-        def __init__(self):
-            self.x = 42
-
-    AClass.simple_method = t.test_33
-    AClass.complex_method = t.test_34
-    a = AClass()
-    assert a.simple_method(7) == 49
-    assert a.complex_method(y=2) == 84
-
-
-def test34_module_docstring():
-    assert t.__doc__ == "function testcase"
-
-
-def test35_return_capture():
-    x = t.test_35()
-    assert x() == "Test Foo"
-
-
-def test36_test_char():
-    assert t.test_cast_char("c") == "c"
-    assert t.test_cast_char("\x00") == "\x00"
-    with pytest.raises(TypeError):
-        assert t.test_cast_char("abc")
-    with pytest.raises(TypeError):
-        assert t.test_cast_char("")
-    with pytest.raises(RuntimeError):
-        assert t.test_cast_char(123)
-
-
-def test37_test_str():
-    assert t.test_cast_str("c") == "c"
-    assert t.test_cast_str("abc") == "abc"
-    with pytest.raises(RuntimeError):
-        assert t.test_cast_str(123)
-
-
-def test38_set():
-    x = t.test_set()
-    assert isinstance(x, set)
-    assert len(x) == 2
-    assert 123 in x and "123" in x
-    assert t.test_set_contains(x, 123)
-    assert t.test_set_contains(x, "123")
-    assert not t.test_set_contains(x, "1234")
-    assert not t.test_set_contains(x, 1234)
-
-
-def test39_del():
-    l = [0, 1, 2, 3, 4]
-    t.test_del_list(l)
-    assert l == [0, 1, 3, 4]
-
-    l = {"a": 0, "b": 1}
-    t.test_del_dict(l)
-    assert l == {"b": 1}
-
-    with pytest.raises(IndexError):
-        t.test_del_list([])
-
-    with pytest.raises(KeyError):
-        t.test_del_dict({})
-
-
-def test40_nb_signature():
-    assert t.test_01.__nb_signature__ == ((r"def test_01() -> None", None, None),)
-    assert t.test_02.__nb_signature__ == (
-        (r"def test_02(up: int = \0, down: int = \1) -> int", None, (8, 1)),
-    )
-    assert t.test_05.__nb_signature__ == (
-        (r"def test_05(arg: int, /) -> int", "doc_1", None),
-        (r"def test_05(arg: float, /) -> int", "doc_2", None),
-    )
-    if sys.version_info >= (3, 9):
-        assert t.test_07.__nb_signature__ == (
-            (
-                r"def test_07(arg0: int, arg1: int, /, *args, **kwargs) -> tuple[int, int]",
-                None,
-                None,
-            ),
-            (
-                r"def test_07(a: int, b: int, *myargs, **mykwargs) -> tuple[int, int]",
-                None,
-                None,
-            ),
-        )
-
-
-def test41_kw_only():
-    # (i, j, *args, z)
-    assert t.test_args_kwonly(2, 2.5, z=22) == (2, 2.5, (), 22)
-    assert t.test_args_kwonly(2, 2.5, "a", "b", z=22) == (2, 2.5, ("a", "b"), 22)
-    assert t.test_args_kwonly(z=22, i=4, j=16) == (4, 16.0, (), 22)
-    assert (
-        t.test_args_kwonly.__doc__
-        == "test_args_kwonly(i: int, j: float, *args, z: int) -> tuple"
-    )
-    with pytest.raises(TypeError):
-        t.test_args_kwonly(2, 2.5, 22)  # missing z= keyword
-
-    # (i, j, *args, z, **kwargs)
-    assert t.test_args_kwonly_kwargs(i=1, k=4, j=10, z=-1, y=9) == (
-        1, 10, (), -1, {"k": 4, "y": 9}
-    )
-    assert t.test_args_kwonly_kwargs(1, 2, 3, 4, z=11, y=12) == (
-        1, 2, (3, 4), 11, {"y": 12}
-    )
-    with pytest.raises(TypeError):
-        t.test_args_kwonly_kwargs(1, 2, 3, 4, 5)
-    assert (
-        t.test_args_kwonly_kwargs.__doc__
-        == "test_args_kwonly_kwargs(i: int, j: float, *args, z: int, **kwargs) -> tuple"
-    )
-
-    # (i, *, j, **kwargs)
-    assert t.test_kwonly_kwargs(j=2, i=1) == (1, 2, {})
-    assert t.test_kwonly_kwargs(j=2, i=1, z=10) == (1, 2, {"z": 10})
-    assert t.test_kwonly_kwargs(1, j=2) == (1, 2, {})
-    assert t.test_kwonly_kwargs(1, j=2, z=10) == (1, 2, {"z": 10})
-    with pytest.raises(TypeError):
-        t.test_kwonly_kwargs(1, 2)
-    with pytest.raises(TypeError):
-        t.test_kwonly_kwargs(1, 2, j=3)
-    with pytest.raises(TypeError):
-        t.test_kwonly_kwargs(1, 2, z=10)
-    assert (
-        t.test_kwonly_kwargs.__doc__
-        == "test_kwonly_kwargs(i: int, *, j: float, **kwargs) -> tuple"
-    )
-
-    # (*, i, j)
-    assert t.test_kw_only_all(i=1, j=2) == (1, 2)
-    assert t.test_kw_only_all(j=1, i=2) == (2, 1)
-    with pytest.raises(TypeError):
-        t.test_kw_only_all(i=1)
-    with pytest.raises(TypeError):
-        t.test_kw_only_all(1, 2)
-    assert (
-        t.test_kw_only_all.__doc__
-        == "test_kw_only_all(*, i: int, j: int) -> tuple"
-    )
-
-    # (__arg0, *, j, k)
-    assert t.test_kw_only_some(1, k=3, j=2) == (1, 2, 3)
-    assert (
-        t.test_kw_only_some.__doc__
-        == "test_kw_only_some(arg0: int, *, j: int, k: int) -> tuple"
-    )
-
-    # (__arg0=3, j=4, *, k=5, z)
-    assert t.test_kw_only_with_defaults(z=8) == (3, 4, 5, 8)
-    assert t.test_kw_only_with_defaults(2, z=8) == (2, 4, 5, 8)
-    assert t.test_kw_only_with_defaults(2, j=7, k=8, z=9) == (2, 7, 8, 9)
-    assert t.test_kw_only_with_defaults(2, 7, z=9, k=8) == (2, 7, 8, 9)
-    with pytest.raises(TypeError):
-        t.test_kw_only_with_defaults(2, 7, 8, z=9)
-    assert (
-        t.test_kw_only_with_defaults.__doc__
-        == "test_kw_only_with_defaults(arg0: int = 3, j: int = 4, *, k: int = 5, z: int) -> tuple"
-    )
-
-    # (i, *, j)
-    assert t.test_kw_only_mixed(1, j=2) == (1, 2)
-    assert t.test_kw_only_mixed(j=2, i=3) == (3, 2)
-    assert t.test_kw_only_mixed(i=2, j=3) == (2, 3)
-    with pytest.raises(TypeError):
-        t.test_kw_only_mixed(i=1)
-    with pytest.raises(TypeError):
-        t.test_kw_only_mixed(1, i=2)
-    assert (
-        t.test_kw_only_mixed.__doc__
-        == "test_kw_only_mixed(i: int, *, j: int) -> tuple"
-    )
-
-    with pytest.raises(TypeError):
-        t.kw_only_methods(42)
-
-    val = t.kw_only_methods(v=42)
-    assert val.v == 42
-
-    # (self, *, i, j)
-    assert val.method_2k() == (1, 2)
-    assert val.method_2k(i=3) == (3, 2)
-    assert val.method_2k(j=4) == (1, 4)
-    assert val.method_2k(i=3, j=4) == (3, 4)
-    assert val.method_2k(j=3, i=4) == (4, 3)
-    with pytest.raises(TypeError):
-        val.method_2k(1)
-    with pytest.raises(TypeError):
-        val.method_2k(1, j=2)
-    assert (
-        t.kw_only_methods.method_2k.__doc__
-        == "method_2k(self, *, i: int = 1, j: int = 2) -> tuple"
-    )
-
-    # (self, i, *, j)
-    assert val.method_1p1k() == (1, 2)
-    assert val.method_1p1k(i=3) == (3, 2)
-    assert val.method_1p1k(j=4) == (1, 4)
-    assert val.method_1p1k(i=3, j=4) == (3, 4)
-    assert val.method_1p1k(j=3, i=4) == (4, 3)
-    assert val.method_1p1k(3) == (3, 2)
-    assert val.method_1p1k(3, j=4) == (3, 4)
-    with pytest.raises(TypeError):
-        val.method_2k(1, 2)
-    assert (
-        t.kw_only_methods.method_1p1k.__doc__
-        == "method_1p1k(self, i: int = 1, *, j: int = 2) -> tuple"
-    )
-
-
-def test42_ptr_return():
-    assert t.test_ptr_return() == (10, 100)
-
-def test41_any():
-    s = "hello"
-    assert t.test_any(s) is s
-    assert t.test_any.__doc__ == "test_any(arg: typing.Any, /) -> typing.Any"
-
-def test42_wrappers_list():
-    assert t.test_wrappers_list()
-
-def test43_wrappers_dict():
-    assert t.test_wrappers_dict()
-
-def test43_wrappers_set():
-    assert t.test_wrappers_set()
-
-def test44_hash():
-    value = (1, 2, 3)
-    assert t.hash_it(value) == hash(value);
-
-
-def test45_new():
-    assert t.test_bytearray_new() == bytearray()
-    assert t.test_bytearray_new("\x00\x01\x02\x03", 4) == bytearray(
-        b"\x00\x01\x02\x03"
-    )
-    assert t.test_bytearray_new("", 0) == bytearray()
-
-
-def test46_copy():
-    o = bytearray(b"\x00\x01\x02\x03")
-    c = t.test_bytearray_copy(o)
-    assert c == o
-    o.clear()
-    assert c != o
-
-
-def test47_c_str():
-    o = bytearray(b"Hello, world!")
-    assert t.test_bytearray_c_str(o) == "Hello, world!"
-
-
-def test48_size():
-    o = bytearray(b"Hello, world!")
-    assert t.test_bytearray_size(o) == len(o)
-
-
-def test49_resize():
-    o = bytearray(b"\x00\x01\x02\x03")
-    assert len(o) == 4
-    t.test_bytearray_resize(o, 8)
-    assert len(o) == 8
-
-
-def test50_call_policy():
-    def case(arg1, arg2, expect_ret):  # type: (str, str, str | None) -> str
-        if hasattr(sys, "getrefcount"):
-            refs_before = (sys.getrefcount(arg1), sys.getrefcount(arg2))
-
-        ret = None
-        try:
-            ret = t.test_call_policy(arg1, arg2)
-            assert ret == expect_ret
-            return ret
-        finally:
-            if expect_ret is None:
-                assert t.call_policy_record() == []
-            else:
-                (((arg1r, arg2r), recorded_ret),) = t.call_policy_record()
-                assert recorded_ret == expect_ret
-                assert ret is None or ret is recorded_ret
-                assert recorded_ret is not expect_ret
-
-                if hasattr(sys, "getrefcount"):
-                    # Make sure no reference leak occurred: should be
-                    # one in getrefcount args, one or two in locals,
-                    # zero or one in the pending-return-value slot.
-                    # We have to decompose this to avoid getting confused
-                    # by transient additional references added by pytest's
-                    # assertion rewriting.
-                    ret_refs = sys.getrefcount(recorded_ret)
-                    expected_refs = 2 + 2 * (ret is not None)
-
-                    # On Python 3.14a7, an optimization was introduced where
-                    # stack-based function calling no longer acquires a reference
-                    if py_3_14a7_or_newer:
-                        assert ret_refs == expected_refs - 1 or ret_refs == expected_refs
-                    else:
-                        assert ret_refs == expected_refs
-
-                for (passed, recorded) in ((arg1, arg1r), (arg2, arg2r)):
-                    if passed == "swapfrom":
-                        assert recorded == "swapto"
-                        if hasattr(sys, "getrefcount"):
-                            recorded_refs = sys.getrefcount(recorded)
-
-                            # recorded, arg1r, unnamed tuple, getrefcount arg
-                            if py_3_14a7_or_newer:
-                                assert recorded_refs == 3 or recorded_refs == 4
-                            else:
-                                assert recorded_refs == 4
-                    else:
-                        assert passed is recorded
-
-                del passed, recorded, arg1r, arg2r
-                if hasattr(sys, "getrefcount"):
-                    refs_after = (sys.getrefcount(arg1), sys.getrefcount(arg2))
-
-                    if not py_3_14a7_or_newer or ret is not None:
-                        assert refs_before == refs_after
-
-    # precall throws exception
-    with pytest.raises(RuntimeError, match="expected only strings"):
-        case(12345, "0", None)
-
-    # conversion of args fails
-    with pytest.raises(TypeError):
-        case("string", "xxx", "<unfinished>")
-
-    # function throws exception
-    with pytest.raises(RuntimeError, match="offset too large"):
-        case("abc", "4", "<unfinished>")
-
-    # conversion of return value fails
-    with pytest.raises(UnicodeDecodeError):
-        case("returnfail", "4", "<return conversion failed>")
-
-    # postcall throws exception
-    with pytest.raises(RuntimeError, match="postcall exception"):
-        case("postthrow", "4", "throw")
-
-    # normal call
-    case("example", "1", "xample")
-
-    # precall modifies args
-    case("swapfrom", "0", "swapto")
-    with pytest.raises(TypeError):
-        case("swapfrom", "xxx", "<unfinished>")
-    with pytest.raises(RuntimeError, match="offset too large"):
-        case("swapfrom", "10", "<unfinished>")
-
-def test51_isinstance():
-    assert t.isinstance_(3, int)
-    assert not t.isinstance_(3, bool)
-    with pytest.raises(TypeError):
-        t.isinstance_(3, 7)
-
-
-def test52_frozenset():
-    x = t.test_frozenset()
-    assert isinstance(x, frozenset)
-    assert len(x) == 2
-    assert 123 in x and "123" in x
-    assert t.test_frozenset_contains(x, 123)
-    assert t.test_frozenset_contains(x, "123")
-    assert not t.test_frozenset_contains(x, "1234")
-    assert not t.test_frozenset_contains(x, 1234)
-
-def test53_fallback():
-    assert t.test_fallback_1(3.0) == 0
-    assert t.test_fallback_1(3) == 1
-    assert t.test_fallback_1('3') == 1
-
-    assert t.test_fallback_2(3.0) == 0
-    assert t.test_fallback_2(3) == 0
-    assert t.test_fallback_2('3') == 1
-
-def test54_dict_default():
-    assert t.test_get_dict_default({'key': 100}) == 100
-    assert t.test_get_dict_default({'key2': 100}) == 123
diff --git a/src/nanobind/tests/test_functions_ext.pyi.ref b/src/nanobind/tests/test_functions_ext.pyi.ref
deleted file mode 100644
index 64ba9af..0000000
--- a/src/nanobind/tests/test_functions_ext.pyi.ref
+++ /dev/null
@@ -1,261 +0,0 @@
-from collections.abc import Callable
-import types
-from typing import Annotated, Any, overload
-
-
-def test_01() -> None: ...
-
-def test_02(up: int = 8, down: int = 1) -> int: ...
-
-def test_03(arg0: int, arg1: int, /) -> int: ...
-
-def test_04() -> int: ...
-
-@overload
-def test_05(arg: int, /) -> int:
-    """doc_1"""
-
-@overload
-def test_05(arg: float, /) -> int:
-    """doc_2"""
-
-@overload
-def test_05b(arg: int, /) -> int:
-    """doc_1"""
-
-@overload
-def test_05b(arg: float, /) -> int: ...
-
-@overload
-def test_05c(arg: int, /) -> int:
-    """doc_1"""
-
-@overload
-def test_05c(arg: float, /) -> int: ...
-
-def test_06() -> None: ...
-
-@overload
-def test_07(arg0: int, arg1: int, /, *args, **kwargs) -> tuple[int, int]: ...
-
-@overload
-def test_07(a: int, b: int, *myargs, **mykwargs) -> tuple[int, int]: ...
-
-@overload
-def test_tuple() -> tuple[str, int]: ...
-
-@overload
-def test_tuple(arg: tuple[int, ...], /) -> int: ...
-
-def test_bad_tuple() -> tuple[str, object]: ...
-
-def test_call_1(arg: Callable[[int], int], /) -> object: ...
-
-def test_call_2(arg: Callable[[int, int], None], /) -> object: ...
-
-def test_call_extra(arg0: Callable[..., None], /, *args, **kwargs) -> object: ...
-
-def test_list(arg: list, /) -> None: ...
-
-def test_call_guard_wrapper_rvalue_ref(arg: int, /) -> int: ...
-
-def test_call_guard() -> int: ...
-
-def call_guard_value() -> int: ...
-
-def test_release_gil() -> bool: ...
-
-def test_print() -> None: ...
-
-def test_iter(arg: object, /) -> list: ...
-
-def test_iter_tuple(arg: tuple, /) -> list: ...
-
-def test_iter_list(arg: list, /) -> list: ...
-
-@overload
-def test_08(arg: int, /) -> int:
-    """first docstring"""
-
-@overload
-def test_08(x: Annotated[float, 'foo']) -> int:
-    """another docstring"""
-
-def test_09(arg: type, /) -> bool: ...
-
-def test_10(arg: dict, /) -> dict: ...
-
-def test_10_contains(arg: dict, /) -> bool: ...
-
-def test_11_sl(arg: int, /) -> int: ...
-
-def test_11_ul(arg: int, /) -> int: ...
-
-def test_11_sll(arg: int, /) -> int: ...
-
-def test_11_ull(arg: int, /) -> int: ...
-
-def test_12(arg: str, /) -> str: ...
-
-def test_13() -> str: ...
-
-def test_14(arg: object, /) -> str: ...
-
-def test_15(arg: bytes, /) -> str: ...
-
-def test_15_d(arg: bytes, /) -> bytes: ...
-
-def test_16(arg: str, /) -> bytes: ...
-
-def test_17(arg: bytes, /) -> int: ...
-
-def test_18(arg0: str, arg1: int, /) -> bytes: ...
-
-def test_19(arg: int, /) -> object: ...
-
-def test_20(arg: str, /) -> object: ...
-
-def test_21(arg: int, /) -> int: ...
-
-def test_21_f(arg: float, /) -> int: ...
-
-def test_21_g() -> int: ...
-
-def test_21_h() -> int: ...
-
-def test_21_dnc(arg: float) -> float: ...
-
-def test_21_fnc(arg: float) -> float: ...
-
-def test_22() -> types.CapsuleType: ...
-
-def test_23() -> types.CapsuleType: ...
-
-def test_24(p: types.CapsuleType | None) -> int: ...
-
-def test_25(arg: slice, /) -> slice: ...
-
-def test_26() -> slice: ...
-
-def test_27() -> slice: ...
-
-def test_28() -> slice: ...
-
-def test_29(arg: types.EllipsisType, /) -> types.EllipsisType: ...
-
-def test_30(arg: Callable, /) -> str: ...
-
-def test_31(arg: int, /) -> int: ...
-
-def test_32(arg: int, /) -> int: ...
-
-def identity_i8(arg: int, /) -> int: ...
-
-def identity_u8(arg: int, /) -> int: ...
-
-def identity_i16(arg: int, /) -> int: ...
-
-def identity_u16(arg: int, /) -> int: ...
-
-def identity_i32(arg: int, /) -> int: ...
-
-def identity_u32(arg: int, /) -> int: ...
-
-def identity_i64(arg: int, /) -> int: ...
-
-def identity_u64(arg: int, /) -> int: ...
-
-def test_33(self, arg: int, /) -> int: ...
-
-def test_34(self, y: int) -> int: ...
-
-def test_35() -> object: ...
-
-def test_cast_char(arg: object, /) -> str: ...
-
-def test_cast_str(arg: object, /) -> str: ...
-
-def test_set() -> set: ...
-
-def test_set_contains(arg0: set, arg1: object, /) -> bool: ...
-
-def test_frozenset() -> frozenset: ...
-
-def test_frozenset_contains(arg0: frozenset, arg1: object, /) -> bool: ...
-
-def test_del_list(arg: list, /) -> None: ...
-
-def test_del_dict(arg: dict, /) -> None: ...
-
-def test_ptr_return() -> tuple[int, int]: ...
-
-def test_args_kwonly(i: int, j: float, *args, z: int) -> tuple: ...
-
-def test_args_kwonly_kwargs(i: int, j: float, *args, z: int, **kwargs) -> tuple: ...
-
-def test_kwonly_kwargs(i: int, *, j: float, **kwargs) -> tuple: ...
-
-def test_kw_only_all(*, i: int, j: int) -> tuple: ...
-
-def test_kw_only_some(arg0: int, *, j: int, k: int) -> tuple: ...
-
-def test_kw_only_with_defaults(arg0: int = 3, j: int = 4, *, k: int = 5, z: int) -> tuple: ...
-
-def test_kw_only_mixed(i: int, *, j: int) -> tuple: ...
-
-class kw_only_methods:
-    def __init__(self, *, v: int) -> None: ...
-
-    @property
-    def v(self) -> int: ...
-
-    @v.setter
-    def v(self, arg: int, /) -> None: ...
-
-    def method_2k(self, *, i: int = 1, j: int = 2) -> tuple: ...
-
-    def method_1p1k(self, i: int = 1, *, j: int = 2) -> tuple: ...
-
-def test_any(arg: Any, /) -> Any: ...
-
-def test_wrappers_list() -> bool: ...
-
-def test_wrappers_dict() -> bool: ...
-
-def test_wrappers_set() -> bool: ...
-
-def hash_it(arg: object, /) -> int: ...
-
-@overload
-def test_bytearray_new() -> bytearray: ...
-
-@overload
-def test_bytearray_new(arg0: str, arg1: int, /) -> bytearray: ...
-
-def test_bytearray_copy(arg: bytearray, /) -> bytearray: ...
-
-def test_bytearray_c_str(arg: bytearray, /) -> str: ...
-
-def test_bytearray_size(arg: bytearray, /) -> int: ...
-
-def test_bytearray_resize(arg0: bytearray, arg1: int, /) -> None: ...
-
-def test_call_policy(arg0: str, arg1: str, /) -> str: ...
-
-def call_policy_record() -> list[tuple[tuple, object]]: ...
-
-def abi_tag() -> str: ...
-
-@overload
-def test_fallback_1(arg: float, /) -> int: ...
-
-@overload
-def test_fallback_1(arg: object, /) -> int: ...
-
-@overload
-def test_fallback_2(arg: float, /) -> int: ...
-
-@overload
-def test_fallback_2(arg: object, /) -> int: ...
-
-def test_get_dict_default(arg: dict, /) -> object: ...
diff --git a/src/nanobind/tests/test_holders.cpp b/src/nanobind/tests/test_holders.cpp
deleted file mode 100644
index 7f8ee60..0000000
--- a/src/nanobind/tests/test_holders.cpp
+++ /dev/null
@@ -1,261 +0,0 @@
-#if defined(__GNUC__)
-// warning: '..' declared with greater visibility than the type of its field '..'
-#  pragma GCC diagnostic ignored "-Wattributes"
-#endif
-
-#include <nanobind/stl/shared_ptr.h>
-#include <nanobind/stl/unique_ptr.h>
-#include <nanobind/stl/pair.h>
-#include <nanobind/stl/vector.h>
-
-namespace nb = nanobind;
-
-static int created = 0;
-static int deleted = 0;
-
-struct Example {
-    int value;
-    Example(int value) : value(value) { created++; }
-    ~Example() { deleted++; }
-
-    static Example *make(int value) { return new Example(value); }
-    static std::shared_ptr<Example> make_shared(int value) {
-        return std::make_shared<Example>(value);
-    }
-};
-
-struct SharedWrapper { std::shared_ptr<Example> value; };
-struct UniqueWrapper { std::unique_ptr<Example> value; };
-struct UniqueWrapper2 { std::unique_ptr<Example, nb::deleter<Example>> value; };
-
-struct ExampleST : std::enable_shared_from_this<ExampleST> {
-    int value;
-    ExampleST(int value) : value(value) { created++; }
-    ~ExampleST() { deleted++; }
-
-    static ExampleST *make(int value) { return new ExampleST(value); }
-    static std::shared_ptr<ExampleST> make_shared(int value) {
-        return std::make_shared<ExampleST>(value);
-    }
-};
-struct SharedWrapperST {
-    std::shared_ptr<ExampleST> value;
-    ExampleST* get() const { return value.get(); }
-};
-
-static_assert(nb::detail::has_shared_from_this_v<ExampleST>);
-static_assert(!nb::detail::has_shared_from_this_v<Example>);
-
-enum class PetKind { Cat, Dog };
-struct Pet { const PetKind kind; };
-struct Dog : Pet { Dog() : Pet{PetKind::Dog} { } };
-struct Cat : Pet { Cat() : Pet{PetKind::Cat} { } };
-
-namespace nanobind::detail {
-    template <> struct type_hook<Pet> {
-        static const std::type_info *get(Pet *p) {
-            if (p) {
-                switch (p->kind) {
-                    case PetKind::Dog: return &typeid(Dog);
-                    case PetKind::Cat: return &typeid(Cat);
-                }
-            }
-            return &typeid(Pet);
-        }
-    };
-} // namespace nanobind::detail
-
-NB_MODULE(test_holders_ext, m) {
-    nb::class_<Example>(m, "Example")
-        .def(nb::init<int>())
-        .def_rw("value", &Example::value)
-        .def_static("make", &Example::make)
-        .def_static("make_shared", &Example::make_shared);
-
-    // ------- shared_ptr -------
-
-    nb::class_<SharedWrapper>(m, "SharedWrapper")
-        .def(nb::init<std::shared_ptr<Example>>())
-        .def_rw("ptr", &SharedWrapper::value)
-        .def_prop_rw("value",
-            [](SharedWrapper &t) { return t.value->value; },
-            [](SharedWrapper &t, int value) { t.value->value = value; });
-
-    m.def("query_shared_1", [](Example *shared) { return shared->value; });
-    m.def("query_shared_2",
-          [](std::shared_ptr<Example> &shared) { return shared->value; });
-    m.def("query_shared_3",
-          [](std::shared_ptr<const Example> &shared) { return shared->value; });
-    m.def("passthrough",
-          [](std::shared_ptr<Example> shared) { return shared; });
-    m.def("passthrough_2",
-          [](std::shared_ptr<const Example> shared) { return shared; });
-
-    // ------- enable_shared_from_this -------
-
-    nb::class_<ExampleST>(m, "ExampleST")
-        .def(nb::init<int>())
-        .def("has_shared_from_this", [](ExampleST& self) {
-            return !self.weak_from_this().expired();
-        })
-        .def("shared_from_this", [](ExampleST& self) {
-            return self.shared_from_this();
-        })
-        .def("use_count", [](ExampleST& self) {
-            return self.weak_from_this().use_count();
-        })
-        .def_rw("value", &ExampleST::value)
-        .def_static("make", &ExampleST::make)
-        .def_static("make_shared", &ExampleST::make_shared);
-
-    struct DerivedST : ExampleST {
-        using ExampleST::ExampleST;
-    };
-    static_assert(nb::detail::has_shared_from_this_v<DerivedST>);
-    nb::class_<DerivedST, ExampleST>(m, "DerivedST")
-        .def(nb::init<int>())
-        .def_static("make", [](int v) {
-            return static_cast<DerivedST*>(ExampleST::make(v));
-        })
-        .def_static("make_shared", [](int v) {
-            return std::static_pointer_cast<DerivedST>(ExampleST::make_shared(v));
-        });
-
-    nb::class_<SharedWrapperST>(m, "SharedWrapperST")
-        .def(nb::init<std::shared_ptr<ExampleST>>())
-        .def_static("from_existing", [](ExampleST *obj) {
-            return SharedWrapperST{obj->shared_from_this()};
-        })
-        .def_static("from_wrapper", [](SharedWrapperST& w) {
-            return SharedWrapperST{w.value};
-        })
-        .def("use_count", [](SharedWrapperST& self) {
-            return self.value.use_count();
-        })
-        .def("same_owner", [](SharedWrapperST& self, ExampleST& other) {
-            auto self_s = self.value;
-            auto other_s = other.shared_from_this();
-            return !self_s.owner_before(other_s) &&
-                   !other_s.owner_before(self_s);
-        })
-        .def("get_own", &SharedWrapperST::get)
-        .def("get_ref", &SharedWrapperST::get, nb::rv_policy::reference)
-        .def_rw("ptr", &SharedWrapperST::value)
-        .def_prop_rw("value",
-            [](SharedWrapperST &t) { return t.value->value; },
-            [](SharedWrapperST &t, int value) { t.value->value = value; });
-
-    m.def("owns_cpp", [](nb::handle h) { return nb::inst_state(h).second; });
-    m.def("same_owner", [](const SharedWrapperST& a,
-                           const SharedWrapperST& b) {
-        return !a.value.owner_before(b.value) && !b.value.owner_before(a.value);
-    });
-
-    // ------- unique_ptr -------
-
-    m.def("unique_from_cpp",
-          [](int val) { return std::make_unique<const Example>(val); },
-          nb::arg() = 1);
-    m.def("unique_from_cpp_2", []() {
-        return std::unique_ptr<Example, nb::deleter<Example>>(new Example(2));
-    });
-
-    nb::class_<UniqueWrapper>(m, "UniqueWrapper")
-        .def(nb::init<std::unique_ptr<Example>>())
-        .def("get", [](UniqueWrapper *uw) { return std::move(uw->value); });
-
-    nb::class_<UniqueWrapper2>(m, "UniqueWrapper2")
-        .def(nb::init<std::unique_ptr<Example, nb::deleter<Example>>>())
-        .def("get", [](UniqueWrapper2 *uw) { return std::move(uw->value); });
-
-    m.def("passthrough_unique",
-          [](std::unique_ptr<Example> unique) { return unique; },
-          nb::arg().none());
-    m.def("passthrough_unique_2",
-          [](std::unique_ptr<Example, nb::deleter<Example>> unique) { return unique; });
-
-    m.def("passthrough_unique_pairs",
-          [](std::vector<std::pair<std::unique_ptr<Example>,
-                                   std::unique_ptr<Example>>> v,
-             bool clear) {
-              if (clear)
-                  v.clear();
-              return v;
-          }, nb::arg("v"), nb::arg("clear") = false);
-
-    m.def("stats", []{ return std::make_pair(created, deleted); });
-    m.def("reset", []{ created = deleted = 0; });
-
-    struct Base { ~Base() = default; };
-    struct PolymorphicBase { virtual ~PolymorphicBase() = default; };
-    struct Subclass : Base { };
-    struct PolymorphicSubclass : PolymorphicBase { };
-    struct AnotherSubclass : Base { };
-    struct AnotherPolymorphicSubclass : PolymorphicBase { };
-
-    nb::class_<Base> (m, "Base");
-    nb::class_<Subclass> (m, "Subclass");
-    nb::class_<PolymorphicBase> (m, "PolymorphicBase");
-    nb::class_<PolymorphicSubclass> (m, "PolymorphicSubclass");
-
-    m.def("u_polymorphic_factory", []() { return std::unique_ptr<PolymorphicBase>(new PolymorphicSubclass()); });
-    m.def("u_polymorphic_factory_2", []() { return std::unique_ptr<PolymorphicBase>(new AnotherPolymorphicSubclass()); });
-    m.def("u_factory", []() { return std::unique_ptr<Base>(new Subclass()); });
-    m.def("u_factory_2", []() { return std::unique_ptr<Base>(new AnotherSubclass()); });
-
-    m.def("s_polymorphic_factory", []() { return std::shared_ptr<PolymorphicBase>(new PolymorphicSubclass()); });
-    m.def("s_polymorphic_factory_2", []() { return std::shared_ptr<PolymorphicBase>(new AnotherPolymorphicSubclass()); });
-    m.def("s_factory", []() { return std::shared_ptr<Base>(new Subclass()); });
-    m.def("s_factory_2", []() { return std::shared_ptr<Base>(new AnotherSubclass()); });
-
-    nb::class_<Pet>(m, "Pet");
-    nb::class_<Dog>(m, "Dog");
-    nb::class_<Cat>(m, "Cat");
-
-    nb::enum_<PetKind>(m, "PetKind")
-        .value("Cat", PetKind::Cat)
-        .value("Dog", PetKind::Dog);
-
-    m.def("make_pet", [](PetKind kind) -> Pet* {
-        switch (kind) {
-            case PetKind::Dog:
-                return new Dog();
-            case PetKind::Cat:
-                return new Cat();
-            default:
-                throw std::runtime_error("Internal error");
-        }
-    });
-
-    m.def("make_pet_u", [](PetKind kind) -> std::unique_ptr<Pet> {
-        switch (kind) {
-            case PetKind::Dog:
-                return std::make_unique<Dog>();
-            case PetKind::Cat:
-                return std::make_unique<Cat>();
-            default:
-                throw std::runtime_error("Internal error");
-        }
-    });
-
-    m.def("make_pet_s", [](PetKind kind) -> std::shared_ptr<Pet> {
-        switch (kind) {
-            case PetKind::Dog:
-                return std::make_shared<Dog>();
-            case PetKind::Cat:
-                return std::make_shared<Cat>();
-            default:
-                throw std::runtime_error("Internal error");
-        }
-    });
-
-    struct ExampleWrapper {
-        Example value{5};
-        std::shared_ptr<Example> value_nullable;
-    };
-
-    nb::class_<ExampleWrapper>(m, "ExampleWrapper")
-        .def(nb::init<>())
-        .def_rw("value", &ExampleWrapper::value)
-        .def_rw("value_nullable", &ExampleWrapper::value_nullable, nb::arg().none());
-}
diff --git a/src/nanobind/tests/test_holders.py b/src/nanobind/tests/test_holders.py
deleted file mode 100644
index 7051b11..0000000
--- a/src/nanobind/tests/test_holders.py
+++ /dev/null
@@ -1,449 +0,0 @@
-import sys
-import test_holders_ext as t
-import pytest
-from common import collect
-
-# Reference counting behavior changed on 3.14a7+
-py_3_14a7_or_newer = sys.version_info >= (3, 14, 0, 'alpha', 7)
-
-@pytest.fixture
-def clean():
-    collect()
-    t.reset()
-
-# ------------------------------------------------------------------
-
-def test01_create(clean):
-    e = t.Example(123)
-    assert e.value == 123
-    assert t.query_shared_1(e) == 123
-    assert t.query_shared_2(e) == 123
-    assert t.query_shared_3(e) == 123
-    del e
-    collect()
-    assert t.stats() == (1, 1)
-
-
-def test02_sharedptr_from_python(clean):
-    e = t.Example(234)
-    w = t.SharedWrapper(e)
-    assert w.ptr is e
-    del e
-    collect()
-    assert t.stats() == (1, 0)
-    del w
-    collect()
-    assert t.stats() == (1, 1)
-
-    w = t.SharedWrapper(t.Example(234))
-    collect()
-    assert t.stats() == (2, 1)
-    w.ptr = t.Example(0)
-    collect()
-    assert t.stats() == (3, 2)
-    del w
-    collect()
-    assert t.stats() == (3, 3)
-
-
-def test03_sharedptr_from_cpp(clean):
-    e = t.Example.make(5)
-    assert t.passthrough(e) is e
-    assert t.passthrough_2(e) is e
-    assert t.query_shared_1(e) == 5
-    assert t.query_shared_2(e) == 5
-    assert t.query_shared_3(e) == 5
-
-    w = t.SharedWrapper(e)
-    assert e is not w.value
-    assert w.value == 5
-    w.value = 6
-    assert e.value == 6
-    del w, e
-
-    e = t.Example.make_shared(6)
-    assert t.query_shared_1(e) == 6
-    assert t.query_shared_2(e) == 6
-    assert t.query_shared_3(e) == 6
-    assert t.passthrough(e) is e
-    assert t.passthrough_2(e) is e
-
-    w = t.SharedWrapper(e)
-    assert e is not w.value
-    assert w.value == 6
-    del w, e
-    collect()
-    assert t.stats() == (2, 2)
-
-# ------------------------------------------------------------------
-
-def test04_uniqueptr_from_cpp(clean):
-    a = t.unique_from_cpp()
-    b = t.unique_from_cpp_2()
-    assert a.value == 1
-    assert b.value == 2
-    del a, b
-    collect()
-    assert t.stats() == (2, 2)
-
-
-def test05a_uniqueptr_from_cpp(clean):
-    # Test ownership exchange when the object has been created on the C++ side
-    a = t.unique_from_cpp()
-    b = t.unique_from_cpp_2()
-    wa = t.UniqueWrapper(a)
-    wb = t.UniqueWrapper(b)
-    with pytest.warns(RuntimeWarning, match='nanobind: attempted to access a relinquished instance of type \'test_holders_ext.Example\'!'):
-        with pytest.raises(TypeError) as excinfo:
-            assert a.value == 1
-        assert 'incompatible function arguments' in str(excinfo.value)
-    with pytest.warns(RuntimeWarning, match='nanobind: attempted to access a relinquished instance of type \'test_holders_ext.Example\'!'):
-        with pytest.raises(TypeError) as excinfo:
-            assert b.value == 2
-        assert 'incompatible function arguments' in str(excinfo.value)
-    del a, b
-    del wa, wb
-    collect()
-    assert t.stats() == (2, 2)
-
-    t.reset()
-    a = t.unique_from_cpp()
-    b = t.unique_from_cpp_2()
-    wa = t.UniqueWrapper(a)
-    wb = t.UniqueWrapper(b)
-
-    a2 = wa.get()
-    b2 = wb.get()
-    assert a2.value == 1 and b2.value == 2
-    assert a2 is a and b2 is b
-    assert a.value == 1 and b.value == 2
-    collect()
-    assert t.stats() == (2, 0)
-    del a, b, a2, b2
-    collect()
-    assert t.stats() == (2, 2)
-
-def test05b_uniqueptr_list(clean):
-    t.reset()
-    # Test ownership exchange as part of a larger data structure
-    k = t.unique_from_cpp(1)
-    v = t.unique_from_cpp(2)
-    res = t.passthrough_unique_pairs([(k, v)])
-    assert res == [(k, v)]
-    assert k.value == 1 and v.value == 2
-
-    res = t.passthrough_unique_pairs([(k, v)], clear=True)
-    assert res == []
-    for obj in (k, v):
-        with pytest.warns(RuntimeWarning, match='nanobind: attempted to access a relinquished instance of type \'test_holders_ext.Example\'!'):
-            with pytest.raises(TypeError) as excinfo:
-                obj.value
-    collect()
-    assert t.stats() == (2, 2)
-
-def test05c_uniqueptr_structure_duplicate(clean):
-    t.reset()
-    # Test ownership exchange that fails partway through
-    # (can't take ownership from k twice)
-    k = t.unique_from_cpp(3)
-    with pytest.warns(RuntimeWarning, match=r'nanobind::detail::nb_relinquish_ownership()'):
-        with pytest.raises(TypeError):
-            t.passthrough_unique_pairs([(k, k)])
-    # Ownership passes back to Python
-    assert k.value == 3
-
-    del k
-    collect()
-    assert t.stats() == (1, 1)
-
-def test05d_uniqueptr_reinit(clean):
-    x = t.unique_from_cpp()
-    assert x.value == 1
-    w = t.UniqueWrapper(x)
-    with pytest.warns(RuntimeWarning, match='nanobind: attempted to access a relinquished instance of type \'test_holders_ext.Example\'!'):
-        with pytest.raises(TypeError):
-            x.value
-    with pytest.warns(RuntimeWarning, match='nanobind: attempted to access a relinquished instance of type \'test_holders_ext.Example\'!'):
-        with pytest.raises(TypeError):
-            x.__init__(3)
-    y = w.get()
-    assert y is x and y.value == 1
-
-
-def test06_uniqueptr_from_py(clean):
-    # Test ownership exchange when the object has been created on the Python side
-    a = t.Example(1)
-    with pytest.warns(RuntimeWarning, match=r'nanobind::detail::nb_relinquish_ownership()'):
-        with pytest.raises(TypeError) as excinfo:
-            wa = t.UniqueWrapper(a)
-    wa = t.UniqueWrapper2(a)
-    with pytest.warns(RuntimeWarning, match='nanobind: attempted to access a relinquished instance of type \'test_holders_ext.Example\'!'):
-        with pytest.raises(TypeError) as excinfo:
-            assert a.value == 1
-        assert 'incompatible function arguments' in str(excinfo.value)
-    a2 = wa.get()
-    assert a2.value == 1 and a is a2
-    del a, a2
-    collect()
-    assert t.stats() == (1, 1)
-
-    # Test that ownership exchange as part of a larger data structure fails
-    # gracefully rather than crashing
-    k = t.Example(1)
-    v = t.Example(2)
-    with pytest.warns(RuntimeWarning, match=r'nanobind::detail::nb_relinquish_ownership()'):
-        with pytest.raises(TypeError) as excinfo:
-            t.passthrough_unique_pairs([(k, v)])
-    assert k.value == 1 and v.value == 2
-
-    # Test the case where the key relinquishes ownership successfully and
-    # then the value can't do
-    v = t.unique_from_cpp(3)
-    with pytest.warns(RuntimeWarning, match=r'nanobind::detail::nb_relinquish_ownership()'):
-        with pytest.raises(TypeError) as excinfo:
-            t.passthrough_unique_pairs([(k, v)])
-    assert k.value == 1 and v.value == 3
-
-    del k, v
-    collect()
-    assert t.stats() == (4, 4)
-
-
-def test07_uniqueptr_passthrough(clean):
-    assert t.passthrough_unique(None) is None
-    assert t.passthrough_unique(t.unique_from_cpp()).value == 1
-    assert t.passthrough_unique(t.unique_from_cpp_2()).value == 2
-    assert t.passthrough_unique_2(t.unique_from_cpp()).value == 1
-    assert t.passthrough_unique_2(t.unique_from_cpp_2()).value == 2
-    collect()
-    assert t.stats() == (4, 4)
-    t.reset()
-
-    with pytest.warns(RuntimeWarning, match=r'nanobind::detail::nb_relinquish_ownership()'):
-        with pytest.raises(TypeError):
-            assert t.passthrough_unique(t.Example(1)).value == 1
-    assert t.passthrough_unique_2(t.Example(1)).value == 1
-    collect()
-    assert t.stats() == (2, 2)
-
-
-def test07_polymorphic_downcast_unique():
-    assert isinstance(t.u_factory(), t.Base)
-    assert isinstance(t.u_factory_2(), t.Base)
-    assert isinstance(t.u_polymorphic_factory(), t.PolymorphicSubclass)
-    assert isinstance(t.u_polymorphic_factory_2(), t.PolymorphicBase)
-
-
-def test08_polymorphic_downcast_shared():
-    assert isinstance(t.s_factory(), t.Base)
-    assert isinstance(t.s_factory_2(), t.Base)
-    assert isinstance(t.s_polymorphic_factory(), t.PolymorphicSubclass)
-    assert isinstance(t.s_polymorphic_factory_2(), t.PolymorphicBase)
-
-def test09_tag_based():
-    assert isinstance(t.make_pet(t.PetKind.Dog), t.Dog)
-    assert isinstance(t.make_pet(t.PetKind.Cat), t.Cat)
-
-
-def test09_tag_based_unique():
-    assert isinstance(t.make_pet_u(t.PetKind.Dog), t.Dog)
-    assert isinstance(t.make_pet_u(t.PetKind.Cat), t.Cat)
-
-def test09_tag_based_shared():
-    assert isinstance(t.make_pet_s(t.PetKind.Dog), t.Dog)
-    assert isinstance(t.make_pet_s(t.PetKind.Cat), t.Cat)
-
-
-def check_shared_from_this_py_owned(ty, factory, value):
-    e = ty(value)
-
-    # Creating from Python does not enable shared_from_this
-    assert e.value == value
-    assert not e.has_shared_from_this()
-    assert t.owns_cpp(e)
-
-    # Passing to C++ as a shared_ptr does
-    w = t.SharedWrapperST(e)
-    assert e.has_shared_from_this()
-    assert w.ptr is e
-
-    # Execute shared_from_this on the C++ side
-    w2 = t.SharedWrapperST.from_existing(e)
-    assert e.use_count() == 2
-    assert w.value == w2.value == e.value == value
-    assert t.same_owner(w, w2)
-
-    # Returning a raw pointer from C++ locates the existing instance
-    assert w2.get_own() is w2.get_ref() is e
-    assert t.owns_cpp(e)
-
-    if hasattr(sys, "getrefcount"):
-        # One reference is held by the C++ shared_ptr, one by our
-        # locals dict, and one by the arg to getrefcount
-        rc = sys.getrefcount(e)
-
-        # On Python 3.14a7, an optimization was introduced where
-        # stack-based function calling no longer acquires a reference
-        if py_3_14a7_or_newer:
-            assert rc == 2 or rc == 3
-        else:
-            assert rc == 3
-
-    # Dropping the Python object does not actually destroy it, because
-    # the shared_ptr holds a reference. There is still a PyObject* at
-    # the same address.
-    prev_id = id(e)
-    del e
-    collect()
-    assert t.stats() == (1, 0)
-    assert id(w.get_ref()) == prev_id
-    assert t.owns_cpp(w.get_ref())
-    assert type(w.get_ref()) is ty
-
-    # Dropping the wrappers' shared_ptrs drops the PyObject reference and
-    # the object is finally GC'ed
-    del w, w2
-    collect()
-    assert t.stats() == (1, 1)
-
-
-def test10_shared_from_this_create_in_python(clean):
-    check_shared_from_this_py_owned(t.ExampleST, t.ExampleST, 42)
-
-    # Subclass in C++
-    t.reset()
-    check_shared_from_this_py_owned(t.DerivedST, t.DerivedST, 30)
-
-    # Subclass in Python
-    class SubST(t.ExampleST):
-        pass
-
-    t.reset()
-    check_shared_from_this_py_owned(SubST, SubST, 20)
-
-
-def test11_shared_from_this_create_raw_in_cpp(clean):
-    # Creating a raw pointer from C++ does not enable shared_from_this;
-    # although the object is held by pointer rather than value, the logical
-    # ownership transfers to Python and the behavior is equivalent to test10.
-    # Once we get a shared_ptr it owns a reference to the Python object.
-    check_shared_from_this_py_owned(t.ExampleST, t.ExampleST.make, 10)
-
-    # Subclass in C++
-    t.reset()
-    check_shared_from_this_py_owned(t.DerivedST, t.DerivedST.make, 5)
-
-
-def test12_shared_from_this_create_shared_in_cpp(clean):
-    # Creating a shared_ptr from C++ enables shared_from_this. Now the
-    # shared_ptr does not keep the Python object alive; it's directly
-    # owning the ExampleST object on the C++ side.
-    e = t.ExampleST.make_shared(10)
-    assert e.value == 10
-    assert e.has_shared_from_this()
-    assert e.shared_from_this() is e  # same instance
-    assert e.use_count() == 1
-    assert not t.owns_cpp(e)
-    if hasattr(sys, "getrefcount"):
-        # One reference is held by our locals dict and one by the
-        # arg to getrefcount
-        rc = sys.getrefcount(e)
-
-        # On Python 3.14a7, an optimization was introduced where
-        # stack-based function calling no longer acquires a reference
-        if py_3_14a7_or_newer:
-            assert rc == 1 or rc == 2
-        else:
-            assert rc == 2
-
-    w = t.SharedWrapperST.from_existing(e)
-    assert w.ptr is e
-    # One shared_ptr whose lifetime is tied to e. And one inside the wrapper
-    assert e.use_count() == 2
-
-    # Drop the Python object; C++ object still remains owned by the wrapper
-    del e
-    collect()
-    assert t.stats() == (1, 0)
-    assert w.use_count() == 1
-
-    # Get a new Python object reference; it will share ownership of the
-    # same underlying C++ object
-    e2 = w.get_own()
-    assert not t.owns_cpp(e2)
-    assert w.ptr is e2
-    assert w.use_count() == 2
-
-    del e2
-    collect()
-    assert t.stats() == (1, 0)
-    assert w.use_count() == 1
-
-    # Get a new C++-side reference
-    w2 = t.SharedWrapperST.from_wrapper(w)
-    assert w2.use_count() == 2
-    assert t.same_owner(w, w2)
-
-    # Get another one by roundtripping through Python.
-    # The nanobind conversion to shared_ptr<ExampleST> should use the
-    # existing shared_from_this shared_ptr
-    w3 = t.SharedWrapperST(w.ptr)
-    collect()  # on pypy the w.ptr temporary can stay alive
-    assert w3.use_count() == 3
-    assert t.same_owner(w2, w3)
-
-    # Destroy everything
-    assert t.stats() == (1, 0)
-    del w, w2, w3
-    collect()
-    assert t.stats() == (1, 1)
-
-
-def test13_shared_from_this_create_derived_in_cpp(clean):
-    # This tests that keep_shared_from_this_alive is inherited by
-    # derived classes properly
-
-    # Pass shared_ptr<T> to Python
-    e = t.DerivedST.make_shared(20)
-    assert type(e) is t.DerivedST
-    assert e.value == 20
-    assert e.has_shared_from_this()
-    assert not t.owns_cpp(e)
-    assert e.use_count() == 1
-
-    # Pass it back to C++
-    w = t.SharedWrapperST(e)
-    assert e.use_count() == w.use_count() == 2
-
-    del e
-    collect()
-    assert t.stats() == (1, 0)
-    assert w.use_count() == 1
-
-    # Pass it back to Python as a raw pointer
-    e = w.get_own()
-    # ExampleST is not polymorphic, so the derived-class identity is
-    # lost once the Python instance is destroyed
-    assert type(e) is t.ExampleST
-    assert not t.owns_cpp(e)
-    assert w.use_count() == 2
-    assert w.get_own() is e
-
-    del e, w
-    collect()
-    assert t.stats() == (1, 1)
-
-
-def test14_nullable_properties():
-    a = t.ExampleWrapper()
-    assert a.value is not None
-    assert a.value.value == 5
-    assert a.value_nullable is None
-    a.value = t.Example(123)
-    a.value_nullable = t.Example(456)
-    assert a.value.value == 123
-    assert a.value_nullable.value == 456
-    a.value_nullable = None
-    assert a.value_nullable is None
-    with pytest.raises(TypeError):
-        a.value = None
diff --git a/src/nanobind/tests/test_inter_module.py b/src/nanobind/tests/test_inter_module.py
deleted file mode 100644
index 97f6187..0000000
--- a/src/nanobind/tests/test_inter_module.py
+++ /dev/null
@@ -1,13 +0,0 @@
-import test_inter_module_1_ext as t1
-import test_inter_module_2_ext as t2
-import test_classes_ext as t3
-import pytest
-from common import xfail_on_pypy_darwin
-
-@xfail_on_pypy_darwin
-def test01_inter_module():
-    s = t1.create_shared()
-    assert t2.check_shared(s)
-    with pytest.raises(TypeError) as excinfo:
-        assert t3.check_shared(s)
-    assert 'incompatible function arguments' in str(excinfo.value)
diff --git a/src/nanobind/tests/test_inter_module_1.cpp b/src/nanobind/tests/test_inter_module_1.cpp
deleted file mode 100644
index edf4dad..0000000
--- a/src/nanobind/tests/test_inter_module_1.cpp
+++ /dev/null
@@ -1,8 +0,0 @@
-#include <nanobind/nanobind.h>
-#include "inter_module.h"
-
-namespace nb = nanobind;
-
-NB_MODULE(test_inter_module_1_ext, m) {
-    m.def("create_shared", &create_shared);
-}
diff --git a/src/nanobind/tests/test_inter_module_2.cpp b/src/nanobind/tests/test_inter_module_2.cpp
deleted file mode 100644
index 3e0a778..0000000
--- a/src/nanobind/tests/test_inter_module_2.cpp
+++ /dev/null
@@ -1,9 +0,0 @@
-#include <nanobind/nanobind.h>
-#include "inter_module.h"
-
-namespace nb = nanobind;
-
-NB_MODULE(test_inter_module_2_ext, m) {
-    nb::class_<Shared>(m, "Shared");
-    m.def("check_shared", &check_shared);
-}
diff --git a/src/nanobind/tests/test_intrusive.cpp b/src/nanobind/tests/test_intrusive.cpp
deleted file mode 100644
index 654b655..0000000
--- a/src/nanobind/tests/test_intrusive.cpp
+++ /dev/null
@@ -1,66 +0,0 @@
-#include <nanobind/nanobind.h>
-#include <nanobind/stl/pair.h>
-#include <nanobind/trampoline.h>
-#include <nanobind/intrusive/counter.h>
-#include <nanobind/intrusive/ref.h>
-
-namespace nb = nanobind;
-using namespace nb::literals;
-
-static int test_constructed = 0;
-static int test_destructed = 0;
-
-class Test : public nb::intrusive_base {
-public:
-    Test() { test_constructed++; }
-
-    virtual ~Test() { test_destructed++; }
-
-    virtual int value(int i) const { return 123 + i; }
-
-    static Test *create_raw() { return new Test(); }
-    static nb::ref<Test> create_ref() { return new Test(); }
-};
-
-class PyTest : Test {
-    NB_TRAMPOLINE(Test, 1);
-    virtual int value(int i) const {
-        NB_OVERRIDE(value, i);
-    }
-};
-
-NB_MODULE(test_intrusive_ext, m) {
-    nb::intrusive_init(
-        [](PyObject *o) noexcept {
-            nb::gil_scoped_acquire guard;
-            Py_INCREF(o);
-        },
-        [](PyObject *o) noexcept {
-            nb::gil_scoped_acquire guard;
-            Py_DECREF(o);
-        });
-
-    nb::class_<nb::intrusive_base>(
-        m, "intrusive_base",
-        nb::intrusive_ptr<nb::intrusive_base>(
-            [](nb::intrusive_base *o, PyObject *po) noexcept { o->set_self_py(po); }));
-
-    nb::class_<Test, nb::intrusive_base, PyTest>(m, "Test")
-        .def(nb::init<>())
-        .def("value", &Test::value)
-        .def_static("create_raw", &Test::create_raw)
-        .def_static("create_ref", &Test::create_ref);
-
-    m.def("reset", [] {
-        test_constructed = 0;
-        test_destructed = 0;
-    });
-
-    m.def("stats", []() -> std::pair<int, int> {
-        return { test_constructed, test_destructed };
-    });
-
-    m.def("get_value_1", [](Test *o) { nb::ref<Test> x(o); return x->value(1); });
-    m.def("get_value_2", [](nb::ref<Test> x) { return x->value(2); });
-    m.def("get_value_3", [](const nb::ref<Test> &x) { return x->value(3); });
-}
diff --git a/src/nanobind/tests/test_intrusive.py b/src/nanobind/tests/test_intrusive.py
deleted file mode 100644
index ef62e25..0000000
--- a/src/nanobind/tests/test_intrusive.py
+++ /dev/null
@@ -1,58 +0,0 @@
-import test_intrusive_ext as t
-import pytest
-from common import collect
-
-@pytest.fixture
-def clean():
-    collect()
-    t.reset()
-
-def test01_construct(clean):
-    o = t.Test()
-    assert o.value(0) == 123
-    assert t.get_value_1(o) == 124
-    assert t.get_value_2(o) == 125
-    assert t.get_value_3(o) == 126
-    del o
-    collect()
-    assert t.stats() == (1, 1)
-
-
-def test02_factory(clean):
-    o = t.Test.create_raw()
-    assert o.value(0) == 123
-    assert t.get_value_1(o) == 124
-    assert t.get_value_2(o) == 125
-    assert t.get_value_3(o) == 126
-    del o
-    collect()
-    assert t.stats() == (1, 1)
-
-
-def test03_factory_ref(clean):
-    o = t.Test.create_ref()
-    assert o.value(0) == 123
-    assert t.get_value_1(o) == 124
-    assert t.get_value_2(o) == 125
-    assert t.get_value_3(o) == 126
-    del o
-    collect()
-    assert t.stats() == (1, 1)
-
-def test04_subclass(clean):
-    class MyTest(t.Test):
-        def __init__(self, x):
-            super().__init__()
-            self.x = x
-
-        def value(self, value):
-            return self.x * value
-
-    o = MyTest(456)
-    assert o.value(0) == 0
-    assert t.get_value_1(o) == 456
-    assert t.get_value_2(o) == 456*2
-    assert t.get_value_3(o) == 456*3
-    del o
-    collect()
-    assert t.stats() == (1, 1)
diff --git a/src/nanobind/tests/test_intrusive_impl.cpp b/src/nanobind/tests/test_intrusive_impl.cpp
deleted file mode 100644
index e9eade0..0000000
--- a/src/nanobind/tests/test_intrusive_impl.cpp
+++ /dev/null
@@ -1 +0,0 @@
-#include <nanobind/intrusive/counter.inl>
diff --git a/src/nanobind/tests/test_issue.cpp b/src/nanobind/tests/test_issue.cpp
deleted file mode 100644
index e51cf0d..0000000
--- a/src/nanobind/tests/test_issue.cpp
+++ /dev/null
@@ -1,68 +0,0 @@
-#include <nanobind/stl/shared_ptr.h>
-#include <nanobind/stl/string.h>
-#include <nanobind/stl/vector.h>
-#include <unordered_map>
-
-namespace nb = nanobind;
-using namespace nb::literals;
-
-
-NB_MODULE(test_issue_ext, m) {
-    // ------------------------------------
-    // issue #279: dynamic_attr broken
-    // ------------------------------------
-
-    struct Component {
-        virtual ~Component() = default;
-    };
-
-    struct Param : Component { };
-
-    struct Model : Component {
-        void add_param(const std::string &name, std::shared_ptr<Param> p) {
-            params_[name] = std::move(p);
-        }
-
-        std::shared_ptr<Param> get_param(const std::string &name) {
-            return params_.find(name) != params_.end() ? params_[name] : nullptr;
-        }
-
-        std::unordered_map<std::string, std::shared_ptr<Param>> params_;
-    };
-
-    struct ModelA : Model {
-        ModelA() {
-            add_param("a", std::make_shared<Param>());
-            add_param("b", std::make_shared<Param>());
-        }
-    };
-
-    nb::class_<Component>(m, "Component");
-    nb::class_<Param, Component>(m, "ParamBase");
-    nb::class_<Model, Component>(m, "Model", nb::dynamic_attr()).def(nb::init<>{})
-        .def("_get_param", &Model::get_param, "name"_a)
-        .def("_add_param", &Model::add_param, "name"_a, "p"_a);
-    nb::class_<ModelA, Model>(m, "ModelA").def(nb::init<>{});
-
-    /// Issue #307: move constructor unexpectedly called
-    struct Example { std::string text; };
-
-    nb::class_<Example>(m, "Example")
-        .def(nb::init<const std::string&>())
-        .def("__repr__",
-             [](const Example& e) {
-                 return std::string("Example(\"") + e.text + "\")";
-             });
-
-    m.def("process",
-          [](const std::vector<Example>& v) {
-              return v.size();
-          }, nb::arg("v"));
-
-
-    // pull/602: stack corruption when binding a copy constructor with a named argument.
-    struct Empty {};
-    nb::class_<Empty>(m, "Empty")
-      .def(nb::init<const Empty&>(), nb::arg("original"));
-
-}
diff --git a/src/nanobind/tests/test_issue.py b/src/nanobind/tests/test_issue.py
deleted file mode 100644
index d2d81b4..0000000
--- a/src/nanobind/tests/test_issue.py
+++ /dev/null
@@ -1,37 +0,0 @@
-import test_issue_ext as m
-import pytest
-
-# Issue #279: dynamic_attr broken
-@pytest.mark.parametrize("variant", [1, 2])
-def test01_issue_279(variant):
-    def _get_parameter(self: m.Model, key: str):
-        p = self._get_param(key)
-        if p is not None:  # cache it for fast access later
-            setattr(self, key, p)
-            return p
-        raise AttributeError(f"'key' not found in {self}")
-
-    m.Model.__getattr__ = _get_parameter
-
-    if variant == 2:
-        def _print_model(self):
-            return f"{self.__class__.__qualname__}()"
-
-        m.Model.__str__ = _print_model
-
-    class Top(m.Model):
-        def __init__(self):
-            super().__init__()
-            self.model_a = m.ModelA()
-
-    top = Top()
-    str(top.model_a)
-    str(top.model_a.a)
-
-
-# Issue #307: move constructor unexpectedly called
-def test02_issue_307():
-    l = [m.Example("A"), m.Example("B")]
-    assert str(l) == '[Example("A"), Example("B")]'
-    m.process(l)
-    assert str(l) == '[Example("A"), Example("B")]'
diff --git a/src/nanobind/tests/test_jax.cpp b/src/nanobind/tests/test_jax.cpp
deleted file mode 100644
index 0729d1d..0000000
--- a/src/nanobind/tests/test_jax.cpp
+++ /dev/null
@@ -1,22 +0,0 @@
-#include <nanobind/nanobind.h>
-#include <nanobind/ndarray.h>
-
-namespace nb = nanobind;
-
-int destruct_count = 0;
-
-NB_MODULE(test_jax_ext, m) {
-    m.def("destruct_count", []() { return destruct_count; });
-    m.def("ret_jax", []() {
-        float *f = new float[8] { 1, 2, 3, 4, 5, 6, 7, 8 };
-        size_t shape[2] = { 2, 4 };
-
-        nb::capsule deleter(f, [](void *data) noexcept {
-           destruct_count++;
-           delete[] (float *) data;
-        });
-
-        return nb::ndarray<nb::jax, float, nb::shape<2, 4>>(f, 2, shape,
-                                                            deleter);
-    });
-}
diff --git a/src/nanobind/tests/test_jax.py b/src/nanobind/tests/test_jax.py
deleted file mode 100644
index e69de29..0000000
diff --git a/src/nanobind/tests/test_jax_ext.pyi.ref b/src/nanobind/tests/test_jax_ext.pyi.ref
deleted file mode 100644
index de4c5d1..0000000
--- a/src/nanobind/tests/test_jax_ext.pyi.ref
+++ /dev/null
@@ -1,4 +0,0 @@
-import jaxlib.xla_extension
-
-
-def ret_jax() -> jaxlib.xla_extension.DeviceArray[dtype=float32, shape=(2, 4)]: ...
diff --git a/src/nanobind/tests/test_make_iterator.cpp b/src/nanobind/tests/test_make_iterator.cpp
deleted file mode 100644
index 79d07df..0000000
--- a/src/nanobind/tests/test_make_iterator.cpp
+++ /dev/null
@@ -1,102 +0,0 @@
-#include <nanobind/make_iterator.h>
-#include <nanobind/stl/unordered_map.h>
-#include <nanobind/stl/string.h>
-
-namespace nb = nanobind;
-
-NB_MODULE(test_make_iterator_ext, m) {
-    struct StringMap {
-        std::unordered_map<std::string, std::string> map;
-        decltype(map.cbegin()) begin() const { return map.cbegin(); }
-        decltype(map.cend()) end() const { return map.cend(); }
-    };
-
-    nb::class_<StringMap>(m, "StringMap")
-        .def(nb::init<>())
-        .def(nb::init<std::unordered_map<std::string, std::string>>())
-        .def("__iter__",
-             [](const StringMap &map) {
-                 return nb::make_key_iterator(nb::type<StringMap>(),
-                                              "key_iterator",
-                                              map.begin(),
-                                              map.end());
-             }, nb::keep_alive<0, 1>())
-        .def("items",
-             [](const StringMap &map) {
-                 return nb::make_iterator(nb::type<StringMap>(),
-                                          "item_iterator",
-                                          map.begin(),
-                                          map.end());
-             }, nb::keep_alive<0, 1>())
-        .def("items_l",
-             [](const StringMap &map) {
-                 // Make sure iterators don't dangle even if passed as lvalue
-                 auto begin = map.begin(), end = map.end();
-                 return nb::make_iterator(nb::type<StringMap>(),
-                                          "item_iterator_l",
-                                          begin, end);
-             }, nb::keep_alive<0, 1>())
-        .def("values", [](const StringMap &map) {
-            return nb::make_value_iterator(nb::type<StringMap>(),
-                                           "value_iterator",
-                                           map.begin(),
-                                           map.end());
-        }, nb::keep_alive<0, 1>());
-
-    nb::handle mod = m;
-    m.def("iterator_passthrough", [mod](nb::iterator s) -> nb::iterator {
-        return nb::make_iterator(mod, "pt_iterator", std::begin(s), std::end(s));
-    });
-
-    // test of map where dereferencing the iterator returns a value,
-    // not a reference
-    struct IdentityMap {
-        struct iterator {
-            int val;
-            std::pair<int, int> operator*() const { return {val, val}; }
-            iterator& operator++() { ++val; return *this; }
-            bool operator==(const iterator& other) const {
-                return val == other.val;
-            }
-        };
-
-        iterator begin() const { return iterator{0}; }
-        iterator end() const { return iterator{10}; }
-    };
-
-    nb::class_<IdentityMap>(m, "IdentityMap")
-        .def(nb::init<>())
-        .def("__iter__",
-             [](const IdentityMap &map) {
-                 return nb::make_key_iterator(nb::type<IdentityMap>(),
-                                              "key_iterator",
-                                              map.begin(),
-                                              map.end());
-             }, nb::keep_alive<0, 1>())
-        .def("items",
-             [](const IdentityMap &map) {
-                 return nb::make_iterator(nb::type<IdentityMap>(),
-                                          "item_iterator",
-                                          map.begin(),
-                                          map.end());
-             }, nb::keep_alive<0, 1>())
-        .def("items_l",
-             [](const IdentityMap &map) {
-                 auto begin = map.begin(), end = map.end();
-                 return nb::make_iterator(nb::type<IdentityMap>(),
-                                          "item_iterator_l",
-                                          begin, end);
-             }, nb::keep_alive<0, 1>())
-        .def("values", [](const IdentityMap &map) {
-            return nb::make_value_iterator(nb::type<IdentityMap>(),
-                                           "value_iterator",
-                                           map.begin(),
-                                           map.end());
-        }, nb::keep_alive<0, 1>());
-
-    nb::list all;
-    all.append("iterator_passthrough");
-    all.append("StringMap");
-    all.append("IdentityMap");
-    m.attr("__all__") = all;
-}
diff --git a/src/nanobind/tests/test_make_iterator.py b/src/nanobind/tests/test_make_iterator.py
deleted file mode 100644
index 2e73669..0000000
--- a/src/nanobind/tests/test_make_iterator.py
+++ /dev/null
@@ -1,48 +0,0 @@
-import test_make_iterator_ext as t
-from common import parallelize
-
-data = [
-    {},
-    { 'a' : 'b' },
-    { str(i) : chr(i) for i in range(1000) }
-]
-
-
-def test01_key_iterator():
-    for d in data:
-        m = t.StringMap(d)
-        assert sorted(list(m)) == sorted(list(d))
-
-
-def test02_value_iterator():
-    types = []
-    for d in data:
-        m = t.StringMap(d)
-        types.append(type(m.values()))
-        assert sorted(list(m.values())) == sorted(list(d.values()))
-    assert types[0] is types[1] and types[1] is types[2]
-
-
-def test03_items_iterator():
-    for d in data:
-        m = t.StringMap(d)
-        assert sorted(list(m.items())) == sorted(list(d.items()))
-        assert sorted(list(m.items_l())) == sorted(list(d.items()))
-
-
-def test03_items_iterator_parallel(n_threads=8):
-    parallelize(test03_items_iterator, n_threads=n_threads)
-
-
-def test04_passthrough_iterator():
-    for d in data:
-        m = t.StringMap(d)
-        assert list(t.iterator_passthrough(m.values())) == list(m.values())
-
-
-def test05_iterator_returning_temporary():
-    im = t.IdentityMap()
-    assert list(im) == list(range(10))
-    assert list(im.values()) == list(range(10))
-    assert list(im.items()) == list(zip(range(10), range(10)))
-    assert list(im.items_l()) == list(zip(range(10), range(10)))
diff --git a/src/nanobind/tests/test_make_iterator_ext.pyi.ref b/src/nanobind/tests/test_make_iterator_ext.pyi.ref
deleted file mode 100644
index 2f0b752..0000000
--- a/src/nanobind/tests/test_make_iterator_ext.pyi.ref
+++ /dev/null
@@ -1,33 +0,0 @@
-from collections.abc import Iterator, Mapping
-from typing import overload
-
-
-class StringMap:
-    @overload
-    def __init__(self) -> None: ...
-
-    @overload
-    def __init__(self, arg: Mapping[str, str], /) -> None: ...
-
-    def __iter__(self) -> Iterator[str]: ...
-
-    def items(self) -> Iterator[tuple[str, str]]: ...
-
-    def items_l(self) -> Iterator[tuple[str, str]]: ...
-
-    def values(self) -> Iterator[str]: ...
-
-def iterator_passthrough(arg: Iterator, /) -> Iterator: ...
-
-class IdentityMap:
-    def __init__(self) -> None: ...
-
-    def __iter__(self) -> Iterator[int]: ...
-
-    def items(self) -> Iterator[tuple[int, int]]: ...
-
-    def items_l(self) -> Iterator[tuple[int, int]]: ...
-
-    def values(self) -> Iterator[int]: ...
-
-__all__: list = ['iterator_passthrough', 'StringMap', 'IdentityMap']
diff --git a/src/nanobind/tests/test_ndarray.cpp b/src/nanobind/tests/test_ndarray.cpp
deleted file mode 100644
index eda0374..0000000
--- a/src/nanobind/tests/test_ndarray.cpp
+++ /dev/null
@@ -1,497 +0,0 @@
-#include <nanobind/nanobind.h>
-#include <nanobind/ndarray.h>
-#include <algorithm>
-#include <complex>
-#include <vector>
-
-namespace nb = nanobind;
-
-using namespace nb::literals;
-
-int destruct_count = 0;
-static float f_global[] { 1, 2, 3, 4, 5, 6, 7, 8 };
-static int i_global[] { 1, 2, 3, 4, 5, 6, 7, 8 };
-
-#if defined(__aarch64__)
-namespace nanobind::detail {
-    template <> struct dtype_traits<__fp16> {
-        static constexpr dlpack::dtype value {
-            (uint8_t) dlpack::dtype_code::Float, // type code
-            16, // size in bits
-            1   // lanes (simd)
-        };
-        static constexpr auto name = const_name("float16");
-    };
-}
-#endif
-
-template<bool expect_ro, bool is_shaped, typename... Ts>
-bool check_ro(const nb::ndarray<Ts...>& a) {  // Pytest passes five doubles
-    static_assert(std::remove_reference_t<decltype(a)>::ReadOnly == expect_ro);
-    static_assert(std::is_const_v<std::remove_pointer_t<decltype(a.data())>>
-                  == expect_ro);
-    auto vd = a.template view<double, nb::ndim<1>>();
-    static_assert(std::is_const_v<std::remove_pointer_t<decltype(vd.data())>>
-                  == expect_ro);
-    static_assert(std::is_const_v<std::remove_reference_t<decltype(vd(0))>>
-                  == expect_ro);
-    auto vcd = a.template view<const double, nb::ndim<1>>();
-    static_assert(std::is_const_v<std::remove_pointer_t<decltype(vcd.data())>>);
-    static_assert(std::is_const_v<std::remove_reference_t<decltype(vcd(0))>>);
-
-    bool pass = vd.data() == a.data() && vcd.data() == a.data();
-    if constexpr (!expect_ro) {
-        vd(1) = 1.414214;
-        pass &= vcd(1) == 1.414214;
-    }
-    if constexpr (is_shaped) {
-        static_assert(std::is_const_v<std::remove_reference_t<decltype(a(0))>>
-                      == expect_ro);
-        auto v = a.view();
-        static_assert(std::is_const_v<std::remove_pointer_t<decltype(v.data())>>
-                      == expect_ro);
-        static_assert(std::is_const_v<std::remove_reference_t<decltype(v(0))>>
-                      == expect_ro);
-        pass &= v.data() == a.data();
-        if constexpr (!expect_ro) {
-              a(2) = 2.718282;
-              v(4) = 16.0;
-        }
-    }
-    pass &= vcd(3) == 3.14159;
-    return pass;
-}
-
-NB_MODULE(test_ndarray_ext, m) {
-    m.def("get_is_valid", [](const nb::ndarray<nb::ro> &t) {
-        return t.is_valid();
-    }, "array"_a.noconvert().none());
-
-    m.def("get_shape", [](const nb::ndarray<nb::ro> &t) {
-        nb::list l;
-        for (size_t i = 0; i < t.ndim(); ++i)
-            l.append(t.shape(i));
-        return l;
-    }, "array"_a.noconvert());
-
-    m.def("get_size", [](const nb::ndarray<> &t) {
-        return t.size();
-    }, "array"_a.noconvert().none());
-
-    m.def("get_itemsize", [](const nb::ndarray<> &t) {
-        return t.itemsize();
-    }, "array"_a.noconvert().none());
-
-    m.def("get_nbytes", [](const nb::ndarray<> &t) {
-        return t.nbytes();
-    }, "array"_a.noconvert().none());
-
-    m.def("get_stride", [](const nb::ndarray<> &t, size_t i) {
-        return t.stride(i);
-    }, "array"_a.noconvert(), "i"_a);
-
-    m.def("check_shape_ptr", [](const nb::ndarray<> &t) {
-        std::vector<int64_t> shape(t.ndim());
-        std::copy(t.shape_ptr(), t.shape_ptr() + t.ndim(), shape.begin());
-        for (size_t i = 0; i < t.ndim(); ++i)
-            if (shape[i] != (int64_t) t.shape(i))
-                return false;
-        return true;
-    });
-
-    m.def("check_stride_ptr", [](const nb::ndarray<> &t) {
-        std::vector<int64_t> stride(t.ndim());
-        std::copy(t.stride_ptr(), t.stride_ptr() + t.ndim(), stride.begin());
-        for (size_t i = 0; i < t.ndim(); ++i)
-            if (stride[i] != (int64_t) t.stride(i))
-                return false;
-        return true;
-    });
-
-    m.def("check_float", [](const nb::ndarray<> &t) {
-        return t.dtype() == nb::dtype<float>();
-    });
-    m.def("check_bool", [](const nb::ndarray<> &t) {
-        return t.dtype() == nb::dtype<bool>();
-    });
-
-    m.def("pass_float32", [](const nb::ndarray<float> &) { }, "array"_a.noconvert());
-    m.def("pass_float32_const", [](const nb::ndarray<const float> &) { }, "array"_a.noconvert());
-    m.def("pass_complex64", [](const nb::ndarray<std::complex<float>> &) { }, "array"_a.noconvert());
-    m.def("pass_complex64_const", [](nb::ndarray<const std::complex<float>>) { }, "array"_a.noconvert());
-    m.def("pass_uint32", [](const nb::ndarray<uint32_t> &) { }, "array"_a.noconvert());
-    m.def("pass_bool", [](const nb::ndarray<bool> &) { }, "array"_a.noconvert());
-    m.def("pass_float32_shaped",
-          [](const nb::ndarray<float, nb::shape<3, -1, 4>> &) {}, "array"_a.noconvert());
-
-    m.def("pass_float32_shaped_ordered",
-          [](const nb::ndarray<float, nb::c_contig,
-                               nb::shape<-1, -1, 4>> &) {}, "array"_a.noconvert());
-
-    m.def("check_rw_by_value",
-          [](nb::ndarray<> a) {
-              return check_ro</*expect_ro=*/false, /*is_shaped=*/false>(a);
-          });
-    m.def("check_ro_by_value_ro",
-          [](nb::ndarray<nb::ro> a) {
-              return check_ro</*expect_ro=*/true, /*is_shaped=*/false>(a);
-          });
-    m.def("check_rw_by_value_float64",
-          [](nb::ndarray<double, nb::ndim<1>> a) {
-              return check_ro</*expect_ro=*/false, /*is_shaped=*/true>(a);
-          });
-    m.def("check_ro_by_value_const_float64",
-          [](nb::ndarray<const double, nb::ndim<1>> a) {
-              return check_ro</*expect_ro=*/true, /*is_shaped=*/true>(a);
-          });
-
-    m.def("check_rw_by_const_ref",
-          [](const nb::ndarray<>& a) {
-              return check_ro</*expect_ro=*/false, /*is_shaped=*/false>(a);
-          });
-    m.def("check_ro_by_const_ref_ro",
-          [](const nb::ndarray<nb::ro>& a) {
-              return check_ro</*expect_ro=*/true, /*is_shaped=*/false>(a);
-          });
-    m.def("check_rw_by_const_ref_float64",
-          [](nb::ndarray<double, nb::ndim<1>> a) {
-              return check_ro</*expect_ro=*/false, /*is_shaped=*/true>(a);
-          });
-    m.def("check_ro_by_const_ref_const_float64",
-          [](const nb::ndarray<const double, nb::ndim<1>>& a) {
-              return check_ro</*expect_ro=*/true, /*is_shaped=*/true>(a);
-          });
-
-    m.def("check_rw_by_rvalue_ref",
-          [](nb::ndarray<>&& a) {
-              return check_ro</*expect_ro=*/false, /*is_shaped=*/false>(a);
-          });
-    m.def("check_ro_by_rvalue_ref_ro",
-          [](nb::ndarray<nb::ro>&& a) {
-              return check_ro</*expect_ro=*/true, /*is_shaped=*/false>(a);
-          });
-    m.def("check_rw_by_rvalue_ref_float64",
-          [](nb::ndarray<double, nb::ndim<1>>&& a) {
-              return check_ro</*expect_ro=*/false, /*is_shaped=*/true>(a);
-          });
-    m.def("check_ro_by_rvalue_ref_const_float64",
-          [](nb::ndarray<const double, nb::ndim<1>>&& a) {
-              return check_ro</*expect_ro=*/true, /*is_shaped=*/true>(a);
-          });
-
-    m.def("check_order", [](nb::ndarray<nb::c_contig>) -> char { return 'C'; });
-    m.def("check_order", [](nb::ndarray<nb::f_contig>) -> char { return 'F'; });
-    m.def("check_order", [](nb::ndarray<>) -> char { return '?'; });
-
-    m.def("make_contig", [](nb::ndarray<nb::c_contig> a) { return a; });
-
-    m.def("check_device", [](nb::ndarray<nb::device::cpu>) -> const char * { return "cpu"; });
-    m.def("check_device", [](nb::ndarray<nb::device::cuda>) -> const char * { return "cuda"; });
-
-    m.def("initialize",
-          [](nb::ndarray<float, nb::shape<10>, nb::device::cpu> &t) {
-              for (size_t i = 0; i < 10; ++i)
-                t(i) = (float) i;
-          });
-
-    m.def("initialize",
-          [](nb::ndarray<float, nb::shape<10, -1>, nb::device::cpu> &t) {
-              int k = 0;
-              for (size_t i = 0; i < 10; ++i)
-                  for (size_t j = 0; j < t.shape(1); ++j)
-                      t(i, j) = (float) k++;
-          });
-
-    m.def(
-        "noimplicit",
-        [](nb::ndarray<float, nb::c_contig, nb::shape<2, 2>>) { return 0; },
-        "array"_a.noconvert());
-
-    m.def(
-        "implicit",
-        [](nb::ndarray<float, nb::c_contig, nb::shape<2, 2>>) { return 0; },
-        "array"_a);
-
-    m.def("inspect_ndarray", [](const nb::ndarray<>& ndarray) {
-        printf("Tensor data pointer : %p\n", ndarray.data());
-        printf("Tensor dimension : %zu\n", ndarray.ndim());
-        for (size_t i = 0; i < ndarray.ndim(); ++i) {
-            printf("Tensor dimension [%zu] : %zu\n", i, ndarray.shape(i));
-            printf("Tensor stride    [%zu] : %zu\n", i, (size_t) ndarray.stride(i));
-        }
-        printf("Tensor is on CPU? %i\n", ndarray.device_type() == nb::device::cpu::value);
-        printf("Device ID = %u\n", ndarray.device_id());
-        printf("Tensor dtype check: int16=%i, uint32=%i, float32=%i complex64=%i\n",
-            ndarray.dtype() == nb::dtype<int16_t>(),
-            ndarray.dtype() == nb::dtype<uint32_t>(),
-            ndarray.dtype() == nb::dtype<float>(),
-            ndarray.dtype() == nb::dtype<std::complex<float>>()
-        );
-    });
-
-    m.def("process", [](nb::ndarray<uint8_t, nb::shape<-1, -1, 3>,
-                                   nb::c_contig, nb::device::cpu> ndarray) {
-        // Double brightness of the MxNx3 RGB image
-        for (size_t y = 0; y < ndarray.shape(0); ++y)
-            for (size_t x = 0; x < ndarray.shape(1); ++x)
-                for (size_t ch = 0; ch < 3; ++ch)
-                    ndarray(y, x, ch) = (uint8_t) std::min(255, ndarray(y, x, ch) * 2);
-
-    });
-
-    m.def("destruct_count", []() { return destruct_count; });
-    m.def("return_dlpack", []() {
-        float *f = new float[8] { 1, 2, 3, 4, 5, 6, 7, 8 };
-        size_t shape[2] = { 2, 4 };
-
-        nb::capsule deleter(f, [](void *data) noexcept {
-            destruct_count++;
-            delete[] (float *) data;
-        });
-
-        return nb::ndarray<float, nb::shape<2, 4>>(f, 2, shape, deleter);
-    });
-
-    m.def("passthrough", [](nb::ndarray<> a) { return a; }, nb::rv_policy::none);
-    m.def("passthrough_copy", [](nb::ndarray<> a) { return a; }, nb::rv_policy::copy);
-
-    m.def("passthrough_arg_none", [](nb::ndarray<> a) { return a; },
-          nb::arg().none(), nb::rv_policy::none);
-
-    m.def("ret_numpy", []() {
-        float *f = new float[8] { 1, 2, 3, 4, 5, 6, 7, 8 };
-        size_t shape[2] = { 2, 4 };
-
-        nb::capsule deleter(f, [](void *data) noexcept {
-            destruct_count++;
-            delete[] (float *) data;
-        });
-
-        return nb::ndarray<nb::numpy, float, nb::shape<2, 4>>(f, 2, shape,
-                                                              deleter);
-    });
-
-    m.def("ret_numpy_const_ref", []() {
-        size_t shape[2] = { 2, 4 };
-        return nb::ndarray<nb::numpy, const float, nb::shape<2, 4>, nb::c_contig>(f_global, 2, shape, nb::handle());
-    }, nb::rv_policy::reference);
-
-    m.def("ret_numpy_const_ref_f", []() {
-        size_t shape[2] = { 2, 4 };
-        return nb::ndarray<nb::numpy, const float, nb::shape<2, 4>, nb::f_contig>(f_global, 2, shape, nb::handle());
-    }, nb::rv_policy::reference);
-
-
-    m.def("ret_numpy_const", []() {
-        return nb::ndarray<nb::numpy, const float, nb::shape<2, 4>>(f_global, { 2, 4 }, nb::handle());
-    });
-
-    m.def("ret_pytorch", []() {
-        float *f = new float[8] { 1, 2, 3, 4, 5, 6, 7, 8 };
-        size_t shape[2] = { 2, 4 };
-
-        nb::capsule deleter(f, [](void *data) noexcept {
-           destruct_count++;
-           delete[] (float *) data;
-        });
-
-        return nb::ndarray<nb::pytorch, float, nb::shape<2, 4>>(f, 2, shape,
-                                                                deleter);
-    });
-
-    m.def("ret_array_scalar", []() {
-            float* f = new float[1] { 1 };
-            size_t shape[1] = {};
-
-            nb::capsule deleter(f, [](void* data) noexcept {
-                destruct_count++;
-                delete[] (float *) data;
-            });
-
-            return nb::ndarray<nb::numpy, float>(f, 0, shape, deleter);
-    });
-
-    m.def("noop_3d_c_contig",
-          [](nb::ndarray<float, nb::ndim<3>, nb::c_contig>) { return; });
-
-    m.def("noop_2d_f_contig",
-          [](nb::ndarray<float, nb::ndim<2>, nb::f_contig>) { return; });
-
-    m.def("accept_rw", [](nb::ndarray<float, nb::shape<2>> a) { return a(0); });
-    m.def("accept_ro", [](nb::ndarray<const float, nb::shape<2>> a) { return a(0); });
-
-    m.def("check", [](nb::handle h) { return nb::ndarray_check(h); });
-
-    m.def("accept_np_both_true_contig_a", 
-          [](nb::ndarray<float, nb::numpy, nb::shape<2, 1>, nb::any_contig> a) { return a(0, 0); });
-    m.def("accept_np_both_true_contig_c", 
-          [](nb::ndarray<float, nb::numpy, nb::shape<2, 1>, nb::c_contig> a) { return a(0, 0); });
-    m.def("accept_np_both_true_contig_f", 
-          [](nb::ndarray<float, nb::numpy, nb::shape<2, 1>, nb::f_contig> a) { return a(0, 0); });
-
-    struct Cls {
-        auto f1() { return nb::ndarray<nb::numpy, float>(data, { 10 }, nb::handle()); }
-        auto f2() { return nb::ndarray<nb::numpy, float>(data, { 10 }, nb::cast(this, nb::rv_policy::none)); }
-        auto f3(nb::handle owner) { return nb::ndarray<nb::numpy, float>(data, { 10 }, owner); }
-
-        ~Cls() {
-           destruct_count++;
-        }
-
-        float data [10] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };
-    };
-
-    nb::class_<Cls>(m, "Cls")
-        .def(nb::init<>())
-        .def("f1", &Cls::f1)
-        .def("f2", &Cls::f2)
-        .def("f1_ri", &Cls::f1, nb::rv_policy::reference_internal)
-        .def("f2_ri", &Cls::f2, nb::rv_policy::reference_internal)
-        .def("f3_ri", &Cls::f3, nb::rv_policy::reference_internal);
-
-    m.def("fill_view_1", [](nb::ndarray<> x) {
-        if (x.ndim() == 2 && x.dtype() == nb::dtype<float>()) {
-            auto v = x.view<float, nb::ndim<2>>();
-            for (size_t i = 0; i < v.shape(0); i++)
-                for (size_t j = 0; j < v.shape(1); j++)
-                    v(i, j) *= 2;
-        }
-    }, "x"_a.noconvert());
-
-    m.def("fill_view_2", [](nb::ndarray<float, nb::ndim<2>, nb::device::cpu> x) {
-        auto v = x.view();
-        for (size_t i = 0; i < v.shape(0); ++i)
-            for (size_t j = 0; j < v.shape(1); ++j)
-                v(i, j) = (float) (i * 10 + j);
-    }, "x"_a.noconvert());
-
-    m.def("fill_view_3", [](nb::ndarray<float, nb::shape<3, 4>, nb::c_contig, nb::device::cpu> x) {
-        auto v = x.view();
-        for (size_t i = 0; i < v.shape(0); ++i)
-            for (size_t j = 0; j < v.shape(1); ++j)
-                v(i, j) = (float) (i * 10 + j);
-    }, "x"_a.noconvert());
-
-    m.def("fill_view_4", [](nb::ndarray<float, nb::shape<3, 4>, nb::f_contig, nb::device::cpu> x) {
-        auto v = x.view();
-        for (size_t i = 0; i < v.shape(0); ++i)
-            for (size_t j = 0; j < v.shape(1); ++j)
-                v(i, j) = (float) (i * 10 + j);
-    }, "x"_a.noconvert());
-
-    m.def("fill_view_5", [](nb::ndarray<std::complex<float>, nb::shape<2, 2>, nb::c_contig, nb::device::cpu> x) {
-        auto v = x.view();
-        for (size_t i = 0; i < v.shape(0); ++i)
-            for (size_t j = 0; j < v.shape(1); ++j)
-                v(i, j) *= std::complex<float>(-1.0f, 2.0f);
-    }, "x"_a.noconvert());
-
-    m.def("fill_view_6", [](nb::ndarray<std::complex<float>, nb::shape<2, 2>, nb::c_contig, nb::device::cpu> x) {
-        auto v = x.view<nb::shape<4>>();
-        for (size_t i = 0; i < v.shape(0); ++i)
-            v(i) = -v(i);
-    }, "x"_a.noconvert());
-
-#if defined(__aarch64__)
-    m.def("ret_numpy_half", []() {
-        __fp16 *f = new __fp16[8] { 1, 2, 3, 4, 5, 6, 7, 8 };
-        size_t shape[2] = { 2, 4 };
-
-        nb::capsule deleter(f, [](void *data) noexcept {
-            destruct_count++;
-            delete[] (__fp16*) data;
-        });
-        return nb::ndarray<nb::numpy, __fp16, nb::shape<2, 4>>(f, 2, shape,
-                                                               deleter);
-    });
-#endif
-
-    m.def("cast", [](bool b) -> nb::ndarray<nb::numpy> {
-        using Ret = nb::ndarray<nb::numpy>;
-        if (b)
-            return Ret(nb::ndarray<nb::numpy, float, nb::shape<>>(f_global, 0, nullptr, nb::handle()));
-        else
-            return Ret(nb::ndarray<nb::numpy, int, nb::shape<>>(i_global, 0, nullptr, nb::handle()));
-    });
-
-    // issue #365
-    m.def("set_item",
-          [](nb::ndarray<double, nb::ndim<1>, nb::c_contig> data, uint32_t) {
-              data(0) = 123;
-          });
-
-    m.def("set_item",
-          [](nb::ndarray<std::complex<double>, nb::ndim<1>, nb::c_contig> data, uint32_t) {
-              data(0) = 123;
-          });
-
-    // issue #709
-    m.def("test_implicit_conversion",
-          [](nb::ndarray<nb::ro, nb::c_contig, nb::device::cpu> arg) {
-              return arg;
-          },
-          nb::arg());
-
-    m.def("ret_infer_c",
-          []() { return nb::ndarray<float, nb::shape<2, 4>, nb::numpy, nb::c_contig>(f_global); });
-    m.def("ret_infer_f",
-          []() { return nb::ndarray<float, nb::shape<2, 4>, nb::numpy, nb::f_contig>(f_global); });
-
-    using Array = nb::ndarray<float, nb::numpy, nb::shape<4, 4>, nb::f_contig>;
-
-    struct Matrix4f {
-        float m[4][4];
-        Array data() { return Array(m); }
-        auto data_ref() { return Array(m).cast(nb::rv_policy::reference_internal, nb::find(this)); }
-        auto data_copy() { return Array(m).cast(nb::rv_policy::copy); }
-    };
-
-    nb::class_<Matrix4f>(m, "Matrix4f")
-        .def(nb::init<>())
-        .def("data", &Matrix4f::data, nb::rv_policy::reference_internal)
-        .def("data_ref", &Matrix4f::data_ref)
-        .def("data_copy", &Matrix4f::data_copy);
-
-    using Vector3f = nb::ndarray<float, nb::numpy, nb::shape<3>>;
-
-    m.def("ret_from_stack_1", []() {
-        float f[] { 1, 2, 3 };
-        return nb::cast(Vector3f(f));
-    });
-
-    m.def("ret_from_stack_2", []() {
-        float f[] { 1, 2, 3 };
-        return Vector3f(f).cast();
-    });
-
-    // Fix issue reported in discussion #930
-    struct Wrapper {
-        nb::ndarray<float> value;
-
-        static int tp_traverse(PyObject* self, visitproc visit, void* arg) {
-            Wrapper* w = nb::inst_ptr<Wrapper>(self);
-            nb::handle value = nb::find(w->value);
-            Py_VISIT(value.ptr());
-#if PY_VERSION_HEX >= 0x03090000
-            Py_VISIT(Py_TYPE(self));
-#endif
-            return 0;
-        }
-
-        static int tp_clear(PyObject* self) {
-            Wrapper* w = nb::inst_ptr<Wrapper>(self);
-            w->value = {};
-            return 0;
-        }
-    };
-
-    PyType_Slot wrapper_slots[] = {
-        {Py_tp_traverse, (void*)Wrapper::tp_traverse},
-        {Py_tp_clear, (void*)Wrapper::tp_clear},
-        {0, 0},
-    };
-
-    nb::class_<Wrapper>(m, "Wrapper", nb::type_slots(wrapper_slots))
-        .def(nb::init<nb::ndarray<float>>())
-        .def_rw("value", &Wrapper::value);
-}
diff --git a/src/nanobind/tests/test_ndarray.py b/src/nanobind/tests/test_ndarray.py
deleted file mode 100644
index 75de2fe..0000000
--- a/src/nanobind/tests/test_ndarray.py
+++ /dev/null
@@ -1,977 +0,0 @@
-import test_ndarray_ext as t
-import test_jax_ext as tj
-import test_tensorflow_ext as tt
-import pytest
-import warnings
-import importlib
-from common import collect
-
-try:
-    import numpy as np
-    def needs_numpy(x):
-        return x
-except:
-    needs_numpy = pytest.mark.skip(reason="NumPy is required")
-
-try:
-    import torch
-    def needs_torch(x):
-        return x
-except:
-    needs_torch = pytest.mark.skip(reason="PyTorch is required")
-
-try:
-    import tensorflow as tf
-    import tensorflow.config
-    def needs_tensorflow(x):
-        return x
-except:
-    needs_tensorflow = pytest.mark.skip(reason="TensorFlow is required")
-
-try:
-    import jax.numpy as jnp
-    def needs_jax(x):
-        return x
-except:
-    needs_jax = pytest.mark.skip(reason="JAX is required")
-
-try:
-    import cupy as cp
-    def needs_cupy(x):
-        return x
-except:
-    needs_cupy = pytest.mark.skip(reason="CuPy is required")
-
-
-@needs_numpy
-def test01_metadata():
-    a = np.zeros(shape=())
-    assert t.get_shape(a) == []
-
-    if hasattr(a, '__dlpack__'):
-        b = a.__dlpack__()
-        assert t.get_shape(b) == []
-    else:
-        b = None
-
-    with pytest.raises(TypeError) as excinfo:
-        # Capsule can only be consumed once
-        assert t.get_shape(b) == []
-    assert 'incompatible function arguments' in str(excinfo.value)
-
-    a = np.zeros(shape=(3, 4, 5), dtype=np.float64)
-    assert t.get_is_valid(a)
-    assert t.get_shape(a) == [3, 4, 5]
-    assert t.get_size(a) == 60
-    assert t.get_nbytes(a) == 60*8
-    assert t.get_itemsize(a) == 8
-    assert t.check_shape_ptr(a)
-    assert t.check_stride_ptr(a)
-    if hasattr(a, '__dlpack__'):
-        assert t.get_shape(a.__dlpack__()) == [3, 4, 5]
-    assert not t.check_float(np.array([1], dtype=np.bool_)) and \
-           not t.check_float(np.array([1], dtype=np.uint32)) and \
-               t.check_float(np.array([1], dtype=np.float32))
-    assert not t.check_bool(np.array([1], dtype=np.uint32)) and \
-           not t.check_bool(np.array([1], dtype=np.float32)) and \
-               t.check_bool(np.array([1], dtype=np.bool_))
-
-    assert not t.get_is_valid(None)
-    assert t.get_size(None) == 0
-    assert t.get_nbytes(None) == 0
-    assert t.get_itemsize(None) == 0
-
-
-def test02_docstr():
-    assert t.pass_uint32.__doc__ == "pass_uint32(array: ndarray[dtype=uint32]) -> None"
-    assert t.get_shape.__doc__ == "get_shape(array: ndarray[writable=False]) -> list"
-    assert t.pass_float32.__doc__ == "pass_float32(array: ndarray[dtype=float32]) -> None"
-    assert t.pass_complex64.__doc__ == "pass_complex64(array: ndarray[dtype=complex64]) -> None"
-    assert t.pass_bool.__doc__ == "pass_bool(array: ndarray[dtype=bool]) -> None"
-    assert t.pass_float32_shaped.__doc__ == "pass_float32_shaped(array: ndarray[dtype=float32, shape=(3, *, 4)]) -> None"
-    assert t.pass_float32_shaped_ordered.__doc__ == "pass_float32_shaped_ordered(array: ndarray[dtype=float32, shape=(*, *, 4), order='C']) -> None"
-    assert t.check_device.__doc__ == ("check_device(arg: ndarray[device='cpu'], /) -> str\n"
-                                      "check_device(arg: ndarray[device='cuda'], /) -> str")
-
-
-@needs_numpy
-def test03_constrain_dtype():
-    a_u32 = np.array([1], dtype=np.uint32)
-    a_f32 = np.array([1], dtype=np.float32)
-    a_cf64 = np.array([1+1j], dtype=np.complex64)
-    a_bool = np.array([1], dtype=np.bool_)
-
-    t.pass_uint32(a_u32)
-    t.pass_float32(a_f32)
-    t.pass_complex64(a_cf64)
-    t.pass_complex64_const(a_cf64)
-    t.pass_bool(a_bool)
-
-    a_f32_const = a_f32.copy()
-    a_f32_const.flags.writeable = False
-    t.pass_float32_const(a_f32_const)
-
-    a_cf64_const = a_cf64.copy()
-    a_cf64_const.flags.writeable = False
-    t.pass_complex64_const(a_cf64_const)
-
-    with pytest.raises(TypeError) as excinfo:
-        t.pass_uint32(a_f32)
-    assert 'incompatible function arguments' in str(excinfo.value)
-
-    with pytest.raises(TypeError) as excinfo:
-        t.pass_float32(a_u32)
-    assert 'incompatible function arguments' in str(excinfo.value)
-
-    with pytest.raises(TypeError) as excinfo:
-        t.pass_complex64(a_u32)
-    assert 'incompatible function arguments' in str(excinfo.value)
-
-    with pytest.raises(TypeError) as excinfo:
-        t.pass_bool(a_u32)
-    assert 'incompatible function arguments' in str(excinfo.value)
-
-
-@needs_numpy
-def test04_constrain_shape():
-    t.pass_float32_shaped(np.zeros((3, 0, 4), dtype=np.float32))
-    t.pass_float32_shaped(np.zeros((3, 5, 4), dtype=np.float32))
-
-    with pytest.raises(TypeError) as excinfo:
-        t.pass_float32_shaped(np.zeros((3, 5), dtype=np.float32))
-
-    with pytest.raises(TypeError) as excinfo:
-        t.pass_float32_shaped(np.zeros((2, 5, 4), dtype=np.float32))
-
-    with pytest.raises(TypeError) as excinfo:
-        t.pass_float32_shaped(np.zeros((3, 5, 6), dtype=np.float32))
-
-    with pytest.raises(TypeError) as excinfo:
-        t.pass_float32_shaped(np.zeros((3, 5, 4, 6), dtype=np.float32))
-
-
-@needs_numpy
-def test05_constrain_order():
-    assert t.check_order(np.zeros((3, 5, 4, 6), order='C')) == 'C'
-    assert t.check_order(np.zeros((3, 5, 4, 6), order='F')) == 'F'
-    assert t.check_order(np.zeros((3, 5, 4, 6), order='C')[:, 2, :, :]) == '?'
-    assert t.check_order(np.zeros((3, 5, 4, 6), order='F')[:, 2, :, :]) == '?'
-
-
-@needs_jax
-def test06_constrain_order_jax():
-    with warnings.catch_warnings():
-        warnings.simplefilter("ignore")
-        try:
-            c = jnp.zeros((3, 5))
-        except:
-            pytest.skip('jax is missing')
-
-    z = jnp.zeros((3, 5, 4, 6))
-    assert t.check_order(z) == 'C'
-
-
-@needs_torch
-@pytest.mark.filterwarnings
-def test07_constrain_order_pytorch():
-    try:
-        c = torch.zeros(3, 5)
-        c.__dlpack__()
-    except:
-        pytest.skip('pytorch is missing')
-
-    f = c.t().contiguous().t()
-    assert t.check_order(c) == 'C'
-    assert t.check_order(f) == 'F'
-    assert t.check_order(c[:, 2:5]) == '?'
-    assert t.check_order(f[1:3, :]) == '?'
-    assert t.check_device(torch.zeros(3, 5)) == 'cpu'
-    if torch.cuda.is_available():
-        assert t.check_device(torch.zeros(3, 5, device='cuda')) == 'cuda'
-
-
-@needs_tensorflow
-def test08_constrain_order_tensorflow():
-    with warnings.catch_warnings():
-        warnings.simplefilter("ignore")
-        try:
-            c = tf.zeros((3, 5))
-        except:
-            pytest.skip('tensorflow is missing')
-
-    assert t.check_order(c) == 'C'
-
-
-@needs_numpy
-def test09_write_from_cpp():
-    x = np.zeros(10, dtype=np.float32)
-    t.initialize(x)
-    assert np.all(x == np.arange(10, dtype=np.float32))
-
-    x = np.zeros((10, 3), dtype=np.float32)
-    t.initialize(x)
-    assert np.all(x == np.arange(30, dtype=np.float32).reshape(10, 3))
-
-
-@needs_numpy
-def test10_implicit_conversion():
-    t.implicit(np.zeros((2, 2), dtype=np.uint32))
-    t.implicit(np.zeros((2, 2, 10), dtype=np.float32)[:, :, 4])
-    t.implicit(np.zeros((2, 2, 10), dtype=np.uint32)[:, :, 4])
-    t.implicit(np.zeros((2, 2, 10), dtype=np.bool_)[:, :, 4])
-
-    with pytest.raises(TypeError) as excinfo:
-        t.noimplicit(np.zeros((2, 2), dtype=np.bool_))
-
-    with pytest.raises(TypeError) as excinfo:
-        t.noimplicit(np.zeros((2, 2), dtype=np.uint32))
-
-    with pytest.raises(TypeError) as excinfo:
-        t.noimplicit(np.zeros((2, 2, 10), dtype=np.float32)[:, :, 4])
-
-
-@needs_torch
-def test11_implicit_conversion_pytorch():
-    with warnings.catch_warnings():
-        warnings.simplefilter("ignore")
-        try:
-            c = torch.zeros(3, 5)
-            c.__dlpack__()
-        except:
-            pytest.skip('pytorch is missing')
-
-    t.implicit(torch.zeros(2, 2, dtype=torch.int32))
-    t.implicit(torch.zeros(2, 2, 10, dtype=torch.float32)[:, :, 4])
-    t.implicit(torch.zeros(2, 2, 10, dtype=torch.int32)[:, :, 4])
-
-    with pytest.raises(TypeError) as excinfo:
-        t.noimplicit(torch.zeros(2, 2, dtype=torch.int32))
-
-    with pytest.raises(TypeError) as excinfo:
-        t.noimplicit(torch.zeros(2, 2, 10, dtype=torch.float32)[:, :, 4])
-
-
-@needs_tensorflow
-def test12_implicit_conversion_tensorflow():
-    with warnings.catch_warnings():
-        warnings.simplefilter("ignore")
-        try:
-            c = tf.zeros((3, 5))
-        except:
-            pytest.skip('tensorflow is missing')
-
-        t.implicit(tf.zeros((2, 2), dtype=tf.int32))
-        t.implicit(tf.zeros((2, 2, 10), dtype=tf.float32)[:, :, 4])
-        t.implicit(tf.zeros((2, 2, 10), dtype=tf.int32)[:, :, 4])
-        t.implicit(tf.zeros((2, 2, 10), dtype=tf.bool)[:, :, 4])
-
-        with pytest.raises(TypeError) as excinfo:
-            t.noimplicit(tf.zeros((2, 2), dtype=tf.int32))
-
-        with pytest.raises(TypeError) as excinfo:
-            t.noimplicit(tf.zeros((2, 2), dtype=tf.bool))
-
-
-@needs_jax
-def test13_implicit_conversion_jax():
-    with warnings.catch_warnings():
-        warnings.simplefilter("ignore")
-        try:
-            c = jnp.zeros((3, 5))
-        except:
-            pytest.skip('jax is missing')
-
-    t.implicit(jnp.zeros((2, 2), dtype=jnp.int32))
-    t.implicit(jnp.zeros((2, 2, 10), dtype=jnp.float32)[:, :, 4])
-    t.implicit(jnp.zeros((2, 2, 10), dtype=jnp.int32)[:, :, 4])
-    t.implicit(jnp.zeros((2, 2, 10), dtype=jnp.bool_)[:, :, 4])
-
-    with pytest.raises(TypeError) as excinfo:
-        t.noimplicit(jnp.zeros((2, 2), dtype=jnp.int32))
-
-    with pytest.raises(TypeError) as excinfo:
-        t.noimplicit(jnp.zeros((2, 2), dtype=jnp.uint8))
-
-
-def test14_destroy_capsule():
-    collect()
-    dc = t.destruct_count()
-    a = t.return_dlpack()
-    assert dc == t.destruct_count()
-    del a
-    collect()
-    assert t.destruct_count() - dc == 1
-
-
-@needs_numpy
-def test15_consume_numpy():
-    collect()
-    class wrapper:
-        def __init__(self, value):
-            self.value = value
-        def __dlpack__(self):
-            return self.value
-    dc = t.destruct_count()
-    a = t.return_dlpack()
-    if hasattr(np, '_from_dlpack'):
-        x = np._from_dlpack(wrapper(a))
-    elif hasattr(np, 'from_dlpack'):
-        x = np.from_dlpack(wrapper(a))
-    else:
-        pytest.skip('your version of numpy is too old')
-
-    del a
-    collect()
-    assert x.shape == (2, 4)
-    assert np.all(x == [[1, 2, 3, 4], [5, 6, 7, 8]])
-    assert dc == t.destruct_count()
-    del x
-    collect()
-    assert t.destruct_count() - dc == 1
-
-
-@needs_numpy
-def test16_passthrough():
-    a = t.ret_numpy()
-    b = t.passthrough(a)
-    assert a is b
-
-    a = np.array([1,2,3])
-    b = t.passthrough(a)
-    assert a is b
-
-    a = None
-    with pytest.raises(TypeError) as excinfo:
-        b = t.passthrough(a)
-    assert 'incompatible function arguments' in str(excinfo.value)
-    b = t.passthrough_arg_none(a)
-    assert a is b
-
-
-@needs_numpy
-def test17_return_numpy():
-    collect()
-    dc = t.destruct_count()
-    x = t.ret_numpy()
-    assert x.shape == (2, 4)
-    assert np.all(x == [[1, 2, 3, 4], [5, 6, 7, 8]])
-    del x
-    collect()
-    assert t.destruct_count() - dc == 1
-
-
-@needs_torch
-def test18_return_pytorch():
-    try:
-        c = torch.zeros(3, 5)
-    except:
-        pytest.skip('pytorch is missing')
-    collect()
-    dc = t.destruct_count()
-    x = t.ret_pytorch()
-    assert x.shape == (2, 4)
-    assert torch.all(x == torch.tensor([[1, 2, 3, 4], [5, 6, 7, 8]]))
-    del x
-    collect()
-    assert t.destruct_count() - dc == 1
-
-
-@needs_jax
-def test19_return_jax():
-    collect()
-    dc = tj.destruct_count()
-    x = tj.ret_jax()
-    assert x.shape == (2, 4)
-    assert jnp.all(x == jnp.array([[1,2,3,4], [5,6,7,8]], dtype=jnp.float32))
-    del x
-    collect()
-    assert tj.destruct_count() - dc == 1
-
-
-@needs_tensorflow
-def test20_return_tensorflow():
-    collect()
-    dc = tt.destruct_count()
-    x = tt.ret_tensorflow()
-    assert x.get_shape().as_list() == [2, 4]
-    assert tf.math.reduce_all(
-               x == tf.constant([[1,2,3,4], [5,6,7,8]], dtype=tf.float32))
-    del x
-    collect()
-    assert tt.destruct_count() - dc == 1
-
-
-@needs_numpy
-def test21_return_array_scalar():
-    collect()
-    dc = t.destruct_count()
-    x = t.ret_array_scalar()
-    assert np.array_equal(x, np.array(1))
-    del x
-    collect()
-    assert t.destruct_count() - dc == 1
-
-
-# See PR #162
-@needs_torch
-def test22_single_and_empty_dimension_pytorch():
-    a = torch.ones((1,100,1025), dtype=torch.float32)
-    t.noop_3d_c_contig(a)
-    a = torch.ones((100,1,1025), dtype=torch.float32)
-    t.noop_3d_c_contig(a)
-    a = torch.ones((0,100,1025), dtype=torch.float32)
-    t.noop_3d_c_contig(a)
-    a = torch.ones((100,0,1025), dtype=torch.float32)
-    t.noop_3d_c_contig(a)
-    a = torch.ones((100,1025,0), dtype=torch.float32)
-    t.noop_3d_c_contig(a)
-    a = torch.ones((100,0,0), dtype=torch.float32)
-    t.noop_3d_c_contig(a)
-    a = torch.ones((0,0,0), dtype=torch.float32)
-    t.noop_3d_c_contig(a)
-
-
-# See PR #162
-@needs_numpy
-def test23_single_and_empty_dimension_numpy():
-    a = np.ones((1,100,1025), dtype=np.float32)
-    t.noop_3d_c_contig(a)
-    a = np.ones((100,1,1025), dtype=np.float32)
-    t.noop_3d_c_contig(a)
-    a = np.ones((0,100,1025), dtype=np.float32)
-    t.noop_3d_c_contig(a)
-    a = np.ones((100,0,1025), dtype=np.float32)
-    t.noop_3d_c_contig(a)
-    a = np.ones((100,1025,0), dtype=np.float32)
-    t.noop_3d_c_contig(a)
-    a = np.ones((100,0,0), dtype=np.float32)
-    t.noop_3d_c_contig(a)
-    a = np.ones((0,0,0), dtype=np.float32)
-    t.noop_3d_c_contig(a)
-
-
-# See PR #162
-@needs_torch
-def test24_single_and_empty_dimension_fortran_order_pytorch():
-    # This idiom creates a pytorch 2D tensor in column major (aka, 'F') ordering
-    a = torch.ones((0,100), dtype=torch.float32).t().contiguous().t()
-    t.noop_2d_f_contig(a)
-    a = torch.ones((100,0), dtype=torch.float32).t().contiguous().t()
-    t.noop_2d_f_contig(a)
-    a = torch.ones((1,100), dtype=torch.float32).t().contiguous().t()
-    t.noop_2d_f_contig(a)
-    a = torch.ones((100,1), dtype=torch.float32).t().contiguous().t()
-    t.noop_2d_f_contig(a)
-
-
-@needs_numpy
-def test25_ro_array():
-    a = np.array([1, 2], dtype=np.float32)
-    assert t.accept_ro(a) == 1
-    assert t.accept_rw(a) == 1
-    a.setflags(write=False)
-    assert t.accept_ro(a) == 1
-    with pytest.raises(TypeError) as excinfo:
-        t.accept_rw(a)
-    assert 'incompatible function arguments' in str(excinfo.value)
-
-
-@needs_numpy
-def test26_return_ro():
-    x = t.ret_numpy_const_ref()
-    y = t.ret_numpy_const_ref_f()
-    assert t.ret_numpy_const_ref.__doc__  == 'ret_numpy_const_ref() -> numpy.ndarray[dtype=float32, shape=(2, 4), order=\'C\', writable=False]'
-    assert t.ret_numpy_const_ref_f.__doc__  == 'ret_numpy_const_ref_f() -> numpy.ndarray[dtype=float32, shape=(2, 4), order=\'F\', writable=False]'
-    assert x.shape == (2, 4)
-    assert y.shape == (2, 4)
-    assert np.all(x == [[1, 2, 3, 4], [5, 6, 7, 8]])
-    assert np.all(y == [[1, 3, 5, 7], [2, 4, 6, 8]])
-    with pytest.raises(ValueError) as excinfo:
-        x[0,0] =1
-    assert 'read-only' in str(excinfo.value)
-    with pytest.raises(ValueError) as excinfo:
-        y[0,0] =1
-    assert 'read-only' in str(excinfo.value)
-
-
-@needs_numpy
-def test27_check_numpy():
-    assert t.check(np.zeros(1))
-
-
-@needs_torch
-def test28_check_torch():
-    assert t.check(torch.zeros((1)))
-
-
-@needs_tensorflow
-def test29_check_tensorflow():
-    assert t.check(tf.zeros((1)))
-
-
-@needs_jax
-def test30_check_jax():
-    assert t.check(jnp.zeros((1)))
-
-
-@needs_numpy
-def test31_rv_policy():
-    def p(a):
-        return a.__array_interface__['data']
-
-    x1 = t.ret_numpy_const_ref()
-    x2 = t.ret_numpy_const_ref()
-    y1 = t.ret_numpy_const()
-    y2 = t.ret_numpy_const()
-
-    z1 = t.passthrough(y1)
-    z2 = t.passthrough(y2)
-    q1 = t.passthrough_copy(y1)
-    q2 = t.passthrough_copy(y2)
-
-    assert p(x1) == p(x2)
-    assert p(y1) != p(y2)
-
-    assert z1 is y1
-    assert z2 is y2
-    assert q1 is not y1
-    assert q2 is not y2
-    assert p(q1) != p(y1)
-    assert p(q2) != p(y2)
-
-
-@needs_numpy
-def test32_reference_internal():
-    collect()
-    dc = t.destruct_count()
-    c = t.Cls()
-
-    v1_a = c.f1()
-    v1_b = c.f1()
-    v2_a = c.f2()
-    v2_b = c.f2()
-    del c
-
-    assert np.all(v1_a == np.arange(10, dtype=np.float32))
-    assert np.all(v1_b == np.arange(10, dtype=np.float32))
-
-    v1_a += 1
-    v1_b += 2
-
-    assert np.all(v1_a == np.arange(10, dtype=np.float32) + 1)
-    assert np.all(v1_b == np.arange(10, dtype=np.float32) + 2)
-    del v1_a
-    del v1_b
-
-    assert np.all(v2_a == np.arange(10, dtype=np.float32))
-    assert np.all(v2_b == np.arange(10, dtype=np.float32))
-
-    v2_a += 1
-    v2_b += 2
-
-    assert np.all(v2_a == np.arange(10, dtype=np.float32) + 3)
-    assert np.all(v2_b == np.arange(10, dtype=np.float32) + 3)
-
-    del v2_a
-    collect()
-    assert t.destruct_count() == dc
-
-    del v2_b
-    collect()
-    dc += 1
-    assert t.destruct_count() == dc
-
-    for i in range(2):
-        c2 = t.Cls()
-
-        if i == 0:
-            v3_a = c2.f1_ri()
-            v3_b = c2.f1_ri()
-        else:
-            v3_a = c2.f2_ri()
-            v3_b = c2.f2_ri()
-        del c2
-
-        assert np.all(v3_a == np.arange(10, dtype=np.float32))
-        assert np.all(v3_b == np.arange(10, dtype=np.float32))
-
-        v3_a += 1
-        v3_b += 2
-
-        assert np.all(v3_a == np.arange(10, dtype=np.float32) + 3)
-        assert np.all(v3_b == np.arange(10, dtype=np.float32) + 3)
-        del v3_a
-
-        collect()
-        assert t.destruct_count() == dc
-
-        del v3_b
-        collect()
-        dc += 1
-        assert t.destruct_count() == dc
-
-    c3 = t.Cls()
-    c3_t = (c3,)
-    with pytest.raises(RuntimeError) as excinfo:
-        c3.f3_ri(c3_t)
-
-    msg = 'nanobind::detail::ndarray_export(): reference_internal policy cannot be applied (ndarray already has an owner)'
-    assert msg in str(excinfo.value)
-
-
-@needs_numpy
-def test33_force_contig_numpy():
-    a = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
-    b = t.make_contig(a)
-    assert b is a
-    a = a.T
-    b = t.make_contig(a)
-    assert b is not a
-    assert np.all(b == a)
-
-@needs_torch
-@pytest.mark.filterwarnings
-def test34_force_contig_pytorch():
-    a = torch.tensor([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
-    b = t.make_contig(a)
-    assert b is a
-    a = a.T
-    b = t.make_contig(a)
-    assert b is not a
-    assert torch.all(b == a)
-
-
-@needs_numpy
-def test35_view():
-    # 1
-    x1 = np.array([[1,2],[3,4]], dtype=np.float32)
-    x2 = np.array([[1,2],[3,4]], dtype=np.float64)
-    assert np.allclose(x1, x2)
-    t.fill_view_1(x1)
-    assert np.allclose(x1, x2*2)
-    t.fill_view_1(x2)
-    assert np.allclose(x1, x2*2)
-
-    # 2
-    x1 = np.zeros((3, 4), dtype=np.float32, order='C')
-    x2 = np.zeros((3, 4), dtype=np.float32, order='F')
-    t.fill_view_2(x1)
-    t.fill_view_2(x2)
-    x3 = np.zeros((3, 4), dtype=np.float32, order='C')
-    t.fill_view_3(x3)
-    x4 = np.zeros((3, 4), dtype=np.float32, order='F')
-    t.fill_view_4(x4)
-
-    assert np.all(x1 == x2) and np.all(x2 == x3) and np.all(x3 == x4)
-
-    # 3
-    x1 = np.array([[1+2j, 3+4j], [5+6j, 7+8j]], dtype=np.complex64)
-    x2 = x1 * 2
-    t.fill_view_1(x1.view(np.float32))
-    assert np.allclose(x1, x2)
-    x2 = x1 * (-1+2j)
-    t.fill_view_5(x1)
-    assert np.allclose(x1, x2)
-    x2 = -x2;
-    t.fill_view_6(x1)
-    assert np.allclose(x1, x2)
-
-
-@needs_numpy
-def test36_half():
-    if not hasattr(t, 'ret_numpy_half'):
-        pytest.skip('half precision test is missing')
-    x = t.ret_numpy_half()
-    assert x.dtype == np.float16
-    assert x.shape == (2, 4)
-    assert np.all(x == [[1, 2, 3, 4], [5, 6, 7, 8]])
-
-@needs_numpy
-def test37_cast():
-    a = t.cast(False)
-    b = t.cast(True)
-    assert a.ndim == 0 and b.ndim == 0
-    assert a.dtype == np.int32 and b.dtype == np.float32
-    assert a == 1 and b == 1
-
-
-@needs_numpy
-def test38_complex_decompose():
-    x1 = np.array([1 + 2j, 3 + 4j, 5 + 6j], dtype=np.complex64)
-
-    assert np.all(x1.real == np.array([1, 3, 5], dtype=np.float32))
-    assert np.all(x1.imag == np.array([2, 4, 6], dtype=np.float32))
-
-
-@needs_numpy
-@pytest.mark.parametrize("variant", [1, 2])
-def test_uint32_complex_do_not_convert(variant):
-    if variant == 1:
-        arg = 1
-    else:
-        arg = np.uint32(1)
-    data = np.array([1.0 + 2.0j, 3.0 + 4.0j])
-    t.set_item(data, arg)
-    data2 = np.array([123, 3.0 + 4.0j])
-    assert np.all(data == data2)
-
-
-@needs_numpy
-def test40_check_generic():
-    class DLPackWrapper:
-        def __init__(self, o):
-            self.o = o
-        def __dlpack__(self):
-            return self.o.__dlpack__()
-
-    arr = DLPackWrapper(np.zeros((1)))
-    assert t.check(arr)
-
-
-@needs_numpy
-def test41_noninteger_stride():
-    a = np.array([[1, 2, 3, 4, 0, 0], [5, 6, 7, 8, 0, 0]], dtype=np.float32)
-    s = a[:, 0:4]  # slice
-    t.pass_float32(s)
-    assert t.get_stride(s, 0) == 6;
-    assert t.get_stride(s, 1) == 1;
-    try:
-        v = s.view(np.complex64)
-    except:
-        pytest.skip('your version of numpy is too old')
-    t.pass_complex64(v)
-    assert t.get_stride(v, 0) == 3;
-    assert t.get_stride(v, 1) == 1;
-
-    a = np.array([[1, 2, 3, 4, 0], [5, 6, 7, 8, 0]], dtype=np.float32)
-    s = a[:, 0:4]  # slice
-    t.pass_float32(s)
-    assert t.get_stride(s, 0) == 5;
-    assert t.get_stride(s, 1) == 1;
-    v = s.view(np.complex64)
-    with pytest.raises(TypeError) as excinfo:
-        t.pass_complex64(v)
-    assert 'incompatible function arguments' in str(excinfo.value)
-    with pytest.raises(TypeError) as excinfo:
-        t.get_stride(v, 0);
-    assert 'incompatible function arguments' in str(excinfo.value)
-
-
-@needs_numpy
-def test42_const_qualifiers_numpy():
-    a = np.array([0, 0, 0, 3.14159, 0], dtype=np.float64)
-    assert t.check_rw_by_value(a);
-    assert a[1] == 1.414214;
-    assert t.check_rw_by_value_float64(a);
-    assert a[2] == 2.718282;
-    assert a[4] == 16.0;
-    assert t.check_ro_by_value_ro(a);
-    assert t.check_ro_by_value_const_float64(a);
-    a.setflags(write=False)
-    assert t.check_ro_by_value_ro(a);
-    assert t.check_ro_by_value_const_float64(a);
-    assert a[0] == 0.0;
-    assert a[3] == 3.14159;
-
-    a = np.array([0, 0, 0, 3.14159, 0], dtype=np.float64)
-    assert t.check_rw_by_const_ref(a);
-    assert a[1] == 1.414214;
-    assert t.check_rw_by_const_ref_float64(a);
-    assert a[2] == 2.718282;
-    assert a[4] == 16.0;
-    assert t.check_ro_by_const_ref_ro(a);
-    assert t.check_ro_by_const_ref_const_float64(a);
-    a.setflags(write=False)
-    assert t.check_ro_by_const_ref_ro(a);
-    assert t.check_ro_by_const_ref_const_float64(a);
-    assert a[0] == 0.0;
-    assert a[3] == 3.14159;
-
-    a = np.array([0, 0, 0, 3.14159, 0], dtype=np.float64)
-    assert t.check_rw_by_rvalue_ref(a);
-    assert a[1] == 1.414214;
-    assert t.check_rw_by_rvalue_ref_float64(a);
-    assert a[2] == 2.718282;
-    assert a[4] == 16.0;
-    assert t.check_ro_by_rvalue_ref_ro(a);
-    assert t.check_ro_by_rvalue_ref_const_float64(a);
-    a.setflags(write=False)
-    assert t.check_ro_by_rvalue_ref_ro(a);
-    assert t.check_ro_by_rvalue_ref_const_float64(a);
-    assert a[0] == 0.0;
-    assert a[3] == 3.14159;
-
-
-@needs_torch
-def test43_const_qualifiers_pytorch():
-    a = torch.tensor([0, 0, 0, 3.14159, 0], dtype=torch.float64)
-    assert t.check_rw_by_value(a);
-    assert a[1] == 1.414214;
-    assert t.check_rw_by_value_float64(a);
-    assert a[2] == 2.718282;
-    assert a[4] == 16.0;
-    assert t.check_ro_by_value_ro(a);
-    assert t.check_ro_by_value_const_float64(a);
-    assert a[0] == 0.0;
-    assert a[3] == 3.14159;
-
-    a = torch.tensor([0, 0, 0, 3.14159, 0], dtype=torch.float64)
-    assert t.check_rw_by_const_ref(a);
-    assert a[1] == 1.414214;
-    assert t.check_rw_by_const_ref_float64(a);
-    assert a[2] == 2.718282;
-    assert a[4] == 16.0;
-    assert t.check_ro_by_const_ref_ro(a);
-    assert t.check_ro_by_const_ref_const_float64(a);
-    assert a[0] == 0.0;
-    assert a[3] == 3.14159;
-
-    a = torch.tensor([0, 0, 0, 3.14159, 0], dtype=torch.float64)
-    assert t.check_rw_by_rvalue_ref(a);
-    assert a[1] == 1.414214;
-    assert t.check_rw_by_rvalue_ref_float64(a);
-    assert a[2] == 2.718282;
-    assert a[4] == 16.0;
-    assert t.check_ro_by_rvalue_ref_ro(a);
-    assert t.check_ro_by_rvalue_ref_const_float64(a);
-    assert a[0] == 0.0;
-    assert a[3] == 3.14159;
-
-
-@needs_cupy
-@pytest.mark.filterwarnings
-def test44_constrain_order_cupy():
-    try:
-        c = cp.zeros((3, 5))
-        c.__dlpack__()
-    except:
-        pytest.skip('cupy is missing')
-
-    f = cp.asarray(c, order="F")
-    assert t.check_order(c) == 'C'
-    assert t.check_order(f) == 'F'
-    assert t.check_order(c[:, 2:5]) == '?'
-    assert t.check_order(f[1:3, :]) == '?'
-    assert t.check_device(cp.zeros((3, 5))) == 'cuda'
-
-
-@needs_cupy
-def test45_implicit_conversion_cupy():
-    with warnings.catch_warnings():
-        warnings.simplefilter("ignore")
-        try:
-            c = cp.zeros((3, 5))
-        except:
-            pytest.skip('cupy is missing')
-
-    t.implicit(cp.zeros((2, 2), dtype=cp.int32))
-    t.implicit(cp.zeros((2, 2, 10), dtype=cp.float32)[:, :, 4])
-    t.implicit(cp.zeros((2, 2, 10), dtype=cp.int32)[:, :, 4])
-    t.implicit(cp.zeros((2, 2, 10), dtype=cp.bool_)[:, :, 4])
-
-    with pytest.raises(TypeError) as excinfo:
-        t.noimplicit(cp.zeros((2, 2), dtype=cp.int32))
-
-    with pytest.raises(TypeError) as excinfo:
-        t.noimplicit(cp.zeros((2, 2), dtype=cp.uint8))
-
-
-@needs_numpy
-def test46_implicit_conversion_contiguous_complex():
-    # Test fix for issue #709
-    import numpy as np
-
-    c_f32 = np.random.rand(10, 10)
-    c_c64 = c_f32.astype(np.complex64)
-
-    assert c_f32.flags['C_CONTIGUOUS']
-    assert c_c64.flags['C_CONTIGUOUS']
-
-    def test_conv(x):
-        y = t.test_implicit_conversion(x)
-        assert np.all(x == y)
-        assert y.flags['C_CONTIGUOUS']
-
-    test_conv(c_f32)
-    test_conv(c_c64)
-
-    nc_f32 = c_f32.T
-    nc_c64 = c_c64.T
-
-    assert not nc_f32.flags['C_CONTIGUOUS']
-    assert not nc_c64.flags['C_CONTIGUOUS']
-
-    test_conv(nc_f32)
-    test_conv(nc_c64)
-
-
-@needs_numpy
-def test_47_ret_infer():
-    import numpy as np
-    assert np.all(t.ret_infer_c() == [[1, 2, 3, 4], [5, 6, 7, 8]])
-    assert np.all(t.ret_infer_f() == [[1, 3, 5, 7], [2, 4, 6, 8]])
-
-
-@needs_numpy
-def test48_test_matrix4f():
-    a = t.Matrix4f()
-    ad = a.data()
-    bd = a.data()
-    for i in range(16):
-        ad[i%4, i//4] = i
-    del a, ad
-    for i in range(16):
-        assert bd[i%4, i//4] == i
-
-
-@needs_numpy
-def test49_test_matrix4f_ref():
-    assert t.Matrix4f.data_ref.__doc__.replace('data_ref', 'data') == t.Matrix4f.data.__doc__
-
-    a = t.Matrix4f()
-    ad = a.data_ref()
-    bd = a.data_ref()
-    for i in range(16):
-        ad[i%4, i//4] = i
-    del a, ad
-    for i in range(16):
-        assert bd[i%4, i//4] == i
-
-
-@needs_numpy
-def test50_test_matrix4f_copy():
-    assert t.Matrix4f.data_ref.__doc__.replace('data_ref', 'data') == t.Matrix4f.data.__doc__
-
-    a = t.Matrix4f()
-    ad = a.data_ref()
-    for i in range(16):
-        ad[i%4, i//4] = i
-    bd = a.data_copy()
-    for i in range(16):
-        ad[i%4, i//4] = 0
-    del a, ad
-    for i in range(16):
-        assert bd[i%4, i//4] == i
-
-
-@needs_numpy
-def test51_return_from_stack():
-    import numpy as np
-    assert np.all(t.ret_from_stack_1() == [1,2,3])
-    assert np.all(t.ret_from_stack_2() == [1,2,3])
-
-@needs_numpy
-def test52_accept_np_both_true_contig():
-    import numpy as np
-    a = np.zeros((2, 1), dtype=np.float32)
-    assert a.flags['C_CONTIGUOUS'] and a.flags['F_CONTIGUOUS']
-    t.accept_np_both_true_contig_a(a)
-    t.accept_np_both_true_contig_c(a)
-    t.accept_np_both_true_contig_f(a)
-
-
-@needs_numpy
-def test53_issue_930():
-    import numpy as np
-    wrapper = t.Wrapper(np.ones(3, dtype=np.float32))
-    assert wrapper.value[0] == 1
diff --git a/src/nanobind/tests/test_ndarray_ext.pyi.ref b/src/nanobind/tests/test_ndarray_ext.pyi.ref
deleted file mode 100644
index dfed2eb..0000000
--- a/src/nanobind/tests/test_ndarray_ext.pyi.ref
+++ /dev/null
@@ -1,196 +0,0 @@
-from typing import Annotated, overload
-
-from numpy.typing import ArrayLike
-
-
-def get_is_valid(array: Annotated[ArrayLike, dict(writable=False)] | None) -> bool: ...
-
-def get_shape(array: Annotated[ArrayLike, dict(writable=False)]) -> list: ...
-
-def get_size(array: ArrayLike | None) -> int: ...
-
-def get_itemsize(array: ArrayLike | None) -> int: ...
-
-def get_nbytes(array: ArrayLike | None) -> int: ...
-
-def get_stride(array: ArrayLike, i: int) -> int: ...
-
-def check_shape_ptr(arg: ArrayLike, /) -> bool: ...
-
-def check_stride_ptr(arg: ArrayLike, /) -> bool: ...
-
-def check_float(arg: ArrayLike, /) -> bool: ...
-
-def check_bool(arg: ArrayLike, /) -> bool: ...
-
-def pass_float32(array: Annotated[ArrayLike, dict(dtype='float32')]) -> None: ...
-
-def pass_float32_const(array: Annotated[ArrayLike, dict(dtype='float32', writable=False)]) -> None: ...
-
-def pass_complex64(array: Annotated[ArrayLike, dict(dtype='complex64')]) -> None: ...
-
-def pass_complex64_const(array: Annotated[ArrayLike, dict(dtype='complex64', writable=False)]) -> None: ...
-
-def pass_uint32(array: Annotated[ArrayLike, dict(dtype='uint32')]) -> None: ...
-
-def pass_bool(array: Annotated[ArrayLike, dict(dtype='bool')]) -> None: ...
-
-def pass_float32_shaped(array: Annotated[ArrayLike, dict(dtype='float32', shape=(3, None, 4))]) -> None: ...
-
-def pass_float32_shaped_ordered(array: Annotated[ArrayLike, dict(dtype='float32', shape=(None, None, 4), order='C')]) -> None: ...
-
-def check_rw_by_value(arg: ArrayLike, /) -> bool: ...
-
-def check_ro_by_value_ro(arg: Annotated[ArrayLike, dict(writable=False)], /) -> bool: ...
-
-def check_rw_by_value_float64(arg: Annotated[ArrayLike, dict(dtype='float64', shape=(None))], /) -> bool: ...
-
-def check_ro_by_value_const_float64(arg: Annotated[ArrayLike, dict(dtype='float64', shape=(None), writable=False)], /) -> bool: ...
-
-def check_rw_by_const_ref(arg: ArrayLike, /) -> bool: ...
-
-def check_ro_by_const_ref_ro(arg: Annotated[ArrayLike, dict(writable=False)], /) -> bool: ...
-
-def check_rw_by_const_ref_float64(arg: Annotated[ArrayLike, dict(dtype='float64', shape=(None))], /) -> bool: ...
-
-def check_ro_by_const_ref_const_float64(arg: Annotated[ArrayLike, dict(dtype='float64', shape=(None), writable=False)], /) -> bool: ...
-
-def check_rw_by_rvalue_ref(arg: ArrayLike, /) -> bool: ...
-
-def check_ro_by_rvalue_ref_ro(arg: Annotated[ArrayLike, dict(writable=False)], /) -> bool: ...
-
-def check_rw_by_rvalue_ref_float64(arg: Annotated[ArrayLike, dict(dtype='float64', shape=(None))], /) -> bool: ...
-
-def check_ro_by_rvalue_ref_const_float64(arg: Annotated[ArrayLike, dict(dtype='float64', shape=(None), writable=False)], /) -> bool: ...
-
-@overload
-def check_order(arg: Annotated[ArrayLike, dict(order='C')], /) -> str: ...
-
-@overload
-def check_order(arg: Annotated[ArrayLike, dict(order='F')], /) -> str: ...
-
-@overload
-def check_order(arg: ArrayLike, /) -> str: ...
-
-def make_contig(arg: Annotated[ArrayLike, dict(order='C')], /) -> Annotated[ArrayLike, dict(order='C')]: ...
-
-@overload
-def check_device(arg: Annotated[ArrayLike, dict(device='cpu')], /) -> str: ...
-
-@overload
-def check_device(arg: Annotated[ArrayLike, dict(device='cuda')], /) -> str: ...
-
-@overload
-def initialize(arg: Annotated[ArrayLike, dict(dtype='float32', shape=(10), device='cpu')], /) -> None: ...
-
-@overload
-def initialize(arg: Annotated[ArrayLike, dict(dtype='float32', shape=(10, None), device='cpu')], /) -> None: ...
-
-def noimplicit(array: Annotated[ArrayLike, dict(dtype='float32', shape=(2, 2), order='C')]) -> int: ...
-
-def implicit(array: Annotated[ArrayLike, dict(dtype='float32', shape=(2, 2), order='C')]) -> int: ...
-
-def inspect_ndarray(arg: ArrayLike, /) -> None: ...
-
-def process(arg: Annotated[ArrayLike, dict(dtype='uint8', shape=(None, None, 3), order='C', device='cpu')], /) -> None: ...
-
-def destruct_count() -> int: ...
-
-def return_dlpack() -> Annotated[ArrayLike, dict(dtype='float32', shape=(2, 4))]: ...
-
-def passthrough(arg: ArrayLike, /) -> ArrayLike: ...
-
-def passthrough_copy(arg: ArrayLike, /) -> ArrayLike: ...
-
-def passthrough_arg_none(arg: ArrayLike | None) -> ArrayLike: ...
-
-def ret_numpy() -> Annotated[ArrayLike, dict(dtype='float32', shape=(2, 4))]: ...
-
-def ret_numpy_const_ref() -> Annotated[ArrayLike, dict(dtype='float32', shape=(2, 4), order='C', writable=False)]: ...
-
-def ret_numpy_const_ref_f() -> Annotated[ArrayLike, dict(dtype='float32', shape=(2, 4), order='F', writable=False)]: ...
-
-def ret_numpy_const() -> Annotated[ArrayLike, dict(dtype='float32', shape=(2, 4), writable=False)]: ...
-
-def ret_pytorch() -> Annotated[ArrayLike, dict(dtype='float32', shape=(2, 4))]: ...
-
-def ret_array_scalar() -> Annotated[ArrayLike, dict(dtype='float32')]: ...
-
-def noop_3d_c_contig(arg: Annotated[ArrayLike, dict(dtype='float32', shape=(None, None, None), order='C')], /) -> None: ...
-
-def noop_2d_f_contig(arg: Annotated[ArrayLike, dict(dtype='float32', shape=(None, None), order='F')], /) -> None: ...
-
-def accept_rw(arg: Annotated[ArrayLike, dict(dtype='float32', shape=(2))], /) -> float: ...
-
-def accept_ro(arg: Annotated[ArrayLike, dict(dtype='float32', shape=(2), writable=False)], /) -> float: ...
-
-def check(arg: object, /) -> bool: ...
-
-def accept_np_both_true_contig_a(arg: Annotated[ArrayLike, dict(dtype='float32', shape=(2, 1), order='A')], /) -> float: ...
-
-def accept_np_both_true_contig_c(arg: Annotated[ArrayLike, dict(dtype='float32', shape=(2, 1), order='C')], /) -> float: ...
-
-def accept_np_both_true_contig_f(arg: Annotated[ArrayLike, dict(dtype='float32', shape=(2, 1), order='F')], /) -> float: ...
-
-class Cls:
-    def __init__(self) -> None: ...
-
-    def f1(self) -> Annotated[ArrayLike, dict(dtype='float32')]: ...
-
-    def f2(self) -> Annotated[ArrayLike, dict(dtype='float32')]: ...
-
-    def f1_ri(self) -> Annotated[ArrayLike, dict(dtype='float32')]: ...
-
-    def f2_ri(self) -> Annotated[ArrayLike, dict(dtype='float32')]: ...
-
-    def f3_ri(self, arg: object, /) -> Annotated[ArrayLike, dict(dtype='float32')]: ...
-
-def fill_view_1(x: ArrayLike) -> None: ...
-
-def fill_view_2(x: Annotated[ArrayLike, dict(dtype='float32', shape=(None, None), device='cpu')]) -> None: ...
-
-def fill_view_3(x: Annotated[ArrayLike, dict(dtype='float32', shape=(3, 4), order='C', device='cpu')]) -> None: ...
-
-def fill_view_4(x: Annotated[ArrayLike, dict(dtype='float32', shape=(3, 4), order='F', device='cpu')]) -> None: ...
-
-def fill_view_5(x: Annotated[ArrayLike, dict(dtype='complex64', shape=(2, 2), order='C', device='cpu')]) -> None: ...
-
-def fill_view_6(x: Annotated[ArrayLike, dict(dtype='complex64', shape=(2, 2), order='C', device='cpu')]) -> None: ...
-
-def ret_numpy_half() -> Annotated[ArrayLike, dict(dtype='float16', shape=(2, 4))]: ...
-
-def cast(arg: bool, /) -> ArrayLike: ...
-
-@overload
-def set_item(arg0: Annotated[ArrayLike, dict(dtype='float64', shape=(None), order='C')], arg1: int, /) -> None: ...
-
-@overload
-def set_item(arg0: Annotated[ArrayLike, dict(dtype='complex128', shape=(None), order='C')], arg1: int, /) -> None: ...
-
-def test_implicit_conversion(arg: Annotated[ArrayLike, dict(order='C', device='cpu', writable=False)]) -> Annotated[ArrayLike, dict(order='C', device='cpu', writable=False)]: ...
-
-def ret_infer_c() -> Annotated[ArrayLike, dict(dtype='float32', shape=(2, 4), order='C')]: ...
-
-def ret_infer_f() -> Annotated[ArrayLike, dict(dtype='float32', shape=(2, 4), order='F')]: ...
-
-class Matrix4f:
-    def __init__(self) -> None: ...
-
-    def data(self) -> Annotated[ArrayLike, dict(dtype='float32', shape=(4, 4), order='F')]: ...
-
-    def data_ref(self) -> Annotated[ArrayLike, dict(dtype='float32', shape=(4, 4), order='F')]: ...
-
-    def data_copy(self) -> Annotated[ArrayLike, dict(dtype='float32', shape=(4, 4), order='F')]: ...
-
-def ret_from_stack_1() -> object: ...
-
-def ret_from_stack_2() -> Annotated[ArrayLike, dict(dtype='float32', shape=(3))]: ...
-
-class Wrapper:
-    def __init__(self, arg: Annotated[ArrayLike, dict(dtype='float32')], /) -> None: ...
-
-    @property
-    def value(self) -> Annotated[ArrayLike, dict(dtype='float32')]: ...
-
-    @value.setter
-    def value(self, arg: Annotated[ArrayLike, dict(dtype='float32')], /) -> None: ...
diff --git a/src/nanobind/tests/test_stl.cpp b/src/nanobind/tests/test_stl.cpp
deleted file mode 100644
index 9fb6098..0000000
--- a/src/nanobind/tests/test_stl.cpp
+++ /dev/null
@@ -1,531 +0,0 @@
-#include <nanobind/stl/tuple.h>
-#include <nanobind/stl/pair.h>
-#include <nanobind/stl/vector.h>
-#include <nanobind/stl/function.h>
-#include <nanobind/stl/list.h>
-#include <nanobind/stl/string.h>
-#include <nanobind/stl/string_view.h>
-#include <nanobind/stl/optional.h>
-#include <nanobind/stl/variant.h>
-#include <nanobind/stl/map.h>
-#include <nanobind/stl/array.h>
-#include <nanobind/stl/unordered_set.h>
-#include <nanobind/stl/set.h>
-#include <nanobind/stl/filesystem.h>
-#include <nanobind/stl/complex.h>
-#include <nanobind/stl/wstring.h>
-
-NB_MAKE_OPAQUE(std::vector<float, std::allocator<float>>)
-
-namespace nb = nanobind;
-
-static int default_constructed = 0, value_constructed = 0, copy_constructed = 0,
-           move_constructed = 0, copy_assigned = 0, move_assigned = 0,
-           destructed = 0;
-
-struct Movable {
-    int value = 5;
-
-    Movable() { default_constructed++; }
-    Movable(int value) : value(value) { value_constructed++; }
-    Movable(const Movable &s) : value(s.value) { copy_constructed++; }
-    Movable(Movable &&s) noexcept : value(s.value) { s.value = 0; move_constructed++; }
-    Movable &operator=(const Movable &s) { value = s.value; copy_assigned++; return *this; }
-    Movable &operator=(Movable &&s) noexcept { std::swap(value, s.value); move_assigned++; return *this; }
-    ~Movable() { destructed++; }
-};
-
-struct Copyable {
-    int value = 5;
-
-    Copyable() { default_constructed++; }
-    Copyable(int value) : value(value) { value_constructed++; }
-    Copyable(const Copyable &s) : value(s.value) { copy_constructed++; }
-    Copyable &operator=(const Copyable &s) { value = s.value; copy_assigned++; return *this; }
-    ~Copyable() { destructed++; }
-};
-
-struct NonAssignable {
-  int value = 5;
-
-  NonAssignable() = default;
-  NonAssignable(const NonAssignable &x) : value(x.value) { }
-  NonAssignable &operator=(const NonAssignable &) = delete;
-};
-
-struct NonDefaultConstructible : Movable {
-    NonDefaultConstructible(int v) : Movable(v) {}
-};
-
-struct StructWithReadonlyMap {
-    std::map<std::string, uint64_t> map;
-};
-
-struct FuncWrapper {
-    std::function<void(void)> f;
-    static int alive;
-    FuncWrapper() { alive++; }
-    ~FuncWrapper() { alive--; }
-};
-
-int funcwrapper_tp_traverse(PyObject *self, visitproc visit, void *arg) {
-    #if PY_VERSION_HEX >= 0x03090000
-        Py_VISIT(Py_TYPE(self));
-    #endif
-
-    if (!nb::inst_ready(self)) {
-        return 0;
-    }
-
-    FuncWrapper *w = nb::inst_ptr<FuncWrapper>(self);
-
-    nb::handle f = nb::cast(w->f, nb::rv_policy::none);
-    Py_VISIT(f.ptr());
-
-    return 0;
-}
-
-int FuncWrapper::alive = 0;
-
-void fail() { throw std::exception(); }
-
-NB_MODULE(test_stl_ext, m) {
-    m.def("stats", []{
-        nb::dict d;
-        d["default_constructed"] = default_constructed;
-        d["value_constructed"] = value_constructed;
-        d["copy_constructed"] = copy_constructed;
-        d["move_constructed"] = move_constructed;
-        d["copy_assigned"] = copy_assigned;
-        d["move_assigned"] = move_assigned;
-        d["destructed"] = destructed;
-        return d;
-    });
-
-    m.def("reset", []() {
-        default_constructed = 0;
-        value_constructed = 0;
-        copy_constructed = 0;
-        move_constructed = 0;
-        copy_assigned = 0;
-        move_assigned = 0;
-        destructed = 0;
-    });
-
-    nb::class_<Movable>(m, "Movable")
-        .def(nb::init<>())
-        .def(nb::init<int>())
-        .def_rw("value", &Movable::value);
-
-    nb::class_<Copyable>(m, "Copyable")
-        .def(nb::init<>())
-        .def(nb::init<int>())
-        .def_rw("value", &Copyable::value);
-
-    nb::class_<NonAssignable>(m, "NonAssignable")
-        .def(nb::init<>())
-        .def_rw("value", &NonAssignable::value);
-
-    nb::class_<NonDefaultConstructible>(m, "NonDefaultConstructible")
-        .def(nb::init<int>())
-        .def_rw("value", &NonDefaultConstructible::value);
-
-    nb::class_<StructWithReadonlyMap>(m, "StructWithReadonlyMap")
-        .def(nb::init<>())
-        .def_ro("map", &StructWithReadonlyMap::map);
-
-    // ----- test01-test12 ------
-
-    m.def("return_movable", []() { return Movable(); });
-    m.def("return_movable_ptr", []() { return new Movable(); });
-    m.def("movable_in_value", [](Movable m) { if (m.value != 5) fail(); });
-    m.def("movable_in_lvalue_ref", [](Movable &m) { if (m.value != 5) fail(); });
-    m.def("movable_in_rvalue_ref", [](Movable &&m) { Movable x(std::move(m)); if (x.value != 5) fail(); });
-    m.def("movable_in_ptr", [](Movable *m) { if (m->value != 5) fail(); });
-    m.def("return_copyable", []() { return Copyable(); });
-    m.def("return_copyable_ptr", []() { return new Copyable(); });
-    m.def("copyable_in_value", [](Copyable m) { if (m.value != 5) fail(); });
-    m.def("copyable_in_lvalue_ref", [](Copyable &m) { if (m.value != 5) fail(); });
-    m.def("copyable_in_rvalue_ref", [](Copyable &&m) { Copyable x(m); if (x.value != 5) fail(); });
-    m.def("copyable_in_ptr", [](Copyable *m) { if (m->value != 5) fail(); });
-
-    // ----- test13-test20 ------
-
-    m.def("tuple_return_movable", []() { return std::make_tuple(Movable()); });
-    m.def("tuple_return_movable_ptr", []() { return std::make_tuple(new Movable()); });
-    m.def("tuple_movable_in_value", [](std::tuple<Movable> m) { if (std::get<0>(m).value != 5) fail(); });
-    m.def("tuple_movable_in_lvalue_ref", [](std::tuple<Movable&> m) { if (std::get<0>(m).value != 5) fail(); });
-    m.def("tuple_movable_in_lvalue_ref_2", [](const std::tuple<Movable> &m) { if (std::get<0>(m).value != 5) fail(); });
-    m.def("tuple_movable_in_rvalue_ref", [](std::tuple<Movable&&> m) { Movable x(std::move(std::get<0>(m))); if (x.value != 5) fail(); });
-    m.def("tuple_movable_in_rvalue_ref_2", [](std::tuple<Movable> &&m) { Movable x(std::move(std::get<0>(m))); if (x.value != 5) fail(); });
-    m.def("tuple_movable_in_ptr", [](std::tuple<Movable*> m) { if (std::get<0>(m)->value != 5) fail(); });
-
-    // ----- test21 ------
-
-    m.def("empty_tuple", [](std::tuple<>) { return std::tuple<>(); });
-    m.def("swap_tuple", [](const std::tuple<int, float> &v) {
-        return std::tuple<float, int>(std::get<1>(v), std::get<0>(v));
-    });
-    m.def("swap_pair", [](const std::pair<int, float> &v) {
-        return std::pair<float, int>(std::get<1>(v), std::get<0>(v));
-    });
-
-    // ----- test22 ------
-    m.def("vec_return_movable", [](){
-        std::vector<Movable> x;
-        x.reserve(10);
-        for (int i = 0; i< 10; ++i)
-            x.emplace_back(i);
-        return x;
-    });
-
-    m.def("vec_return_copyable", [](){
-        std::vector<Copyable> x;
-        x.reserve(10);
-        for (int i = 0; i < 10; ++i) {
-            Copyable c(i);
-            x.push_back(c);
-        }
-        return x;
-    });
-
-    m.def("vec_movable_in_value", [](std::vector<Movable> x) {
-        if (x.size() != 10)
-            fail();
-        for (int i = 0; i< 10; ++i)
-            if (x[i].value != i)
-                fail();
-    });
-
-
-    m.def("vec_copyable_in_value", [](std::vector<Copyable> x) {
-        if (x.size() != 10)
-            fail();
-        for (int i = 0; i< 10; ++i)
-            if (x[i].value != i)
-                fail();
-    });
-
-
-    m.def("vec_movable_in_lvalue_ref", [](std::vector<Movable> &x) {
-        if (x.size() != 10)
-            fail();
-        for (int i = 0; i< 10; ++i)
-            if (x[i].value != i)
-                fail();
-    });
-
-
-    m.def("vec_movable_in_rvalue_ref", [](std::vector<Movable> &&x) {
-        if (x.size() != 10)
-            fail();
-        for (int i = 0; i< 10; ++i)
-            if (x[i].value != i)
-                fail();
-    });
-
-    m.def("vec_movable_in_ptr_2", [](std::vector<Movable *> x) {
-        if (x.size() != 10)
-            fail();
-        for (int i = 0; i< 10; ++i)
-            if (x[i]->value != i)
-                fail();
-    });
-
-    // ----- test29 ------
-    using fvec = std::vector<float, std::allocator<float>>;
-    nb::class_<fvec>(m, "float_vec")
-        .def(nb::init<>())
-        .def("push_back", [](fvec *fv, float f) { fv->push_back(f); })
-        .def("size", [](const fvec &fv) { return fv.size(); });
-
-    // ----- test30 ------
-
-    m.def("return_empty_function", []() -> std::function<int(int)> {
-        return {};
-    });
-    m.def("return_function", []() -> std::function<int(int)> {
-        int k = 5;
-        return [k](int l) { return k + l; };
-    });
-
-    m.def("call_function", [](std::function<int(int)> &f, int x) {
-        return f(x);
-    });
-
-    m.def("return_void_function", [](std::function<void(void)> &f) {
-        return f;
-    });
-
-    m.def("identity_list", [](std::list<int> &x) { return x; });
-
-    PyType_Slot slots[] = {
-        { Py_tp_traverse, (void *) funcwrapper_tp_traverse },
-        { 0, 0 }
-    };
-
-    nb::class_<FuncWrapper>(m, "FuncWrapper", nb::type_slots(slots))
-        .def(nb::init<>())
-        .def_rw("f", &FuncWrapper::f)
-        .def_ro_static("alive", &FuncWrapper::alive, "static read-only property");
-
-    // ----- test35 ------
-    m.def("identity_string", [](std::string& x) { return x; });
-    m.def("identity_string_view", [](std::string_view& x) { return x; });
-
-    // ----- test36-test42 ------
-    m.def("optional_copyable", [](std::optional<Copyable> &) {}, nb::arg("x").none());
-    m.def("optional_copyable_ptr", [](std::optional<Copyable *> &) {}, nb::arg("x").none());
-    m.def("optional_none", [](std::optional<Copyable> &x) { if(x) fail(); }, nb::arg("x").none());
-    m.def("optional_ret_opt_movable", []() { return std::optional<Movable>(Movable()); });
-    m.def("optional_ret_opt_movable_ptr", []() { return new std::optional<Movable *>(new Movable()); });
-    m.def("optional_ret_opt_none", []() { return std::optional<Movable>(); });
-    m.def("optional_unbound_type", [](std::optional<int> &x) { return x; }, nb::arg("x") = nb::none());
-    m.def("optional_unbound_type_with_nullopt_as_default", [](std::optional<int> &x) { return x; }, nb::arg("x") = std::nullopt);
-    m.def("optional_non_assignable", [](std::optional<NonAssignable> &x) { return x; });
-
-    // ----- test43-test50 ------
-    m.def("variant_copyable", [](std::variant<Copyable, int> &) {});
-    m.def("variant_copyable_none", [](std::variant<std::monostate, int, Copyable> &) {}, nb::arg("x").none());
-    m.def("variant_copyable_ptr", [](std::variant<Copyable *, int> &) {});
-    m.def("variant_copyable_ptr_none", [](std::variant<Copyable *, int> &) {}, nb::arg("x").none());
-    m.def("variant_ret_var_copyable", []() { return std::variant<Copyable, int>(); });
-    m.def("variant_ret_var_none", []() { return std::variant<std::monostate, Copyable, int>(); });
-    m.def("variant_unbound_type", [](std::variant<std::monostate, nb::list, nb::tuple, int> &x) { return x; },
-          nb::arg("x") = nb::none());
-    m.def("variant_nondefault",
-          [](std::variant<NonDefaultConstructible, int> v) {
-              return v.index() == 0 ? std::get<0>(v).value : -std::get<1>(v);
-          });
-
-    // ----- test50-test57 ------
-    m.def("map_return_movable_value", [](){
-        std::map<std::string, Movable> x;
-        for (int i = 0; i < 10; ++i)
-            x.emplace(std::string(1, (char) ('a' + i)), i);
-        return x;
-    });
-
-    m.def("map_return_copyable_value", [](){
-        std::map<std::string, Copyable> x;
-        for (int i = 0; i < 10; ++i) {
-            Copyable c(i);
-            x.insert({std::string(1, (char) ('a' + i)), c});
-        }
-        return x;
-    });
-
-    m.def("map_movable_in_value", [](std::map<std::string, Movable> x) {
-        if (x.size() != 10) fail();
-        for (int i = 0; i < 10; ++i) {
-            std::string key(1, (char) ('a' + i));
-            if (x.find(key) == x.end()) fail();
-            if (x[key].value != i) fail();
-        }
-    }, nb::arg("x"));
-
-    m.def("map_copyable_in_value", [](std::map<std::string, Copyable> x) {
-        if (x.size() != 10) fail();
-        for (int i = 0; i < 10; ++i) {
-            std::string key(1, (char) ('a' + i));
-            if (x.find(key) == x.end()) fail();
-            if (x[key].value != i) fail();
-        }
-    }, nb::arg("x"));
-
-    m.def("map_movable_in_lvalue_ref", [](std::map<std::string, Movable> &x) {
-        if (x.size() != 10) fail();
-        for (int i = 0; i < 10; ++i) {
-            std::string key(1, (char) ('a' + i));
-            if (x.find(key) == x.end()) fail();
-            if (x[key].value != i) fail();
-        }
-    }, nb::arg("x"));
-
-    m.def("map_movable_in_rvalue_ref", [](std::map<std::string, Movable> &&x) {
-        if (x.size() != 10) fail();
-        for (int i = 0; i < 10; ++i) {
-            std::string key(1, (char) ('a' + i));
-            if (x.find(key) == x.end()) fail();
-            if (x[key].value != i) fail();
-        }
-    }, nb::arg("x"));
-
-    m.def("map_movable_in_ptr", [](std::map<std::string, Movable *> x) {
-        if (x.size() != 10) fail();
-        for (int i = 0; i < 10; ++i) {
-            std::string key(1, (char) ('a' + i));
-            if (x.find(key) == x.end()) fail();
-            if (x[key]->value != i) fail();
-        }
-    }, nb::arg("x"));
-
-    m.def("map_return_readonly_value", [](){
-        StructWithReadonlyMap x;
-        for (int i = 0; i < 10; ++i) {
-            x.map.insert({std::string(1, (char) ('a' + i)), i});
-        }
-        return x;
-    });
-
-    // test58
-    m.def("array_out", [](){ return std::array<int, 3>{1, 2, 3}; });
-    m.def("array_in", [](std::array<int, 3> x) { return x[0] + x[1] + x[2]; });
-
-    // ----- test60-test64 ------
-    m.def("set_return_value", []() {
-        std::set<std::string> x;
-        for (int i = 0; i < 10; ++i)
-            x.emplace(std::string(1, (char) ('a' + i)));
-        return x;
-    });
-
-    m.def("unordered_set_return_value", []() {
-        std::unordered_set<std::string> x;
-        for (int i = 0; i < 10; ++i)
-            x.emplace(std::string(1, (char) ('a' + i)));
-        return x;
-    });
-
-    m.def("set_in_value", [](std::set<std::string> x) {
-            if (x.size() != 10)
-                fail();
-            for (int i = 0; i < 10; ++i) {
-                std::string key(1, (char) ('a' + i));
-                if (x.find(key) == x.end())
-                    fail();
-            }
-        },
-        nb::arg("x"));
-
-
-    m.def(
-        "unordered_set_in_value", [](std::unordered_set<std::string> x) {
-            if (x.size() != 10)
-                fail();
-            for (int i = 0; i < 10; ++i) {
-                std::string key(1, (char) ('a' + i));
-                if (x.find(key) == x.end())
-                    fail();
-            }
-        },
-        nb::arg("x"));
-
-    m.def(
-        "set_in_lvalue_ref", [](std::set<std::string>& x) {
-            if (x.size() != 10)
-                fail();
-            for (int i = 0; i < 10; ++i) {
-                std::string key(1, (char) ('a' + i));
-                if (x.find(key) == x.end())
-                    fail();
-            }
-        },
-        nb::arg("x"));
-
-    m.def(
-        "set_in_rvalue_ref", [](std::set<std::string>&& x) {
-            if (x.size() != 10)
-                fail();
-            for (int i = 0; i < 10; ++i) {
-                std::string key(1, (char) ('a' + i));
-                if (x.find(key) == x.end())
-                    fail();
-            }
-        },
-        nb::arg("x"));
-
-    // std::filesystem incomplete on GCC 8
-#if !(defined(__GNUC__) && !defined(__clang__) && __GNUC__ <= 8)
-    // test66
-    m.def("replace_extension", [](std::filesystem::path p, std::string ext) {
-        return p.replace_extension(ext);
-    });
-    m.def("parent_path", [](const std::filesystem::path &p) { return p.parent_path(); });
-#endif
-
-    struct ClassWithMovableField {
-        std::vector<Movable> movable;
-    };
-
-    nb::class_<ClassWithMovableField>(m, "ClassWithMovableField")
-        .def(nb::init<>())
-        .def_rw("movable", &ClassWithMovableField::movable);
-
-    // test67 std::vector<bool>
-    m.def("flip_vector_bool", [](std::vector<bool> vec) {
-        vec.flip();
-        return vec;
-    });
-
-
-    m.def("complex_value_float", [](const std::complex<float>& x) {
-        return x;
-    });
-    m.def("complex_value_float_nc", [](const std::complex<float>& x) {
-        return x;
-    }, nb::arg().noconvert());
-    m.def("complex_value_double", [](const std::complex<double>& x) {
-        return x;
-    });
-    m.def("complex_value_double_nc", [](const std::complex<double>& x) {
-        return x;
-    }, nb::arg().noconvert());
-
-    m.def("complex_array_float", [](const std::vector<std::complex<float>>& x) {
-        return x;
-    });
-    m.def("complex_array_double", [](const std::vector<std::complex<double>>& x) {
-        return x;
-    });
-
-    m.def("vector_str", [](const std::vector<std::string>& x){
-        return x;
-    });
-    m.def("vector_str", [](std::string& x){
-        return x;
-    });
-
-    m.def("vector_optional_str", [](const std::vector<std::optional<std::string>>& x) {
-        return x;
-    });
-
-    m.def("pass_wstr", [](std::wstring ws) { return ws; });
-
-    // uncomment to see compiler error:
-    // m.def("optional_intptr", [](std::optional<int*>) {});
-    m.def("optional_cstr", [](std::optional<const char*> arg) {
-        return arg.value_or("none");
-    }, nb::arg().none());
-
-
-    // test74
-    struct BasicID1 {
-        uint64_t id;
-        BasicID1(uint64_t id) : id(id) {}
-    };
-
-    struct BasicID2 {
-        uint64_t id;
-        BasicID2(uint64_t id) : id(id) {}
-    };
-
-    nb::class_<BasicID1>(m, "BasicID1")
-        .def(nb::init<uint64_t>())
-        .def("__int__", [](const BasicID1& x) { return x.id; })
-        ;
-
-    nb::class_<BasicID2>(m, "BasicID2")
-        .def(nb::init_implicit<uint64_t>());
-
-    using IDVariants = std::variant<std::monostate, BasicID2, BasicID1>;
-
-    struct IDHavingEvent {
-        IDVariants id;
-        IDHavingEvent() = default;
-    };
-
-    nb::class_<IDHavingEvent>(m, "IDHavingEvent")
-        .def(nb::init<>())
-        .def_rw("id", &IDHavingEvent::id);
-}
diff --git a/src/nanobind/tests/test_stl.py b/src/nanobind/tests/test_stl.py
deleted file mode 100644
index 5fe715f..0000000
--- a/src/nanobind/tests/test_stl.py
+++ /dev/null
@@ -1,884 +0,0 @@
-import test_stl_ext as t
-import typing
-import pytest
-import sys
-from common import collect, skip_on_pypy
-
-# Some helper declaration to check types across different Python versions
-if sys.version_info < (3, 9):
-    TYPING_DICT = "typing.Dict"
-    TYPING_SET = "typing.Set"
-    TYPING_ABC = "typing"
-    TYPING_ABSTRACT_SET = "typing.AbstractSet"
-else:
-    TYPING_DICT = "dict"
-    TYPING_SET = "set"
-    TYPING_ABC = "collections.abc"
-    TYPING_ABSTRACT_SET = "collections.abc.Set"
-
-
-def optional(arg: str, /) -> str:
-    if sys.version_info < (3, 10):
-        return "typing.Optional[" + arg + "]"
-    else:
-        return arg + " | " + "None"
-
-
-def union(*args: str) -> str:
-    if sys.version_info < (3, 10):
-        return "typing.Union[" + ", ".join(args) + "]"
-    else:
-        return " | ".join(args)
-
-
-@pytest.fixture
-def clean():
-    collect()
-    t.reset()
-
-
-def assert_stats(**kwargs):
-    collect()
-    for k, v in t.stats().items():
-        fail = False
-        if k in kwargs:
-            if v != kwargs[k]:
-                fail = True
-        elif v != 0:
-            fail = True
-        if fail:
-            raise Exception(f"Mismatch for key {k}: {t.stats()}")
-
-
-# ------------------------------------------------------------------
-# The following aren't strictly STL tests, but they are helpful in
-# ensuring that move constructors/copy constructors of bound C++ types
-# are properly triggered, which the STL type casters depend on.
-# ------------------------------------------------------------------
-
-
-def test01_movable_return(clean):
-    assert t.return_movable().value == 5
-    assert_stats(default_constructed=1, move_constructed=1, destructed=2)
-
-
-def test02_movable_return_ptr(clean):
-    assert t.return_movable_ptr().value == 5
-    assert_stats(default_constructed=1, destructed=1)
-
-
-def test03_movable_in_value(clean):
-    s = t.Movable()
-    t.movable_in_value(s)
-    assert s.value == 5
-    del s
-    assert_stats(default_constructed=1, copy_constructed=1, destructed=2)
-
-
-def test04_movable_in_lvalue_ref(clean):
-    s = t.Movable()
-    t.movable_in_lvalue_ref(s)
-    assert s.value == 5
-    del s
-    assert_stats(default_constructed=1, destructed=1)
-
-
-def test05_movable_in_ptr(clean):
-    s = t.Movable()
-    t.movable_in_ptr(s)
-    assert s.value == 5
-    del s
-    assert_stats(default_constructed=1, destructed=1)
-
-
-def test06_movable_in_rvalue_ref(clean):
-    s = t.Movable()
-    t.movable_in_rvalue_ref(s)
-    assert s.value == 0
-    del s
-    assert_stats(default_constructed=1, move_constructed=1, destructed=2)
-
-
-def test07_copyable_return(clean):
-    assert t.return_copyable().value == 5
-    assert_stats(default_constructed=1, copy_constructed=1, destructed=2)
-
-
-def test08_copyable_return_ptr(clean):
-    assert t.return_copyable_ptr().value == 5
-    assert_stats(default_constructed=1, destructed=1)
-
-
-def test09_copyable_in_value(clean):
-    s = t.Copyable()
-    t.copyable_in_value(s)
-    assert s.value == 5
-    del s
-    assert_stats(default_constructed=1, copy_constructed=1, destructed=2)
-
-
-def test10_copyable_in_lvalue_ref(clean):
-    s = t.Copyable()
-    t.copyable_in_lvalue_ref(s)
-    assert s.value == 5
-    del s
-    assert_stats(default_constructed=1, destructed=1)
-
-
-def test11_copyable_in_ptr(clean):
-    s = t.Copyable()
-    t.copyable_in_ptr(s)
-    assert s.value == 5
-    del s
-    assert_stats(default_constructed=1, destructed=1)
-
-
-def test12_copyable_in_rvalue_ref(clean):
-    s = t.Copyable()
-    t.copyable_in_rvalue_ref(s)
-    assert s.value == 5
-    del s
-    assert_stats(default_constructed=1, copy_constructed=1, destructed=2)
-
-
-# ------------------------------------------------------------------
-
-
-def test13_tuple_movable_return(clean):
-    assert t.tuple_return_movable()[0].value == 5
-    assert_stats(default_constructed=1, move_constructed=2, destructed=3)
-
-
-def test14_tuple_movable_return_ptr(clean):
-    assert t.return_movable_ptr().value == 5
-    assert_stats(default_constructed=1, destructed=1)
-
-
-def test15_tuple_movable_in_value(clean):
-    s = t.Movable()
-    t.tuple_movable_in_value((s,))
-    assert s.value == 5
-    del s
-    assert_stats(default_constructed=1, copy_constructed=1, destructed=2)
-
-
-def test16_tuple_movable_in_lvalue_ref(clean):
-    s = t.Movable()
-    t.tuple_movable_in_lvalue_ref((s,))
-    assert s.value == 5
-    del s
-    assert_stats(default_constructed=1, destructed=1)
-
-
-def test17_tuple_movable_in_lvalue_ref_2(clean):
-    s = t.Movable()
-    t.tuple_movable_in_lvalue_ref_2((s,))
-    assert s.value == 5
-    del s
-    assert_stats(default_constructed=1, copy_constructed=1, destructed=2)
-
-
-def test18_tuple_movable_in_ptr(clean):
-    s = t.Movable()
-    t.tuple_movable_in_ptr((s,))
-    assert s.value == 5
-    del s
-    assert_stats(default_constructed=1, destructed=1)
-
-
-def test19_tuple_movable_in_rvalue_ref(clean):
-    s = t.Movable()
-    t.tuple_movable_in_rvalue_ref((s,))
-    assert s.value == 0
-    del s
-    assert_stats(default_constructed=1, move_constructed=1, destructed=2)
-
-
-def test20_tuple_movable_in_rvalue_ref_2(clean):
-    s = t.Movable()
-    t.tuple_movable_in_rvalue_ref_2((s,))
-    assert s.value == 5
-    del s
-    assert_stats(
-        default_constructed=1, copy_constructed=1, move_constructed=1, destructed=3
-    )
-
-
-# ------------------------------------------------------------------
-
-
-def test21_tuple_pair_basic():
-    assert t.empty_tuple(()) == ()
-    assert t.swap_tuple((1, 2.5)) == (2.5, 1)
-    assert t.swap_pair((1, 2.5)) == (2.5, 1)
-
-
-# ------------------------------------------------------------------
-
-
-def test22_vec_return_movable(clean):
-    for i, x in enumerate(t.vec_return_movable()):
-        assert x.value == i
-    del x
-    assert_stats(value_constructed=10, move_constructed=10, destructed=20)
-
-
-def test23_vec_return_copyable(clean):
-    for i, x in enumerate(t.vec_return_copyable()):
-        assert x.value == i
-    del x
-    assert_stats(value_constructed=10, copy_constructed=20, destructed=30)
-
-
-def test24_vec_movable_in_value(clean):
-    t.vec_movable_in_value([t.Movable(i) for i in range(10)])
-    assert_stats(value_constructed=10, copy_constructed=10, destructed=20)
-
-    # Test that None values don't cause a crash
-    with pytest.raises(TypeError):
-        t.vec_movable_in_value([None])
-
-
-def test25_vec_movable_in_value(clean):
-    t.vec_copyable_in_value([t.Copyable(i) for i in range(10)])
-    assert_stats(value_constructed=10, copy_constructed=10, destructed=20)
-
-
-def test26_vec_movable_in_lvalue_ref(clean):
-    t.vec_movable_in_lvalue_ref([t.Movable(i) for i in range(10)])
-    assert_stats(value_constructed=10, copy_constructed=10, destructed=20)
-
-
-def test27_vec_movable_in_ptr_2(clean):
-    t.vec_movable_in_ptr_2([t.Movable(i) for i in range(10)])
-    assert_stats(value_constructed=10, destructed=10)
-
-    # Test that None values are permitted when casting to pointer;
-    # instead we reach 'if (x.size() != 10) fail();' in the bound function
-    with pytest.raises(RuntimeError):
-        t.vec_movable_in_ptr_2([None])
-
-
-def test28_vec_movable_in_rvalue_ref(clean):
-    t.vec_movable_in_rvalue_ref([t.Movable(i) for i in range(10)])
-    assert_stats(value_constructed=10, copy_constructed=10, destructed=20)
-
-
-def test29_opaque_vector():
-    f = t.float_vec()
-    assert f.size() == 0
-    assert isinstance(f, t.float_vec)
-    f.push_back(1)
-    assert f.size() == 1
-
-
-def test30_std_function():
-    assert t.return_empty_function() is None
-    assert t.return_function()(3) == 8
-    assert t.call_function(lambda x: 5 + x, 3) == 8
-
-    with pytest.raises(TypeError) as excinfo:
-        assert t.call_function(5, 3) == 8
-    assert "incompatible function arguments" in str(excinfo.value)
-
-    with pytest.raises(TypeError) as excinfo:
-        assert t.call_function(lambda x, y: x + y, 3) == 8
-    assert "missing 1 required positional argument" in str(excinfo.value)
-
-    l = []
-
-    def f():
-        l.append(1)
-
-    f2 = t.return_void_function(f)
-    f2()
-    assert l == [1]
-
-
-def test31_std_function_roundtrip():
-    def f():
-        l.append(1)
-
-    f2 = t.return_void_function(f)
-    assert f2 is f
-
-
-# cpyext reference cycles are not supported, see https://foss.heptapod.net/pypy/pypy/-/issues/3849
-@skip_on_pypy
-def test32_std_function_gc():
-    # Test class -> function -> class cyclic reference
-    class A(t.FuncWrapper):
-        pass
-
-    assert t.FuncWrapper.alive == 0
-    a = A()
-    assert t.FuncWrapper.alive == 1
-    del a
-    collect()
-    assert t.FuncWrapper.alive == 0
-
-    # t.FuncWrapper is a C extension type with a custom property 'f', which
-    # can store Python function objects It implements the tp_traverse
-    # callback so that reference cycles arising from this function object
-    # can be detected.
-
-    class Test(t.FuncWrapper):
-        def __init__(self):
-            super().__init__()
-
-            # The constructor creates a closure, which references 'self'
-            # and assigns it to the 'self.f' member.
-            # This creates a cycle self -> self.f -> self
-            def f():
-                print(self.f)
-
-            self.f = f
-
-
-    # The Test class declared above inherits from 'FuncWrapper'.
-    # This class keeps track of how many references are alive at
-    # any point to help track down leak issues.
-    assert t.FuncWrapper.alive == 0
-    b = Test()
-    assert t.FuncWrapper.alive == 1
-    del b
-    collect()
-    assert t.FuncWrapper.alive == 0
-
-
-def test33_vec_type_check():
-    with pytest.raises(TypeError) as excinfo:
-        t.vec_movable_in_value(0)
-
-
-def test34_list():
-    assert t.identity_list([]) == []
-    assert t.identity_list([1, 2, 3]) == [1, 2, 3]
-    assert t.identity_list(()) == []
-    assert t.identity_list((1, 2, 3)) == [1, 2, 3]
-
-
-def test35_string_and_string_view():
-    assert t.identity_string("") == ""
-    assert t.identity_string("orange") == "orange"
-    assert t.identity_string("橘子") == "橘子"
-    assert t.identity_string("ส้ม") == "ส้ม"
-    assert t.identity_string("البرتقالي") == "البرتقالي"
-    assert t.identity_string("🍊") == "🍊"
-
-    assert t.identity_string_view("") == ""
-    assert t.identity_string_view("orange") == "orange"
-    assert t.identity_string_view("橘子") == "橘子"
-    assert t.identity_string_view("ส้ม") == "ส้ม"
-    assert t.identity_string_view("البرتقالي") == "البرتقالي"
-    assert t.identity_string_view("🍊") == "🍊"
-
-
-def test36_std_optional_copyable(clean):
-    t.optional_copyable(t.Copyable())
-    opt_copyable = optional("test_stl_ext.Copyable")
-    assert t.optional_copyable.__doc__ == (
-        f"optional_copyable(x: {opt_copyable}) -> None"
-    )
-    assert_stats(default_constructed=1, copy_constructed=1, destructed=2)
-
-
-def test37_std_optional_copyable_ptr(clean):
-    t.optional_copyable_ptr(t.Copyable())
-    opt_copyable = optional("test_stl_ext.Copyable")
-    assert t.optional_copyable_ptr.__doc__ == (
-        f"optional_copyable_ptr(x: {opt_copyable}) -> None"
-    )
-    assert_stats(default_constructed=1, destructed=1)
-
-
-def test38_std_optional_none():
-    t.optional_none(None)
-    assert t.optional_cstr(None) == "none"
-    assert t.optional_cstr("hi") == "hi"
-
-
-def test39_std_optional_ret_opt_movable(clean):
-    assert t.optional_ret_opt_movable().value == 5
-    opt_movable = optional("test_stl_ext.Movable")
-    assert t.optional_ret_opt_movable.__doc__ == (
-        f"optional_ret_opt_movable() -> {opt_movable}"
-    )
-    assert_stats(default_constructed=1, move_constructed=2, destructed=3)
-
-
-def test40_std_optional_ret_opt_movable_ptr(clean):
-    assert t.optional_ret_opt_movable_ptr().value == 5
-    assert_stats(default_constructed=1, destructed=1)
-
-
-def test41_std_optional_ret_opt_none():
-    assert t.optional_ret_opt_none() is None
-
-
-def test42_std_optional_unbound_type():
-    for method_name in (
-        "optional_unbound_type",
-        "optional_unbound_type_with_nullopt_as_default",
-    ):
-        method = getattr(t, method_name)
-        assert method(3) == 3
-        assert method(None) is None
-        assert method() is None
-        opt_int = optional("int")
-        assert method.__doc__ == (f"{method_name}(x: {opt_int} = None) -> {opt_int}")
-
-
-def test42a_std_optional_non_assignable():
-    assert t.optional_non_assignable(t.NonAssignable()).value == 5
-
-
-def test43_std_variant_copyable(clean):
-    t.variant_copyable(t.Copyable())
-    t.variant_copyable(5)
-    arg_t = union('test_stl_ext.Copyable', 'int')
-    assert t.variant_copyable.__doc__ == (
-        f"variant_copyable(arg: {arg_t}, /) -> None"
-    )
-    assert_stats(default_constructed=3, copy_assigned=1, destructed=3)
-
-
-def test44_std_variant_copyable_none(clean):
-    t.variant_copyable_none(t.Copyable())
-    t.variant_copyable_none(5)
-    t.variant_copyable_none(None)
-    arg_t = optional(union("int", "test_stl_ext.Copyable"))
-    assert t.variant_copyable_none.__doc__ == (
-        f"variant_copyable_none(x: {arg_t}) -> None"
-    )
-    assert_stats(default_constructed=1, copy_constructed=1, destructed=2)
-
-
-def test45_std_variant_copyable_ptr(clean):
-    t.variant_copyable_ptr(t.Copyable())
-    t.variant_copyable_ptr(5)
-    arg_t = union("test_stl_ext.Copyable", "int")
-    assert t.variant_copyable_ptr.__doc__ == (
-        f"variant_copyable_ptr(arg: {arg_t}, /) -> None"
-    )
-    assert_stats(default_constructed=1, destructed=1)
-
-
-def test46_std_variant_copyable_ptr_none(clean):
-    t.variant_copyable_ptr_none(t.Copyable())
-    t.variant_copyable_ptr_none(5)
-    t.variant_copyable_ptr_none(None)
-    arg_t = optional(union("test_stl_ext.Copyable", "int"))
-    assert t.variant_copyable_ptr_none.__doc__ == (
-        f"variant_copyable_ptr_none(x: {arg_t}) -> None"
-    )
-    assert_stats(default_constructed=1, destructed=1)
-
-
-def test47_std_variant_ret_var_copyable():
-    assert t.variant_ret_var_copyable().value == 5
-    rv_t = union("test_stl_ext.Copyable", "int")
-    assert t.variant_ret_var_copyable.__doc__ == (
-        f"variant_ret_var_copyable() -> {rv_t}"
-    )
-
-
-def test48_std_variant_ret_var_none():
-    assert t.variant_ret_var_none() is None
-
-    rv_t = union("None", "test_stl_ext.Copyable", "int")
-    assert t.variant_ret_var_none.__doc__ == (f"variant_ret_var_none() -> {rv_t}")
-
-
-def test49_std_variant_unbound_type():
-    assert t.variant_unbound_type() is None
-    assert t.variant_unbound_type(None) is None
-    assert t.variant_unbound_type([5]) == [5]
-    assert t.variant_unbound_type((1, 2, 3)) == (1, 2, 3)
-    assert t.variant_unbound_type(5) == 5
-    arg_t = optional(union("list", "tuple", "int"))
-    rv_t = union("None", "list", "tuple", "int")
-    assert t.variant_unbound_type.__doc__ == (
-        f"variant_unbound_type(x: {arg_t} = None) -> {rv_t}"
-    )
-
-def test49b_std_variant_nondefault(clean):
-    assert t.variant_nondefault(t.NonDefaultConstructible(10)) == 10
-    assert t.variant_nondefault(20) == -20
-    assert_stats(
-        value_constructed=1, # constructed in NonDefaultConstructible pyobject
-        copy_constructed=1, # copied into type_caster variant member
-        move_constructed=1, # moved into function argument value
-        destructed=3,
-    )
-
-def test50_map_return_movable_value():
-    for i, (k, v) in enumerate(sorted(t.map_return_movable_value().items())):
-        assert k == chr(ord("a") + i)
-        assert v.value == i
-        assert t.map_return_movable_value.__doc__ == (
-            f"map_return_movable_value() -> {TYPING_DICT}[str, test_stl_ext.Movable]"
-        )
-
-
-def test51_map_return_copyable_value():
-    for i, (k, v) in enumerate(sorted(t.map_return_copyable_value().items())):
-        assert k == chr(ord("a") + i)
-        assert v.value == i
-        assert t.map_return_copyable_value.__doc__ == (
-            f"map_return_copyable_value() -> {TYPING_DICT}[str, test_stl_ext.Copyable]"
-        )
-
-
-def test52_map_movable_in_value():
-    t.map_movable_in_value(dict([(chr(ord("a") + i), t.Movable(i)) for i in range(10)]))
-    assert t.map_movable_in_value.__doc__ == (
-        f"map_movable_in_value(x: {TYPING_ABC}.Mapping[str, test_stl_ext.Movable]) -> None"
-    )
-
-
-def test53_map_copyable_in_value():
-    t.map_copyable_in_value(
-        dict([(chr(ord("a") + i), t.Copyable(i)) for i in range(10)])
-    )
-    assert t.map_copyable_in_value.__doc__ == (
-        f"map_copyable_in_value(x: {TYPING_ABC}.Mapping[str, test_stl_ext.Copyable]) -> None"
-    )
-
-
-def test54_map_movable_in_lvalue_ref():
-    t.map_movable_in_lvalue_ref(
-        dict([(chr(ord("a") + i), t.Movable(i)) for i in range(10)])
-    )
-    assert t.map_movable_in_lvalue_ref.__doc__ == (
-        f"map_movable_in_lvalue_ref(x: {TYPING_ABC}.Mapping[str, test_stl_ext.Movable]) -> None"
-    )
-
-
-def test55_map_movable_in_rvalue_ref():
-    t.map_movable_in_rvalue_ref(
-        dict([(chr(ord("a") + i), t.Movable(i)) for i in range(10)])
-    )
-    assert t.map_movable_in_rvalue_ref.__doc__ == (
-        f"map_movable_in_rvalue_ref(x: {TYPING_ABC}.Mapping[str, test_stl_ext.Movable]) -> None"
-    )
-
-
-def test56_map_movable_in_ptr():
-    t.map_movable_in_ptr(dict([(chr(ord("a") + i), t.Movable(i)) for i in range(10)]))
-    assert t.map_movable_in_ptr.__doc__ == (
-        f"map_movable_in_ptr(x: {TYPING_ABC}.Mapping[str, test_stl_ext.Movable]) -> None"
-    )
-
-
-def test57_map_return_readonly_value():
-    for i, (k, v) in enumerate(sorted(t.map_return_readonly_value().map.items())):
-        assert k == chr(ord("a") + i)
-        assert v == i
-    assert t.map_return_readonly_value.__doc__ == (
-        "map_return_readonly_value() -> test_stl_ext.StructWithReadonlyMap"
-    )
-
-
-def test58_array():
-    o = t.array_out()
-    assert isinstance(o, list) and o == [1, 2, 3]
-    assert t.array_in([1, 2, 3]) == 6
-    assert t.array_in((1, 2, 3)) == 6
-    with pytest.raises(TypeError) as excinfo:
-        assert t.array_in((1, 2, 3, 4)) == 6
-    assert "incompatible function arguments" in str(excinfo.value)
-
-
-def test59_map_movable_in_failure():
-    with pytest.raises(TypeError) as excinfo:
-        t.map_copyable_in_value({1: 2})
-    assert "incompatible function arguments" in str(excinfo.value)
-
-
-def test60_set_return_value():
-    for i, k in enumerate(sorted(t.set_return_value())):
-        assert k == chr(ord("a") + i)
-    for i, k in enumerate(sorted(t.unordered_set_return_value())):
-        assert k == chr(ord("a") + i)
-    assert t.set_return_value.__doc__ == (f"set_return_value() -> {TYPING_SET}[str]")
-    assert t.unordered_set_return_value.__doc__ == (
-        f"unordered_set_return_value() -> {TYPING_SET}[str]"
-    )
-
-
-def test61_set_in_value():
-    t.set_in_value(set([chr(ord("a") + i) for i in range(10)]))
-    t.unordered_set_in_value(set([chr(ord("a") + i) for i in range(10)]))
-    assert t.set_in_value.__doc__ == (
-        f"set_in_value(x: {TYPING_ABSTRACT_SET}[str]) -> None"
-    )
-    assert t.unordered_set_in_value.__doc__ == (
-        f"unordered_set_in_value(x: {TYPING_ABSTRACT_SET}[str]) -> None"
-    )
-
-
-def test62_set_in_lvalue_ref():
-    t.set_in_lvalue_ref(set([chr(ord("a") + i) for i in range(10)]))
-    assert t.set_in_lvalue_ref.__doc__ == (
-        f"set_in_lvalue_ref(x: {TYPING_ABSTRACT_SET}[str]) -> None"
-    )
-
-
-def test63_set_in_rvalue_ref():
-    t.set_in_rvalue_ref(set([chr(ord("a") + i) for i in range(10)]))
-    assert t.set_in_rvalue_ref.__doc__ == (
-        f"set_in_rvalue_ref(x: {TYPING_ABSTRACT_SET}[str]) -> None"
-    )
-
-
-def test64_set_in_failure():
-    with pytest.raises(TypeError) as excinfo:
-        t.set_in_value(set([i for i in range(10)]))
-    assert "incompatible function arguments" in str(excinfo.value)
-
-
-def test65_class_with_movable_field(clean):
-    cwmf = t.ClassWithMovableField()
-    m1 = t.Movable(1)
-    m2 = t.Movable(2)
-
-    assert_stats(value_constructed=2)
-
-    cwmf.movable = [m1, m2]
-
-    assert_stats(value_constructed=2, copy_constructed=2)
-
-    del m1, m2
-    collect()
-
-    assert_stats(value_constructed=2, copy_constructed=2, destructed=2)
-
-    del cwmf
-    collect()
-
-    assert_stats(value_constructed=2, copy_constructed=2, destructed=4)
-
-
-def test66_replace_extension():
-    from pathlib import Path
-
-    if not hasattr(t, "replace_extension"):
-        pytest.skip("filesystem tests not compiled")
-
-    filename = Path("test.txt")
-    assert t.replace_extension(filename, ".obj") == filename.with_suffix(".obj")
-
-    filename = Path("🍊.html")
-    assert t.replace_extension(filename, ".svg") == filename.with_suffix(".svg")
-
-    class PseudoStrPath:
-        def __fspath__(self):
-            return "foo/bar"
-
-    class PseudoBytesPath:
-        def __fspath__(self):
-            return b"foo/bar"
-
-    assert t.parent_path(Path("foo/bar")) == Path("foo")
-    assert t.parent_path("foo/bar") == Path("foo")
-    assert t.parent_path(b"foo/bar") == Path("foo")
-    assert t.parent_path(PseudoStrPath()) == Path("foo")
-    assert t.parent_path(PseudoBytesPath()) == Path("foo")
-
-
-def test67_vector_bool():
-    bool_vector = [True, False, True, False]
-    result = t.flip_vector_bool(bool_vector)
-    assert result == [not x for x in bool_vector]
-
-
-def test68_complex_value():
-    # double: 64bits
-    assert t.complex_value_double(1.0) == complex(1.0)
-    assert t.complex_value_double(1.0j) == 1.0j
-    assert t.complex_value_double(0.0) == complex(0.0)
-    assert t.complex_value_double(0.0j) == 0.0j
-    assert t.complex_value_double(0) == complex(0.0)
-    assert t.complex_value_double_nc(1.0 + 2.0j) == 1.0 + 2.0j
-    assert t.complex_value_double_nc(1.0j) == 1.0j
-    assert t.complex_value_double_nc(0.0 + 0.0j) == complex(0.0)
-    assert t.complex_value_double_nc(0.0j) == 0.0j
-    with pytest.raises(TypeError, match="incompatible function arguments"):
-        t.complex_value_double_nc(0)
-    with pytest.raises(TypeError, match="incompatible function arguments"):
-        t.complex_value_double_nc(0.0)
-
-    # float: 32bits
-    assert t.complex_value_float(1.0) == complex(1.0)
-    assert t.complex_value_float(1.0j) == 1.0j
-    assert t.complex_value_float(0.0) == complex(0.0)
-    assert t.complex_value_float(0.0j) == 0.0j
-    assert t.complex_value_float(0) == complex(0.0)
-    assert t.complex_value_float_nc(1.0 + 2.0j) == 1.0 + 2.0j
-    assert t.complex_value_float_nc(1.0j) == 1.0j
-    assert t.complex_value_float_nc(0.0 + 0.0j) == complex(0.0)
-    assert t.complex_value_float_nc(0.0j) == 0.0j
-    with pytest.raises(TypeError, match="incompatible function arguments"):
-        t.complex_value_float_nc(0)
-    with pytest.raises(TypeError, match="incompatible function arguments"):
-        t.complex_value_float_nc(0.0)
-    with pytest.raises(TypeError, match="incompatible function arguments"):
-        t.complex_value_float_nc(1.1 + 2.0j)  # Inexact narrowing conversion
-    with pytest.raises(TypeError, match="incompatible function arguments"):
-        t.complex_value_float_nc(1.0 + 2.1j)  # Inexact narrowing conversion
-
-    val_64 = 2.7 - 3.2j
-    val_32 = 2.700000047683716 - 3.200000047683716j
-    assert val_64 != val_32
-
-    assert t.complex_value_double(val_32) == val_32
-    assert t.complex_value_double(val_64) == val_64
-    assert t.complex_value_double_nc(val_32) == val_32
-    assert t.complex_value_double_nc(val_64) == val_64
-
-    assert t.complex_value_float(val_32) == val_32
-    assert t.complex_value_float(val_64) == val_32
-    assert t.complex_value_float_nc(val_32) == val_32
-    with pytest.raises(TypeError, match="incompatible function arguments"):
-        t.complex_value_float_nc(val_64)  # Inexact narrowing conversion
-
-    with pytest.raises(TypeError, match="incompatible function arguments"):
-        t.complex_value_float([])
-
-    class MyInt(int):
-        def __new__(cls, value):
-            return super().__new__(cls, value)
-
-    assert t.complex_value_double(MyInt(7)) == complex(7.0)
-    assert t.complex_value_float(MyInt(7)) == complex(7.0)
-    with pytest.raises(TypeError, match="incompatible function arguments"):
-        t.complex_value_double_nc(MyInt(7))
-    with pytest.raises(TypeError, match="incompatible function arguments"):
-        t.complex_value_float_nc(MyInt(7))
-
-    class MyComplex:
-        def __init__(self, real, imag):
-            self.re = real
-            self.im = imag
-        def __complex__(self):
-            return complex(self.re, self.im)
-
-    assert t.complex_value_double(MyComplex(1, 2)) == complex(1.0, 2.0)
-    assert t.complex_value_float(MyComplex(1, 2)) == complex(1.0, 2.0)
-    with pytest.raises(TypeError, match="incompatible function arguments"):
-        t.complex_value_double_nc(MyComplex(1, 2))
-    with pytest.raises(TypeError, match="incompatible function arguments"):
-        t.complex_value_float_nc(MyComplex(1, 2))
-
-    class MyComplexSubclass(complex): ...
-
-    assert t.complex_value_double(MyComplexSubclass(1, 2)) == complex(1.0, 2.0)
-    assert t.complex_value_float(MyComplexSubclass(1, 2)) == complex(1.0, 2.0)
-    with pytest.raises(TypeError, match="incompatible function arguments"):
-        t.complex_value_double_nc(MyComplexSubclass(1, 2))
-    with pytest.raises(TypeError, match="incompatible function arguments"):
-        t.complex_value_float_nc(MyComplexSubclass(1, 2))
-
-    try:
-        import numpy as np
-
-        assert t.complex_value_float(np.complex64(val_32)) == val_32
-        assert t.complex_value_float(np.complex64(val_64)) == val_32
-        assert t.complex_value_double(np.complex64(val_32)) == val_32
-        assert t.complex_value_double(np.complex64(val_64)) == val_32
-
-        assert t.complex_value_float(np.complex128(val_32)) == val_32
-        assert t.complex_value_float(np.complex128(val_64)) == val_32
-        assert t.complex_value_double(np.complex128(val_32)) == val_32
-        assert t.complex_value_double(np.complex128(val_64)) == val_64
-
-        with pytest.raises(TypeError, match="incompatible function arguments"):
-            t.complex_value_double_nc(np.complex128(val_64))
-        with pytest.raises(TypeError, match="incompatible function arguments"):
-            t.complex_value_float_nc(np.complex64(val_32))
-
-    except ImportError:
-        pass
-
-
-def test69_complex_array():
-    val1_64 = 2.7 - 3.2j
-    val1_32 = 2.700000047683716 - 3.200000047683716j
-    val2_64 = 3.1415
-    val2_32 = 3.1414999961853027 + 0j
-
-    # test 64 bit casts
-    assert t.complex_array_double([val1_64, -1j, val2_64]) == [
-        val1_64,
-        -0 - 1j,
-        val2_64,
-    ]
-
-    # test 32 bit casts
-    assert t.complex_array_float([val1_64, -1j, val2_64]) == [
-        val1_32,
-        (-0 - 1j),
-        val2_32,
-    ]
-
-    with pytest.raises(TypeError, match="incompatible function arguments"):
-        t.complex_array_float([[]])
-
-    try:
-        import numpy as np
-
-        # test 64 bit casts
-        assert t.complex_array_double(np.array([val1_64, -1j, val2_64])) == [
-            val1_64,
-            -0 - 1j,
-            val2_64,
-        ]
-        assert t.complex_array_double(
-            np.array([val1_64, -1j, val2_64], dtype=np.complex128)
-        ) == [val1_64, -0 - 1j, val2_64]
-        assert t.complex_array_double(
-            np.array([val1_64, -1j, val2_64], dtype=np.complex64)
-        ) == [val1_32, -0 - 1j, val2_32]
-
-        # test 32 bit casts
-        assert t.complex_array_float(np.array([val1_64, -1j, val2_64])) == [
-            val1_32,
-            (-0 - 1j),
-            val2_32,
-        ]
-        assert t.complex_array_float(
-            np.array([val1_64, -1j, val2_64], dtype=np.complex128)
-        ) == [val1_32, (-0 - 1j), val2_32]
-        assert t.complex_array_float(
-            np.array([val1_64, -1j, val2_64], dtype=np.complex64)
-        ) == [val1_32, (-0 - 1j), val2_32]
-    except ImportError:
-        pass
-
-
-def test70_vec_char():
-    assert isinstance(t.vector_str("123"), str)
-    assert isinstance(t.vector_str(["123", "345"]), list)
-    assert t.vector_optional_str(["abc", None]) == ["abc", None]
-
-
-def test71_null_input():
-    with pytest.raises(TypeError):
-        t.vec_movable_in_value([None])
-    with pytest.raises(TypeError):
-        t.map_copyable_in_value({"a": None})
-
-@skip_on_pypy # PyPy fails this test on Windows :-(
-def test72_wstr():
-    assert t.pass_wstr('🎈') == '🎈'
-
-def test73_bad_input_to_set():
-    with pytest.raises(TypeError):
-        t.set_in_value(None)
-
-def test74_variant_implicit_conversions():
-    event = t.IDHavingEvent()
-    assert event.id is None
-    event.id = t.BasicID1(78)
-    assert type(event.id) is t.BasicID1
diff --git a/src/nanobind/tests/test_stl_bind_map.cpp b/src/nanobind/tests/test_stl_bind_map.cpp
deleted file mode 100644
index 6c933ab..0000000
--- a/src/nanobind/tests/test_stl_bind_map.cpp
+++ /dev/null
@@ -1,94 +0,0 @@
-#include <map>
-#include <string>
-#include <unordered_map>
-#include <vector>
-
-#include <nanobind/stl/bind_map.h>
-#include <nanobind/stl/string.h>
-#include <nanobind/stl/vector.h>
-
-namespace nb = nanobind;
-
-// testing for insertion of non-copyable class
-class E_nc {
-public:
-    explicit E_nc(int i) : value{i} {}
-    E_nc(const E_nc &) = delete;
-    E_nc &operator=(const E_nc &) = delete;
-    E_nc(E_nc &&) = default;
-    E_nc &operator=(E_nc &&) = default;
-
-    int value;
-};
-
-template <class Map>
-Map *times_ten(int n) {
-    auto *m = new Map();
-    for (int i = 1; i <= n; i++) {
-        m->emplace(int(i), E_nc(10 * i));
-    }
-    return m;
-}
-
-template <class NestMap>
-NestMap *times_hundred(int n) {
-    auto *m = new NestMap();
-    for (int i = 1; i <= n; i++) {
-        for (int j = 1; j <= n; j++) {
-            (*m)[i].emplace(int(j * 10), E_nc(100 * j));
-        }
-    }
-    return m;
-}
-
-NB_MODULE(test_stl_bind_map_ext, m) {
-    // test_map_string_double
-    nb::bind_map<std::map<std::string, double>>(m, "MapStringDouble");
-    nb::bind_map<std::unordered_map<std::string, double>>(m, "UnorderedMapStringDouble");
-    // test_map_string_double_const
-    nb::bind_map<std::map<std::string, double const>>(m, "MapStringDoubleConst");
-    nb::bind_map<std::unordered_map<std::string, double const>>(m,
-                                                                "UnorderedMapStringDoubleConst");
-
-    nb::class_<E_nc>(m, "ENC").def(nb::init<int>()).def_rw("value", &E_nc::value);
-
-    // On Windows, NVCC has difficulties with the following code. My guess is that
-    // decltype() in the iterator_value_access macro used in bind_map.h loses a reference.
-#if defined(_WIN32) && !defined(__CUDACC__)
-    // By default, the bindings produce a __getitem__ that makes a copy, which
-    // won't take this non-copyable type: (uncomment to verify build error)
-    //nb::bind_map<std::map<int, E_nc>>(m, "MapENC");
-    //nb::bind_map<std::unordered_map<int, E_nc>>(m, "UmapENC");
-
-    // But we can request reference semantics instead (some care required, read
-    // the documentation):
-    nb::bind_map<std::map<int, E_nc>,
-                 nb::rv_policy::reference_internal>(m, "MapENC");
-    nb::bind_map<std::unordered_map<int, E_nc>,
-                 nb::rv_policy::reference_internal>(m, "UmapENC");
-
-    m.def("get_mnc", &times_ten<std::map<int, E_nc>>);
-    m.def("get_umnc", &times_ten<std::unordered_map<int, E_nc>>);
-
-    // pybind11 issue #1885: binding nested std::map<X, Container<E>>
-    // with E non-copyable
-    nb::bind_map<std::map<int, std::vector<E_nc>>,
-                 nb::rv_policy::reference_internal>(m, "MapVecENC");
-    m.def("get_nvnc", [](int n) {
-        auto *m = new std::map<int, std::vector<E_nc>>();
-        for (int i = 1; i <= n; i++) {
-            for (int j = 1; j <= n; j++) {
-                (*m)[i].emplace_back(j);
-            }
-        }
-        return m;
-    });
-
-    nb::bind_map<std::map<int, std::map<int, E_nc>>,
-                 nb::rv_policy::reference_internal>(m, "MapMapENC");
-    m.def("get_nmnc", &times_hundred<std::map<int, std::map<int, E_nc>>>);
-    nb::bind_map<std::unordered_map<int, std::unordered_map<int, E_nc>>,
-                 nb::rv_policy::reference_internal>(m, "UmapUmapENC");
-    m.def("get_numnc", &times_hundred<std::unordered_map<int, std::unordered_map<int, E_nc>>>);
-#endif
-}
diff --git a/src/nanobind/tests/test_stl_bind_map.py b/src/nanobind/tests/test_stl_bind_map.py
deleted file mode 100644
index e8823d8..0000000
--- a/src/nanobind/tests/test_stl_bind_map.py
+++ /dev/null
@@ -1,222 +0,0 @@
-import pytest
-import sys
-import platform
-
-import test_stl_bind_map_ext as t
-
-
-def test_map_string_double(capfd):
-    mm = t.MapStringDouble()
-    mm["a"] = 1
-    mm["b"] = 2.5
-
-    assert list(mm) == ["a", "b"]
-    assert "b" in mm
-    assert 123 not in mm
-    assert mm["b"] == 2.5
-
-    assert "c" not in mm
-    with pytest.raises(KeyError):
-        mm["c"]
-    assert "c" not in mm
-
-    # Copy constructor
-    mm2 = t.MapStringDouble(mm)
-    assert list(mm2) == ["a", "b"]
-    assert "b" in mm2
-    assert "c" not in mm2
-    assert 123 not in mm2
-    assert mm2["b"] == 2.5
-    assert mm == mm2
-    assert not (mm != mm2)
-    del mm2["b"]
-    assert not (mm == mm2)
-    assert mm != mm2
-    assert len(mm2) == 1
-    mm2.clear()
-    assert len(mm2) == 0
-    assert repr(mm) == "test_stl_bind_map_ext.MapStringDouble({'a': 1.0, 'b': 2.5})"
-
-    with pytest.raises(TypeError):
-        mm2.update({"a" : "b"})
-    captured = capfd.readouterr().err.strip()
-    ref = "nanobind: implicit conversion from type 'dict' to type 'test_stl_bind_map_ext.MapStringDouble' failed!"
-
-    # Work around Pytest-related flakiness (https://github.com/pytest-dev/pytest/issues/10843)
-    if platform.system() == 'Windows':
-        assert captured == ref or captured == ''
-    else:
-        assert captured == ref
-
-    mm2.update({"a" : 2.5})
-    assert len(mm2) == 1
-
-    # Construction from an iterable
-    mm3 = t.MapStringDouble(
-        { "a" : 1, "b" : 2.5 })
-    assert list(mm3) == ["a", "b"]
-    assert mm3["b"] == 2.5
-
-    # Check that keys, values, items are views, not merely iterable
-    keys = mm.keys()
-    values = mm.values()
-    items = mm.items()
-    assert list(keys) == ["a", "b"]
-    assert len(keys) == 2
-    assert "a" in keys
-    assert "c" not in keys
-    assert 123 not in keys
-    assert list(items) == [("a", 1), ("b", 2.5)]
-    assert len(items) == 2
-    assert ("b", 2.5) in items
-    assert "hello" not in items
-    assert ("b", 2.5, None) not in items
-    assert list(values) == [1, 2.5]
-    assert len(values) == 2
-    assert 1 in values
-    assert 2 not in values
-
-    # Check that views update when the map is updated
-    mm["c"] = -1
-    assert list(keys) == ["a", "b", "c"]
-    assert list(values) == [1, 2.5, -1]
-    assert list(items) == [("a", 1), ("b", 2.5), ("c", -1)]
-
-    um = t.UnorderedMapStringDouble()
-    um["ua"] = 1.1
-    um["ub"] = 2.6
-
-    assert sorted(list(um)) == ["ua", "ub"]
-    assert list(um.keys()) == list(um)
-    assert sorted(list(um.items())) == [("ua", 1.1), ("ub", 2.6)]
-    assert list(zip(um.keys(), um.values())) == list(um.items())
-
-    assert type(keys).__qualname__ == 'MapStringDouble.KeyView'
-    assert type(values).__qualname__ == 'MapStringDouble.ValueView'
-    assert type(items).__qualname__ == 'MapStringDouble.ItemView'
-
-    if sys.version_info < (3, 9):
-        d = "typing.Dict"
-    else:
-        d = "dict"
-
-    assert t.MapStringDouble.__init__.__doc__ == \
-"""__init__(self) -> None
-__init__(self, arg: test_stl_bind_map_ext.MapStringDouble) -> None
-__init__(self, arg: %s[str, float], /) -> None
-
-Overloaded function.
-
-1. ``__init__(self) -> None``
-
-Default constructor
-
-2. ``__init__(self, arg: test_stl_bind_map_ext.MapStringDouble) -> None``
-
-Copy constructor
-
-3. ``__init__(self, arg: %s[str, float], /) -> None``
-
-Construct from a dictionary""" % (d, d)
-
-
-def test_map_string_double_const():
-    mc = t.MapStringDoubleConst()
-    mc["a"] = 10
-    mc["b"] = 20.5
-
-    umc = t.UnorderedMapStringDoubleConst()
-    umc["a"] = 11
-    umc["b"] = 21.5
-
-    str(umc)
-
-
-def test_maps_with_noncopyable_values():
-    if not hasattr(t, 'get_mnc'):
-        return
-
-    # std::map
-    mnc = t.get_mnc(5)
-    for i in range(1, 6):
-        assert mnc[i].value == 10 * i
-
-    vsum = 0
-    for k, v in mnc.items():
-        assert v.value == 10 * k
-        vsum += v.value
-
-    assert vsum == 150
-
-    # std::unordered_map
-    mnc = t.get_umnc(5)
-    for i in range(1, 6):
-        assert mnc[i].value == 10 * i
-
-    vsum = 0
-    for k, v in mnc.items():
-        assert v.value == 10 * k
-        vsum += v.value
-
-    assert vsum == 150
-
-    # nested std::map<std::vector>
-    nvnc = t.get_nvnc(5)
-    for i in range(1, 6):
-        for j in range(0, 5):
-            assert nvnc[i][j].value == j + 1
-
-    # Note: maps do not have .values()
-    for _, v in nvnc.items():
-        for i, j in enumerate(v, start=1):
-            assert j.value == i
-
-    # nested std::map<std::map>
-    nmnc = t.get_nmnc(5)
-    for i in range(1, 6):
-        for j in range(10, 60, 10):
-            assert nmnc[i][j].value == 10 * j
-
-    vsum = 0
-    for _, v_o in nmnc.items():
-        for k_i, v_i in v_o.items():
-            assert v_i.value == 10 * k_i
-            vsum += v_i.value
-
-    assert vsum == 7500
-
-    # nested std::unordered_map<std::unordered_map>
-    numnc = t.get_numnc(5)
-    for i in range(1, 6):
-        for j in range(10, 60, 10):
-            assert numnc[i][j].value == 10 * j
-
-    vsum = 0
-    for _, v_o in numnc.items():
-        for k_i, v_i in v_o.items():
-            assert v_i.value == 10 * k_i
-            vsum += v_i.value
-
-    assert vsum == 7500
-
-
-def test_map_delitem():
-    mm = t.MapStringDouble()
-    mm["a"] = 1
-    mm["b"] = 2.5
-
-    assert list(mm) == ["a", "b"]
-    assert list(mm.items()) == [("a", 1), ("b", 2.5)]
-    del mm["a"]
-    assert list(mm) == ["b"]
-    assert list(mm.items()) == [("b", 2.5)]
-
-    um = t.UnorderedMapStringDouble()
-    um["ua"] = 1.1
-    um["ub"] = 2.6
-
-    assert sorted(list(um)) == ["ua", "ub"]
-    assert sorted(list(um.items())) == [("ua", 1.1), ("ub", 2.6)]
-    del um["ua"]
-    assert sorted(list(um)) == ["ub"]
-    assert sorted(list(um.items())) == [("ub", 2.6)]
diff --git a/src/nanobind/tests/test_stl_bind_vector.cpp b/src/nanobind/tests/test_stl_bind_vector.cpp
deleted file mode 100644
index b16bb0d..0000000
--- a/src/nanobind/tests/test_stl_bind_vector.cpp
+++ /dev/null
@@ -1,56 +0,0 @@
-#include <nanobind/stl/bind_vector.h>
-#include <nanobind/stl/shared_ptr.h>
-
-namespace nb = nanobind;
-
-NB_MODULE(test_stl_bind_vector_ext, m) {
-    nb::bind_vector<std::vector<unsigned int>>(m, "VectorInt");
-    nb::bind_vector<std::vector<bool>>(m, "VectorBool");
-
-    // Ensure that a repeated binding call is ignored
-    nb::bind_vector<std::vector<bool>>(m, "VectorBool");
-
-    struct El {
-        explicit El(int v) : a(v) {}
-        int a;
-    };
-
-    // test_vector_custom
-    nb::class_<El>(m, "El").def(nb::init<int>())
-        .def_rw("a", &El::a);
-    nb::bind_vector<std::vector<El>>(m, "VectorEl");
-    nb::bind_vector<std::vector<std::vector<El>>>(m, "VectorVectorEl");
-
-    // test_vector_shared_ptr
-    nb::bind_vector<std::vector<std::shared_ptr<El>>>(m, "VectorElShared");
-
-    struct E_nc {
-        explicit E_nc(int i) : value{i} {}
-        E_nc(const E_nc &) = delete;
-        E_nc &operator=(const E_nc &) = delete;
-        E_nc(E_nc &&) = default;
-        E_nc &operator=(E_nc &&) = default;
-
-        int value;
-    };
-
-    // test_noncopyable_containers
-    nb::class_<E_nc>(m, "ENC")
-        .def(nb::init<int>())
-        .def_rw("value", &E_nc::value);
-
-    // By default, the bindings produce a __getitem__ that makes a copy, which
-    // won't take this non-copyable type: (uncomment to verify build error)
-    //nb::bind_vector<std::vector<E_nc>>(m, "VectorENC");
-
-    // But we can request reference semantics instead (extreme care required,
-    // read the documentation):
-    nb::bind_vector<std::vector<E_nc>,
-                    nb::rv_policy::reference_internal>(m, "VectorENC");
-    m.def("get_vnc", [](int n) {
-        std::vector<E_nc> result;
-        for (int i = 1; i <= n; i++)
-            result.emplace_back(i);
-        return result;
-    });
-}
diff --git a/src/nanobind/tests/test_stl_bind_vector.py b/src/nanobind/tests/test_stl_bind_vector.py
deleted file mode 100644
index 8cd2d91..0000000
--- a/src/nanobind/tests/test_stl_bind_vector.py
+++ /dev/null
@@ -1,188 +0,0 @@
-import pytest
-import platform
-
-import test_stl_bind_vector_ext as t
-
-def test01_vector_int(capfd):
-    v_int = t.VectorInt([0, 0])
-    assert len(v_int) == 2
-    assert bool(v_int) is True
-
-    # test construction from a generator
-    v_int1 = t.VectorInt(x for x in range(5))
-    assert t.VectorInt(v_int1) == t.VectorInt([0, 1, 2, 3, 4])
-    assert repr(v_int1) == "test_stl_bind_vector_ext.VectorInt([0, 1, 2, 3, 4])"
-
-    v_int2 = t.VectorInt([0, 0])
-    assert v_int == v_int2
-    v_int2[1] = 2
-    v_int2[1] -= 1
-    assert v_int2[1] == 1
-    assert v_int != v_int2
-
-    v_int2.append(2)
-    v_int2.insert(0, 1)
-    v_int2.insert(0, 2)
-    v_int2.insert(0, 3)
-    v_int2.insert(6, 3)
-    with pytest.raises(IndexError):
-        v_int2.insert(8, 4)
-
-    v_int.append(99)
-    v_int2[2:-2] = v_int
-    assert v_int2 == t.VectorInt([3, 2, 0, 0, 99, 2, 3])
-    del v_int2[1:3]
-    assert v_int2 == t.VectorInt([3, 0, 99, 2, 3])
-    del v_int2[0]
-    assert v_int2 == t.VectorInt([0, 99, 2, 3])
-
-    v_int2.extend(t.VectorInt([4, 5]))
-    assert v_int2 == t.VectorInt([0, 99, 2, 3, 4, 5])
-
-    v_int2.extend([6, 7])
-    assert v_int2 == t.VectorInt([0, 99, 2, 3, 4, 5, 6, 7])
-
-    # test error handling, and that the vector is unchanged
-    with pytest.raises(TypeError):
-        v_int2.extend([8, "a"])
-
-    captured = capfd.readouterr().err.strip()
-    ref = "nanobind: implicit conversion from type 'list' to type 'test_stl_bind_vector_ext.VectorInt' failed!"
-
-    # Work around Pytest-related flakiness (https://github.com/pytest-dev/pytest/issues/10843)
-    if platform.system() == 'Windows':
-        assert captured == ref or captured == ''
-    else:
-        assert captured == ref
-
-    assert v_int2 == t.VectorInt([0, 99, 2, 3, 4, 5, 6, 7])
-
-    # test extending from a generator
-    v_int2.extend(x for x in range(5))
-    assert v_int2 == t.VectorInt([0, 99, 2, 3, 4, 5, 6, 7, 0, 1, 2, 3, 4])
-
-    # Test count feature
-    assert v_int2.count(2) == 2
-    assert v_int2.count(5) == 1
-    assert v_int2.count(8) == 0
-    assert 2 in v_int2
-    assert 5 in v_int2
-    assert 8 not in v_int2
-
-    # test negative indexing
-    assert v_int2[-1] == 4
-
-    # insert with negative index
-    v_int2.insert(-1, 88)
-    assert v_int2 == t.VectorInt([0, 99, 2, 3, 4, 5, 6, 7, 0, 1, 2, 3, 88, 4])
-
-    # delete negative index
-    del v_int2[-1]
-    assert v_int2 == t.VectorInt([0, 99, 2, 3, 4, 5, 6, 7, 0, 1, 2, 3, 88])
-
-    assert v_int2.pop() == 88
-    assert v_int2 == t.VectorInt([0, 99, 2, 3, 4, 5, 6, 7, 0, 1, 2, 3])
-
-    assert v_int2.pop(1) == 99
-    assert v_int2 == t.VectorInt([0, 2, 3, 4, 5, 6, 7, 0, 1, 2, 3])
-
-    v_int2.clear()
-    assert len(v_int2) == 0
-
-
-def test02_vector_bool():
-    vv_c = t.VectorBool()
-    for i in range(9):
-        vv_c.append(i % 2 == 0)
-    for i in range(9):
-        assert vv_c[i] == (i % 2 == 0)
-    assert vv_c.count(True) == 5
-    assert vv_c.count(False) == 4
-
-
-def test03_vector_custom():
-    v_a = t.VectorEl()
-    v_a.append(t.El(1))
-    v_a.append(t.El(2))
-    assert len(v_a) == 2 and v_a[0].a == 1 and v_a[1].a == 2
-
-    vv_a = t.VectorVectorEl()
-    vv_a.append(v_a)
-    v_b = vv_a[0]
-    assert len(v_b) == 2 and v_b[0].a == 1 and v_b[1].a == 2
-
-
-def test04_vector_slicing():
-    l1 = list(range(100))
-    l2 = t.VectorInt(l1)
-
-    def check_same(s):
-        assert l1[s] == l2[s]
-
-    def check_del(s):
-        l1c = type(l1)(l1)
-        l2c = type(l2)(l2)
-        del l1c[s]
-        del l2c[s]
-        l2c = list(l2c)
-        assert l1c == l2c
-
-    check_same(slice(1, 13, 4))
-    check_same(slice(1, 14, 4))
-    check_same(slice(10, 2000, 1))
-    check_same(slice(200, 10, 1))
-    check_same(slice(200, 10, -1))
-    check_same(slice(200, 10, -3))
-    check_del(slice(1, 13, 4))
-    check_del(slice(1, 14, 4))
-    check_del(slice(10, 2000, 1))
-    check_del(slice(200, 10, 1))
-    check_del(slice(200, 10, -1))
-    check_del(slice(200, 10, -3))
-
-
-def test05_vector_non_shared():
-    v = t.VectorEl()
-    v.append(t.El(1))
-    v.append(t.El(2))
-
-    v0, v1 = v[0], v[1]
-    v0.a, v1.a = 100, 200
-
-    assert v[0].a == 1
-    assert v[1].a == 2
-
-    # Check that elements accessed through the iterator *cannot* be modified
-    q = next(iter(v))
-    q.a = 5
-    assert v[0].a == 1
-
-def test06_vector_shared():
-    v = t.VectorElShared()
-    v.append(t.El(1))
-    v.append(t.El(2))
-
-    v0, v1 = v[0], v[1]
-    v0.a, v1.a = 100, 200
-
-    assert v[0].a == 100
-    assert v[1].a == 200
-
-    # Check that elements accessed through the iterator *can* be modified
-    q = next(iter(v))
-    q.a = 5
-    assert v[0].a == 5
-
-
-def test07_vector_noncopyable():
-    vnc = t.get_vnc(5)
-    for i in range(0, 5):
-        assert vnc[i].value == i + 1
-
-    for i, j in enumerate(vnc, start=1):
-        assert j.value == i
-
-    # Check that elements accessed through the iterator *can* be modified
-    q = next(iter(vnc))
-    q.value = 5
-    assert vnc[0].value == 5
diff --git a/src/nanobind/tests/test_stl_ext.pyi.ref b/src/nanobind/tests/test_stl_ext.pyi.ref
deleted file mode 100644
index f39f3a1..0000000
--- a/src/nanobind/tests/test_stl_ext.pyi.ref
+++ /dev/null
@@ -1,274 +0,0 @@
-from collections.abc import Callable, Mapping, Sequence, Set
-import os
-import pathlib
-from typing import overload
-
-
-def stats() -> dict: ...
-
-def reset() -> None: ...
-
-class Movable:
-    @overload
-    def __init__(self) -> None: ...
-
-    @overload
-    def __init__(self, arg: int, /) -> None: ...
-
-    @property
-    def value(self) -> int: ...
-
-    @value.setter
-    def value(self, arg: int, /) -> None: ...
-
-class Copyable:
-    @overload
-    def __init__(self) -> None: ...
-
-    @overload
-    def __init__(self, arg: int, /) -> None: ...
-
-    @property
-    def value(self) -> int: ...
-
-    @value.setter
-    def value(self, arg: int, /) -> None: ...
-
-class NonAssignable:
-    def __init__(self) -> None: ...
-
-    @property
-    def value(self) -> int: ...
-
-    @value.setter
-    def value(self, arg: int, /) -> None: ...
-
-class NonDefaultConstructible:
-    def __init__(self, arg: int, /) -> None: ...
-
-    @property
-    def value(self) -> int: ...
-
-    @value.setter
-    def value(self, arg: int, /) -> None: ...
-
-class StructWithReadonlyMap:
-    def __init__(self) -> None: ...
-
-    @property
-    def map(self) -> dict[str, int]: ...
-
-def return_movable() -> Movable: ...
-
-def return_movable_ptr() -> Movable: ...
-
-def movable_in_value(arg: Movable, /) -> None: ...
-
-def movable_in_lvalue_ref(arg: Movable, /) -> None: ...
-
-def movable_in_rvalue_ref(arg: Movable, /) -> None: ...
-
-def movable_in_ptr(arg: Movable, /) -> None: ...
-
-def return_copyable() -> Copyable: ...
-
-def return_copyable_ptr() -> Copyable: ...
-
-def copyable_in_value(arg: Copyable, /) -> None: ...
-
-def copyable_in_lvalue_ref(arg: Copyable, /) -> None: ...
-
-def copyable_in_rvalue_ref(arg: Copyable, /) -> None: ...
-
-def copyable_in_ptr(arg: Copyable, /) -> None: ...
-
-def tuple_return_movable() -> tuple[Movable]: ...
-
-def tuple_return_movable_ptr() -> tuple[Movable]: ...
-
-def tuple_movable_in_value(arg: tuple[Movable], /) -> None: ...
-
-def tuple_movable_in_lvalue_ref(arg: tuple[Movable], /) -> None: ...
-
-def tuple_movable_in_lvalue_ref_2(arg: tuple[Movable], /) -> None: ...
-
-def tuple_movable_in_rvalue_ref(arg: tuple[Movable], /) -> None: ...
-
-def tuple_movable_in_rvalue_ref_2(arg: tuple[Movable], /) -> None: ...
-
-def tuple_movable_in_ptr(arg: tuple[Movable], /) -> None: ...
-
-def empty_tuple(arg: tuple[()], /) -> tuple[()]: ...
-
-def swap_tuple(arg: tuple[int, float], /) -> tuple[float, int]: ...
-
-def swap_pair(arg: tuple[int, float], /) -> tuple[float, int]: ...
-
-def vec_return_movable() -> list[Movable]: ...
-
-def vec_return_copyable() -> list[Copyable]: ...
-
-def vec_movable_in_value(arg: Sequence[Movable], /) -> None: ...
-
-def vec_copyable_in_value(arg: Sequence[Copyable], /) -> None: ...
-
-def vec_movable_in_lvalue_ref(arg: Sequence[Movable], /) -> None: ...
-
-def vec_movable_in_rvalue_ref(arg: Sequence[Movable], /) -> None: ...
-
-def vec_movable_in_ptr_2(arg: Sequence[Movable], /) -> None: ...
-
-class float_vec:
-    def __init__(self) -> None: ...
-
-    def push_back(self, arg: float, /) -> None: ...
-
-    def size(self) -> int: ...
-
-def return_empty_function() -> Callable[[int], int]: ...
-
-def return_function() -> Callable[[int], int]: ...
-
-def call_function(arg0: Callable[[int], int], arg1: int, /) -> int: ...
-
-def return_void_function(arg: Callable[[], None], /) -> Callable[[], None]: ...
-
-def identity_list(arg: Sequence[int], /) -> list[int]: ...
-
-class FuncWrapper:
-    def __init__(self) -> None: ...
-
-    @property
-    def f(self) -> Callable[[], None]: ...
-
-    @f.setter
-    def f(self, arg: Callable[[], None], /) -> None: ...
-
-    alive: int = ...
-    """static read-only property"""
-
-def identity_string(arg: str, /) -> str: ...
-
-def identity_string_view(arg: str, /) -> str: ...
-
-def optional_copyable(x: Copyable | None) -> None: ...
-
-def optional_copyable_ptr(x: Copyable | None) -> None: ...
-
-def optional_none(x: Copyable | None) -> None: ...
-
-def optional_ret_opt_movable() -> Movable | None: ...
-
-def optional_ret_opt_movable_ptr() -> Movable | None: ...
-
-def optional_ret_opt_none() -> Movable | None: ...
-
-def optional_unbound_type(x: int | None = None) -> int | None: ...
-
-def optional_unbound_type_with_nullopt_as_default(x: int | None = None) -> int | None: ...
-
-def optional_non_assignable(arg: NonAssignable, /) -> NonAssignable | None: ...
-
-def variant_copyable(arg: Copyable | int, /) -> None: ...
-
-def variant_copyable_none(x: int | Copyable | None) -> None: ...
-
-def variant_copyable_ptr(arg: Copyable | int, /) -> None: ...
-
-def variant_copyable_ptr_none(x: Copyable | int | None) -> None: ...
-
-def variant_ret_var_copyable() -> Copyable | int: ...
-
-def variant_ret_var_none() -> None | Copyable | int: ...
-
-def variant_unbound_type(x: list | tuple | int | None = None) -> None | list | tuple | int: ...
-
-def variant_nondefault(arg: NonDefaultConstructible | int, /) -> int: ...
-
-def map_return_movable_value() -> dict[str, Movable]: ...
-
-def map_return_copyable_value() -> dict[str, Copyable]: ...
-
-def map_movable_in_value(x: Mapping[str, Movable]) -> None: ...
-
-def map_copyable_in_value(x: Mapping[str, Copyable]) -> None: ...
-
-def map_movable_in_lvalue_ref(x: Mapping[str, Movable]) -> None: ...
-
-def map_movable_in_rvalue_ref(x: Mapping[str, Movable]) -> None: ...
-
-def map_movable_in_ptr(x: Mapping[str, Movable]) -> None: ...
-
-def map_return_readonly_value() -> StructWithReadonlyMap: ...
-
-def array_out() -> list[int]: ...
-
-def array_in(arg: Sequence[int], /) -> int: ...
-
-def set_return_value() -> set[str]: ...
-
-def unordered_set_return_value() -> set[str]: ...
-
-def set_in_value(x: Set[str]) -> None: ...
-
-def unordered_set_in_value(x: Set[str]) -> None: ...
-
-def set_in_lvalue_ref(x: Set[str]) -> None: ...
-
-def set_in_rvalue_ref(x: Set[str]) -> None: ...
-
-def replace_extension(arg0: str | os.PathLike, arg1: str, /) -> pathlib.Path: ...
-
-def parent_path(arg: str | os.PathLike, /) -> pathlib.Path: ...
-
-class ClassWithMovableField:
-    def __init__(self) -> None: ...
-
-    @property
-    def movable(self) -> list[Movable]: ...
-
-    @movable.setter
-    def movable(self, arg: Sequence[Movable], /) -> None: ...
-
-def flip_vector_bool(arg: Sequence[bool], /) -> list[bool]: ...
-
-def complex_value_float(arg: complex, /) -> complex: ...
-
-def complex_value_float_nc(arg: complex) -> complex: ...
-
-def complex_value_double(arg: complex, /) -> complex: ...
-
-def complex_value_double_nc(arg: complex) -> complex: ...
-
-def complex_array_float(arg: Sequence[complex], /) -> list[complex]: ...
-
-def complex_array_double(arg: Sequence[complex], /) -> list[complex]: ...
-
-@overload
-def vector_str(arg: Sequence[str], /) -> list[str]: ...
-
-@overload
-def vector_str(arg: str, /) -> str: ...
-
-def vector_optional_str(arg: Sequence[str | None], /) -> list[str | None]: ...
-
-def pass_wstr(arg: str, /) -> str: ...
-
-def optional_cstr(arg: str | None) -> str: ...
-
-class BasicID1:
-    def __init__(self, arg: int, /) -> None: ...
-
-    def __int__(self) -> int: ...
-
-class BasicID2:
-    def __init__(self, arg: int, /) -> None: ...
-
-class IDHavingEvent:
-    def __init__(self) -> None: ...
-
-    @property
-    def id(self) -> None | BasicID2 | BasicID1: ...
-
-    @id.setter
-    def id(self, arg: BasicID2 | BasicID1, /) -> None: ...
diff --git a/src/nanobind/tests/test_stubs.py b/src/nanobind/tests/test_stubs.py
deleted file mode 100644
index 85146a6..0000000
--- a/src/nanobind/tests/test_stubs.py
+++ /dev/null
@@ -1,72 +0,0 @@
-import os
-import pathlib
-import difflib
-import sys
-import platform
-import pytest
-
-is_unsupported = platform.python_implementation() == 'PyPy' or sys.version_info < (3, 10)
-skip_on_unsupported = pytest.mark.skipif(
-    is_unsupported, reason="Stub generation is only tested on CPython >= 3.10.0")
-
-def remove_platform_dependent(s):
-    '''Remove platform-dependent functions from the stubs'''
-    s2 = []
-    i = 0
-    while i < len(s):
-        v = s[i]
-        if v.startswith('def ret_numpy_half()') or \
-           v.startswith('def test_slots()') or \
-           v.startswith('TypeAlias'):
-            i += 2
-        else:
-            s2.append(v)
-            i += 1
-    return s2
-
-
-ref_paths = list(pathlib.Path(__file__).parent.glob('*.pyi.ref'))
-ref_path_ids = [p.name[:-len('.pyi.ref')] for p in ref_paths]
-assert len(ref_paths) > 0, "Stub reference files not found!"
-
-@skip_on_unsupported
-@pytest.mark.parametrize('p_ref', ref_paths, ids=ref_path_ids)
-def test01_check_stub_refs(p_ref, request):
-    """
-    Check that generated stub files match reference input
-    """
-    if not request.config.getoption('enable-slow-tests') and any(
-        (x in p_ref.name for x in ['jax', 'tensorflow'])):
-        pytest.skip("skipping because slow tests are not enabled")
-
-    p_in = p_ref.with_suffix('')
-    with open(p_ref, 'r') as f:
-        s_ref = f.read().split('\n')
-    with open(p_in, 'r') as f:
-        s_in = f.read().split('\n')
-
-    if "test_functions_ext" in p_in.name and sys.version_info < (3, 13):
-        s_ref = [line.replace("types.CapsuleType", "typing_extensions.CapsuleType") for line in s_ref]
-        s_ref.insert(3, "")
-        s_ref.insert(4, "import typing_extensions")
-
-    s_in = remove_platform_dependent(s_in)
-    s_ref = remove_platform_dependent(s_ref)
-
-    diff = list(difflib.unified_diff(
-        s_ref,
-        s_in,
-        fromfile=str(p_ref),
-        tofile=str(p_in)
-    ))
-    if len(diff):
-        for p in diff:
-            print(p.rstrip(), file=sys.stderr)
-        print(
-            '\nWarning: generated stubs do not match their references. If you\n'
-            'intentionally changed a test suite extension, it may be necessary\n'
-            'to replace the .pyi.ref file with the generated .pyi file. But\n'
-            'please double-check that the change makes sense.',
-            file=sys.stderr
-        )
-        assert False
diff --git a/src/nanobind/tests/test_tensorflow.cpp b/src/nanobind/tests/test_tensorflow.cpp
deleted file mode 100644
index 37088e1..0000000
--- a/src/nanobind/tests/test_tensorflow.cpp
+++ /dev/null
@@ -1,25 +0,0 @@
-#include <nanobind/nanobind.h>
-#include <nanobind/ndarray.h>
-namespace nb = nanobind;
-
-int destruct_count = 0;
-
-
-NB_MODULE(test_tensorflow_ext, m) {
-    m.def("destruct_count", []() { return destruct_count; });
-    m.def("ret_tensorflow", []() {
-        struct alignas(256) Buf {
-            float f[8];
-        };
-        Buf *buf = new Buf({ 1, 2, 3, 4, 5, 6, 7, 8 });
-        size_t shape[2] = { 2, 4 };
-
-        nb::capsule deleter(buf, [](void *data) noexcept {
-           destruct_count++;
-           delete (Buf *) data;
-        });
-
-        return nb::ndarray<nb::tensorflow, float, nb::shape<2, 4>>(buf->f, 2, shape,
-                                                                   deleter);
-    });
-}
diff --git a/src/nanobind/tests/test_tensorflow.py b/src/nanobind/tests/test_tensorflow.py
deleted file mode 100644
index e69de29..0000000
diff --git a/src/nanobind/tests/test_tensorflow_ext.pyi.ref b/src/nanobind/tests/test_tensorflow_ext.pyi.ref
deleted file mode 100644
index d65f43a..0000000
--- a/src/nanobind/tests/test_tensorflow_ext.pyi.ref
+++ /dev/null
@@ -1,4 +0,0 @@
-import tensorflow.python.framework.ops
-
-
-def ret_tensorflow() -> tensorflow.python.framework.ops.EagerTensor[dtype=float32, shape=(2, 4)]: ...
diff --git a/src/nanobind/tests/test_thread.cpp b/src/nanobind/tests/test_thread.cpp
deleted file mode 100644
index 97e8296..0000000
--- a/src/nanobind/tests/test_thread.cpp
+++ /dev/null
@@ -1,71 +0,0 @@
-#include <nanobind/nanobind.h>
-
-namespace nb = nanobind;
-using namespace nb::literals;
-
-struct Counter {
-    size_t value = 0;
-    void inc() { value++; }
-    void merge(Counter &o) {
-        value += o.value;
-        o.value = 0;
-    }
-};
-
-struct GlobalData {} global_data;
-
-nb::ft_mutex mutex;
-
-struct ClassWithProperty {
-public:
-    ClassWithProperty(int value): value_(value) {}
-    int get_prop() const { return value_; }
-private:
-    int value_;
-};
-
-class ClassWithClassProperty {
-public:
-    ClassWithClassProperty(ClassWithProperty value) : value_(std::move(value)) {};
-    const ClassWithProperty& get_prop() const { return value_; }
-private:
-    ClassWithProperty value_;
-};
-
-
-NB_MODULE(test_thread_ext, m) {
-    nb::class_<Counter>(m, "Counter")
-        .def(nb::init<>())
-        .def_ro("value", &Counter::value)
-        .def("inc_unsafe", &Counter::inc)
-        .def("inc_safe", &Counter::inc, nb::lock_self())
-        .def("merge_unsafe", &Counter::merge)
-        .def("merge_safe", &Counter::merge, nb::lock_self(), "o"_a.lock());
-
-    m.def("return_self", [](Counter *c) -> Counter * { return c; });
-
-    m.def("inc_safe",
-          [](Counter &c) { c.inc(); },
-          nb::arg().lock());
-
-    m.def("inc_global",
-          [](Counter &c) {
-              nb::ft_lock_guard guard(mutex);
-              c.inc();
-          }, "counter");
-
-    nb::class_<GlobalData>(m, "GlobalData")
-        .def_static("get", [] { return &global_data; }, nb::rv_policy::reference);
-
-    nb::class_<ClassWithProperty>(m, "ClassWithProperty")
-        .def(nb::init<int>(), nb::arg("value"))
-        .def_prop_ro("prop2", &ClassWithProperty::get_prop);
-
-    nb::class_<ClassWithClassProperty>(m, "ClassWithClassProperty")
-        .def(
-          "__init__",
-          [](ClassWithClassProperty* self, ClassWithProperty value) {
-            new (self) ClassWithClassProperty(std::move(value));
-          }, nb::arg("value"))
-        .def_prop_ro("prop1", &ClassWithClassProperty::get_prop);
-}
diff --git a/src/nanobind/tests/test_thread.py b/src/nanobind/tests/test_thread.py
deleted file mode 100644
index 1d5992e..0000000
--- a/src/nanobind/tests/test_thread.py
+++ /dev/null
@@ -1,102 +0,0 @@
-import test_thread_ext as t
-from test_thread_ext import Counter, GlobalData, ClassWithProperty, ClassWithClassProperty
-from common import parallelize
-
-def test01_object_creation(n_threads=8):
-    # This test hammers 'inst_c2p' from multiple threads, and
-    # checks that the locking of internal data structures works
-
-    n = 100000
-    def f():
-        r = [None]*n
-        for i in range(n):
-            c = Counter()
-            c.inc_unsafe()
-            r[i] = c
-        for i in range(n):
-            assert t.return_self(r[i]) is r[i]
-        return r
-
-    v = parallelize(f, n_threads=n_threads)
-    assert len(v) == n_threads
-    for v2 in v:
-        assert len(v2) == n
-        for v3 in v2:
-            assert v3.value == 1
-
-def test02_global_lock(n_threads=8):
-    # Test that a global PyMutex protects the counter
-    n = 100000
-    c = Counter()
-    def f():
-        for _ in range(n):
-            t.inc_global(c)
-
-    parallelize(f, n_threads=n_threads)
-    assert c.value == n * n_threads
-
-
-def test03_locked_method(n_threads=8):
-    # Checks that nb::lock_self() protects an internal counter
-    n = 100000
-    c = Counter()
-    def f():
-        for i in range(n):
-            c.inc_safe()
-
-    parallelize(f, n_threads=n_threads)
-    assert c.value == n * n_threads
-
-
-def test04_locked_function(n_threads=8):
-    # Checks that nb::lock_self() protects an internal counter
-    n = 100000
-    c = Counter()
-    def f():
-        for _ in range(n):
-            t.inc_safe(c)
-
-    parallelize(f, n_threads=n_threads)
-    assert c.value == n * n_threads
-
-
-def test05_locked_twoargs(n_threads=8):
-    # Check two-argument locking
-    n = 100000
-    c = Counter()
-    def f():
-        c2 = Counter()
-        for i in range(n):
-            c2.inc_unsafe()
-            if i & 1 == 0:
-                c2.merge_safe(c)
-            else:
-                c.merge_safe(c2)
-
-    parallelize(f, n_threads=n_threads)
-    assert c.value == n * n_threads
-
-
-def test06_global_wrapper(n_threads=8):
-    # Check wrapper lookup racing with wrapper deallocation
-    n = 10000
-    def f():
-        for _ in range(n):
-            GlobalData.get()
-            GlobalData.get()
-            GlobalData.get()
-            GlobalData.get()
-
-    parallelize(f, n_threads=n_threads)
-
-
-def test07_access_attributes(n_threads=8):
-    n = 1000
-    c1 = ClassWithProperty(123)
-    c2 = ClassWithClassProperty(c1)
-
-    def f():
-        for i in range(n):
-            _ = c2.prop1.prop2
-
-    parallelize(f, n_threads=n_threads)
diff --git a/src/nanobind/tests/test_typing.cpp b/src/nanobind/tests/test_typing.cpp
deleted file mode 100644
index a78404c..0000000
--- a/src/nanobind/tests/test_typing.cpp
+++ /dev/null
@@ -1,118 +0,0 @@
-#include <nanobind/typing.h>
-#include <nanobind/operators.h>
-
-namespace nb = nanobind;
-using namespace nb::literals;
-
-class NestedClass {};
-
-namespace nanobind {
-namespace detail {
-template <>
-struct type_caster<NestedClass> {
-    NB_TYPE_CASTER(NestedClass, const_name("py_stub_test.AClass.NestedClass"));
-
-    bool from_python(handle /*src*/, uint8_t /*flags*/, cleanup_list*) noexcept {
-        return true;
-    }
-
-    static handle from_cpp(const NestedClass&, rv_policy, cleanup_list*) noexcept {
-        nanobind::object py_class =
-            nanobind::module_::import_("py_stub_test").attr("AClass").attr("NestedClass");
-        return py_class().release();
-    }
-};
-}
-}
-
-// Declarations of various advanced constructions to test the stub generator
-NB_MODULE(test_typing_ext, m) {
-    // A submodule which won't be included, but we must be able to import it
-    // and resolve declarations from there
-    nb::module_ sm = m.def_submodule("submodule");
-
-    // Some elements of the submodule
-    struct F { };
-    sm.def("f", [] { });
-    nb::class_<F>(sm, "F");
-
-    // Submodule aliases
-    m.attr("f2") = sm.attr("f");
-    m.attr("F") = sm.attr("F");
-
-    // A top-level type and a function
-    struct Foo {
-        bool operator<(Foo) const { return false; }
-        bool operator>(Foo) const { return false; }
-        bool operator<=(Foo) const { return false; }
-        bool operator>=(Foo) const { return false; }
-    };
-    nb::class_<Foo>(m, "Foo")
-        .def(nb::self < nb::self)
-        .def(nb::self > nb::self)
-        .def(nb::self <= nb::self)
-        .def(nb::self >= nb::self);
-
-    m.def("f", []{});
-
-    m.def("makeNestedClass", [] { return NestedClass(); });
-
-    // Aliases to local functoins and types
-    m.attr("FooAlias") = m.attr("Foo");
-    m.attr("f_alias") = m.attr("f");
-    nb::type<Foo>().attr("lt_alias") = nb::type<Foo>().attr("__lt__");
-
-    // Custom signature generation for classes and methods
-    struct CustomSignature { int value; };
-    nb::class_<CustomSignature>(
-        m, "CustomSignature", nb::sig("@my_decorator\nclass CustomSignature(" NB_TYPING_ITERABLE "[int])"))
-        .def("method", []{}, nb::sig("@my_decorator\ndef method(self: typing.Self)"))
-        .def("method_with_default", [](CustomSignature&,bool){}, "value"_a.sig("bool(True)") = true)
-        .def_rw("value", &CustomSignature::value,
-                nb::for_getter(nb::sig("def value(self, /) -> typing.Optional[int]")),
-                nb::for_setter(nb::sig("def value(self, value: typing.Optional[int], /) -> None")),
-                nb::for_getter("docstring for getter"),
-                nb::for_setter("docstring for setter"));
-
-    // Stubification of simple constants
-    nb::dict d;
-    nb::list l;
-    l.append(123);
-    d["a"] = nb::make_tuple("b", l);
-    m.attr("pytree") = d;
-
-    // A generic type
-    struct Wrapper {
-        nb::object value;
-        bool operator==(const Wrapper &w) const { return value.is(w.value); }
-    };
-
-    // 1. Instantiate a placeholder ("type variable") used below
-    m.attr("T") = nb::type_var("T", "contravariant"_a = true);
-
-    // 2. Create a generic type, and indicate in generated stubs
-    //    that it derives from Generic[T]
-    auto wrapper = nb::class_<Wrapper>(m, "Wrapper", nb::is_generic(),
-                        nb::sig("class Wrapper(typing.Generic[T])"))
-       .def(nb::init<nb::object>(),
-            nb::sig("def __init__(self, arg: T, /) -> None"))
-       .def("get", [](Wrapper &w) { return w.value; },
-            nb::sig("def get(self, /) -> T"))
-       .def(nb::self == nb::self, nb::sig("def __eq__(self, arg: object, /) -> bool"));
-
-#if PY_VERSION_HEX >= 0x03090000 && !defined(PYPY_VERSION) // https://github.com/pypy/pypy/issues/4914
-    struct WrapperFoo : Wrapper { };
-    nb::class_<WrapperFoo>(m, "WrapperFoo", wrapper[nb::type<Foo>()]);
-#endif
-
-    // Type parameter syntax for Python 3.12+
-    struct WrapperTypeParam { };
-    nb::class_<WrapperTypeParam>(m, "WrapperTypeParam",
-                                 nb::sig("class WrapperTypeParam[T]"));
-    m.def("list_front", [](nb::list l) { return l[0]; },
-          nb::sig("def list_front[T](arg: list[T], /) -> T"));
-
-    // Some statements that will be modified by the pattern file
-    m.def("remove_me", []{});
-    m.def("tweak_me", [](nb::object o) { return o; }, "prior docstring\nremains preserved");
-}
diff --git a/src/nanobind/tests/test_typing.py b/src/nanobind/tests/test_typing.py
deleted file mode 100644
index 8a89db8..0000000
--- a/src/nanobind/tests/test_typing.py
+++ /dev/null
@@ -1,13 +0,0 @@
-import test_typing_ext as t
-import sys
-import pytest
-import platform
-
-@pytest.mark.skipif(sys.version_info < (3, 9), reason="requires python3.9 or higher")
-def test01_parameterize_generic():
-    assert str(type(t.Wrapper[int]) == 't.Wrapper[int]')
-    if platform.python_implementation() != 'PyPy':
-        assert issubclass(t.WrapperFoo, t.Wrapper)
-        assert t.WrapperFoo.__bases__ == (t.Wrapper,)
-        assert t.WrapperFoo.__orig_bases__ == (t.Wrapper[t.Foo],)
-
diff --git a/src/nanobind/tests/test_typing_ext.pyi.ref b/src/nanobind/tests/test_typing_ext.pyi.ref
deleted file mode 100644
index f2df74e..0000000
--- a/src/nanobind/tests/test_typing_ext.pyi.ref
+++ /dev/null
@@ -1,70 +0,0 @@
-from collections.abc import Iterable
-import py_stub_test
-from typing import Generic, Optional, Self, TypeAlias, TypeVar
-
-from . import submodule as submodule
-from .submodule import F as F, f as f2
-
-
-# a prefix
-
-class Foo:
-    def __lt__(self, arg: int, /) -> bool: ...
-
-    def __gt__(self, arg: int, /) -> bool: ...
-
-    def __le__(self, arg: Foo, /) -> bool: ...
-
-    def __ge__(self, arg: Foo, /) -> bool: ...
-
-    lt_alias = __lt__
-
-def f() -> None: ...
-
-def makeNestedClass() -> py_stub_test.AClass.NestedClass: ...
-
-FooAlias: TypeAlias = Foo
-
-f_alias = f
-
-@my_decorator
-class CustomSignature(Iterable[int]):
-    @my_decorator
-    def method(self: Self): ...
-
-    def method_with_default(self, value: bool = bool(True)) -> None: ...
-
-    @property
-    def value(self, /) -> Optional[int]:
-        """docstring for getter"""
-
-    @value.setter
-    def value(self, value: Optional[int], /) -> None:
-        """docstring for setter"""
-
-pytree: dict = {'a' : ('b', [123])}
-
-T = TypeVar("T", contravariant=True)
-
-class Wrapper(Generic[T]):
-    def __init__(self, arg: T, /) -> None: ...
-
-    def get(self, /) -> T: ...
-
-    def __eq__(self, arg: object, /) -> bool: ...
-
-class WrapperFoo(Wrapper[Foo]):
-    pass
-
-class WrapperTypeParam[T]:
-    pass
-
-def list_front[T](arg: list[T], /) -> T: ...
-
-def tweak_me(arg: int):
-    """
-    prior docstring
-    remains preserved
-    """
-
-# a suffix
diff --git a/src/pauliengine/__init__.py b/src/pauliengine/__init__.py
new file mode 100644
index 0000000..efe767e
--- /dev/null
+++ b/src/pauliengine/__init__.py
@@ -0,0 +1,12 @@
+"""PauliEngine library."""
+
+from ._core import PauliString, QubitHamiltonian, __build_type__, __compiler_flags__
+from ._version import __version__
+
+__all__ = [
+    "PauliString",
+    "QubitHamiltonian",
+    "__build_type__",
+    "__compiler_flags__",
+    "__version__"
+]
\ No newline at end of file
diff --git a/src/pauliengine/_version.py b/src/pauliengine/_version.py
new file mode 100644
index 0000000..e63bed8
--- /dev/null
+++ b/src/pauliengine/_version.py
@@ -0,0 +1,34 @@
+# file generated by setuptools-scm
+# don't change, don't track in version control
+
+__all__ = [
+    "__version__",
+    "__version_tuple__",
+    "version",
+    "version_tuple",
+    "__commit_id__",
+    "commit_id",
+]
+
+TYPE_CHECKING = False
+if TYPE_CHECKING:
+    from typing import Tuple
+    from typing import Union
+
+    VERSION_TUPLE = Tuple[Union[int, str], ...]
+    COMMIT_ID = Union[str, None]
+else:
+    VERSION_TUPLE = object
+    COMMIT_ID = object
+
+version: str
+__version__: str
+__version_tuple__: VERSION_TUPLE
+version_tuple: VERSION_TUPLE
+commit_id: COMMIT_ID
+__commit_id__: COMMIT_ID
+
+__version__ = version = '0.2.dev3+g47975ba94.d20260114'
+__version_tuple__ = version_tuple = (0, 2, 'dev3', 'g47975ba94.d20260114')
+
+__commit_id__ = commit_id = 'g47975ba94'
diff --git a/src/python/__init__.py b/src/python/__init__.py
deleted file mode 100644
index e69de29..0000000
diff --git a/tests/test_package.py b/tests/test_package.py
new file mode 100644
index 0000000..9e237bb
--- /dev/null
+++ b/tests/test_package.py
@@ -0,0 +1,9 @@
+from __future__ import annotations
+
+import importlib.metadata
+
+import pauliengine as m
+
+
+def test_version():
+    assert importlib.metadata.version("pauliengine") == m.__version__
diff --git a/tests/test_pauli_string.py b/tests/test_pauli_string.py
new file mode 100644
index 0000000..1ac5d45
--- /dev/null
+++ b/tests/test_pauli_string.py
@@ -0,0 +1,50 @@
+import pytest
+
+import pauliengine as pe
+
+
+@pytest.mark.parametrize(("pauli_string", "coeff", "expected_x", "expected_z"), [
+    ({0:"I", 1:"Z", 2:"X"}, 5.0, [6], [2]), # using dict input
+    ({10: 'Z', 2: 'X'}, 6.0, [2**10 + 2**2] , [2**10]), # using dict input with non-consecutive qubits
+])
+def test_pauli_string_valid_pauli_string_input(pauli_string, coeff, expected_x, expected_z):
+    ps = pe.PauliString(pauli_string, coeff)
+    # TODO: coeff is an Expression object, need to be exposed to Python somehow. 
+    # assert ps.coeff == coeff
+    assert ps.x == expected_x
+    assert ps.y == expected_z
+
+@pytest.mark.xfail
+@pytest.mark.parametrize("invalid_pauli_string", [
+    {0: "A", 2: "B", 3: "Z"}, # invalid character
+    {0: "i", 2: "z", 3: "y"}, # lowercase character
+])
+def test_pauli_string_invalid_pauli_string_input(invalid_pauli_string):
+    with pytest.raises(ValueError):
+        pe.PauliString(invalid_pauli_string, 1.0)
+
+
+@pytest.mark.parametrize(("pauli_string", "other", "expected_product"), [
+    (pe.PauliString({0: "X", 1: "Z", 2: "Y", 3: "Z"}, 1.0),
+     pe.PauliString({0: "Z", 1: "Z", 3: "X"}, 2.0),
+     pe.PauliString({0: "Y", 2: "Y", 3: "Y"}, 2.0)), # XZYZ * ZZIX = YIYY 
+
+    (pe.PauliString({0: "Z", 2: "Z"}, 2.0j),
+     pe.PauliString({0: "Y", 2: "Y"}, 3.0),
+     pe.PauliString({0: "X", 2: "X"}, -6.0j)), # XZ * ZX = YY
+
+    (pe.PauliString({0: "X", 1: "Y"}, -4.0),
+     1.0 - 2.0j,
+     pe.PauliString({0: "X", 1: "Y"}, -4.0 + 8.0j)), # -4.0XY * 1.0 - 2.0j
+])
+
+class TestPauliStringMultiplication:
+
+    def test_pauli_string_multiplication(self, pauli_string, other, expected_product):
+        product = pauli_string * other
+        assert expected_product == product
+
+    def test_pauli_string_multiplication_inplace(self, pauli_string, other, expected_product):
+        pauli_string *= other
+        assert expected_product == pauli_string
+
diff --git a/tools/install-deps.sh b/tools/install-deps.sh
new file mode 100755
index 0000000..0d6428d
--- /dev/null
+++ b/tools/install-deps.sh
@@ -0,0 +1,81 @@
+#!/usr/bin/env bash
+
+set -euo pipefail
+
+# Script to install dependencies for pauliengine project
+# Usage: ./install-deps.sh [install_prefix] [--skip-boost-test] [--skip-msgpack] [--help]
+
+show_help() {
+    cat << EOF
+Usage: $0 [INSTALL_PREFIX] [OPTIONS]
+
+Install C++ dependencies for pauliengine project.
+
+Arguments:
+    INSTALL_PREFIX      Directory to install dependencies (default: /usr/local)
+
+Options:
+    --help, -h          Show this help message
+
+Examples:
+    $0                                   # Install all deps to /usr/local
+    $0 \$HOME/Software                   # Install all deps to \$HOME/Software
+EOF
+}
+
+# Default values
+DEFAULT_PREFIX="/usr/local"
+INSTALL_PREFIX="$DEFAULT_PREFIX"
+
+# Parse arguments
+while [[ $# -gt 0 ]]; do
+    case $1 in
+        --help|-h)
+            show_help
+            exit 0
+            ;;
+        --*)
+            echo "Unknown option: $1" >&2
+            echo "Use --help for usage information." >&2
+            exit 1
+            ;;
+        *)
+            # Assume it's the install prefix if it doesn't start with --
+            if [[ -z "${INSTALL_PREFIX_SET:-}" ]]; then
+                INSTALL_PREFIX="$1"
+                INSTALL_PREFIX_SET=true
+            else
+                echo "Multiple install prefixes specified: $INSTALL_PREFIX and $1" >&2
+                exit 1
+            fi
+            shift
+            ;;
+    esac
+done
+
+echo "Installing C++ dependencies to: $INSTALL_PREFIX"
+
+# Create install directory if it doesn't exist
+mkdir -p "$INSTALL_PREFIX"
+
+
+curl -L https://github.com/symengine/symengine/archive/master.tar.gz | tar -xz
+rm -f master.tar.gz
+
+cmake -S"symengine-master" -B"symengine-master/build" \
+  -DCMAKE_INSTALL_PREFIX="$INSTALL_PREFIX" \
+  -DBUILD_TESTS=OFF \
+  -DBUILD_BENCHMARKS=OFF \
+  -GNinja
+
+cmake --build "symengine-master/build" --target install
+rm -rf symengine-master
+
+if [[ "$INSTALL_PREFIX" == "$DEFAULT_PREFIX" ]]; then
+    echo "Remember to export SymEngine_DIR=$INSTALL_PREFIX/lib/cmake/SymEngine"
+fi
+
+echo
+echo "Dependencies installation completed successfully!"
+echo "Install location: $INSTALL_PREFIX"
+echo "Make sure to set CMAKE_PREFIX_PATH=$INSTALL_PREFIX when building pauliengine"
diff --git a/uv.lock b/uv.lock
new file mode 100644
index 0000000..7e1e3c5
--- /dev/null
+++ b/uv.lock
@@ -0,0 +1,1154 @@
+version = 1
+revision = 3
+requires-python = ">=3.11, <3.14"
+
+[[package]]
+name = "appnope"
+version = "0.1.4"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/35/5d/752690df9ef5b76e169e68d6a129fa6d08a7100ca7f754c89495db3c6019/appnope-0.1.4.tar.gz", hash = "sha256:1de3860566df9caf38f01f86f65e0e13e379af54f9e4bee1e66b48f2efffd1ee", size = 4170, upload-time = "2024-02-06T09:43:11.258Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/81/29/5ecc3a15d5a33e31b26c11426c45c501e439cb865d0bff96315d86443b78/appnope-0.1.4-py2.py3-none-any.whl", hash = "sha256:502575ee11cd7a28c0205f379b525beefebab9d161b7c964670864014ed7213c", size = 4321, upload-time = "2024-02-06T09:43:09.663Z" },
+]
+
+[[package]]
+name = "asttokens"
+version = "3.0.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/be/a5/8e3f9b6771b0b408517c82d97aed8f2036509bc247d46114925e32fe33f0/asttokens-3.0.1.tar.gz", hash = "sha256:71a4ee5de0bde6a31d64f6b13f2293ac190344478f081c3d1bccfcf5eacb0cb7", size = 62308, upload-time = "2025-11-15T16:43:48.578Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/d2/39/e7eaf1799466a4aef85b6a4fe7bd175ad2b1c6345066aa33f1f58d4b18d0/asttokens-3.0.1-py3-none-any.whl", hash = "sha256:15a3ebc0f43c2d0a50eeafea25e19046c68398e487b9f1f5b517f7c0f40f976a", size = 27047, upload-time = "2025-11-15T16:43:16.109Z" },
+]
+
+[[package]]
+name = "cffi"
+version = "2.0.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "pycparser", marker = "implementation_name != 'PyPy'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/eb/56/b1ba7935a17738ae8453301356628e8147c79dbb825bcbc73dc7401f9846/cffi-2.0.0.tar.gz", hash = "sha256:44d1b5909021139fe36001ae048dbdde8214afa20200eda0f64c068cac5d5529", size = 523588, upload-time = "2025-09-08T23:24:04.541Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/12/4a/3dfd5f7850cbf0d06dc84ba9aa00db766b52ca38d8b86e3a38314d52498c/cffi-2.0.0-cp311-cp311-macosx_10_13_x86_64.whl", hash = "sha256:b4c854ef3adc177950a8dfc81a86f5115d2abd545751a304c5bcf2c2c7283cfe", size = 184344, upload-time = "2025-09-08T23:22:26.456Z" },
+    { url = "https://files.pythonhosted.org/packages/4f/8b/f0e4c441227ba756aafbe78f117485b25bb26b1c059d01f137fa6d14896b/cffi-2.0.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:2de9a304e27f7596cd03d16f1b7c72219bd944e99cc52b84d0145aefb07cbd3c", size = 180560, upload-time = "2025-09-08T23:22:28.197Z" },
+    { url = "https://files.pythonhosted.org/packages/b1/b7/1200d354378ef52ec227395d95c2576330fd22a869f7a70e88e1447eb234/cffi-2.0.0-cp311-cp311-manylinux1_i686.manylinux2014_i686.manylinux_2_17_i686.manylinux_2_5_i686.whl", hash = "sha256:baf5215e0ab74c16e2dd324e8ec067ef59e41125d3eade2b863d294fd5035c92", size = 209613, upload-time = "2025-09-08T23:22:29.475Z" },
+    { url = "https://files.pythonhosted.org/packages/b8/56/6033f5e86e8cc9bb629f0077ba71679508bdf54a9a5e112a3c0b91870332/cffi-2.0.0-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:730cacb21e1bdff3ce90babf007d0a0917cc3e6492f336c2f0134101e0944f93", size = 216476, upload-time = "2025-09-08T23:22:31.063Z" },
+    { url = "https://files.pythonhosted.org/packages/dc/7f/55fecd70f7ece178db2f26128ec41430d8720f2d12ca97bf8f0a628207d5/cffi-2.0.0-cp311-cp311-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:6824f87845e3396029f3820c206e459ccc91760e8fa24422f8b0c3d1731cbec5", size = 203374, upload-time = "2025-09-08T23:22:32.507Z" },
+    { url = "https://files.pythonhosted.org/packages/84/ef/a7b77c8bdc0f77adc3b46888f1ad54be8f3b7821697a7b89126e829e676a/cffi-2.0.0-cp311-cp311-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:9de40a7b0323d889cf8d23d1ef214f565ab154443c42737dfe52ff82cf857664", size = 202597, upload-time = "2025-09-08T23:22:34.132Z" },
+    { url = "https://files.pythonhosted.org/packages/d7/91/500d892b2bf36529a75b77958edfcd5ad8e2ce4064ce2ecfeab2125d72d1/cffi-2.0.0-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:8941aaadaf67246224cee8c3803777eed332a19d909b47e29c9842ef1e79ac26", size = 215574, upload-time = "2025-09-08T23:22:35.443Z" },
+    { url = "https://files.pythonhosted.org/packages/44/64/58f6255b62b101093d5df22dcb752596066c7e89dd725e0afaed242a61be/cffi-2.0.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:a05d0c237b3349096d3981b727493e22147f934b20f6f125a3eba8f994bec4a9", size = 218971, upload-time = "2025-09-08T23:22:36.805Z" },
+    { url = "https://files.pythonhosted.org/packages/ab/49/fa72cebe2fd8a55fbe14956f9970fe8eb1ac59e5df042f603ef7c8ba0adc/cffi-2.0.0-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:94698a9c5f91f9d138526b48fe26a199609544591f859c870d477351dc7b2414", size = 211972, upload-time = "2025-09-08T23:22:38.436Z" },
+    { url = "https://files.pythonhosted.org/packages/0b/28/dd0967a76aab36731b6ebfe64dec4e981aff7e0608f60c2d46b46982607d/cffi-2.0.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:5fed36fccc0612a53f1d4d9a816b50a36702c28a2aa880cb8a122b3466638743", size = 217078, upload-time = "2025-09-08T23:22:39.776Z" },
+    { url = "https://files.pythonhosted.org/packages/2b/c0/015b25184413d7ab0a410775fdb4a50fca20f5589b5dab1dbbfa3baad8ce/cffi-2.0.0-cp311-cp311-win32.whl", hash = "sha256:c649e3a33450ec82378822b3dad03cc228b8f5963c0c12fc3b1e0ab940f768a5", size = 172076, upload-time = "2025-09-08T23:22:40.95Z" },
+    { url = "https://files.pythonhosted.org/packages/ae/8f/dc5531155e7070361eb1b7e4c1a9d896d0cb21c49f807a6c03fd63fc877e/cffi-2.0.0-cp311-cp311-win_amd64.whl", hash = "sha256:66f011380d0e49ed280c789fbd08ff0d40968ee7b665575489afa95c98196ab5", size = 182820, upload-time = "2025-09-08T23:22:42.463Z" },
+    { url = "https://files.pythonhosted.org/packages/95/5c/1b493356429f9aecfd56bc171285a4c4ac8697f76e9bbbbb105e537853a1/cffi-2.0.0-cp311-cp311-win_arm64.whl", hash = "sha256:c6638687455baf640e37344fe26d37c404db8b80d037c3d29f58fe8d1c3b194d", size = 177635, upload-time = "2025-09-08T23:22:43.623Z" },
+    { url = "https://files.pythonhosted.org/packages/ea/47/4f61023ea636104d4f16ab488e268b93008c3d0bb76893b1b31db1f96802/cffi-2.0.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:6d02d6655b0e54f54c4ef0b94eb6be0607b70853c45ce98bd278dc7de718be5d", size = 185271, upload-time = "2025-09-08T23:22:44.795Z" },
+    { url = "https://files.pythonhosted.org/packages/df/a2/781b623f57358e360d62cdd7a8c681f074a71d445418a776eef0aadb4ab4/cffi-2.0.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:8eca2a813c1cb7ad4fb74d368c2ffbbb4789d377ee5bb8df98373c2cc0dee76c", size = 181048, upload-time = "2025-09-08T23:22:45.938Z" },
+    { url = "https://files.pythonhosted.org/packages/ff/df/a4f0fbd47331ceeba3d37c2e51e9dfc9722498becbeec2bd8bc856c9538a/cffi-2.0.0-cp312-cp312-manylinux1_i686.manylinux2014_i686.manylinux_2_17_i686.manylinux_2_5_i686.whl", hash = "sha256:21d1152871b019407d8ac3985f6775c079416c282e431a4da6afe7aefd2bccbe", size = 212529, upload-time = "2025-09-08T23:22:47.349Z" },
+    { url = "https://files.pythonhosted.org/packages/d5/72/12b5f8d3865bf0f87cf1404d8c374e7487dcf097a1c91c436e72e6badd83/cffi-2.0.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:b21e08af67b8a103c71a250401c78d5e0893beff75e28c53c98f4de42f774062", size = 220097, upload-time = "2025-09-08T23:22:48.677Z" },
+    { url = "https://files.pythonhosted.org/packages/c2/95/7a135d52a50dfa7c882ab0ac17e8dc11cec9d55d2c18dda414c051c5e69e/cffi-2.0.0-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:1e3a615586f05fc4065a8b22b8152f0c1b00cdbc60596d187c2a74f9e3036e4e", size = 207983, upload-time = "2025-09-08T23:22:50.06Z" },
+    { url = "https://files.pythonhosted.org/packages/3a/c8/15cb9ada8895957ea171c62dc78ff3e99159ee7adb13c0123c001a2546c1/cffi-2.0.0-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:81afed14892743bbe14dacb9e36d9e0e504cd204e0b165062c488942b9718037", size = 206519, upload-time = "2025-09-08T23:22:51.364Z" },
+    { url = "https://files.pythonhosted.org/packages/78/2d/7fa73dfa841b5ac06c7b8855cfc18622132e365f5b81d02230333ff26e9e/cffi-2.0.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:3e17ed538242334bf70832644a32a7aae3d83b57567f9fd60a26257e992b79ba", size = 219572, upload-time = "2025-09-08T23:22:52.902Z" },
+    { url = "https://files.pythonhosted.org/packages/07/e0/267e57e387b4ca276b90f0434ff88b2c2241ad72b16d31836adddfd6031b/cffi-2.0.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:3925dd22fa2b7699ed2617149842d2e6adde22b262fcbfada50e3d195e4b3a94", size = 222963, upload-time = "2025-09-08T23:22:54.518Z" },
+    { url = "https://files.pythonhosted.org/packages/b6/75/1f2747525e06f53efbd878f4d03bac5b859cbc11c633d0fb81432d98a795/cffi-2.0.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:2c8f814d84194c9ea681642fd164267891702542f028a15fc97d4674b6206187", size = 221361, upload-time = "2025-09-08T23:22:55.867Z" },
+    { url = "https://files.pythonhosted.org/packages/7b/2b/2b6435f76bfeb6bbf055596976da087377ede68df465419d192acf00c437/cffi-2.0.0-cp312-cp312-win32.whl", hash = "sha256:da902562c3e9c550df360bfa53c035b2f241fed6d9aef119048073680ace4a18", size = 172932, upload-time = "2025-09-08T23:22:57.188Z" },
+    { url = "https://files.pythonhosted.org/packages/f8/ed/13bd4418627013bec4ed6e54283b1959cf6db888048c7cf4b4c3b5b36002/cffi-2.0.0-cp312-cp312-win_amd64.whl", hash = "sha256:da68248800ad6320861f129cd9c1bf96ca849a2771a59e0344e88681905916f5", size = 183557, upload-time = "2025-09-08T23:22:58.351Z" },
+    { url = "https://files.pythonhosted.org/packages/95/31/9f7f93ad2f8eff1dbc1c3656d7ca5bfd8fb52c9d786b4dcf19b2d02217fa/cffi-2.0.0-cp312-cp312-win_arm64.whl", hash = "sha256:4671d9dd5ec934cb9a73e7ee9676f9362aba54f7f34910956b84d727b0d73fb6", size = 177762, upload-time = "2025-09-08T23:22:59.668Z" },
+    { url = "https://files.pythonhosted.org/packages/4b/8d/a0a47a0c9e413a658623d014e91e74a50cdd2c423f7ccfd44086ef767f90/cffi-2.0.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:00bdf7acc5f795150faa6957054fbbca2439db2f775ce831222b66f192f03beb", size = 185230, upload-time = "2025-09-08T23:23:00.879Z" },
+    { url = "https://files.pythonhosted.org/packages/4a/d2/a6c0296814556c68ee32009d9c2ad4f85f2707cdecfd7727951ec228005d/cffi-2.0.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:45d5e886156860dc35862657e1494b9bae8dfa63bf56796f2fb56e1679fc0bca", size = 181043, upload-time = "2025-09-08T23:23:02.231Z" },
+    { url = "https://files.pythonhosted.org/packages/b0/1e/d22cc63332bd59b06481ceaac49d6c507598642e2230f201649058a7e704/cffi-2.0.0-cp313-cp313-manylinux1_i686.manylinux2014_i686.manylinux_2_17_i686.manylinux_2_5_i686.whl", hash = "sha256:07b271772c100085dd28b74fa0cd81c8fb1a3ba18b21e03d7c27f3436a10606b", size = 212446, upload-time = "2025-09-08T23:23:03.472Z" },
+    { url = "https://files.pythonhosted.org/packages/a9/f5/a2c23eb03b61a0b8747f211eb716446c826ad66818ddc7810cc2cc19b3f2/cffi-2.0.0-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:d48a880098c96020b02d5a1f7d9251308510ce8858940e6fa99ece33f610838b", size = 220101, upload-time = "2025-09-08T23:23:04.792Z" },
+    { url = "https://files.pythonhosted.org/packages/f2/7f/e6647792fc5850d634695bc0e6ab4111ae88e89981d35ac269956605feba/cffi-2.0.0-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:f93fd8e5c8c0a4aa1f424d6173f14a892044054871c771f8566e4008eaa359d2", size = 207948, upload-time = "2025-09-08T23:23:06.127Z" },
+    { url = "https://files.pythonhosted.org/packages/cb/1e/a5a1bd6f1fb30f22573f76533de12a00bf274abcdc55c8edab639078abb6/cffi-2.0.0-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:dd4f05f54a52fb558f1ba9f528228066954fee3ebe629fc1660d874d040ae5a3", size = 206422, upload-time = "2025-09-08T23:23:07.753Z" },
+    { url = "https://files.pythonhosted.org/packages/98/df/0a1755e750013a2081e863e7cd37e0cdd02664372c754e5560099eb7aa44/cffi-2.0.0-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:c8d3b5532fc71b7a77c09192b4a5a200ea992702734a2e9279a37f2478236f26", size = 219499, upload-time = "2025-09-08T23:23:09.648Z" },
+    { url = "https://files.pythonhosted.org/packages/50/e1/a969e687fcf9ea58e6e2a928ad5e2dd88cc12f6f0ab477e9971f2309b57c/cffi-2.0.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:d9b29c1f0ae438d5ee9acb31cadee00a58c46cc9c0b2f9038c6b0b3470877a8c", size = 222928, upload-time = "2025-09-08T23:23:10.928Z" },
+    { url = "https://files.pythonhosted.org/packages/36/54/0362578dd2c9e557a28ac77698ed67323ed5b9775ca9d3fe73fe191bb5d8/cffi-2.0.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:6d50360be4546678fc1b79ffe7a66265e28667840010348dd69a314145807a1b", size = 221302, upload-time = "2025-09-08T23:23:12.42Z" },
+    { url = "https://files.pythonhosted.org/packages/eb/6d/bf9bda840d5f1dfdbf0feca87fbdb64a918a69bca42cfa0ba7b137c48cb8/cffi-2.0.0-cp313-cp313-win32.whl", hash = "sha256:74a03b9698e198d47562765773b4a8309919089150a0bb17d829ad7b44b60d27", size = 172909, upload-time = "2025-09-08T23:23:14.32Z" },
+    { url = "https://files.pythonhosted.org/packages/37/18/6519e1ee6f5a1e579e04b9ddb6f1676c17368a7aba48299c3759bbc3c8b3/cffi-2.0.0-cp313-cp313-win_amd64.whl", hash = "sha256:19f705ada2530c1167abacb171925dd886168931e0a7b78f5bffcae5c6b5be75", size = 183402, upload-time = "2025-09-08T23:23:15.535Z" },
+    { url = "https://files.pythonhosted.org/packages/cb/0e/02ceeec9a7d6ee63bb596121c2c8e9b3a9e150936f4fbef6ca1943e6137c/cffi-2.0.0-cp313-cp313-win_arm64.whl", hash = "sha256:256f80b80ca3853f90c21b23ee78cd008713787b1b1e93eae9f3d6a7134abd91", size = 177780, upload-time = "2025-09-08T23:23:16.761Z" },
+]
+
+[[package]]
+name = "cfgv"
+version = "3.5.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/4e/b5/721b8799b04bf9afe054a3899c6cf4e880fcf8563cc71c15610242490a0c/cfgv-3.5.0.tar.gz", hash = "sha256:d5b1034354820651caa73ede66a6294d6e95c1b00acc5e9b098e917404669132", size = 7334, upload-time = "2025-11-19T20:55:51.612Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/db/3c/33bac158f8ab7f89b2e59426d5fe2e4f63f7ed25df84c036890172b412b5/cfgv-3.5.0-py2.py3-none-any.whl", hash = "sha256:a8dc6b26ad22ff227d2634a65cb388215ce6cc96bbcc5cfde7641ae87e8dacc0", size = 7445, upload-time = "2025-11-19T20:55:50.744Z" },
+]
+
+[[package]]
+name = "colorama"
+version = "0.4.6"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/d8/53/6f443c9a4a8358a93a6792e2acffb9d9d5cb0a5cfd8802644b7b1c9a02e4/colorama-0.4.6.tar.gz", hash = "sha256:08695f5cb7ed6e0531a20572697297273c47b8cae5a63ffc6d6ed5c201be6e44", size = 27697, upload-time = "2022-10-25T02:36:22.414Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/d1/d6/3965ed04c63042e047cb6a3e6ed1a63a35087b6a609aa3a15ed8ac56c221/colorama-0.4.6-py2.py3-none-any.whl", hash = "sha256:4f1d9991f5acc0ca119f9d443620b77f9d6b33703e51011c16baf57afb285fc6", size = 25335, upload-time = "2022-10-25T02:36:20.889Z" },
+]
+
+[[package]]
+name = "comm"
+version = "0.2.3"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/4c/13/7d740c5849255756bc17888787313b61fd38a0a8304fc4f073dfc46122aa/comm-0.2.3.tar.gz", hash = "sha256:2dc8048c10962d55d7ad693be1e7045d891b7ce8d999c97963a5e3e99c055971", size = 6319, upload-time = "2025-07-25T14:02:04.452Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/60/97/891a0971e1e4a8c5d2b20bbe0e524dc04548d2307fee33cdeba148fd4fc7/comm-0.2.3-py3-none-any.whl", hash = "sha256:c615d91d75f7f04f095b30d1c1711babd43bdc6419c1be9886a85f2f4e489417", size = 7294, upload-time = "2025-07-25T14:02:02.896Z" },
+]
+
+[[package]]
+name = "contourpy"
+version = "1.3.3"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "numpy" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/58/01/1253e6698a07380cd31a736d248a3f2a50a7c88779a1813da27503cadc2a/contourpy-1.3.3.tar.gz", hash = "sha256:083e12155b210502d0bca491432bb04d56dc3432f95a979b429f2848c3dbe880", size = 13466174, upload-time = "2025-07-26T12:03:12.549Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/91/2e/c4390a31919d8a78b90e8ecf87cd4b4c4f05a5b48d05ec17db8e5404c6f4/contourpy-1.3.3-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:709a48ef9a690e1343202916450bc48b9e51c049b089c7f79a267b46cffcdaa1", size = 288773, upload-time = "2025-07-26T12:01:02.277Z" },
+    { url = "https://files.pythonhosted.org/packages/0d/44/c4b0b6095fef4dc9c420e041799591e3b63e9619e3044f7f4f6c21c0ab24/contourpy-1.3.3-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:23416f38bfd74d5d28ab8429cc4d63fa67d5068bd711a85edb1c3fb0c3e2f381", size = 270149, upload-time = "2025-07-26T12:01:04.072Z" },
+    { url = "https://files.pythonhosted.org/packages/30/2e/dd4ced42fefac8470661d7cb7e264808425e6c5d56d175291e93890cce09/contourpy-1.3.3-cp311-cp311-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:929ddf8c4c7f348e4c0a5a3a714b5c8542ffaa8c22954862a46ca1813b667ee7", size = 329222, upload-time = "2025-07-26T12:01:05.688Z" },
+    { url = "https://files.pythonhosted.org/packages/f2/74/cc6ec2548e3d276c71389ea4802a774b7aa3558223b7bade3f25787fafc2/contourpy-1.3.3-cp311-cp311-manylinux_2_26_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:9e999574eddae35f1312c2b4b717b7885d4edd6cb46700e04f7f02db454e67c1", size = 377234, upload-time = "2025-07-26T12:01:07.054Z" },
+    { url = "https://files.pythonhosted.org/packages/03/b3/64ef723029f917410f75c09da54254c5f9ea90ef89b143ccadb09df14c15/contourpy-1.3.3-cp311-cp311-manylinux_2_26_s390x.manylinux_2_28_s390x.whl", hash = "sha256:0bf67e0e3f482cb69779dd3061b534eb35ac9b17f163d851e2a547d56dba0a3a", size = 380555, upload-time = "2025-07-26T12:01:08.801Z" },
+    { url = "https://files.pythonhosted.org/packages/5f/4b/6157f24ca425b89fe2eb7e7be642375711ab671135be21e6faa100f7448c/contourpy-1.3.3-cp311-cp311-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:51e79c1f7470158e838808d4a996fa9bac72c498e93d8ebe5119bc1e6becb0db", size = 355238, upload-time = "2025-07-26T12:01:10.319Z" },
+    { url = "https://files.pythonhosted.org/packages/98/56/f914f0dd678480708a04cfd2206e7c382533249bc5001eb9f58aa693e200/contourpy-1.3.3-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:598c3aaece21c503615fd59c92a3598b428b2f01bfb4b8ca9c4edeecc2438620", size = 1326218, upload-time = "2025-07-26T12:01:12.659Z" },
+    { url = "https://files.pythonhosted.org/packages/fb/d7/4a972334a0c971acd5172389671113ae82aa7527073980c38d5868ff1161/contourpy-1.3.3-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:322ab1c99b008dad206d406bb61d014cf0174df491ae9d9d0fac6a6fda4f977f", size = 1392867, upload-time = "2025-07-26T12:01:15.533Z" },
+    { url = "https://files.pythonhosted.org/packages/75/3e/f2cc6cd56dc8cff46b1a56232eabc6feea52720083ea71ab15523daab796/contourpy-1.3.3-cp311-cp311-win32.whl", hash = "sha256:fd907ae12cd483cd83e414b12941c632a969171bf90fc937d0c9f268a31cafff", size = 183677, upload-time = "2025-07-26T12:01:17.088Z" },
+    { url = "https://files.pythonhosted.org/packages/98/4b/9bd370b004b5c9d8045c6c33cf65bae018b27aca550a3f657cdc99acdbd8/contourpy-1.3.3-cp311-cp311-win_amd64.whl", hash = "sha256:3519428f6be58431c56581f1694ba8e50626f2dd550af225f82fb5f5814d2a42", size = 225234, upload-time = "2025-07-26T12:01:18.256Z" },
+    { url = "https://files.pythonhosted.org/packages/d9/b6/71771e02c2e004450c12b1120a5f488cad2e4d5b590b1af8bad060360fe4/contourpy-1.3.3-cp311-cp311-win_arm64.whl", hash = "sha256:15ff10bfada4bf92ec8b31c62bf7c1834c244019b4a33095a68000d7075df470", size = 193123, upload-time = "2025-07-26T12:01:19.848Z" },
+    { url = "https://files.pythonhosted.org/packages/be/45/adfee365d9ea3d853550b2e735f9d66366701c65db7855cd07621732ccfc/contourpy-1.3.3-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:b08a32ea2f8e42cf1d4be3169a98dd4be32bafe4f22b6c4cb4ba810fa9e5d2cb", size = 293419, upload-time = "2025-07-26T12:01:21.16Z" },
+    { url = "https://files.pythonhosted.org/packages/53/3e/405b59cfa13021a56bba395a6b3aca8cec012b45bf177b0eaf7a202cde2c/contourpy-1.3.3-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:556dba8fb6f5d8742f2923fe9457dbdd51e1049c4a43fd3986a0b14a1d815fc6", size = 273979, upload-time = "2025-07-26T12:01:22.448Z" },
+    { url = "https://files.pythonhosted.org/packages/d4/1c/a12359b9b2ca3a845e8f7f9ac08bdf776114eb931392fcad91743e2ea17b/contourpy-1.3.3-cp312-cp312-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:92d9abc807cf7d0e047b95ca5d957cf4792fcd04e920ca70d48add15c1a90ea7", size = 332653, upload-time = "2025-07-26T12:01:24.155Z" },
+    { url = "https://files.pythonhosted.org/packages/63/12/897aeebfb475b7748ea67b61e045accdfcf0d971f8a588b67108ed7f5512/contourpy-1.3.3-cp312-cp312-manylinux_2_26_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:b2e8faa0ed68cb29af51edd8e24798bb661eac3bd9f65420c1887b6ca89987c8", size = 379536, upload-time = "2025-07-26T12:01:25.91Z" },
+    { url = "https://files.pythonhosted.org/packages/43/8a/a8c584b82deb248930ce069e71576fc09bd7174bbd35183b7943fb1064fd/contourpy-1.3.3-cp312-cp312-manylinux_2_26_s390x.manylinux_2_28_s390x.whl", hash = "sha256:626d60935cf668e70a5ce6ff184fd713e9683fb458898e4249b63be9e28286ea", size = 384397, upload-time = "2025-07-26T12:01:27.152Z" },
+    { url = "https://files.pythonhosted.org/packages/cc/8f/ec6289987824b29529d0dfda0d74a07cec60e54b9c92f3c9da4c0ac732de/contourpy-1.3.3-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:4d00e655fcef08aba35ec9610536bfe90267d7ab5ba944f7032549c55a146da1", size = 362601, upload-time = "2025-07-26T12:01:28.808Z" },
+    { url = "https://files.pythonhosted.org/packages/05/0a/a3fe3be3ee2dceb3e615ebb4df97ae6f3828aa915d3e10549ce016302bd1/contourpy-1.3.3-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:451e71b5a7d597379ef572de31eeb909a87246974d960049a9848c3bc6c41bf7", size = 1331288, upload-time = "2025-07-26T12:01:31.198Z" },
+    { url = "https://files.pythonhosted.org/packages/33/1d/acad9bd4e97f13f3e2b18a3977fe1b4a37ecf3d38d815333980c6c72e963/contourpy-1.3.3-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:459c1f020cd59fcfe6650180678a9993932d80d44ccde1fa1868977438f0b411", size = 1403386, upload-time = "2025-07-26T12:01:33.947Z" },
+    { url = "https://files.pythonhosted.org/packages/cf/8f/5847f44a7fddf859704217a99a23a4f6417b10e5ab1256a179264561540e/contourpy-1.3.3-cp312-cp312-win32.whl", hash = "sha256:023b44101dfe49d7d53932be418477dba359649246075c996866106da069af69", size = 185018, upload-time = "2025-07-26T12:01:35.64Z" },
+    { url = "https://files.pythonhosted.org/packages/19/e8/6026ed58a64563186a9ee3f29f41261fd1828f527dd93d33b60feca63352/contourpy-1.3.3-cp312-cp312-win_amd64.whl", hash = "sha256:8153b8bfc11e1e4d75bcb0bff1db232f9e10b274e0929de9d608027e0d34ff8b", size = 226567, upload-time = "2025-07-26T12:01:36.804Z" },
+    { url = "https://files.pythonhosted.org/packages/d1/e2/f05240d2c39a1ed228d8328a78b6f44cd695f7ef47beb3e684cf93604f86/contourpy-1.3.3-cp312-cp312-win_arm64.whl", hash = "sha256:07ce5ed73ecdc4a03ffe3e1b3e3c1166db35ae7584be76f65dbbe28a7791b0cc", size = 193655, upload-time = "2025-07-26T12:01:37.999Z" },
+    { url = "https://files.pythonhosted.org/packages/68/35/0167aad910bbdb9599272bd96d01a9ec6852f36b9455cf2ca67bd4cc2d23/contourpy-1.3.3-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:177fb367556747a686509d6fef71d221a4b198a3905fe824430e5ea0fda54eb5", size = 293257, upload-time = "2025-07-26T12:01:39.367Z" },
+    { url = "https://files.pythonhosted.org/packages/96/e4/7adcd9c8362745b2210728f209bfbcf7d91ba868a2c5f40d8b58f54c509b/contourpy-1.3.3-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:d002b6f00d73d69333dac9d0b8d5e84d9724ff9ef044fd63c5986e62b7c9e1b1", size = 274034, upload-time = "2025-07-26T12:01:40.645Z" },
+    { url = "https://files.pythonhosted.org/packages/73/23/90e31ceeed1de63058a02cb04b12f2de4b40e3bef5e082a7c18d9c8ae281/contourpy-1.3.3-cp313-cp313-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:348ac1f5d4f1d66d3322420f01d42e43122f43616e0f194fc1c9f5d830c5b286", size = 334672, upload-time = "2025-07-26T12:01:41.942Z" },
+    { url = "https://files.pythonhosted.org/packages/ed/93/b43d8acbe67392e659e1d984700e79eb67e2acb2bd7f62012b583a7f1b55/contourpy-1.3.3-cp313-cp313-manylinux_2_26_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:655456777ff65c2c548b7c454af9c6f33f16c8884f11083244b5819cc214f1b5", size = 381234, upload-time = "2025-07-26T12:01:43.499Z" },
+    { url = "https://files.pythonhosted.org/packages/46/3b/bec82a3ea06f66711520f75a40c8fc0b113b2a75edb36aa633eb11c4f50f/contourpy-1.3.3-cp313-cp313-manylinux_2_26_s390x.manylinux_2_28_s390x.whl", hash = "sha256:644a6853d15b2512d67881586bd03f462c7ab755db95f16f14d7e238f2852c67", size = 385169, upload-time = "2025-07-26T12:01:45.219Z" },
+    { url = "https://files.pythonhosted.org/packages/4b/32/e0f13a1c5b0f8572d0ec6ae2f6c677b7991fafd95da523159c19eff0696a/contourpy-1.3.3-cp313-cp313-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:4debd64f124ca62069f313a9cb86656ff087786016d76927ae2cf37846b006c9", size = 362859, upload-time = "2025-07-26T12:01:46.519Z" },
+    { url = "https://files.pythonhosted.org/packages/33/71/e2a7945b7de4e58af42d708a219f3b2f4cff7386e6b6ab0a0fa0033c49a9/contourpy-1.3.3-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:a15459b0f4615b00bbd1e91f1b9e19b7e63aea7483d03d804186f278c0af2659", size = 1332062, upload-time = "2025-07-26T12:01:48.964Z" },
+    { url = "https://files.pythonhosted.org/packages/12/fc/4e87ac754220ccc0e807284f88e943d6d43b43843614f0a8afa469801db0/contourpy-1.3.3-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:ca0fdcd73925568ca027e0b17ab07aad764be4706d0a925b89227e447d9737b7", size = 1403932, upload-time = "2025-07-26T12:01:51.979Z" },
+    { url = "https://files.pythonhosted.org/packages/a6/2e/adc197a37443f934594112222ac1aa7dc9a98faf9c3842884df9a9d8751d/contourpy-1.3.3-cp313-cp313-win32.whl", hash = "sha256:b20c7c9a3bf701366556e1b1984ed2d0cedf999903c51311417cf5f591d8c78d", size = 185024, upload-time = "2025-07-26T12:01:53.245Z" },
+    { url = "https://files.pythonhosted.org/packages/18/0b/0098c214843213759692cc638fce7de5c289200a830e5035d1791d7a2338/contourpy-1.3.3-cp313-cp313-win_amd64.whl", hash = "sha256:1cadd8b8969f060ba45ed7c1b714fe69185812ab43bd6b86a9123fe8f99c3263", size = 226578, upload-time = "2025-07-26T12:01:54.422Z" },
+    { url = "https://files.pythonhosted.org/packages/8a/9a/2f6024a0c5995243cd63afdeb3651c984f0d2bc727fd98066d40e141ad73/contourpy-1.3.3-cp313-cp313-win_arm64.whl", hash = "sha256:fd914713266421b7536de2bfa8181aa8c699432b6763a0ea64195ebe28bff6a9", size = 193524, upload-time = "2025-07-26T12:01:55.73Z" },
+    { url = "https://files.pythonhosted.org/packages/c0/b3/f8a1a86bd3298513f500e5b1f5fd92b69896449f6cab6a146a5d52715479/contourpy-1.3.3-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:88df9880d507169449d434c293467418b9f6cbe82edd19284aa0409e7fdb933d", size = 306730, upload-time = "2025-07-26T12:01:57.051Z" },
+    { url = "https://files.pythonhosted.org/packages/3f/11/4780db94ae62fc0c2053909b65dc3246bd7cecfc4f8a20d957ad43aa4ad8/contourpy-1.3.3-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:d06bb1f751ba5d417047db62bca3c8fde202b8c11fb50742ab3ab962c81e8216", size = 287897, upload-time = "2025-07-26T12:01:58.663Z" },
+    { url = "https://files.pythonhosted.org/packages/ae/15/e59f5f3ffdd6f3d4daa3e47114c53daabcb18574a26c21f03dc9e4e42ff0/contourpy-1.3.3-cp313-cp313t-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:e4e6b05a45525357e382909a4c1600444e2a45b4795163d3b22669285591c1ae", size = 326751, upload-time = "2025-07-26T12:02:00.343Z" },
+    { url = "https://files.pythonhosted.org/packages/0f/81/03b45cfad088e4770b1dcf72ea78d3802d04200009fb364d18a493857210/contourpy-1.3.3-cp313-cp313t-manylinux_2_26_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:ab3074b48c4e2cf1a960e6bbeb7f04566bf36b1861d5c9d4d8ac04b82e38ba20", size = 375486, upload-time = "2025-07-26T12:02:02.128Z" },
+    { url = "https://files.pythonhosted.org/packages/0c/ba/49923366492ffbdd4486e970d421b289a670ae8cf539c1ea9a09822b371a/contourpy-1.3.3-cp313-cp313t-manylinux_2_26_s390x.manylinux_2_28_s390x.whl", hash = "sha256:6c3d53c796f8647d6deb1abe867daeb66dcc8a97e8455efa729516b997b8ed99", size = 388106, upload-time = "2025-07-26T12:02:03.615Z" },
+    { url = "https://files.pythonhosted.org/packages/9f/52/5b00ea89525f8f143651f9f03a0df371d3cbd2fccd21ca9b768c7a6500c2/contourpy-1.3.3-cp313-cp313t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:50ed930df7289ff2a8d7afeb9603f8289e5704755c7e5c3bbd929c90c817164b", size = 352548, upload-time = "2025-07-26T12:02:05.165Z" },
+    { url = "https://files.pythonhosted.org/packages/32/1d/a209ec1a3a3452d490f6b14dd92e72280c99ae3d1e73da74f8277d4ee08f/contourpy-1.3.3-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:4feffb6537d64b84877da813a5c30f1422ea5739566abf0bd18065ac040e120a", size = 1322297, upload-time = "2025-07-26T12:02:07.379Z" },
+    { url = "https://files.pythonhosted.org/packages/bc/9e/46f0e8ebdd884ca0e8877e46a3f4e633f6c9c8c4f3f6e72be3fe075994aa/contourpy-1.3.3-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:2b7e9480ffe2b0cd2e787e4df64270e3a0440d9db8dc823312e2c940c167df7e", size = 1391023, upload-time = "2025-07-26T12:02:10.171Z" },
+    { url = "https://files.pythonhosted.org/packages/b9/70/f308384a3ae9cd2209e0849f33c913f658d3326900d0ff5d378d6a1422d2/contourpy-1.3.3-cp313-cp313t-win32.whl", hash = "sha256:283edd842a01e3dcd435b1c5116798d661378d83d36d337b8dde1d16a5fc9ba3", size = 196157, upload-time = "2025-07-26T12:02:11.488Z" },
+    { url = "https://files.pythonhosted.org/packages/b2/dd/880f890a6663b84d9e34a6f88cded89d78f0091e0045a284427cb6b18521/contourpy-1.3.3-cp313-cp313t-win_amd64.whl", hash = "sha256:87acf5963fc2b34825e5b6b048f40e3635dd547f590b04d2ab317c2619ef7ae8", size = 240570, upload-time = "2025-07-26T12:02:12.754Z" },
+    { url = "https://files.pythonhosted.org/packages/80/99/2adc7d8ffead633234817ef8e9a87115c8a11927a94478f6bb3d3f4d4f7d/contourpy-1.3.3-cp313-cp313t-win_arm64.whl", hash = "sha256:3c30273eb2a55024ff31ba7d052dde990d7d8e5450f4bbb6e913558b3d6c2301", size = 199713, upload-time = "2025-07-26T12:02:14.4Z" },
+    { url = "https://files.pythonhosted.org/packages/a5/29/8dcfe16f0107943fa92388c23f6e05cff0ba58058c4c95b00280d4c75a14/contourpy-1.3.3-pp311-pypy311_pp73-macosx_10_15_x86_64.whl", hash = "sha256:cd5dfcaeb10f7b7f9dc8941717c6c2ade08f587be2226222c12b25f0483ed497", size = 278809, upload-time = "2025-07-26T12:02:52.74Z" },
+    { url = "https://files.pythonhosted.org/packages/85/a9/8b37ef4f7dafeb335daee3c8254645ef5725be4d9c6aa70b50ec46ef2f7e/contourpy-1.3.3-pp311-pypy311_pp73-macosx_11_0_arm64.whl", hash = "sha256:0c1fc238306b35f246d61a1d416a627348b5cf0648648a031e14bb8705fcdfe8", size = 261593, upload-time = "2025-07-26T12:02:54.037Z" },
+    { url = "https://files.pythonhosted.org/packages/0a/59/ebfb8c677c75605cc27f7122c90313fd2f375ff3c8d19a1694bda74aaa63/contourpy-1.3.3-pp311-pypy311_pp73-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:70f9aad7de812d6541d29d2bbf8feb22ff7e1c299523db288004e3157ff4674e", size = 302202, upload-time = "2025-07-26T12:02:55.947Z" },
+    { url = "https://files.pythonhosted.org/packages/3c/37/21972a15834d90bfbfb009b9d004779bd5a07a0ec0234e5ba8f64d5736f4/contourpy-1.3.3-pp311-pypy311_pp73-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:5ed3657edf08512fc3fe81b510e35c2012fbd3081d2e26160f27ca28affec989", size = 329207, upload-time = "2025-07-26T12:02:57.468Z" },
+    { url = "https://files.pythonhosted.org/packages/0c/58/bd257695f39d05594ca4ad60df5bcb7e32247f9951fd09a9b8edb82d1daa/contourpy-1.3.3-pp311-pypy311_pp73-win_amd64.whl", hash = "sha256:3d1a3799d62d45c18bafd41c5fa05120b96a28079f2393af559b843d1a966a77", size = 225315, upload-time = "2025-07-26T12:02:58.801Z" },
+]
+
+[[package]]
+name = "coverage"
+version = "7.13.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/23/f9/e92df5e07f3fc8d4c7f9a0f146ef75446bf870351cd37b788cf5897f8079/coverage-7.13.1.tar.gz", hash = "sha256:b7593fe7eb5feaa3fbb461ac79aac9f9fc0387a5ca8080b0c6fe2ca27b091afd", size = 825862, upload-time = "2025-12-28T15:42:56.969Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/b4/9b/77baf488516e9ced25fc215a6f75d803493fc3f6a1a1227ac35697910c2a/coverage-7.13.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:1a55d509a1dc5a5b708b5dad3b5334e07a16ad4c2185e27b40e4dba796ab7f88", size = 218755, upload-time = "2025-12-28T15:40:30.812Z" },
+    { url = "https://files.pythonhosted.org/packages/d7/cd/7ab01154e6eb79ee2fab76bf4d89e94c6648116557307ee4ebbb85e5c1bf/coverage-7.13.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:4d010d080c4888371033baab27e47c9df7d6fb28d0b7b7adf85a4a49be9298b3", size = 219257, upload-time = "2025-12-28T15:40:32.333Z" },
+    { url = "https://files.pythonhosted.org/packages/01/d5/b11ef7863ffbbdb509da0023fad1e9eda1c0eaea61a6d2ea5b17d4ac706e/coverage-7.13.1-cp311-cp311-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:d938b4a840fb1523b9dfbbb454f652967f18e197569c32266d4d13f37244c3d9", size = 249657, upload-time = "2025-12-28T15:40:34.1Z" },
+    { url = "https://files.pythonhosted.org/packages/f7/7c/347280982982383621d29b8c544cf497ae07ac41e44b1ca4903024131f55/coverage-7.13.1-cp311-cp311-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:bf100a3288f9bb7f919b87eb84f87101e197535b9bd0e2c2b5b3179633324fee", size = 251581, upload-time = "2025-12-28T15:40:36.131Z" },
+    { url = "https://files.pythonhosted.org/packages/82/f6/ebcfed11036ade4c0d75fa4453a6282bdd225bc073862766eec184a4c643/coverage-7.13.1-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ef6688db9bf91ba111ae734ba6ef1a063304a881749726e0d3575f5c10a9facf", size = 253691, upload-time = "2025-12-28T15:40:37.626Z" },
+    { url = "https://files.pythonhosted.org/packages/02/92/af8f5582787f5d1a8b130b2dcba785fa5e9a7a8e121a0bb2220a6fdbdb8a/coverage-7.13.1-cp311-cp311-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:0b609fc9cdbd1f02e51f67f51e5aee60a841ef58a68d00d5ee2c0faf357481a3", size = 249799, upload-time = "2025-12-28T15:40:39.47Z" },
+    { url = "https://files.pythonhosted.org/packages/24/aa/0e39a2a3b16eebf7f193863323edbff38b6daba711abaaf807d4290cf61a/coverage-7.13.1-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:c43257717611ff5e9a1d79dce8e47566235ebda63328718d9b65dd640bc832ef", size = 251389, upload-time = "2025-12-28T15:40:40.954Z" },
+    { url = "https://files.pythonhosted.org/packages/73/46/7f0c13111154dc5b978900c0ccee2e2ca239b910890e674a77f1363d483e/coverage-7.13.1-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:e09fbecc007f7b6afdfb3b07ce5bd9f8494b6856dd4f577d26c66c391b829851", size = 249450, upload-time = "2025-12-28T15:40:42.489Z" },
+    { url = "https://files.pythonhosted.org/packages/ac/ca/e80da6769e8b669ec3695598c58eef7ad98b0e26e66333996aee6316db23/coverage-7.13.1-cp311-cp311-musllinux_1_2_riscv64.whl", hash = "sha256:a03a4f3a19a189919c7055098790285cc5c5b0b3976f8d227aea39dbf9f8bfdb", size = 249170, upload-time = "2025-12-28T15:40:44.279Z" },
+    { url = "https://files.pythonhosted.org/packages/af/18/9e29baabdec1a8644157f572541079b4658199cfd372a578f84228e860de/coverage-7.13.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:3820778ea1387c2b6a818caec01c63adc5b3750211af6447e8dcfb9b6f08dbba", size = 250081, upload-time = "2025-12-28T15:40:45.748Z" },
+    { url = "https://files.pythonhosted.org/packages/00/f8/c3021625a71c3b2f516464d322e41636aea381018319050a8114105872ee/coverage-7.13.1-cp311-cp311-win32.whl", hash = "sha256:ff10896fa55167371960c5908150b434b71c876dfab97b69478f22c8b445ea19", size = 221281, upload-time = "2025-12-28T15:40:47.232Z" },
+    { url = "https://files.pythonhosted.org/packages/27/56/c216625f453df6e0559ed666d246fcbaaa93f3aa99eaa5080cea1229aa3d/coverage-7.13.1-cp311-cp311-win_amd64.whl", hash = "sha256:a998cc0aeeea4c6d5622a3754da5a493055d2d95186bad877b0a34ea6e6dbe0a", size = 222215, upload-time = "2025-12-28T15:40:49.19Z" },
+    { url = "https://files.pythonhosted.org/packages/5c/9a/be342e76f6e531cae6406dc46af0d350586f24d9b67fdfa6daee02df71af/coverage-7.13.1-cp311-cp311-win_arm64.whl", hash = "sha256:fea07c1a39a22614acb762e3fbbb4011f65eedafcb2948feeef641ac78b4ee5c", size = 220886, upload-time = "2025-12-28T15:40:51.067Z" },
+    { url = "https://files.pythonhosted.org/packages/ce/8a/87af46cccdfa78f53db747b09f5f9a21d5fc38d796834adac09b30a8ce74/coverage-7.13.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:6f34591000f06e62085b1865c9bc5f7858df748834662a51edadfd2c3bfe0dd3", size = 218927, upload-time = "2025-12-28T15:40:52.814Z" },
+    { url = "https://files.pythonhosted.org/packages/82/a8/6e22fdc67242a4a5a153f9438d05944553121c8f4ba70cb072af4c41362e/coverage-7.13.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:b67e47c5595b9224599016e333f5ec25392597a89d5744658f837d204e16c63e", size = 219288, upload-time = "2025-12-28T15:40:54.262Z" },
+    { url = "https://files.pythonhosted.org/packages/d0/0a/853a76e03b0f7c4375e2ca025df45c918beb367f3e20a0a8e91967f6e96c/coverage-7.13.1-cp312-cp312-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:3e7b8bd70c48ffb28461ebe092c2345536fb18bbbf19d287c8913699735f505c", size = 250786, upload-time = "2025-12-28T15:40:56.059Z" },
+    { url = "https://files.pythonhosted.org/packages/ea/b4/694159c15c52b9f7ec7adf49d50e5f8ee71d3e9ef38adb4445d13dd56c20/coverage-7.13.1-cp312-cp312-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:c223d078112e90dc0e5c4e35b98b9584164bea9fbbd221c0b21c5241f6d51b62", size = 253543, upload-time = "2025-12-28T15:40:57.585Z" },
+    { url = "https://files.pythonhosted.org/packages/96/b2/7f1f0437a5c855f87e17cf5d0dc35920b6440ff2b58b1ba9788c059c26c8/coverage-7.13.1-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:794f7c05af0763b1bbd1b9e6eff0e52ad068be3b12cd96c87de037b01390c968", size = 254635, upload-time = "2025-12-28T15:40:59.443Z" },
+    { url = "https://files.pythonhosted.org/packages/e9/d1/73c3fdb8d7d3bddd9473c9c6a2e0682f09fc3dfbcb9c3f36412a7368bcab/coverage-7.13.1-cp312-cp312-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:0642eae483cc8c2902e4af7298bf886d605e80f26382124cddc3967c2a3df09e", size = 251202, upload-time = "2025-12-28T15:41:01.328Z" },
+    { url = "https://files.pythonhosted.org/packages/66/3c/f0edf75dcc152f145d5598329e864bbbe04ab78660fe3e8e395f9fff010f/coverage-7.13.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:9f5e772ed5fef25b3de9f2008fe67b92d46831bd2bc5bdc5dd6bfd06b83b316f", size = 252566, upload-time = "2025-12-28T15:41:03.319Z" },
+    { url = "https://files.pythonhosted.org/packages/17/b3/e64206d3c5f7dcbceafd14941345a754d3dbc78a823a6ed526e23b9cdaab/coverage-7.13.1-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:45980ea19277dc0a579e432aef6a504fe098ef3a9032ead15e446eb0f1191aee", size = 250711, upload-time = "2025-12-28T15:41:06.411Z" },
+    { url = "https://files.pythonhosted.org/packages/dc/ad/28a3eb970a8ef5b479ee7f0c484a19c34e277479a5b70269dc652b730733/coverage-7.13.1-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:e4f18eca6028ffa62adbd185a8f1e1dd242f2e68164dba5c2b74a5204850b4cf", size = 250278, upload-time = "2025-12-28T15:41:08.285Z" },
+    { url = "https://files.pythonhosted.org/packages/54/e3/c8f0f1a93133e3e1291ca76cbb63565bd4b5c5df63b141f539d747fff348/coverage-7.13.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:f8dca5590fec7a89ed6826fce625595279e586ead52e9e958d3237821fbc750c", size = 252154, upload-time = "2025-12-28T15:41:09.969Z" },
+    { url = "https://files.pythonhosted.org/packages/d0/bf/9939c5d6859c380e405b19e736321f1c7d402728792f4c752ad1adcce005/coverage-7.13.1-cp312-cp312-win32.whl", hash = "sha256:ff86d4e85188bba72cfb876df3e11fa243439882c55957184af44a35bd5880b7", size = 221487, upload-time = "2025-12-28T15:41:11.468Z" },
+    { url = "https://files.pythonhosted.org/packages/fa/dc/7282856a407c621c2aad74021680a01b23010bb8ebf427cf5eacda2e876f/coverage-7.13.1-cp312-cp312-win_amd64.whl", hash = "sha256:16cc1da46c04fb0fb128b4dc430b78fa2aba8a6c0c9f8eb391fd5103409a6ac6", size = 222299, upload-time = "2025-12-28T15:41:13.386Z" },
+    { url = "https://files.pythonhosted.org/packages/10/79/176a11203412c350b3e9578620013af35bcdb79b651eb976f4a4b32044fa/coverage-7.13.1-cp312-cp312-win_arm64.whl", hash = "sha256:8d9bc218650022a768f3775dd7fdac1886437325d8d295d923ebcfef4892ad5c", size = 220941, upload-time = "2025-12-28T15:41:14.975Z" },
+    { url = "https://files.pythonhosted.org/packages/a3/a4/e98e689347a1ff1a7f67932ab535cef82eb5e78f32a9e4132e114bbb3a0a/coverage-7.13.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:cb237bfd0ef4d5eb6a19e29f9e528ac67ac3be932ea6b44fb6cc09b9f3ecff78", size = 218951, upload-time = "2025-12-28T15:41:16.653Z" },
+    { url = "https://files.pythonhosted.org/packages/32/33/7cbfe2bdc6e2f03d6b240d23dc45fdaf3fd270aaf2d640be77b7f16989ab/coverage-7.13.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:1dcb645d7e34dcbcc96cd7c132b1fc55c39263ca62eb961c064eb3928997363b", size = 219325, upload-time = "2025-12-28T15:41:18.609Z" },
+    { url = "https://files.pythonhosted.org/packages/59/f6/efdabdb4929487baeb7cb2a9f7dac457d9356f6ad1b255be283d58b16316/coverage-7.13.1-cp313-cp313-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:3d42df8201e00384736f0df9be2ced39324c3907607d17d50d50116c989d84cd", size = 250309, upload-time = "2025-12-28T15:41:20.629Z" },
+    { url = "https://files.pythonhosted.org/packages/12/da/91a52516e9d5aea87d32d1523f9cdcf7a35a3b298e6be05d6509ba3cfab2/coverage-7.13.1-cp313-cp313-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:fa3edde1aa8807de1d05934982416cb3ec46d1d4d91e280bcce7cca01c507992", size = 252907, upload-time = "2025-12-28T15:41:22.257Z" },
+    { url = "https://files.pythonhosted.org/packages/75/38/f1ea837e3dc1231e086db1638947e00d264e7e8c41aa8ecacf6e1e0c05f4/coverage-7.13.1-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:9edd0e01a343766add6817bc448408858ba6b489039eaaa2018474e4001651a4", size = 254148, upload-time = "2025-12-28T15:41:23.87Z" },
+    { url = "https://files.pythonhosted.org/packages/7f/43/f4f16b881aaa34954ba446318dea6b9ed5405dd725dd8daac2358eda869a/coverage-7.13.1-cp313-cp313-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:985b7836931d033570b94c94713c6dba5f9d3ff26045f72c3e5dbc5fe3361e5a", size = 250515, upload-time = "2025-12-28T15:41:25.437Z" },
+    { url = "https://files.pythonhosted.org/packages/84/34/8cba7f00078bd468ea914134e0144263194ce849ec3baad187ffb6203d1c/coverage-7.13.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:ffed1e4980889765c84a5d1a566159e363b71d6b6fbaf0bebc9d3c30bc016766", size = 252292, upload-time = "2025-12-28T15:41:28.459Z" },
+    { url = "https://files.pythonhosted.org/packages/8c/a4/cffac66c7652d84ee4ac52d3ccb94c015687d3b513f9db04bfcac2ac800d/coverage-7.13.1-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:8842af7f175078456b8b17f1b73a0d16a65dcbdc653ecefeb00a56b3c8c298c4", size = 250242, upload-time = "2025-12-28T15:41:30.02Z" },
+    { url = "https://files.pythonhosted.org/packages/f4/78/9a64d462263dde416f3c0067efade7b52b52796f489b1037a95b0dc389c9/coverage-7.13.1-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:ccd7a6fca48ca9c131d9b0a2972a581e28b13416fc313fb98b6d24a03ce9a398", size = 250068, upload-time = "2025-12-28T15:41:32.007Z" },
+    { url = "https://files.pythonhosted.org/packages/69/c8/a8994f5fece06db7c4a97c8fc1973684e178599b42e66280dded0524ef00/coverage-7.13.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:0403f647055de2609be776965108447deb8e384fe4a553c119e3ff6bfbab4784", size = 251846, upload-time = "2025-12-28T15:41:33.946Z" },
+    { url = "https://files.pythonhosted.org/packages/cc/f7/91fa73c4b80305c86598a2d4e54ba22df6bf7d0d97500944af7ef155d9f7/coverage-7.13.1-cp313-cp313-win32.whl", hash = "sha256:549d195116a1ba1e1ae2f5ca143f9777800f6636eab917d4f02b5310d6d73461", size = 221512, upload-time = "2025-12-28T15:41:35.519Z" },
+    { url = "https://files.pythonhosted.org/packages/45/0b/0768b4231d5a044da8f75e097a8714ae1041246bb765d6b5563bab456735/coverage-7.13.1-cp313-cp313-win_amd64.whl", hash = "sha256:5899d28b5276f536fcf840b18b61a9fce23cc3aec1d114c44c07fe94ebeaa500", size = 222321, upload-time = "2025-12-28T15:41:37.371Z" },
+    { url = "https://files.pythonhosted.org/packages/9b/b8/bdcb7253b7e85157282450262008f1366aa04663f3e3e4c30436f596c3e2/coverage-7.13.1-cp313-cp313-win_arm64.whl", hash = "sha256:868a2fae76dfb06e87291bcbd4dcbcc778a8500510b618d50496e520bd94d9b9", size = 220949, upload-time = "2025-12-28T15:41:39.553Z" },
+    { url = "https://files.pythonhosted.org/packages/70/52/f2be52cc445ff75ea8397948c96c1b4ee14f7f9086ea62fc929c5ae7b717/coverage-7.13.1-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:67170979de0dacac3f3097d02b0ad188d8edcea44ccc44aaa0550af49150c7dc", size = 219643, upload-time = "2025-12-28T15:41:41.567Z" },
+    { url = "https://files.pythonhosted.org/packages/47/79/c85e378eaa239e2edec0c5523f71542c7793fe3340954eafb0bc3904d32d/coverage-7.13.1-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:f80e2bb21bfab56ed7405c2d79d34b5dc0bc96c2c1d2a067b643a09fb756c43a", size = 219997, upload-time = "2025-12-28T15:41:43.418Z" },
+    { url = "https://files.pythonhosted.org/packages/fe/9b/b1ade8bfb653c0bbce2d6d6e90cc6c254cbb99b7248531cc76253cb4da6d/coverage-7.13.1-cp313-cp313t-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:f83351e0f7dcdb14d7326c3d8d8c4e915fa685cbfdc6281f9470d97a04e9dfe4", size = 261296, upload-time = "2025-12-28T15:41:45.207Z" },
+    { url = "https://files.pythonhosted.org/packages/1f/af/ebf91e3e1a2473d523e87e87fd8581e0aa08741b96265730e2d79ce78d8d/coverage-7.13.1-cp313-cp313t-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:bb3f6562e89bad0110afbe64e485aac2462efdce6232cdec7862a095dc3412f6", size = 263363, upload-time = "2025-12-28T15:41:47.163Z" },
+    { url = "https://files.pythonhosted.org/packages/c4/8b/fb2423526d446596624ac7fde12ea4262e66f86f5120114c3cfd0bb2befa/coverage-7.13.1-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:77545b5dcda13b70f872c3b5974ac64c21d05e65b1590b441c8560115dc3a0d1", size = 265783, upload-time = "2025-12-28T15:41:49.03Z" },
+    { url = "https://files.pythonhosted.org/packages/9b/26/ef2adb1e22674913b89f0fe7490ecadcef4a71fa96f5ced90c60ec358789/coverage-7.13.1-cp313-cp313t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:a4d240d260a1aed814790bbe1f10a5ff31ce6c21bc78f0da4a1e8268d6c80dbd", size = 260508, upload-time = "2025-12-28T15:41:51.035Z" },
+    { url = "https://files.pythonhosted.org/packages/ce/7d/f0f59b3404caf662e7b5346247883887687c074ce67ba453ea08c612b1d5/coverage-7.13.1-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:d2287ac9360dec3837bfdad969963a5d073a09a85d898bd86bea82aa8876ef3c", size = 263357, upload-time = "2025-12-28T15:41:52.631Z" },
+    { url = "https://files.pythonhosted.org/packages/1a/b1/29896492b0b1a047604d35d6fa804f12818fa30cdad660763a5f3159e158/coverage-7.13.1-cp313-cp313t-musllinux_1_2_i686.whl", hash = "sha256:0d2c11f3ea4db66b5cbded23b20185c35066892c67d80ec4be4bab257b9ad1e0", size = 260978, upload-time = "2025-12-28T15:41:54.589Z" },
+    { url = "https://files.pythonhosted.org/packages/48/f2/971de1238a62e6f0a4128d37adadc8bb882ee96afbe03ff1570291754629/coverage-7.13.1-cp313-cp313t-musllinux_1_2_riscv64.whl", hash = "sha256:3fc6a169517ca0d7ca6846c3c5392ef2b9e38896f61d615cb75b9e7134d4ee1e", size = 259877, upload-time = "2025-12-28T15:41:56.263Z" },
+    { url = "https://files.pythonhosted.org/packages/6a/fc/0474efcbb590ff8628830e9aaec5f1831594874360e3251f1fdec31d07a3/coverage-7.13.1-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:d10a2ed46386e850bb3de503a54f9fe8192e5917fcbb143bfef653a9355e9a53", size = 262069, upload-time = "2025-12-28T15:41:58.093Z" },
+    { url = "https://files.pythonhosted.org/packages/88/4f/3c159b7953db37a7b44c0eab8a95c37d1aa4257c47b4602c04022d5cb975/coverage-7.13.1-cp313-cp313t-win32.whl", hash = "sha256:75a6f4aa904301dab8022397a22c0039edc1f51e90b83dbd4464b8a38dc87842", size = 222184, upload-time = "2025-12-28T15:41:59.763Z" },
+    { url = "https://files.pythonhosted.org/packages/58/a5/6b57d28f81417f9335774f20679d9d13b9a8fb90cd6160957aa3b54a2379/coverage-7.13.1-cp313-cp313t-win_amd64.whl", hash = "sha256:309ef5706e95e62578cda256b97f5e097916a2c26247c287bbe74794e7150df2", size = 223250, upload-time = "2025-12-28T15:42:01.52Z" },
+    { url = "https://files.pythonhosted.org/packages/81/7c/160796f3b035acfbb58be80e02e484548595aa67e16a6345e7910ace0a38/coverage-7.13.1-cp313-cp313t-win_arm64.whl", hash = "sha256:92f980729e79b5d16d221038dbf2e8f9a9136afa072f9d5d6ed4cb984b126a09", size = 221521, upload-time = "2025-12-28T15:42:03.275Z" },
+    { url = "https://files.pythonhosted.org/packages/cc/48/d9f421cb8da5afaa1a64570d9989e00fb7955e6acddc5a12979f7666ef60/coverage-7.13.1-py3-none-any.whl", hash = "sha256:2016745cb3ba554469d02819d78958b571792bb68e31302610e898f80dd3a573", size = 210722, upload-time = "2025-12-28T15:42:54.901Z" },
+]
+
+[[package]]
+name = "cycler"
+version = "0.12.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/a9/95/a3dbbb5028f35eafb79008e7522a75244477d2838f38cbb722248dabc2a8/cycler-0.12.1.tar.gz", hash = "sha256:88bb128f02ba341da8ef447245a9e138fae777f6a23943da4540077d3601eb1c", size = 7615, upload-time = "2023-10-07T05:32:18.335Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/e7/05/c19819d5e3d95294a6f5947fb9b9629efb316b96de511b418c53d245aae6/cycler-0.12.1-py3-none-any.whl", hash = "sha256:85cef7cff222d8644161529808465972e51340599459b8ac3ccbac5a854e0d30", size = 8321, upload-time = "2023-10-07T05:32:16.783Z" },
+]
+
+[[package]]
+name = "debugpy"
+version = "1.8.19"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/73/75/9e12d4d42349b817cd545b89247696c67917aab907012ae5b64bbfea3199/debugpy-1.8.19.tar.gz", hash = "sha256:eea7e5987445ab0b5ed258093722d5ecb8bb72217c5c9b1e21f64efe23ddebdb", size = 1644590, upload-time = "2025-12-15T21:53:28.044Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/80/e2/48531a609b5a2aa94c6b6853afdfec8da05630ab9aaa96f1349e772119e9/debugpy-1.8.19-cp311-cp311-macosx_15_0_universal2.whl", hash = "sha256:c5dcfa21de1f735a4f7ced4556339a109aa0f618d366ede9da0a3600f2516d8b", size = 2207620, upload-time = "2025-12-15T21:53:37.1Z" },
+    { url = "https://files.pythonhosted.org/packages/1b/d4/97775c01d56071969f57d93928899e5616a4cfbbf4c8cc75390d3a51c4a4/debugpy-1.8.19-cp311-cp311-manylinux_2_34_x86_64.whl", hash = "sha256:806d6800246244004625d5222d7765874ab2d22f3ba5f615416cf1342d61c488", size = 3170796, upload-time = "2025-12-15T21:53:38.513Z" },
+    { url = "https://files.pythonhosted.org/packages/8d/7e/8c7681bdb05be9ec972bbb1245eb7c4c7b0679bb6a9e6408d808bc876d3d/debugpy-1.8.19-cp311-cp311-win32.whl", hash = "sha256:783a519e6dfb1f3cd773a9bda592f4887a65040cb0c7bd38dde410f4e53c40d4", size = 5164287, upload-time = "2025-12-15T21:53:40.857Z" },
+    { url = "https://files.pythonhosted.org/packages/f2/a8/aaac7ff12ddf5d68a39e13a423a8490426f5f661384f5ad8d9062761bd8e/debugpy-1.8.19-cp311-cp311-win_amd64.whl", hash = "sha256:14035cbdbb1fe4b642babcdcb5935c2da3b1067ac211c5c5a8fdc0bb31adbcaa", size = 5188269, upload-time = "2025-12-15T21:53:42.359Z" },
+    { url = "https://files.pythonhosted.org/packages/4a/15/d762e5263d9e25b763b78be72dc084c7a32113a0bac119e2f7acae7700ed/debugpy-1.8.19-cp312-cp312-macosx_15_0_universal2.whl", hash = "sha256:bccb1540a49cde77edc7ce7d9d075c1dbeb2414751bc0048c7a11e1b597a4c2e", size = 2549995, upload-time = "2025-12-15T21:53:43.773Z" },
+    { url = "https://files.pythonhosted.org/packages/a7/88/f7d25c68b18873b7c53d7c156ca7a7ffd8e77073aa0eac170a9b679cf786/debugpy-1.8.19-cp312-cp312-manylinux_2_34_x86_64.whl", hash = "sha256:e9c68d9a382ec754dc05ed1d1b4ed5bd824b9f7c1a8cd1083adb84b3c93501de", size = 4309891, upload-time = "2025-12-15T21:53:45.26Z" },
+    { url = "https://files.pythonhosted.org/packages/c5/4f/a65e973aba3865794da65f71971dca01ae66666132c7b2647182d5be0c5f/debugpy-1.8.19-cp312-cp312-win32.whl", hash = "sha256:6599cab8a783d1496ae9984c52cb13b7c4a3bd06a8e6c33446832a5d97ce0bee", size = 5286355, upload-time = "2025-12-15T21:53:46.763Z" },
+    { url = "https://files.pythonhosted.org/packages/d8/3a/d3d8b48fec96e3d824e404bf428276fb8419dfa766f78f10b08da1cb2986/debugpy-1.8.19-cp312-cp312-win_amd64.whl", hash = "sha256:66e3d2fd8f2035a8f111eb127fa508469dfa40928a89b460b41fd988684dc83d", size = 5328239, upload-time = "2025-12-15T21:53:48.868Z" },
+    { url = "https://files.pythonhosted.org/packages/71/3d/388035a31a59c26f1ecc8d86af607d0c42e20ef80074147cd07b180c4349/debugpy-1.8.19-cp313-cp313-macosx_15_0_universal2.whl", hash = "sha256:91e35db2672a0abaf325f4868fcac9c1674a0d9ad9bb8a8c849c03a5ebba3e6d", size = 2538859, upload-time = "2025-12-15T21:53:50.478Z" },
+    { url = "https://files.pythonhosted.org/packages/4a/19/c93a0772d0962294f083dbdb113af1a7427bb632d36e5314297068f55db7/debugpy-1.8.19-cp313-cp313-manylinux_2_34_x86_64.whl", hash = "sha256:85016a73ab84dea1c1f1dcd88ec692993bcbe4532d1b49ecb5f3c688ae50c606", size = 4292575, upload-time = "2025-12-15T21:53:51.821Z" },
+    { url = "https://files.pythonhosted.org/packages/5c/56/09e48ab796b0a77e3d7dc250f95251832b8bf6838c9632f6100c98bdf426/debugpy-1.8.19-cp313-cp313-win32.whl", hash = "sha256:b605f17e89ba0ecee994391194285fada89cee111cfcd29d6f2ee11cbdc40976", size = 5286209, upload-time = "2025-12-15T21:53:53.602Z" },
+    { url = "https://files.pythonhosted.org/packages/fb/4e/931480b9552c7d0feebe40c73725dd7703dcc578ba9efc14fe0e6d31cfd1/debugpy-1.8.19-cp313-cp313-win_amd64.whl", hash = "sha256:c30639998a9f9cd9699b4b621942c0179a6527f083c72351f95c6ab1728d5b73", size = 5328206, upload-time = "2025-12-15T21:53:55.433Z" },
+    { url = "https://files.pythonhosted.org/packages/25/3e/e27078370414ef35fafad2c06d182110073daaeb5d3bf734b0b1eeefe452/debugpy-1.8.19-py2.py3-none-any.whl", hash = "sha256:360ffd231a780abbc414ba0f005dad409e71c78637efe8f2bd75837132a41d38", size = 5292321, upload-time = "2025-12-15T21:54:16.024Z" },
+]
+
+[[package]]
+name = "decorator"
+version = "5.2.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/43/fa/6d96a0978d19e17b68d634497769987b16c8f4cd0a7a05048bec693caa6b/decorator-5.2.1.tar.gz", hash = "sha256:65f266143752f734b0a7cc83c46f4618af75b8c5911b00ccb61d0ac9b6da0360", size = 56711, upload-time = "2025-02-24T04:41:34.073Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/4e/8c/f3147f5c4b73e7550fe5f9352eaa956ae838d5c51eb58e7a25b9f3e2643b/decorator-5.2.1-py3-none-any.whl", hash = "sha256:d316bb415a2d9e2d2b3abcc4084c6502fc09240e292cd76a76afc106a1c8e04a", size = 9190, upload-time = "2025-02-24T04:41:32.565Z" },
+]
+
+[[package]]
+name = "distlib"
+version = "0.4.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/96/8e/709914eb2b5749865801041647dc7f4e6d00b549cfe88b65ca192995f07c/distlib-0.4.0.tar.gz", hash = "sha256:feec40075be03a04501a973d81f633735b4b69f98b05450592310c0f401a4e0d", size = 614605, upload-time = "2025-07-17T16:52:00.465Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/33/6b/e0547afaf41bf2c42e52430072fa5658766e3d65bd4b03a563d1b6336f57/distlib-0.4.0-py2.py3-none-any.whl", hash = "sha256:9659f7d87e46584a30b5780e43ac7a2143098441670ff0a49d5f9034c54a6c16", size = 469047, upload-time = "2025-07-17T16:51:58.613Z" },
+]
+
+[[package]]
+name = "executing"
+version = "2.2.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/cc/28/c14e053b6762b1044f34a13aab6859bbf40456d37d23aa286ac24cfd9a5d/executing-2.2.1.tar.gz", hash = "sha256:3632cc370565f6648cc328b32435bd120a1e4ebb20c77e3fdde9a13cd1e533c4", size = 1129488, upload-time = "2025-09-01T09:48:10.866Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/c1/ea/53f2148663b321f21b5a606bd5f191517cf40b7072c0497d3c92c4a13b1e/executing-2.2.1-py2.py3-none-any.whl", hash = "sha256:760643d3452b4d777d295bb167ccc74c64a81df23fb5e08eff250c425a4b2017", size = 28317, upload-time = "2025-09-01T09:48:08.5Z" },
+]
+
+[[package]]
+name = "filelock"
+version = "3.20.3"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/1d/65/ce7f1b70157833bf3cb851b556a37d4547ceafc158aa9b34b36782f23696/filelock-3.20.3.tar.gz", hash = "sha256:18c57ee915c7ec61cff0ecf7f0f869936c7c30191bb0cf406f1341778d0834e1", size = 19485, upload-time = "2026-01-09T17:55:05.421Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/b5/36/7fb70f04bf00bc646cd5bb45aa9eddb15e19437a28b8fb2b4a5249fac770/filelock-3.20.3-py3-none-any.whl", hash = "sha256:4b0dda527ee31078689fc205ec4f1c1bf7d56cf88b6dc9426c4f230e46c2dce1", size = 16701, upload-time = "2026-01-09T17:55:04.334Z" },
+]
+
+[[package]]
+name = "fonttools"
+version = "4.61.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/ec/ca/cf17b88a8df95691275a3d77dc0a5ad9907f328ae53acbe6795da1b2f5ed/fonttools-4.61.1.tar.gz", hash = "sha256:6675329885c44657f826ef01d9e4fb33b9158e9d93c537d84ad8399539bc6f69", size = 3565756, upload-time = "2025-12-12T17:31:24.246Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/69/12/bf9f4eaa2fad039356cc627587e30ed008c03f1cebd3034376b5ee8d1d44/fonttools-4.61.1-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:c6604b735bb12fef8e0efd5578c9fb5d3d8532d5001ea13a19cddf295673ee09", size = 2852213, upload-time = "2025-12-12T17:29:46.675Z" },
+    { url = "https://files.pythonhosted.org/packages/ac/49/4138d1acb6261499bedde1c07f8c2605d1d8f9d77a151e5507fd3ef084b6/fonttools-4.61.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:5ce02f38a754f207f2f06557523cd39a06438ba3aafc0639c477ac409fc64e37", size = 2401689, upload-time = "2025-12-12T17:29:48.769Z" },
+    { url = "https://files.pythonhosted.org/packages/e5/fe/e6ce0fe20a40e03aef906af60aa87668696f9e4802fa283627d0b5ed777f/fonttools-4.61.1-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:77efb033d8d7ff233385f30c62c7c79271c8885d5c9657d967ede124671bbdfb", size = 5058809, upload-time = "2025-12-12T17:29:51.701Z" },
+    { url = "https://files.pythonhosted.org/packages/79/61/1ca198af22f7dd22c17ab86e9024ed3c06299cfdb08170640e9996d501a0/fonttools-4.61.1-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:75c1a6dfac6abd407634420c93864a1e274ebc1c7531346d9254c0d8f6ca00f9", size = 5036039, upload-time = "2025-12-12T17:29:53.659Z" },
+    { url = "https://files.pythonhosted.org/packages/99/cc/fa1801e408586b5fce4da9f5455af8d770f4fc57391cd5da7256bb364d38/fonttools-4.61.1-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:0de30bfe7745c0d1ffa2b0b7048fb7123ad0d71107e10ee090fa0b16b9452e87", size = 5034714, upload-time = "2025-12-12T17:29:55.592Z" },
+    { url = "https://files.pythonhosted.org/packages/bf/aa/b7aeafe65adb1b0a925f8f25725e09f078c635bc22754f3fecb7456955b0/fonttools-4.61.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:58b0ee0ab5b1fc9921eccfe11d1435added19d6494dde14e323f25ad2bc30c56", size = 5158648, upload-time = "2025-12-12T17:29:57.861Z" },
+    { url = "https://files.pythonhosted.org/packages/99/f9/08ea7a38663328881384c6e7777bbefc46fd7d282adfd87a7d2b84ec9d50/fonttools-4.61.1-cp311-cp311-win32.whl", hash = "sha256:f79b168428351d11e10c5aeb61a74e1851ec221081299f4cf56036a95431c43a", size = 2280681, upload-time = "2025-12-12T17:29:59.943Z" },
+    { url = "https://files.pythonhosted.org/packages/07/ad/37dd1ae5fa6e01612a1fbb954f0927681f282925a86e86198ccd7b15d515/fonttools-4.61.1-cp311-cp311-win_amd64.whl", hash = "sha256:fe2efccb324948a11dd09d22136fe2ac8a97d6c1347cf0b58a911dcd529f66b7", size = 2331951, upload-time = "2025-12-12T17:30:02.254Z" },
+    { url = "https://files.pythonhosted.org/packages/6f/16/7decaa24a1bd3a70c607b2e29f0adc6159f36a7e40eaba59846414765fd4/fonttools-4.61.1-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:f3cb4a569029b9f291f88aafc927dd53683757e640081ca8c412781ea144565e", size = 2851593, upload-time = "2025-12-12T17:30:04.225Z" },
+    { url = "https://files.pythonhosted.org/packages/94/98/3c4cb97c64713a8cf499b3245c3bf9a2b8fd16a3e375feff2aed78f96259/fonttools-4.61.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:41a7170d042e8c0024703ed13b71893519a1a6d6e18e933e3ec7507a2c26a4b2", size = 2400231, upload-time = "2025-12-12T17:30:06.47Z" },
+    { url = "https://files.pythonhosted.org/packages/b7/37/82dbef0f6342eb01f54bca073ac1498433d6ce71e50c3c3282b655733b31/fonttools-4.61.1-cp312-cp312-manylinux1_x86_64.manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:10d88e55330e092940584774ee5e8a6971b01fc2f4d3466a1d6c158230880796", size = 4954103, upload-time = "2025-12-12T17:30:08.432Z" },
+    { url = "https://files.pythonhosted.org/packages/6c/44/f3aeac0fa98e7ad527f479e161aca6c3a1e47bb6996b053d45226fe37bf2/fonttools-4.61.1-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:15acc09befd16a0fb8a8f62bc147e1a82817542d72184acca9ce6e0aeda9fa6d", size = 5004295, upload-time = "2025-12-12T17:30:10.56Z" },
+    { url = "https://files.pythonhosted.org/packages/14/e8/7424ced75473983b964d09f6747fa09f054a6d656f60e9ac9324cf40c743/fonttools-4.61.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:e6bcdf33aec38d16508ce61fd81838f24c83c90a1d1b8c68982857038673d6b8", size = 4944109, upload-time = "2025-12-12T17:30:12.874Z" },
+    { url = "https://files.pythonhosted.org/packages/c8/8b/6391b257fa3d0b553d73e778f953a2f0154292a7a7a085e2374b111e5410/fonttools-4.61.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:5fade934607a523614726119164ff621e8c30e8fa1ffffbbd358662056ba69f0", size = 5093598, upload-time = "2025-12-12T17:30:15.79Z" },
+    { url = "https://files.pythonhosted.org/packages/d9/71/fd2ea96cdc512d92da5678a1c98c267ddd4d8c5130b76d0f7a80f9a9fde8/fonttools-4.61.1-cp312-cp312-win32.whl", hash = "sha256:75da8f28eff26defba42c52986de97b22106cb8f26515b7c22443ebc9c2d3261", size = 2269060, upload-time = "2025-12-12T17:30:18.058Z" },
+    { url = "https://files.pythonhosted.org/packages/80/3b/a3e81b71aed5a688e89dfe0e2694b26b78c7d7f39a5ffd8a7d75f54a12a8/fonttools-4.61.1-cp312-cp312-win_amd64.whl", hash = "sha256:497c31ce314219888c0e2fce5ad9178ca83fe5230b01a5006726cdf3ac9f24d9", size = 2319078, upload-time = "2025-12-12T17:30:22.862Z" },
+    { url = "https://files.pythonhosted.org/packages/4b/cf/00ba28b0990982530addb8dc3e9e6f2fa9cb5c20df2abdda7baa755e8fe1/fonttools-4.61.1-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:8c56c488ab471628ff3bfa80964372fc13504ece601e0d97a78ee74126b2045c", size = 2846454, upload-time = "2025-12-12T17:30:24.938Z" },
+    { url = "https://files.pythonhosted.org/packages/5a/ca/468c9a8446a2103ae645d14fee3f610567b7042aba85031c1c65e3ef7471/fonttools-4.61.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:dc492779501fa723b04d0ab1f5be046797fee17d27700476edc7ee9ae535a61e", size = 2398191, upload-time = "2025-12-12T17:30:27.343Z" },
+    { url = "https://files.pythonhosted.org/packages/a3/4b/d67eedaed19def5967fade3297fed8161b25ba94699efc124b14fb68cdbc/fonttools-4.61.1-cp313-cp313-manylinux1_x86_64.manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:64102ca87e84261419c3747a0d20f396eb024bdbeb04c2bfb37e2891f5fadcb5", size = 4928410, upload-time = "2025-12-12T17:30:29.771Z" },
+    { url = "https://files.pythonhosted.org/packages/b0/8d/6fb3494dfe61a46258cd93d979cf4725ded4eb46c2a4ca35e4490d84daea/fonttools-4.61.1-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:4c1b526c8d3f615a7b1867f38a9410849c8f4aef078535742198e942fba0e9bd", size = 4984460, upload-time = "2025-12-12T17:30:32.073Z" },
+    { url = "https://files.pythonhosted.org/packages/f7/f1/a47f1d30b3dc00d75e7af762652d4cbc3dff5c2697a0dbd5203c81afd9c3/fonttools-4.61.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:41ed4b5ec103bd306bb68f81dc166e77409e5209443e5773cb4ed837bcc9b0d3", size = 4925800, upload-time = "2025-12-12T17:30:34.339Z" },
+    { url = "https://files.pythonhosted.org/packages/a7/01/e6ae64a0981076e8a66906fab01539799546181e32a37a0257b77e4aa88b/fonttools-4.61.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:b501c862d4901792adaec7c25b1ecc749e2662543f68bb194c42ba18d6eec98d", size = 5067859, upload-time = "2025-12-12T17:30:36.593Z" },
+    { url = "https://files.pythonhosted.org/packages/73/aa/28e40b8d6809a9b5075350a86779163f074d2b617c15d22343fce81918db/fonttools-4.61.1-cp313-cp313-win32.whl", hash = "sha256:4d7092bb38c53bbc78e9255a59158b150bcdc115a1e3b3ce0b5f267dc35dd63c", size = 2267821, upload-time = "2025-12-12T17:30:38.478Z" },
+    { url = "https://files.pythonhosted.org/packages/1a/59/453c06d1d83dc0951b69ef692d6b9f1846680342927df54e9a1ca91c6f90/fonttools-4.61.1-cp313-cp313-win_amd64.whl", hash = "sha256:21e7c8d76f62ab13c9472ccf74515ca5b9a761d1bde3265152a6dc58700d895b", size = 2318169, upload-time = "2025-12-12T17:30:40.951Z" },
+    { url = "https://files.pythonhosted.org/packages/c7/4e/ce75a57ff3aebf6fc1f4e9d508b8e5810618a33d900ad6c19eb30b290b97/fonttools-4.61.1-py3-none-any.whl", hash = "sha256:17d2bf5d541add43822bcf0c43d7d847b160c9bb01d15d5007d84e2217aaa371", size = 1148996, upload-time = "2025-12-12T17:31:21.03Z" },
+]
+
+[[package]]
+name = "identify"
+version = "2.6.15"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/ff/e7/685de97986c916a6d93b3876139e00eef26ad5bbbd61925d670ae8013449/identify-2.6.15.tar.gz", hash = "sha256:e4f4864b96c6557ef2a1e1c951771838f4edc9df3a72ec7118b338801b11c7bf", size = 99311, upload-time = "2025-10-02T17:43:40.631Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/0f/1c/e5fd8f973d4f375adb21565739498e2e9a1e54c858a97b9a8ccfdc81da9b/identify-2.6.15-py2.py3-none-any.whl", hash = "sha256:1181ef7608e00704db228516541eb83a88a9f94433a8c80bb9b5bd54b1d81757", size = 99183, upload-time = "2025-10-02T17:43:39.137Z" },
+]
+
+[[package]]
+name = "iniconfig"
+version = "2.3.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/72/34/14ca021ce8e5dfedc35312d08ba8bf51fdd999c576889fc2c24cb97f4f10/iniconfig-2.3.0.tar.gz", hash = "sha256:c76315c77db068650d49c5b56314774a7804df16fee4402c1f19d6d15d8c4730", size = 20503, upload-time = "2025-10-18T21:55:43.219Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/cb/b1/3846dd7f199d53cb17f49cba7e651e9ce294d8497c8c150530ed11865bb8/iniconfig-2.3.0-py3-none-any.whl", hash = "sha256:f631c04d2c48c52b84d0d0549c99ff3859c98df65b3101406327ecc7d53fbf12", size = 7484, upload-time = "2025-10-18T21:55:41.639Z" },
+]
+
+[[package]]
+name = "ipykernel"
+version = "7.1.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "appnope", marker = "sys_platform == 'darwin'" },
+    { name = "comm" },
+    { name = "debugpy" },
+    { name = "ipython" },
+    { name = "jupyter-client" },
+    { name = "jupyter-core" },
+    { name = "matplotlib-inline" },
+    { name = "nest-asyncio" },
+    { name = "packaging" },
+    { name = "psutil" },
+    { name = "pyzmq" },
+    { name = "tornado" },
+    { name = "traitlets" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/b9/a4/4948be6eb88628505b83a1f2f40d90254cab66abf2043b3c40fa07dfce0f/ipykernel-7.1.0.tar.gz", hash = "sha256:58a3fc88533d5930c3546dc7eac66c6d288acde4f801e2001e65edc5dc9cf0db", size = 174579, upload-time = "2025-10-27T09:46:39.471Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/a3/17/20c2552266728ceba271967b87919664ecc0e33efca29c3efc6baf88c5f9/ipykernel-7.1.0-py3-none-any.whl", hash = "sha256:763b5ec6c5b7776f6a8d7ce09b267693b4e5ce75cb50ae696aaefb3c85e1ea4c", size = 117968, upload-time = "2025-10-27T09:46:37.805Z" },
+]
+
+[[package]]
+name = "ipython"
+version = "9.9.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "colorama", marker = "sys_platform == 'win32'" },
+    { name = "decorator" },
+    { name = "ipython-pygments-lexers" },
+    { name = "jedi" },
+    { name = "matplotlib-inline" },
+    { name = "pexpect", marker = "sys_platform != 'emscripten' and sys_platform != 'win32'" },
+    { name = "prompt-toolkit" },
+    { name = "pygments" },
+    { name = "stack-data" },
+    { name = "traitlets" },
+    { name = "typing-extensions", marker = "python_full_version < '3.12'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/46/dd/fb08d22ec0c27e73c8bc8f71810709870d51cadaf27b7ddd3f011236c100/ipython-9.9.0.tar.gz", hash = "sha256:48fbed1b2de5e2c7177eefa144aba7fcb82dac514f09b57e2ac9da34ddb54220", size = 4425043, upload-time = "2026-01-05T12:36:46.233Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/86/92/162cfaee4ccf370465c5af1ce36a9eacec1becb552f2033bb3584e6f640a/ipython-9.9.0-py3-none-any.whl", hash = "sha256:b457fe9165df2b84e8ec909a97abcf2ed88f565970efba16b1f7229c283d252b", size = 621431, upload-time = "2026-01-05T12:36:44.669Z" },
+]
+
+[[package]]
+name = "ipython-pygments-lexers"
+version = "1.1.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "pygments" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/ef/4c/5dd1d8af08107f88c7f741ead7a40854b8ac24ddf9ae850afbcf698aa552/ipython_pygments_lexers-1.1.1.tar.gz", hash = "sha256:09c0138009e56b6854f9535736f4171d855c8c08a563a0dcd8022f78355c7e81", size = 8393, upload-time = "2025-01-17T11:24:34.505Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/d9/33/1f075bf72b0b747cb3288d011319aaf64083cf2efef8354174e3ed4540e2/ipython_pygments_lexers-1.1.1-py3-none-any.whl", hash = "sha256:a9462224a505ade19a605f71f8fa63c2048833ce50abc86768a0d81d876dc81c", size = 8074, upload-time = "2025-01-17T11:24:33.271Z" },
+]
+
+[[package]]
+name = "jedi"
+version = "0.19.2"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "parso" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/72/3a/79a912fbd4d8dd6fbb02bf69afd3bb72cf0c729bb3063c6f4498603db17a/jedi-0.19.2.tar.gz", hash = "sha256:4770dc3de41bde3966b02eb84fbcf557fb33cce26ad23da12c742fb50ecb11f0", size = 1231287, upload-time = "2024-11-11T01:41:42.873Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/c0/5a/9cac0c82afec3d09ccd97c8b6502d48f165f9124db81b4bcb90b4af974ee/jedi-0.19.2-py2.py3-none-any.whl", hash = "sha256:a8ef22bde8490f57fe5c7681a3c83cb58874daf72b4784de3cce5b6ef6edb5b9", size = 1572278, upload-time = "2024-11-11T01:41:40.175Z" },
+]
+
+[[package]]
+name = "jupyter-client"
+version = "8.8.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "jupyter-core" },
+    { name = "python-dateutil" },
+    { name = "pyzmq" },
+    { name = "tornado" },
+    { name = "traitlets" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/05/e4/ba649102a3bc3fbca54e7239fb924fd434c766f855693d86de0b1f2bec81/jupyter_client-8.8.0.tar.gz", hash = "sha256:d556811419a4f2d96c869af34e854e3f059b7cc2d6d01a9cd9c85c267691be3e", size = 348020, upload-time = "2026-01-08T13:55:47.938Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/2d/0b/ceb7694d864abc0a047649aec263878acb9f792e1fec3e676f22dc9015e3/jupyter_client-8.8.0-py3-none-any.whl", hash = "sha256:f93a5b99c5e23a507b773d3a1136bd6e16c67883ccdbd9a829b0bbdb98cd7d7a", size = 107371, upload-time = "2026-01-08T13:55:45.562Z" },
+]
+
+[[package]]
+name = "jupyter-core"
+version = "5.9.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "platformdirs" },
+    { name = "traitlets" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/02/49/9d1284d0dc65e2c757b74c6687b6d319b02f822ad039e5c512df9194d9dd/jupyter_core-5.9.1.tar.gz", hash = "sha256:4d09aaff303b9566c3ce657f580bd089ff5c91f5f89cf7d8846c3cdf465b5508", size = 89814, upload-time = "2025-10-16T19:19:18.444Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/e7/e7/80988e32bf6f73919a113473a604f5a8f09094de312b9d52b79c2df7612b/jupyter_core-5.9.1-py3-none-any.whl", hash = "sha256:ebf87fdc6073d142e114c72c9e29a9d7ca03fad818c5d300ce2adc1fb0743407", size = 29032, upload-time = "2025-10-16T19:19:16.783Z" },
+]
+
+[[package]]
+name = "kiwisolver"
+version = "1.4.9"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/5c/3c/85844f1b0feb11ee581ac23fe5fce65cd049a200c1446708cc1b7f922875/kiwisolver-1.4.9.tar.gz", hash = "sha256:c3b22c26c6fd6811b0ae8363b95ca8ce4ea3c202d3d0975b2914310ceb1bcc4d", size = 97564, upload-time = "2025-08-10T21:27:49.279Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/6f/ab/c80b0d5a9d8a1a65f4f815f2afff9798b12c3b9f31f1d304dd233dd920e2/kiwisolver-1.4.9-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:eb14a5da6dc7642b0f3a18f13654847cd8b7a2550e2645a5bda677862b03ba16", size = 124167, upload-time = "2025-08-10T21:25:53.403Z" },
+    { url = "https://files.pythonhosted.org/packages/a0/c0/27fe1a68a39cf62472a300e2879ffc13c0538546c359b86f149cc19f6ac3/kiwisolver-1.4.9-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:39a219e1c81ae3b103643d2aedb90f1ef22650deb266ff12a19e7773f3e5f089", size = 66579, upload-time = "2025-08-10T21:25:54.79Z" },
+    { url = "https://files.pythonhosted.org/packages/31/a2/a12a503ac1fd4943c50f9822678e8015a790a13b5490354c68afb8489814/kiwisolver-1.4.9-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:2405a7d98604b87f3fc28b1716783534b1b4b8510d8142adca34ee0bc3c87543", size = 65309, upload-time = "2025-08-10T21:25:55.76Z" },
+    { url = "https://files.pythonhosted.org/packages/66/e1/e533435c0be77c3f64040d68d7a657771194a63c279f55573188161e81ca/kiwisolver-1.4.9-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:dc1ae486f9abcef254b5618dfb4113dd49f94c68e3e027d03cf0143f3f772b61", size = 1435596, upload-time = "2025-08-10T21:25:56.861Z" },
+    { url = "https://files.pythonhosted.org/packages/67/1e/51b73c7347f9aabdc7215aa79e8b15299097dc2f8e67dee2b095faca9cb0/kiwisolver-1.4.9-cp311-cp311-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:8a1f570ce4d62d718dce3f179ee78dac3b545ac16c0c04bb363b7607a949c0d1", size = 1246548, upload-time = "2025-08-10T21:25:58.246Z" },
+    { url = "https://files.pythonhosted.org/packages/21/aa/72a1c5d1e430294f2d32adb9542719cfb441b5da368d09d268c7757af46c/kiwisolver-1.4.9-cp311-cp311-manylinux_2_24_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:cb27e7b78d716c591e88e0a09a2139c6577865d7f2e152488c2cc6257f460872", size = 1263618, upload-time = "2025-08-10T21:25:59.857Z" },
+    { url = "https://files.pythonhosted.org/packages/a3/af/db1509a9e79dbf4c260ce0cfa3903ea8945f6240e9e59d1e4deb731b1a40/kiwisolver-1.4.9-cp311-cp311-manylinux_2_24_s390x.manylinux_2_28_s390x.whl", hash = "sha256:15163165efc2f627eb9687ea5f3a28137217d217ac4024893d753f46bce9de26", size = 1317437, upload-time = "2025-08-10T21:26:01.105Z" },
+    { url = "https://files.pythonhosted.org/packages/e0/f2/3ea5ee5d52abacdd12013a94130436e19969fa183faa1e7c7fbc89e9a42f/kiwisolver-1.4.9-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:bdee92c56a71d2b24c33a7d4c2856bd6419d017e08caa7802d2963870e315028", size = 2195742, upload-time = "2025-08-10T21:26:02.675Z" },
+    { url = "https://files.pythonhosted.org/packages/6f/9b/1efdd3013c2d9a2566aa6a337e9923a00590c516add9a1e89a768a3eb2fc/kiwisolver-1.4.9-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:412f287c55a6f54b0650bd9b6dce5aceddb95864a1a90c87af16979d37c89771", size = 2290810, upload-time = "2025-08-10T21:26:04.009Z" },
+    { url = "https://files.pythonhosted.org/packages/fb/e5/cfdc36109ae4e67361f9bc5b41323648cb24a01b9ade18784657e022e65f/kiwisolver-1.4.9-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:2c93f00dcba2eea70af2be5f11a830a742fe6b579a1d4e00f47760ef13be247a", size = 2461579, upload-time = "2025-08-10T21:26:05.317Z" },
+    { url = "https://files.pythonhosted.org/packages/62/86/b589e5e86c7610842213994cdea5add00960076bef4ae290c5fa68589cac/kiwisolver-1.4.9-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:f117e1a089d9411663a3207ba874f31be9ac8eaa5b533787024dc07aeb74f464", size = 2268071, upload-time = "2025-08-10T21:26:06.686Z" },
+    { url = "https://files.pythonhosted.org/packages/3b/c6/f8df8509fd1eee6c622febe54384a96cfaf4d43bf2ccec7a0cc17e4715c9/kiwisolver-1.4.9-cp311-cp311-win_amd64.whl", hash = "sha256:be6a04e6c79819c9a8c2373317d19a96048e5a3f90bec587787e86a1153883c2", size = 73840, upload-time = "2025-08-10T21:26:07.94Z" },
+    { url = "https://files.pythonhosted.org/packages/e2/2d/16e0581daafd147bc11ac53f032a2b45eabac897f42a338d0a13c1e5c436/kiwisolver-1.4.9-cp311-cp311-win_arm64.whl", hash = "sha256:0ae37737256ba2de764ddc12aed4956460277f00c4996d51a197e72f62f5eec7", size = 65159, upload-time = "2025-08-10T21:26:09.048Z" },
+    { url = "https://files.pythonhosted.org/packages/86/c9/13573a747838aeb1c76e3267620daa054f4152444d1f3d1a2324b78255b5/kiwisolver-1.4.9-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:ac5a486ac389dddcc5bef4f365b6ae3ffff2c433324fb38dd35e3fab7c957999", size = 123686, upload-time = "2025-08-10T21:26:10.034Z" },
+    { url = "https://files.pythonhosted.org/packages/51/ea/2ecf727927f103ffd1739271ca19c424d0e65ea473fbaeea1c014aea93f6/kiwisolver-1.4.9-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:f2ba92255faa7309d06fe44c3a4a97efe1c8d640c2a79a5ef728b685762a6fd2", size = 66460, upload-time = "2025-08-10T21:26:11.083Z" },
+    { url = "https://files.pythonhosted.org/packages/5b/5a/51f5464373ce2aeb5194508298a508b6f21d3867f499556263c64c621914/kiwisolver-1.4.9-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:4a2899935e724dd1074cb568ce7ac0dce28b2cd6ab539c8e001a8578eb106d14", size = 64952, upload-time = "2025-08-10T21:26:12.058Z" },
+    { url = "https://files.pythonhosted.org/packages/70/90/6d240beb0f24b74371762873e9b7f499f1e02166a2d9c5801f4dbf8fa12e/kiwisolver-1.4.9-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:f6008a4919fdbc0b0097089f67a1eb55d950ed7e90ce2cc3e640abadd2757a04", size = 1474756, upload-time = "2025-08-10T21:26:13.096Z" },
+    { url = "https://files.pythonhosted.org/packages/12/42/f36816eaf465220f683fb711efdd1bbf7a7005a2473d0e4ed421389bd26c/kiwisolver-1.4.9-cp312-cp312-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:67bb8b474b4181770f926f7b7d2f8c0248cbcb78b660fdd41a47054b28d2a752", size = 1276404, upload-time = "2025-08-10T21:26:14.457Z" },
+    { url = "https://files.pythonhosted.org/packages/2e/64/bc2de94800adc830c476dce44e9b40fd0809cddeef1fde9fcf0f73da301f/kiwisolver-1.4.9-cp312-cp312-manylinux_2_24_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:2327a4a30d3ee07d2fbe2e7933e8a37c591663b96ce42a00bc67461a87d7df77", size = 1294410, upload-time = "2025-08-10T21:26:15.73Z" },
+    { url = "https://files.pythonhosted.org/packages/5f/42/2dc82330a70aa8e55b6d395b11018045e58d0bb00834502bf11509f79091/kiwisolver-1.4.9-cp312-cp312-manylinux_2_24_s390x.manylinux_2_28_s390x.whl", hash = "sha256:7a08b491ec91b1d5053ac177afe5290adacf1f0f6307d771ccac5de30592d198", size = 1343631, upload-time = "2025-08-10T21:26:17.045Z" },
+    { url = "https://files.pythonhosted.org/packages/22/fd/f4c67a6ed1aab149ec5a8a401c323cee7a1cbe364381bb6c9c0d564e0e20/kiwisolver-1.4.9-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:d8fc5c867c22b828001b6a38d2eaeb88160bf5783c6cb4a5e440efc981ce286d", size = 2224963, upload-time = "2025-08-10T21:26:18.737Z" },
+    { url = "https://files.pythonhosted.org/packages/45/aa/76720bd4cb3713314677d9ec94dcc21ced3f1baf4830adde5bb9b2430a5f/kiwisolver-1.4.9-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:3b3115b2581ea35bb6d1f24a4c90af37e5d9b49dcff267eeed14c3893c5b86ab", size = 2321295, upload-time = "2025-08-10T21:26:20.11Z" },
+    { url = "https://files.pythonhosted.org/packages/80/19/d3ec0d9ab711242f56ae0dc2fc5d70e298bb4a1f9dfab44c027668c673a1/kiwisolver-1.4.9-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:858e4c22fb075920b96a291928cb7dea5644e94c0ee4fcd5af7e865655e4ccf2", size = 2487987, upload-time = "2025-08-10T21:26:21.49Z" },
+    { url = "https://files.pythonhosted.org/packages/39/e9/61e4813b2c97e86b6fdbd4dd824bf72d28bcd8d4849b8084a357bc0dd64d/kiwisolver-1.4.9-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:ed0fecd28cc62c54b262e3736f8bb2512d8dcfdc2bcf08be5f47f96bf405b145", size = 2291817, upload-time = "2025-08-10T21:26:22.812Z" },
+    { url = "https://files.pythonhosted.org/packages/a0/41/85d82b0291db7504da3c2defe35c9a8a5c9803a730f297bd823d11d5fb77/kiwisolver-1.4.9-cp312-cp312-win_amd64.whl", hash = "sha256:f68208a520c3d86ea51acf688a3e3002615a7f0238002cccc17affecc86a8a54", size = 73895, upload-time = "2025-08-10T21:26:24.37Z" },
+    { url = "https://files.pythonhosted.org/packages/e2/92/5f3068cf15ee5cb624a0c7596e67e2a0bb2adee33f71c379054a491d07da/kiwisolver-1.4.9-cp312-cp312-win_arm64.whl", hash = "sha256:2c1a4f57df73965f3f14df20b80ee29e6a7930a57d2d9e8491a25f676e197c60", size = 64992, upload-time = "2025-08-10T21:26:25.732Z" },
+    { url = "https://files.pythonhosted.org/packages/31/c1/c2686cda909742ab66c7388e9a1a8521a59eb89f8bcfbee28fc980d07e24/kiwisolver-1.4.9-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:a5d0432ccf1c7ab14f9949eec60c5d1f924f17c037e9f8b33352fa05799359b8", size = 123681, upload-time = "2025-08-10T21:26:26.725Z" },
+    { url = "https://files.pythonhosted.org/packages/ca/f0/f44f50c9f5b1a1860261092e3bc91ecdc9acda848a8b8c6abfda4a24dd5c/kiwisolver-1.4.9-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:efb3a45b35622bb6c16dbfab491a8f5a391fe0e9d45ef32f4df85658232ca0e2", size = 66464, upload-time = "2025-08-10T21:26:27.733Z" },
+    { url = "https://files.pythonhosted.org/packages/2d/7a/9d90a151f558e29c3936b8a47ac770235f436f2120aca41a6d5f3d62ae8d/kiwisolver-1.4.9-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:1a12cf6398e8a0a001a059747a1cbf24705e18fe413bc22de7b3d15c67cffe3f", size = 64961, upload-time = "2025-08-10T21:26:28.729Z" },
+    { url = "https://files.pythonhosted.org/packages/e9/e9/f218a2cb3a9ffbe324ca29a9e399fa2d2866d7f348ec3a88df87fc248fc5/kiwisolver-1.4.9-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:b67e6efbf68e077dd71d1a6b37e43e1a99d0bff1a3d51867d45ee8908b931098", size = 1474607, upload-time = "2025-08-10T21:26:29.798Z" },
+    { url = "https://files.pythonhosted.org/packages/d9/28/aac26d4c882f14de59041636292bc838db8961373825df23b8eeb807e198/kiwisolver-1.4.9-cp313-cp313-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:5656aa670507437af0207645273ccdfee4f14bacd7f7c67a4306d0dcaeaf6eed", size = 1276546, upload-time = "2025-08-10T21:26:31.401Z" },
+    { url = "https://files.pythonhosted.org/packages/8b/ad/8bfc1c93d4cc565e5069162f610ba2f48ff39b7de4b5b8d93f69f30c4bed/kiwisolver-1.4.9-cp313-cp313-manylinux_2_24_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:bfc08add558155345129c7803b3671cf195e6a56e7a12f3dde7c57d9b417f525", size = 1294482, upload-time = "2025-08-10T21:26:32.721Z" },
+    { url = "https://files.pythonhosted.org/packages/da/f1/6aca55ff798901d8ce403206d00e033191f63d82dd708a186e0ed2067e9c/kiwisolver-1.4.9-cp313-cp313-manylinux_2_24_s390x.manylinux_2_28_s390x.whl", hash = "sha256:40092754720b174e6ccf9e845d0d8c7d8e12c3d71e7fc35f55f3813e96376f78", size = 1343720, upload-time = "2025-08-10T21:26:34.032Z" },
+    { url = "https://files.pythonhosted.org/packages/d1/91/eed031876c595c81d90d0f6fc681ece250e14bf6998c3d7c419466b523b7/kiwisolver-1.4.9-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:497d05f29a1300d14e02e6441cf0f5ee81c1ff5a304b0d9fb77423974684e08b", size = 2224907, upload-time = "2025-08-10T21:26:35.824Z" },
+    { url = "https://files.pythonhosted.org/packages/e9/ec/4d1925f2e49617b9cca9c34bfa11adefad49d00db038e692a559454dfb2e/kiwisolver-1.4.9-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:bdd1a81a1860476eb41ac4bc1e07b3f07259e6d55bbf739b79c8aaedcf512799", size = 2321334, upload-time = "2025-08-10T21:26:37.534Z" },
+    { url = "https://files.pythonhosted.org/packages/43/cb/450cd4499356f68802750c6ddc18647b8ea01ffa28f50d20598e0befe6e9/kiwisolver-1.4.9-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:e6b93f13371d341afee3be9f7c5964e3fe61d5fa30f6a30eb49856935dfe4fc3", size = 2488313, upload-time = "2025-08-10T21:26:39.191Z" },
+    { url = "https://files.pythonhosted.org/packages/71/67/fc76242bd99f885651128a5d4fa6083e5524694b7c88b489b1b55fdc491d/kiwisolver-1.4.9-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:d75aa530ccfaa593da12834b86a0724f58bff12706659baa9227c2ccaa06264c", size = 2291970, upload-time = "2025-08-10T21:26:40.828Z" },
+    { url = "https://files.pythonhosted.org/packages/75/bd/f1a5d894000941739f2ae1b65a32892349423ad49c2e6d0771d0bad3fae4/kiwisolver-1.4.9-cp313-cp313-win_amd64.whl", hash = "sha256:dd0a578400839256df88c16abddf9ba14813ec5f21362e1fe65022e00c883d4d", size = 73894, upload-time = "2025-08-10T21:26:42.33Z" },
+    { url = "https://files.pythonhosted.org/packages/95/38/dce480814d25b99a391abbddadc78f7c117c6da34be68ca8b02d5848b424/kiwisolver-1.4.9-cp313-cp313-win_arm64.whl", hash = "sha256:d4188e73af84ca82468f09cadc5ac4db578109e52acb4518d8154698d3a87ca2", size = 64995, upload-time = "2025-08-10T21:26:43.889Z" },
+    { url = "https://files.pythonhosted.org/packages/e2/37/7d218ce5d92dadc5ebdd9070d903e0c7cf7edfe03f179433ac4d13ce659c/kiwisolver-1.4.9-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:5a0f2724dfd4e3b3ac5a82436a8e6fd16baa7d507117e4279b660fe8ca38a3a1", size = 126510, upload-time = "2025-08-10T21:26:44.915Z" },
+    { url = "https://files.pythonhosted.org/packages/23/b0/e85a2b48233daef4b648fb657ebbb6f8367696a2d9548a00b4ee0eb67803/kiwisolver-1.4.9-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:1b11d6a633e4ed84fc0ddafd4ebfd8ea49b3f25082c04ad12b8315c11d504dc1", size = 67903, upload-time = "2025-08-10T21:26:45.934Z" },
+    { url = "https://files.pythonhosted.org/packages/44/98/f2425bc0113ad7de24da6bb4dae1343476e95e1d738be7c04d31a5d037fd/kiwisolver-1.4.9-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:61874cdb0a36016354853593cffc38e56fc9ca5aa97d2c05d3dcf6922cd55a11", size = 66402, upload-time = "2025-08-10T21:26:47.101Z" },
+    { url = "https://files.pythonhosted.org/packages/98/d8/594657886df9f34c4177cc353cc28ca7e6e5eb562d37ccc233bff43bbe2a/kiwisolver-1.4.9-cp313-cp313t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:60c439763a969a6af93b4881db0eed8fadf93ee98e18cbc35bc8da868d0c4f0c", size = 1582135, upload-time = "2025-08-10T21:26:48.665Z" },
+    { url = "https://files.pythonhosted.org/packages/5c/c6/38a115b7170f8b306fc929e166340c24958347308ea3012c2b44e7e295db/kiwisolver-1.4.9-cp313-cp313t-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:92a2f997387a1b79a75e7803aa7ded2cfbe2823852ccf1ba3bcf613b62ae3197", size = 1389409, upload-time = "2025-08-10T21:26:50.335Z" },
+    { url = "https://files.pythonhosted.org/packages/bf/3b/e04883dace81f24a568bcee6eb3001da4ba05114afa622ec9b6fafdc1f5e/kiwisolver-1.4.9-cp313-cp313t-manylinux_2_24_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:a31d512c812daea6d8b3be3b2bfcbeb091dbb09177706569bcfc6240dcf8b41c", size = 1401763, upload-time = "2025-08-10T21:26:51.867Z" },
+    { url = "https://files.pythonhosted.org/packages/9f/80/20ace48e33408947af49d7d15c341eaee69e4e0304aab4b7660e234d6288/kiwisolver-1.4.9-cp313-cp313t-manylinux_2_24_s390x.manylinux_2_28_s390x.whl", hash = "sha256:52a15b0f35dad39862d376df10c5230155243a2c1a436e39eb55623ccbd68185", size = 1453643, upload-time = "2025-08-10T21:26:53.592Z" },
+    { url = "https://files.pythonhosted.org/packages/64/31/6ce4380a4cd1f515bdda976a1e90e547ccd47b67a1546d63884463c92ca9/kiwisolver-1.4.9-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:a30fd6fdef1430fd9e1ba7b3398b5ee4e2887783917a687d86ba69985fb08748", size = 2330818, upload-time = "2025-08-10T21:26:55.051Z" },
+    { url = "https://files.pythonhosted.org/packages/fa/e9/3f3fcba3bcc7432c795b82646306e822f3fd74df0ee81f0fa067a1f95668/kiwisolver-1.4.9-cp313-cp313t-musllinux_1_2_ppc64le.whl", hash = "sha256:cc9617b46837c6468197b5945e196ee9ca43057bb7d9d1ae688101e4e1dddf64", size = 2419963, upload-time = "2025-08-10T21:26:56.421Z" },
+    { url = "https://files.pythonhosted.org/packages/99/43/7320c50e4133575c66e9f7dadead35ab22d7c012a3b09bb35647792b2a6d/kiwisolver-1.4.9-cp313-cp313t-musllinux_1_2_s390x.whl", hash = "sha256:0ab74e19f6a2b027ea4f845a78827969af45ce790e6cb3e1ebab71bdf9f215ff", size = 2594639, upload-time = "2025-08-10T21:26:57.882Z" },
+    { url = "https://files.pythonhosted.org/packages/65/d6/17ae4a270d4a987ef8a385b906d2bdfc9fce502d6dc0d3aea865b47f548c/kiwisolver-1.4.9-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:dba5ee5d3981160c28d5490f0d1b7ed730c22470ff7f6cc26cfcfaacb9896a07", size = 2391741, upload-time = "2025-08-10T21:26:59.237Z" },
+    { url = "https://files.pythonhosted.org/packages/2a/8f/8f6f491d595a9e5912971f3f863d81baddccc8a4d0c3749d6a0dd9ffc9df/kiwisolver-1.4.9-cp313-cp313t-win_arm64.whl", hash = "sha256:0749fd8f4218ad2e851e11cc4dc05c7cbc0cbc4267bdfdb31782e65aace4ee9c", size = 68646, upload-time = "2025-08-10T21:27:00.52Z" },
+    { url = "https://files.pythonhosted.org/packages/a3/0f/36d89194b5a32c054ce93e586d4049b6c2c22887b0eb229c61c68afd3078/kiwisolver-1.4.9-pp311-pypy311_pp73-macosx_10_15_x86_64.whl", hash = "sha256:720e05574713db64c356e86732c0f3c5252818d05f9df320f0ad8380641acea5", size = 60104, upload-time = "2025-08-10T21:27:43.287Z" },
+    { url = "https://files.pythonhosted.org/packages/52/ba/4ed75f59e4658fd21fe7dde1fee0ac397c678ec3befba3fe6482d987af87/kiwisolver-1.4.9-pp311-pypy311_pp73-macosx_11_0_arm64.whl", hash = "sha256:17680d737d5335b552994a2008fab4c851bcd7de33094a82067ef3a576ff02fa", size = 58592, upload-time = "2025-08-10T21:27:44.314Z" },
+    { url = "https://files.pythonhosted.org/packages/33/01/a8ea7c5ea32a9b45ceeaee051a04c8ed4320f5add3c51bfa20879b765b70/kiwisolver-1.4.9-pp311-pypy311_pp73-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:85b5352f94e490c028926ea567fc569c52ec79ce131dadb968d3853e809518c2", size = 80281, upload-time = "2025-08-10T21:27:45.369Z" },
+    { url = "https://files.pythonhosted.org/packages/da/e3/dbd2ecdce306f1d07a1aaf324817ee993aab7aee9db47ceac757deabafbe/kiwisolver-1.4.9-pp311-pypy311_pp73-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:464415881e4801295659462c49461a24fb107c140de781d55518c4b80cb6790f", size = 78009, upload-time = "2025-08-10T21:27:46.376Z" },
+    { url = "https://files.pythonhosted.org/packages/da/e9/0d4add7873a73e462aeb45c036a2dead2562b825aa46ba326727b3f31016/kiwisolver-1.4.9-pp311-pypy311_pp73-win_amd64.whl", hash = "sha256:fb940820c63a9590d31d88b815e7a3aa5915cad3ce735ab45f0c730b39547de1", size = 73929, upload-time = "2025-08-10T21:27:48.236Z" },
+]
+
+[[package]]
+name = "matplotlib"
+version = "3.10.8"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "contourpy" },
+    { name = "cycler" },
+    { name = "fonttools" },
+    { name = "kiwisolver" },
+    { name = "numpy" },
+    { name = "packaging" },
+    { name = "pillow" },
+    { name = "pyparsing" },
+    { name = "python-dateutil" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/8a/76/d3c6e3a13fe484ebe7718d14e269c9569c4eb0020a968a327acb3b9a8fe6/matplotlib-3.10.8.tar.gz", hash = "sha256:2299372c19d56bcd35cf05a2738308758d32b9eaed2371898d8f5bd33f084aa3", size = 34806269, upload-time = "2025-12-10T22:56:51.155Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/f8/86/de7e3a1cdcfc941483af70609edc06b83e7c8a0e0dc9ac325200a3f4d220/matplotlib-3.10.8-cp311-cp311-macosx_10_12_x86_64.whl", hash = "sha256:6be43b667360fef5c754dda5d25a32e6307a03c204f3c0fc5468b78fa87b4160", size = 8251215, upload-time = "2025-12-10T22:55:16.175Z" },
+    { url = "https://files.pythonhosted.org/packages/fd/14/baad3222f424b19ce6ad243c71de1ad9ec6b2e4eb1e458a48fdc6d120401/matplotlib-3.10.8-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:a2b336e2d91a3d7006864e0990c83b216fcdca64b5a6484912902cef87313d78", size = 8139625, upload-time = "2025-12-10T22:55:17.712Z" },
+    { url = "https://files.pythonhosted.org/packages/8f/a0/7024215e95d456de5883e6732e708d8187d9753a21d32f8ddb3befc0c445/matplotlib-3.10.8-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:efb30e3baaea72ce5928e32bab719ab4770099079d66726a62b11b1ef7273be4", size = 8712614, upload-time = "2025-12-10T22:55:20.8Z" },
+    { url = "https://files.pythonhosted.org/packages/5a/f4/b8347351da9a5b3f41e26cf547252d861f685c6867d179a7c9d60ad50189/matplotlib-3.10.8-cp311-cp311-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:d56a1efd5bfd61486c8bc968fa18734464556f0fb8e51690f4ac25d85cbbbbc2", size = 9540997, upload-time = "2025-12-10T22:55:23.258Z" },
+    { url = "https://files.pythonhosted.org/packages/9e/c0/c7b914e297efe0bc36917bf216b2acb91044b91e930e878ae12981e461e5/matplotlib-3.10.8-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:238b7ce5717600615c895050239ec955d91f321c209dd110db988500558e70d6", size = 9596825, upload-time = "2025-12-10T22:55:25.217Z" },
+    { url = "https://files.pythonhosted.org/packages/6f/d3/a4bbc01c237ab710a1f22b4da72f4ff6d77eb4c7735ea9811a94ae239067/matplotlib-3.10.8-cp311-cp311-win_amd64.whl", hash = "sha256:18821ace09c763ec93aef5eeff087ee493a24051936d7b9ebcad9662f66501f9", size = 8135090, upload-time = "2025-12-10T22:55:27.162Z" },
+    { url = "https://files.pythonhosted.org/packages/89/dd/a0b6588f102beab33ca6f5218b31725216577b2a24172f327eaf6417d5c9/matplotlib-3.10.8-cp311-cp311-win_arm64.whl", hash = "sha256:bab485bcf8b1c7d2060b4fcb6fc368a9e6f4cd754c9c2fea281f4be21df394a2", size = 8012377, upload-time = "2025-12-10T22:55:29.185Z" },
+    { url = "https://files.pythonhosted.org/packages/9e/67/f997cdcbb514012eb0d10cd2b4b332667997fb5ebe26b8d41d04962fa0e6/matplotlib-3.10.8-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:64fcc24778ca0404ce0cb7b6b77ae1f4c7231cdd60e6778f999ee05cbd581b9a", size = 8260453, upload-time = "2025-12-10T22:55:30.709Z" },
+    { url = "https://files.pythonhosted.org/packages/7e/65/07d5f5c7f7c994f12c768708bd2e17a4f01a2b0f44a1c9eccad872433e2e/matplotlib-3.10.8-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:b9a5ca4ac220a0cdd1ba6bcba3608547117d30468fefce49bb26f55c1a3d5c58", size = 8148321, upload-time = "2025-12-10T22:55:33.265Z" },
+    { url = "https://files.pythonhosted.org/packages/3e/f3/c5195b1ae57ef85339fd7285dfb603b22c8b4e79114bae5f4f0fcf688677/matplotlib-3.10.8-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:3ab4aabc72de4ff77b3ec33a6d78a68227bf1123465887f9905ba79184a1cc04", size = 8716944, upload-time = "2025-12-10T22:55:34.922Z" },
+    { url = "https://files.pythonhosted.org/packages/00/f9/7638f5cc82ec8a7aa005de48622eecc3ed7c9854b96ba15bd76b7fd27574/matplotlib-3.10.8-cp312-cp312-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:24d50994d8c5816ddc35411e50a86ab05f575e2530c02752e02538122613371f", size = 9550099, upload-time = "2025-12-10T22:55:36.789Z" },
+    { url = "https://files.pythonhosted.org/packages/57/61/78cd5920d35b29fd2a0fe894de8adf672ff52939d2e9b43cb83cd5ce1bc7/matplotlib-3.10.8-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:99eefd13c0dc3b3c1b4d561c1169e65fe47aab7b8158754d7c084088e2329466", size = 9613040, upload-time = "2025-12-10T22:55:38.715Z" },
+    { url = "https://files.pythonhosted.org/packages/30/4e/c10f171b6e2f44d9e3a2b96efa38b1677439d79c99357600a62cc1e9594e/matplotlib-3.10.8-cp312-cp312-win_amd64.whl", hash = "sha256:dd80ecb295460a5d9d260df63c43f4afbdd832d725a531f008dad1664f458adf", size = 8142717, upload-time = "2025-12-10T22:55:41.103Z" },
+    { url = "https://files.pythonhosted.org/packages/f1/76/934db220026b5fef85f45d51a738b91dea7d70207581063cd9bd8fafcf74/matplotlib-3.10.8-cp312-cp312-win_arm64.whl", hash = "sha256:3c624e43ed56313651bc18a47f838b60d7b8032ed348911c54906b130b20071b", size = 8012751, upload-time = "2025-12-10T22:55:42.684Z" },
+    { url = "https://files.pythonhosted.org/packages/3d/b9/15fd5541ef4f5b9a17eefd379356cf12175fe577424e7b1d80676516031a/matplotlib-3.10.8-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:3f2e409836d7f5ac2f1c013110a4d50b9f7edc26328c108915f9075d7d7a91b6", size = 8261076, upload-time = "2025-12-10T22:55:44.648Z" },
+    { url = "https://files.pythonhosted.org/packages/8d/a0/2ba3473c1b66b9c74dc7107c67e9008cb1782edbe896d4c899d39ae9cf78/matplotlib-3.10.8-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:56271f3dac49a88d7fca5060f004d9d22b865f743a12a23b1e937a0be4818ee1", size = 8148794, upload-time = "2025-12-10T22:55:46.252Z" },
+    { url = "https://files.pythonhosted.org/packages/75/97/a471f1c3eb1fd6f6c24a31a5858f443891d5127e63a7788678d14e249aea/matplotlib-3.10.8-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:a0a7f52498f72f13d4a25ea70f35f4cb60642b466cbb0a9be951b5bc3f45a486", size = 8718474, upload-time = "2025-12-10T22:55:47.864Z" },
+    { url = "https://files.pythonhosted.org/packages/01/be/cd478f4b66f48256f42927d0acbcd63a26a893136456cd079c0cc24fbabf/matplotlib-3.10.8-cp313-cp313-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:646d95230efb9ca614a7a594d4fcacde0ac61d25e37dd51710b36477594963ce", size = 9549637, upload-time = "2025-12-10T22:55:50.048Z" },
+    { url = "https://files.pythonhosted.org/packages/5d/7c/8dc289776eae5109e268c4fb92baf870678dc048a25d4ac903683b86d5bf/matplotlib-3.10.8-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:f89c151aab2e2e23cb3fe0acad1e8b82841fd265379c4cecd0f3fcb34c15e0f6", size = 9613678, upload-time = "2025-12-10T22:55:52.21Z" },
+    { url = "https://files.pythonhosted.org/packages/64/40/37612487cc8a437d4dd261b32ca21fe2d79510fe74af74e1f42becb1bdb8/matplotlib-3.10.8-cp313-cp313-win_amd64.whl", hash = "sha256:e8ea3e2d4066083e264e75c829078f9e149fa119d27e19acd503de65e0b13149", size = 8142686, upload-time = "2025-12-10T22:55:54.253Z" },
+    { url = "https://files.pythonhosted.org/packages/66/52/8d8a8730e968185514680c2a6625943f70269509c3dcfc0dcf7d75928cb8/matplotlib-3.10.8-cp313-cp313-win_arm64.whl", hash = "sha256:c108a1d6fa78a50646029cb6d49808ff0fc1330fda87fa6f6250c6b5369b6645", size = 8012917, upload-time = "2025-12-10T22:55:56.268Z" },
+    { url = "https://files.pythonhosted.org/packages/b5/27/51fe26e1062f298af5ef66343d8ef460e090a27fea73036c76c35821df04/matplotlib-3.10.8-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:ad3d9833a64cf48cc4300f2b406c3d0f4f4724a91c0bd5640678a6ba7c102077", size = 8305679, upload-time = "2025-12-10T22:55:57.856Z" },
+    { url = "https://files.pythonhosted.org/packages/2c/1e/4de865bc591ac8e3062e835f42dd7fe7a93168d519557837f0e37513f629/matplotlib-3.10.8-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:eb3823f11823deade26ce3b9f40dcb4a213da7a670013929f31d5f5ed1055b22", size = 8198336, upload-time = "2025-12-10T22:55:59.371Z" },
+    { url = "https://files.pythonhosted.org/packages/c6/cb/2f7b6e75fb4dce87ef91f60cac4f6e34f4c145ab036a22318ec837971300/matplotlib-3.10.8-cp313-cp313t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:d9050fee89a89ed57b4fb2c1bfac9a3d0c57a0d55aed95949eedbc42070fea39", size = 8731653, upload-time = "2025-12-10T22:56:01.032Z" },
+    { url = "https://files.pythonhosted.org/packages/46/b3/bd9c57d6ba670a37ab31fb87ec3e8691b947134b201f881665b28cc039ff/matplotlib-3.10.8-cp313-cp313t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:b44d07310e404ba95f8c25aa5536f154c0a8ec473303535949e52eb71d0a1565", size = 9561356, upload-time = "2025-12-10T22:56:02.95Z" },
+    { url = "https://files.pythonhosted.org/packages/c0/3d/8b94a481456dfc9dfe6e39e93b5ab376e50998cddfd23f4ae3b431708f16/matplotlib-3.10.8-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:0a33deb84c15ede243aead39f77e990469fff93ad1521163305095b77b72ce4a", size = 9614000, upload-time = "2025-12-10T22:56:05.411Z" },
+    { url = "https://files.pythonhosted.org/packages/bd/cd/bc06149fe5585ba800b189a6a654a75f1f127e8aab02fd2be10df7fa500c/matplotlib-3.10.8-cp313-cp313t-win_amd64.whl", hash = "sha256:3a48a78d2786784cc2413e57397981fb45c79e968d99656706018d6e62e57958", size = 8220043, upload-time = "2025-12-10T22:56:07.551Z" },
+    { url = "https://files.pythonhosted.org/packages/e3/de/b22cf255abec916562cc04eef457c13e58a1990048de0c0c3604d082355e/matplotlib-3.10.8-cp313-cp313t-win_arm64.whl", hash = "sha256:15d30132718972c2c074cd14638c7f4592bd98719e2308bccea40e0538bc0cb5", size = 8062075, upload-time = "2025-12-10T22:56:09.178Z" },
+    { url = "https://files.pythonhosted.org/packages/04/30/3afaa31c757f34b7725ab9d2ba8b48b5e89c2019c003e7d0ead143aabc5a/matplotlib-3.10.8-pp311-pypy311_pp73-macosx_10_15_x86_64.whl", hash = "sha256:6da7c2ce169267d0d066adcf63758f0604aa6c3eebf67458930f9d9b79ad1db1", size = 8249198, upload-time = "2025-12-10T22:56:45.584Z" },
+    { url = "https://files.pythonhosted.org/packages/48/2f/6334aec331f57485a642a7c8be03cb286f29111ae71c46c38b363230063c/matplotlib-3.10.8-pp311-pypy311_pp73-macosx_11_0_arm64.whl", hash = "sha256:9153c3292705be9f9c64498a8872118540c3f4123d1a1c840172edf262c8be4a", size = 8136817, upload-time = "2025-12-10T22:56:47.339Z" },
+    { url = "https://files.pythonhosted.org/packages/73/e4/6d6f14b2a759c622f191b2d67e9075a3f56aaccb3be4bb9bb6890030d0a0/matplotlib-3.10.8-pp311-pypy311_pp73-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:1ae029229a57cd1e8fe542485f27e7ca7b23aa9e8944ddb4985d0bc444f1eca2", size = 8713867, upload-time = "2025-12-10T22:56:48.954Z" },
+]
+
+[[package]]
+name = "matplotlib-inline"
+version = "0.2.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "traitlets" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/c7/74/97e72a36efd4ae2bccb3463284300f8953f199b5ffbc04cbbb0ec78f74b1/matplotlib_inline-0.2.1.tar.gz", hash = "sha256:e1ee949c340d771fc39e241ea75683deb94762c8fa5f2927ec57c83c4dffa9fe", size = 8110, upload-time = "2025-10-23T09:00:22.126Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/af/33/ee4519fa02ed11a94aef9559552f3b17bb863f2ecfe1a35dc7f548cde231/matplotlib_inline-0.2.1-py3-none-any.whl", hash = "sha256:d56ce5156ba6085e00a9d54fead6ed29a9c47e215cd1bba2e976ef39f5710a76", size = 9516, upload-time = "2025-10-23T09:00:20.675Z" },
+]
+
+[[package]]
+name = "nest-asyncio"
+version = "1.6.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/83/f8/51569ac65d696c8ecbee95938f89d4abf00f47d58d48f6fbabfe8f0baefe/nest_asyncio-1.6.0.tar.gz", hash = "sha256:6f172d5449aca15afd6c646851f4e31e02c598d553a667e38cafa997cfec55fe", size = 7418, upload-time = "2024-01-21T14:25:19.227Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/a0/c4/c2971a3ba4c6103a3d10c4b0f24f461ddc027f0f09763220cf35ca1401b3/nest_asyncio-1.6.0-py3-none-any.whl", hash = "sha256:87af6efd6b5e897c81050477ef65c62e2b2f35d51703cae01aff2905b1852e1c", size = 5195, upload-time = "2024-01-21T14:25:17.223Z" },
+]
+
+[[package]]
+name = "nodeenv"
+version = "1.10.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/24/bf/d1bda4f6168e0b2e9e5958945e01910052158313224ada5ce1fb2e1113b8/nodeenv-1.10.0.tar.gz", hash = "sha256:996c191ad80897d076bdfba80a41994c2b47c68e224c542b48feba42ba00f8bb", size = 55611, upload-time = "2025-12-20T14:08:54.006Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/88/b2/d0896bdcdc8d28a7fc5717c305f1a861c26e18c05047949fb371034d98bd/nodeenv-1.10.0-py2.py3-none-any.whl", hash = "sha256:5bb13e3eed2923615535339b3c620e76779af4cb4c6a90deccc9e36b274d3827", size = 23438, upload-time = "2025-12-20T14:08:52.782Z" },
+]
+
+[[package]]
+name = "numpy"
+version = "2.4.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/24/62/ae72ff66c0f1fd959925b4c11f8c2dea61f47f6acaea75a08512cdfe3fed/numpy-2.4.1.tar.gz", hash = "sha256:a1ceafc5042451a858231588a104093474c6a5c57dcc724841f5c888d237d690", size = 20721320, upload-time = "2026-01-10T06:44:59.619Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/a5/34/2b1bc18424f3ad9af577f6ce23600319968a70575bd7db31ce66731bbef9/numpy-2.4.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:0cce2a669e3c8ba02ee563c7835f92c153cf02edff1ae05e1823f1dde21b16a5", size = 16944563, upload-time = "2026-01-10T06:42:14.615Z" },
+    { url = "https://files.pythonhosted.org/packages/2c/57/26e5f97d075aef3794045a6ca9eada6a4ed70eb9a40e7a4a93f9ac80d704/numpy-2.4.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:899d2c18024984814ac7e83f8f49d8e8180e2fbe1b2e252f2e7f1d06bea92425", size = 12645658, upload-time = "2026-01-10T06:42:17.298Z" },
+    { url = "https://files.pythonhosted.org/packages/8e/ba/80fc0b1e3cb2fd5c6143f00f42eb67762aa043eaa05ca924ecc3222a7849/numpy-2.4.1-cp311-cp311-macosx_14_0_arm64.whl", hash = "sha256:09aa8a87e45b55a1c2c205d42e2808849ece5c484b2aab11fecabec3841cafba", size = 5474132, upload-time = "2026-01-10T06:42:19.637Z" },
+    { url = "https://files.pythonhosted.org/packages/40/ae/0a5b9a397f0e865ec171187c78d9b57e5588afc439a04ba9cab1ebb2c945/numpy-2.4.1-cp311-cp311-macosx_14_0_x86_64.whl", hash = "sha256:edee228f76ee2dab4579fad6f51f6a305de09d444280109e0f75df247ff21501", size = 6804159, upload-time = "2026-01-10T06:42:21.44Z" },
+    { url = "https://files.pythonhosted.org/packages/86/9c/841c15e691c7085caa6fd162f063eff494099c8327aeccd509d1ab1e36ab/numpy-2.4.1-cp311-cp311-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:a92f227dbcdc9e4c3e193add1a189a9909947d4f8504c576f4a732fd0b54240a", size = 14708058, upload-time = "2026-01-10T06:42:23.546Z" },
+    { url = "https://files.pythonhosted.org/packages/5d/9d/7862db06743f489e6a502a3b93136d73aea27d97b2cf91504f70a27501d6/numpy-2.4.1-cp311-cp311-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:538bf4ec353709c765ff75ae616c34d3c3dca1a68312727e8f2676ea644f8509", size = 16651501, upload-time = "2026-01-10T06:42:25.909Z" },
+    { url = "https://files.pythonhosted.org/packages/a6/9c/6fc34ebcbd4015c6e5f0c0ce38264010ce8a546cb6beacb457b84a75dfc8/numpy-2.4.1-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:ac08c63cb7779b85e9d5318e6c3518b424bc1f364ac4cb2c6136f12e5ff2dccc", size = 16492627, upload-time = "2026-01-10T06:42:28.938Z" },
+    { url = "https://files.pythonhosted.org/packages/aa/63/2494a8597502dacda439f61b3c0db4da59928150e62be0e99395c3ad23c5/numpy-2.4.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:4f9c360ecef085e5841c539a9a12b883dff005fbd7ce46722f5e9cef52634d82", size = 18585052, upload-time = "2026-01-10T06:42:31.312Z" },
+    { url = "https://files.pythonhosted.org/packages/6a/93/098e1162ae7522fc9b618d6272b77404c4656c72432ecee3abc029aa3de0/numpy-2.4.1-cp311-cp311-win32.whl", hash = "sha256:0f118ce6b972080ba0758c6087c3617b5ba243d806268623dc34216d69099ba0", size = 6236575, upload-time = "2026-01-10T06:42:33.872Z" },
+    { url = "https://files.pythonhosted.org/packages/8c/de/f5e79650d23d9e12f38a7bc6b03ea0835b9575494f8ec94c11c6e773b1b1/numpy-2.4.1-cp311-cp311-win_amd64.whl", hash = "sha256:18e14c4d09d55eef39a6ab5b08406e84bc6869c1e34eef45564804f90b7e0574", size = 12604479, upload-time = "2026-01-10T06:42:35.778Z" },
+    { url = "https://files.pythonhosted.org/packages/dd/65/e1097a7047cff12ce3369bd003811516b20ba1078dbdec135e1cd7c16c56/numpy-2.4.1-cp311-cp311-win_arm64.whl", hash = "sha256:6461de5113088b399d655d45c3897fa188766415d0f568f175ab071c8873bd73", size = 10578325, upload-time = "2026-01-10T06:42:38.518Z" },
+    { url = "https://files.pythonhosted.org/packages/78/7f/ec53e32bf10c813604edf07a3682616bd931d026fcde7b6d13195dfb684a/numpy-2.4.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:d3703409aac693fa82c0aee023a1ae06a6e9d065dba10f5e8e80f642f1e9d0a2", size = 16656888, upload-time = "2026-01-10T06:42:40.913Z" },
+    { url = "https://files.pythonhosted.org/packages/b8/e0/1f9585d7dae8f14864e948fd7fa86c6cb72dee2676ca2748e63b1c5acfe0/numpy-2.4.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:7211b95ca365519d3596a1d8688a95874cc94219d417504d9ecb2df99fa7bfa8", size = 12373956, upload-time = "2026-01-10T06:42:43.091Z" },
+    { url = "https://files.pythonhosted.org/packages/8e/43/9762e88909ff2326f5e7536fa8cb3c49fb03a7d92705f23e6e7f553d9cb3/numpy-2.4.1-cp312-cp312-macosx_14_0_arm64.whl", hash = "sha256:5adf01965456a664fc727ed69cc71848f28d063217c63e1a0e200a118d5eec9a", size = 5202567, upload-time = "2026-01-10T06:42:45.107Z" },
+    { url = "https://files.pythonhosted.org/packages/4b/ee/34b7930eb61e79feb4478800a4b95b46566969d837546aa7c034c742ef98/numpy-2.4.1-cp312-cp312-macosx_14_0_x86_64.whl", hash = "sha256:26f0bcd9c79a00e339565b303badc74d3ea2bd6d52191eeca5f95936cad107d0", size = 6549459, upload-time = "2026-01-10T06:42:48.152Z" },
+    { url = "https://files.pythonhosted.org/packages/79/e3/5f115fae982565771be994867c89bcd8d7208dbfe9469185497d70de5ddf/numpy-2.4.1-cp312-cp312-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:0093e85df2960d7e4049664b26afc58b03236e967fb942354deef3208857a04c", size = 14404859, upload-time = "2026-01-10T06:42:49.947Z" },
+    { url = "https://files.pythonhosted.org/packages/d9/7d/9c8a781c88933725445a859cac5d01b5871588a15969ee6aeb618ba99eee/numpy-2.4.1-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:7ad270f438cbdd402c364980317fb6b117d9ec5e226fff5b4148dd9aa9fc6e02", size = 16371419, upload-time = "2026-01-10T06:42:52.409Z" },
+    { url = "https://files.pythonhosted.org/packages/a6/d2/8aa084818554543f17cf4162c42f162acbd3bb42688aefdba6628a859f77/numpy-2.4.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:297c72b1b98100c2e8f873d5d35fb551fce7040ade83d67dd51d38c8d42a2162", size = 16182131, upload-time = "2026-01-10T06:42:54.694Z" },
+    { url = "https://files.pythonhosted.org/packages/60/db/0425216684297c58a8df35f3284ef56ec4a043e6d283f8a59c53562caf1b/numpy-2.4.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:cf6470d91d34bf669f61d515499859fa7a4c2f7c36434afb70e82df7217933f9", size = 18295342, upload-time = "2026-01-10T06:42:56.991Z" },
+    { url = "https://files.pythonhosted.org/packages/31/4c/14cb9d86240bd8c386c881bafbe43f001284b7cce3bc01623ac9475da163/numpy-2.4.1-cp312-cp312-win32.whl", hash = "sha256:b6bcf39112e956594b3331316d90c90c90fb961e39696bda97b89462f5f3943f", size = 5959015, upload-time = "2026-01-10T06:42:59.631Z" },
+    { url = "https://files.pythonhosted.org/packages/51/cf/52a703dbeb0c65807540d29699fef5fda073434ff61846a564d5c296420f/numpy-2.4.1-cp312-cp312-win_amd64.whl", hash = "sha256:e1a27bb1b2dee45a2a53f5ca6ff2d1a7f135287883a1689e930d44d1ff296c87", size = 12310730, upload-time = "2026-01-10T06:43:01.627Z" },
+    { url = "https://files.pythonhosted.org/packages/69/80/a828b2d0ade5e74a9fe0f4e0a17c30fdc26232ad2bc8c9f8b3197cf7cf18/numpy-2.4.1-cp312-cp312-win_arm64.whl", hash = "sha256:0e6e8f9d9ecf95399982019c01223dc130542960a12edfa8edd1122dfa66a8a8", size = 10312166, upload-time = "2026-01-10T06:43:03.673Z" },
+    { url = "https://files.pythonhosted.org/packages/04/68/732d4b7811c00775f3bd522a21e8dd5a23f77eb11acdeb663e4a4ebf0ef4/numpy-2.4.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:d797454e37570cfd61143b73b8debd623c3c0952959adb817dd310a483d58a1b", size = 16652495, upload-time = "2026-01-10T06:43:06.283Z" },
+    { url = "https://files.pythonhosted.org/packages/20/ca/857722353421a27f1465652b2c66813eeeccea9d76d5f7b74b99f298e60e/numpy-2.4.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:82c55962006156aeef1629b953fd359064aa47e4d82cfc8e67f0918f7da3344f", size = 12368657, upload-time = "2026-01-10T06:43:09.094Z" },
+    { url = "https://files.pythonhosted.org/packages/81/0d/2377c917513449cc6240031a79d30eb9a163d32a91e79e0da47c43f2c0c8/numpy-2.4.1-cp313-cp313-macosx_14_0_arm64.whl", hash = "sha256:71abbea030f2cfc3092a0ff9f8c8fdefdc5e0bf7d9d9c99663538bb0ecdac0b9", size = 5197256, upload-time = "2026-01-10T06:43:13.634Z" },
+    { url = "https://files.pythonhosted.org/packages/17/39/569452228de3f5de9064ac75137082c6214be1f5c532016549a7923ab4b5/numpy-2.4.1-cp313-cp313-macosx_14_0_x86_64.whl", hash = "sha256:5b55aa56165b17aaf15520beb9cbd33c9039810e0d9643dd4379e44294c7303e", size = 6545212, upload-time = "2026-01-10T06:43:15.661Z" },
+    { url = "https://files.pythonhosted.org/packages/8c/a4/77333f4d1e4dac4395385482557aeecf4826e6ff517e32ca48e1dafbe42a/numpy-2.4.1-cp313-cp313-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:c0faba4a331195bfa96f93dd9dfaa10b2c7aa8cda3a02b7fd635e588fe821bf5", size = 14402871, upload-time = "2026-01-10T06:43:17.324Z" },
+    { url = "https://files.pythonhosted.org/packages/ba/87/d341e519956273b39d8d47969dd1eaa1af740615394fe67d06f1efa68773/numpy-2.4.1-cp313-cp313-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:d3e3087f53e2b4428766b54932644d148613c5a595150533ae7f00dab2f319a8", size = 16359305, upload-time = "2026-01-10T06:43:19.376Z" },
+    { url = "https://files.pythonhosted.org/packages/32/91/789132c6666288eaa20ae8066bb99eba1939362e8f1a534949a215246e97/numpy-2.4.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:49e792ec351315e16da54b543db06ca8a86985ab682602d90c60ef4ff4db2a9c", size = 16181909, upload-time = "2026-01-10T06:43:21.808Z" },
+    { url = "https://files.pythonhosted.org/packages/cf/b8/090b8bd27b82a844bb22ff8fdf7935cb1980b48d6e439ae116f53cdc2143/numpy-2.4.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:79e9e06c4c2379db47f3f6fc7a8652e7498251789bf8ff5bd43bf478ef314ca2", size = 18284380, upload-time = "2026-01-10T06:43:23.957Z" },
+    { url = "https://files.pythonhosted.org/packages/67/78/722b62bd31842ff029412271556a1a27a98f45359dea78b1548a3a9996aa/numpy-2.4.1-cp313-cp313-win32.whl", hash = "sha256:3d1a100e48cb266090a031397863ff8a30050ceefd798f686ff92c67a486753d", size = 5957089, upload-time = "2026-01-10T06:43:27.535Z" },
+    { url = "https://files.pythonhosted.org/packages/da/a6/cf32198b0b6e18d4fbfa9a21a992a7fca535b9bb2b0cdd217d4a3445b5ca/numpy-2.4.1-cp313-cp313-win_amd64.whl", hash = "sha256:92a0e65272fd60bfa0d9278e0484c2f52fe03b97aedc02b357f33fe752c52ffb", size = 12307230, upload-time = "2026-01-10T06:43:29.298Z" },
+    { url = "https://files.pythonhosted.org/packages/44/6c/534d692bfb7d0afe30611320c5fb713659dcb5104d7cc182aff2aea092f5/numpy-2.4.1-cp313-cp313-win_arm64.whl", hash = "sha256:20d4649c773f66cc2fc36f663e091f57c3b7655f936a4c681b4250855d1da8f5", size = 10313125, upload-time = "2026-01-10T06:43:31.782Z" },
+    { url = "https://files.pythonhosted.org/packages/da/a1/354583ac5c4caa566de6ddfbc42744409b515039e085fab6e0ff942e0df5/numpy-2.4.1-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:f93bc6892fe7b0663e5ffa83b61aab510aacffd58c16e012bb9352d489d90cb7", size = 12496156, upload-time = "2026-01-10T06:43:34.237Z" },
+    { url = "https://files.pythonhosted.org/packages/51/b0/42807c6e8cce58c00127b1dc24d365305189991f2a7917aa694a109c8d7d/numpy-2.4.1-cp313-cp313t-macosx_14_0_arm64.whl", hash = "sha256:178de8f87948163d98a4c9ab5bee4ce6519ca918926ec8df195af582de28544d", size = 5324663, upload-time = "2026-01-10T06:43:36.211Z" },
+    { url = "https://files.pythonhosted.org/packages/fe/55/7a621694010d92375ed82f312b2f28017694ed784775269115323e37f5e2/numpy-2.4.1-cp313-cp313t-macosx_14_0_x86_64.whl", hash = "sha256:98b35775e03ab7f868908b524fc0a84d38932d8daf7b7e1c3c3a1b6c7a2c9f15", size = 6645224, upload-time = "2026-01-10T06:43:37.884Z" },
+    { url = "https://files.pythonhosted.org/packages/50/96/9fa8635ed9d7c847d87e30c834f7109fac5e88549d79ef3324ab5c20919f/numpy-2.4.1-cp313-cp313t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:941c2a93313d030f219f3a71fd3d91a728b82979a5e8034eb2e60d394a2b83f9", size = 14462352, upload-time = "2026-01-10T06:43:39.479Z" },
+    { url = "https://files.pythonhosted.org/packages/03/d1/8cf62d8bb2062da4fb82dd5d49e47c923f9c0738032f054e0a75342faba7/numpy-2.4.1-cp313-cp313t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:529050522e983e00a6c1c6b67411083630de8b57f65e853d7b03d9281b8694d2", size = 16407279, upload-time = "2026-01-10T06:43:41.93Z" },
+    { url = "https://files.pythonhosted.org/packages/86/1c/95c86e17c6b0b31ce6ef219da00f71113b220bcb14938c8d9a05cee0ff53/numpy-2.4.1-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:2302dc0224c1cbc49bb94f7064f3f923a971bfae45c33870dcbff63a2a550505", size = 16248316, upload-time = "2026-01-10T06:43:44.121Z" },
+    { url = "https://files.pythonhosted.org/packages/30/b4/e7f5ff8697274c9d0fa82398b6a372a27e5cef069b37df6355ccb1f1db1a/numpy-2.4.1-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:9171a42fcad32dcf3fa86f0a4faa5e9f8facefdb276f54b8b390d90447cff4e2", size = 18329884, upload-time = "2026-01-10T06:43:46.613Z" },
+    { url = "https://files.pythonhosted.org/packages/37/a4/b073f3e9d77f9aec8debe8ca7f9f6a09e888ad1ba7488f0c3b36a94c03ac/numpy-2.4.1-cp313-cp313t-win32.whl", hash = "sha256:382ad67d99ef49024f11d1ce5dcb5ad8432446e4246a4b014418ba3a1175a1f4", size = 6081138, upload-time = "2026-01-10T06:43:48.854Z" },
+    { url = "https://files.pythonhosted.org/packages/16/16/af42337b53844e67752a092481ab869c0523bc95c4e5c98e4dac4e9581ac/numpy-2.4.1-cp313-cp313t-win_amd64.whl", hash = "sha256:62fea415f83ad8fdb6c20840578e5fbaf5ddd65e0ec6c3c47eda0f69da172510", size = 12447478, upload-time = "2026-01-10T06:43:50.476Z" },
+    { url = "https://files.pythonhosted.org/packages/6c/f8/fa85b2eac68ec631d0b631abc448552cb17d39afd17ec53dcbcc3537681a/numpy-2.4.1-cp313-cp313t-win_arm64.whl", hash = "sha256:a7870e8c5fc11aef57d6fea4b4085e537a3a60ad2cdd14322ed531fdca68d261", size = 10382981, upload-time = "2026-01-10T06:43:52.575Z" },
+    { url = "https://files.pythonhosted.org/packages/1e/48/d86f97919e79314a1cdee4c832178763e6e98e623e123d0bada19e92c15a/numpy-2.4.1-pp311-pypy311_pp73-macosx_10_15_x86_64.whl", hash = "sha256:8ad35f20be147a204e28b6a0575fbf3540c5e5f802634d4258d55b1ff5facce1", size = 16822202, upload-time = "2026-01-10T06:44:43.738Z" },
+    { url = "https://files.pythonhosted.org/packages/51/e9/1e62a7f77e0f37dcfb0ad6a9744e65df00242b6ea37dfafb55debcbf5b55/numpy-2.4.1-pp311-pypy311_pp73-macosx_11_0_arm64.whl", hash = "sha256:8097529164c0f3e32bb89412a0905d9100bf434d9692d9fc275e18dcf53c9344", size = 12569985, upload-time = "2026-01-10T06:44:45.945Z" },
+    { url = "https://files.pythonhosted.org/packages/c7/7e/914d54f0c801342306fdcdce3e994a56476f1b818c46c47fc21ae968088c/numpy-2.4.1-pp311-pypy311_pp73-macosx_14_0_arm64.whl", hash = "sha256:ea66d2b41ca4a1630aae5507ee0a71647d3124d1741980138aa8f28f44dac36e", size = 5398484, upload-time = "2026-01-10T06:44:48.012Z" },
+    { url = "https://files.pythonhosted.org/packages/1c/d8/9570b68584e293a33474e7b5a77ca404f1dcc655e40050a600dee81d27fb/numpy-2.4.1-pp311-pypy311_pp73-macosx_14_0_x86_64.whl", hash = "sha256:d3f8f0df9f4b8be57b3bf74a1d087fec68f927a2fab68231fdb442bf2c12e426", size = 6713216, upload-time = "2026-01-10T06:44:49.725Z" },
+    { url = "https://files.pythonhosted.org/packages/33/9b/9dd6e2db8d49eb24f86acaaa5258e5f4c8ed38209a4ee9de2d1a0ca25045/numpy-2.4.1-pp311-pypy311_pp73-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:2023ef86243690c2791fd6353e5b4848eedaa88ca8a2d129f462049f6d484696", size = 14538937, upload-time = "2026-01-10T06:44:51.498Z" },
+    { url = "https://files.pythonhosted.org/packages/53/87/d5bd995b0f798a37105b876350d346eea5838bd8f77ea3d7a48392f3812b/numpy-2.4.1-pp311-pypy311_pp73-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:8361ea4220d763e54cff2fbe7d8c93526b744f7cd9ddab47afeff7e14e8503be", size = 16479830, upload-time = "2026-01-10T06:44:53.931Z" },
+    { url = "https://files.pythonhosted.org/packages/5b/c7/b801bf98514b6ae6475e941ac05c58e6411dd863ea92916bfd6d510b08c1/numpy-2.4.1-pp311-pypy311_pp73-win_amd64.whl", hash = "sha256:4f1b68ff47680c2925f8063402a693ede215f0257f02596b1318ecdfb1d79e33", size = 12492579, upload-time = "2026-01-10T06:44:57.094Z" },
+]
+
+[[package]]
+name = "packaging"
+version = "25.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/a1/d4/1fc4078c65507b51b96ca8f8c3ba19e6a61c8253c72794544580a7b6c24d/packaging-25.0.tar.gz", hash = "sha256:d443872c98d677bf60f6a1f2f8c1cb748e8fe762d2bf9d3148b5599295b0fc4f", size = 165727, upload-time = "2025-04-19T11:48:59.673Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/20/12/38679034af332785aac8774540895e234f4d07f7545804097de4b666afd8/packaging-25.0-py3-none-any.whl", hash = "sha256:29572ef2b1f17581046b3a2227d5c611fb25ec70ca1ba8554b24b0e69331a484", size = 66469, upload-time = "2025-04-19T11:48:57.875Z" },
+]
+
+[[package]]
+name = "parso"
+version = "0.8.5"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/d4/de/53e0bcf53d13e005bd8c92e7855142494f41171b34c2536b86187474184d/parso-0.8.5.tar.gz", hash = "sha256:034d7354a9a018bdce352f48b2a8a450f05e9d6ee85db84764e9b6bd96dafe5a", size = 401205, upload-time = "2025-08-23T15:15:28.028Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/16/32/f8e3c85d1d5250232a5d3477a2a28cc291968ff175caeadaf3cc19ce0e4a/parso-0.8.5-py2.py3-none-any.whl", hash = "sha256:646204b5ee239c396d040b90f9e272e9a8017c630092bf59980beb62fd033887", size = 106668, upload-time = "2025-08-23T15:15:25.663Z" },
+]
+
+[[package]]
+name = "pauliengine"
+source = { editable = "." }
+dependencies = [
+    { name = "numpy" },
+]
+
+[package.dev-dependencies]
+dev = [
+    { name = "coverage" },
+    { name = "pre-commit" },
+    { name = "pytest" },
+    { name = "pytest-datadir" },
+    { name = "ruff" },
+]
+interactive = [
+    { name = "ipykernel" },
+    { name = "matplotlib" },
+    { name = "pydot" },
+    { name = "pylatexenc" },
+    { name = "tqdm" },
+]
+test = [
+    { name = "pytest" },
+    { name = "pytest-datadir" },
+]
+
+[package.metadata]
+requires-dist = [{ name = "numpy" }]
+
+[package.metadata.requires-dev]
+dev = [
+    { name = "coverage" },
+    { name = "pre-commit", specifier = ">=3" },
+    { name = "pytest", specifier = ">=8.2.2,<9.0" },
+    { name = "pytest-datadir" },
+    { name = "ruff", specifier = "==0.14.4" },
+]
+interactive = [
+    { name = "ipykernel", specifier = ">=6.25" },
+    { name = "matplotlib", specifier = ">=3" },
+    { name = "pydot", specifier = ">=1.4" },
+    { name = "pylatexenc" },
+    { name = "tqdm", specifier = ">=4.65.0" },
+]
+test = [
+    { name = "pytest", specifier = ">=8.2.2,<9.0" },
+    { name = "pytest-datadir" },
+]
+
+[[package]]
+name = "pexpect"
+version = "4.9.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "ptyprocess" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/42/92/cc564bf6381ff43ce1f4d06852fc19a2f11d180f23dc32d9588bee2f149d/pexpect-4.9.0.tar.gz", hash = "sha256:ee7d41123f3c9911050ea2c2dac107568dc43b2d3b0c7557a33212c398ead30f", size = 166450, upload-time = "2023-11-25T09:07:26.339Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/9e/c3/059298687310d527a58bb01f3b1965787ee3b40dce76752eda8b44e9a2c5/pexpect-4.9.0-py2.py3-none-any.whl", hash = "sha256:7236d1e080e4936be2dc3e326cec0af72acf9212a7e1d060210e70a47e253523", size = 63772, upload-time = "2023-11-25T06:56:14.81Z" },
+]
+
+[[package]]
+name = "pillow"
+version = "12.1.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/d0/02/d52c733a2452ef1ffcc123b68e6606d07276b0e358db70eabad7e40042b7/pillow-12.1.0.tar.gz", hash = "sha256:5c5ae0a06e9ea030ab786b0251b32c7e4ce10e58d983c0d5c56029455180b5b9", size = 46977283, upload-time = "2026-01-02T09:13:29.892Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/43/c4/bf8328039de6cc22182c3ef007a2abfbbdab153661c0a9aa78af8d706391/pillow-12.1.0-cp311-cp311-macosx_10_10_x86_64.whl", hash = "sha256:a83e0850cb8f5ac975291ebfc4170ba481f41a28065277f7f735c202cd8e0af3", size = 5304057, upload-time = "2026-01-02T09:10:46.627Z" },
+    { url = "https://files.pythonhosted.org/packages/43/06/7264c0597e676104cc22ca73ee48f752767cd4b1fe084662620b17e10120/pillow-12.1.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:b6e53e82ec2db0717eabb276aa56cf4e500c9a7cec2c2e189b55c24f65a3e8c0", size = 4657811, upload-time = "2026-01-02T09:10:49.548Z" },
+    { url = "https://files.pythonhosted.org/packages/72/64/f9189e44474610daf83da31145fa56710b627b5c4c0b9c235e34058f6b31/pillow-12.1.0-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:40a8e3b9e8773876d6e30daed22f016509e3987bab61b3b7fe309d7019a87451", size = 6232243, upload-time = "2026-01-02T09:10:51.62Z" },
+    { url = "https://files.pythonhosted.org/packages/ef/30/0df458009be6a4caca4ca2c52975e6275c387d4e5c95544e34138b41dc86/pillow-12.1.0-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:800429ac32c9b72909c671aaf17ecd13110f823ddb7db4dfef412a5587c2c24e", size = 8037872, upload-time = "2026-01-02T09:10:53.446Z" },
+    { url = "https://files.pythonhosted.org/packages/e4/86/95845d4eda4f4f9557e25381d70876aa213560243ac1a6d619c46caaedd9/pillow-12.1.0-cp311-cp311-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:0b022eaaf709541b391ee069f0022ee5b36c709df71986e3f7be312e46f42c84", size = 6345398, upload-time = "2026-01-02T09:10:55.426Z" },
+    { url = "https://files.pythonhosted.org/packages/5c/1f/8e66ab9be3aaf1435bc03edd1ebdf58ffcd17f7349c1d970cafe87af27d9/pillow-12.1.0-cp311-cp311-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:1f345e7bc9d7f368887c712aa5054558bad44d2a301ddf9248599f4161abc7c0", size = 7034667, upload-time = "2026-01-02T09:10:57.11Z" },
+    { url = "https://files.pythonhosted.org/packages/f9/f6/683b83cb9b1db1fb52b87951b1c0b99bdcfceaa75febf11406c19f82cb5e/pillow-12.1.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:d70347c8a5b7ccd803ec0c85c8709f036e6348f1e6a5bf048ecd9c64d3550b8b", size = 6458743, upload-time = "2026-01-02T09:10:59.331Z" },
+    { url = "https://files.pythonhosted.org/packages/9a/7d/de833d63622538c1d58ce5395e7c6cb7e7dce80decdd8bde4a484e095d9f/pillow-12.1.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:1fcc52d86ce7a34fd17cb04e87cfdb164648a3662a6f20565910a99653d66c18", size = 7159342, upload-time = "2026-01-02T09:11:01.82Z" },
+    { url = "https://files.pythonhosted.org/packages/8c/40/50d86571c9e5868c42b81fe7da0c76ca26373f3b95a8dd675425f4a92ec1/pillow-12.1.0-cp311-cp311-win32.whl", hash = "sha256:3ffaa2f0659e2f740473bcf03c702c39a8d4b2b7ffc629052028764324842c64", size = 6328655, upload-time = "2026-01-02T09:11:04.556Z" },
+    { url = "https://files.pythonhosted.org/packages/6c/af/b1d7e301c4cd26cd45d4af884d9ee9b6fab893b0ad2450d4746d74a6968c/pillow-12.1.0-cp311-cp311-win_amd64.whl", hash = "sha256:806f3987ffe10e867bab0ddad45df1148a2b98221798457fa097ad85d6e8bc75", size = 7031469, upload-time = "2026-01-02T09:11:06.538Z" },
+    { url = "https://files.pythonhosted.org/packages/48/36/d5716586d887fb2a810a4a61518a327a1e21c8b7134c89283af272efe84b/pillow-12.1.0-cp311-cp311-win_arm64.whl", hash = "sha256:9f5fefaca968e700ad1a4a9de98bf0869a94e397fe3524c4c9450c1445252304", size = 2452515, upload-time = "2026-01-02T09:11:08.226Z" },
+    { url = "https://files.pythonhosted.org/packages/20/31/dc53fe21a2f2996e1b7d92bf671cdb157079385183ef7c1ae08b485db510/pillow-12.1.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:a332ac4ccb84b6dde65dbace8431f3af08874bf9770719d32a635c4ef411b18b", size = 5262642, upload-time = "2026-01-02T09:11:10.138Z" },
+    { url = "https://files.pythonhosted.org/packages/ab/c1/10e45ac9cc79419cedf5121b42dcca5a50ad2b601fa080f58c22fb27626e/pillow-12.1.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:907bfa8a9cb790748a9aa4513e37c88c59660da3bcfffbd24a7d9e6abf224551", size = 4657464, upload-time = "2026-01-02T09:11:12.319Z" },
+    { url = "https://files.pythonhosted.org/packages/ad/26/7b82c0ab7ef40ebede7a97c72d473bda5950f609f8e0c77b04af574a0ddb/pillow-12.1.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:efdc140e7b63b8f739d09a99033aa430accce485ff78e6d311973a67b6bf3208", size = 6234878, upload-time = "2026-01-02T09:11:14.096Z" },
+    { url = "https://files.pythonhosted.org/packages/76/25/27abc9792615b5e886ca9411ba6637b675f1b77af3104710ac7353fe5605/pillow-12.1.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:bef9768cab184e7ae6e559c032e95ba8d07b3023c289f79a2bd36e8bf85605a5", size = 8044868, upload-time = "2026-01-02T09:11:15.903Z" },
+    { url = "https://files.pythonhosted.org/packages/0a/ea/f200a4c36d836100e7bc738fc48cd963d3ba6372ebc8298a889e0cfc3359/pillow-12.1.0-cp312-cp312-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:742aea052cf5ab5034a53c3846165bc3ce88d7c38e954120db0ab867ca242661", size = 6349468, upload-time = "2026-01-02T09:11:17.631Z" },
+    { url = "https://files.pythonhosted.org/packages/11/8f/48d0b77ab2200374c66d344459b8958c86693be99526450e7aee714e03e4/pillow-12.1.0-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:a6dfc2af5b082b635af6e08e0d1f9f1c4e04d17d4e2ca0ef96131e85eda6eb17", size = 7041518, upload-time = "2026-01-02T09:11:19.389Z" },
+    { url = "https://files.pythonhosted.org/packages/1d/23/c281182eb986b5d31f0a76d2a2c8cd41722d6fb8ed07521e802f9bba52de/pillow-12.1.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:609e89d9f90b581c8d16358c9087df76024cf058fa693dd3e1e1620823f39670", size = 6462829, upload-time = "2026-01-02T09:11:21.28Z" },
+    { url = "https://files.pythonhosted.org/packages/25/ef/7018273e0faac099d7b00982abdcc39142ae6f3bd9ceb06de09779c4a9d6/pillow-12.1.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:43b4899cfd091a9693a1278c4982f3e50f7fb7cff5153b05174b4afc9593b616", size = 7166756, upload-time = "2026-01-02T09:11:23.559Z" },
+    { url = "https://files.pythonhosted.org/packages/8f/c8/993d4b7ab2e341fe02ceef9576afcf5830cdec640be2ac5bee1820d693d4/pillow-12.1.0-cp312-cp312-win32.whl", hash = "sha256:aa0c9cc0b82b14766a99fbe6084409972266e82f459821cd26997a488a7261a7", size = 6328770, upload-time = "2026-01-02T09:11:25.661Z" },
+    { url = "https://files.pythonhosted.org/packages/a7/87/90b358775a3f02765d87655237229ba64a997b87efa8ccaca7dd3e36e7a7/pillow-12.1.0-cp312-cp312-win_amd64.whl", hash = "sha256:d70534cea9e7966169ad29a903b99fc507e932069a881d0965a1a84bb57f6c6d", size = 7033406, upload-time = "2026-01-02T09:11:27.474Z" },
+    { url = "https://files.pythonhosted.org/packages/5d/cf/881b457eccacac9e5b2ddd97d5071fb6d668307c57cbf4e3b5278e06e536/pillow-12.1.0-cp312-cp312-win_arm64.whl", hash = "sha256:65b80c1ee7e14a87d6a068dd3b0aea268ffcabfe0498d38661b00c5b4b22e74c", size = 2452612, upload-time = "2026-01-02T09:11:29.309Z" },
+    { url = "https://files.pythonhosted.org/packages/dd/c7/2530a4aa28248623e9d7f27316b42e27c32ec410f695929696f2e0e4a778/pillow-12.1.0-cp313-cp313-ios_13_0_arm64_iphoneos.whl", hash = "sha256:7b5dd7cbae20285cdb597b10eb5a2c13aa9de6cde9bb64a3c1317427b1db1ae1", size = 4062543, upload-time = "2026-01-02T09:11:31.566Z" },
+    { url = "https://files.pythonhosted.org/packages/8f/1f/40b8eae823dc1519b87d53c30ed9ef085506b05281d313031755c1705f73/pillow-12.1.0-cp313-cp313-ios_13_0_arm64_iphonesimulator.whl", hash = "sha256:29a4cef9cb672363926f0470afc516dbf7305a14d8c54f7abbb5c199cd8f8179", size = 4138373, upload-time = "2026-01-02T09:11:33.367Z" },
+    { url = "https://files.pythonhosted.org/packages/d4/77/6fa60634cf06e52139fd0e89e5bbf055e8166c691c42fb162818b7fda31d/pillow-12.1.0-cp313-cp313-ios_13_0_x86_64_iphonesimulator.whl", hash = "sha256:681088909d7e8fa9e31b9799aaa59ba5234c58e5e4f1951b4c4d1082a2e980e0", size = 3601241, upload-time = "2026-01-02T09:11:35.011Z" },
+    { url = "https://files.pythonhosted.org/packages/4f/bf/28ab865de622e14b747f0cd7877510848252d950e43002e224fb1c9ababf/pillow-12.1.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:983976c2ab753166dc66d36af6e8ec15bb511e4a25856e2227e5f7e00a160587", size = 5262410, upload-time = "2026-01-02T09:11:36.682Z" },
+    { url = "https://files.pythonhosted.org/packages/1c/34/583420a1b55e715937a85bd48c5c0991598247a1fd2eb5423188e765ea02/pillow-12.1.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:db44d5c160a90df2d24a24760bbd37607d53da0b34fb546c4c232af7192298ac", size = 4657312, upload-time = "2026-01-02T09:11:38.535Z" },
+    { url = "https://files.pythonhosted.org/packages/1d/fd/f5a0896839762885b3376ff04878f86ab2b097c2f9a9cdccf4eda8ba8dc0/pillow-12.1.0-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:6b7a9d1db5dad90e2991645874f708e87d9a3c370c243c2d7684d28f7e133e6b", size = 6232605, upload-time = "2026-01-02T09:11:40.602Z" },
+    { url = "https://files.pythonhosted.org/packages/98/aa/938a09d127ac1e70e6ed467bd03834350b33ef646b31edb7452d5de43792/pillow-12.1.0-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:6258f3260986990ba2fa8a874f8b6e808cf5abb51a94015ca3dc3c68aa4f30ea", size = 8041617, upload-time = "2026-01-02T09:11:42.721Z" },
+    { url = "https://files.pythonhosted.org/packages/17/e8/538b24cb426ac0186e03f80f78bc8dc7246c667f58b540bdd57c71c9f79d/pillow-12.1.0-cp313-cp313-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:e115c15e3bc727b1ca3e641a909f77f8ca72a64fff150f666fcc85e57701c26c", size = 6346509, upload-time = "2026-01-02T09:11:44.955Z" },
+    { url = "https://files.pythonhosted.org/packages/01/9a/632e58ec89a32738cabfd9ec418f0e9898a2b4719afc581f07c04a05e3c9/pillow-12.1.0-cp313-cp313-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:6741e6f3074a35e47c77b23a4e4f2d90db3ed905cb1c5e6e0d49bff2045632bc", size = 7038117, upload-time = "2026-01-02T09:11:46.736Z" },
+    { url = "https://files.pythonhosted.org/packages/c7/a2/d40308cf86eada842ca1f3ffa45d0ca0df7e4ab33c83f81e73f5eaed136d/pillow-12.1.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:935b9d1aed48fcfb3f838caac506f38e29621b44ccc4f8a64d575cb1b2a88644", size = 6460151, upload-time = "2026-01-02T09:11:48.625Z" },
+    { url = "https://files.pythonhosted.org/packages/f1/88/f5b058ad6453a085c5266660a1417bdad590199da1b32fb4efcff9d33b05/pillow-12.1.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:5fee4c04aad8932da9f8f710af2c1a15a83582cfb884152a9caa79d4efcdbf9c", size = 7164534, upload-time = "2026-01-02T09:11:50.445Z" },
+    { url = "https://files.pythonhosted.org/packages/19/ce/c17334caea1db789163b5d855a5735e47995b0b5dc8745e9a3605d5f24c0/pillow-12.1.0-cp313-cp313-win32.whl", hash = "sha256:a786bf667724d84aa29b5db1c61b7bfdde380202aaca12c3461afd6b71743171", size = 6332551, upload-time = "2026-01-02T09:11:52.234Z" },
+    { url = "https://files.pythonhosted.org/packages/e5/07/74a9d941fa45c90a0d9465098fe1ec85de3e2afbdc15cc4766622d516056/pillow-12.1.0-cp313-cp313-win_amd64.whl", hash = "sha256:461f9dfdafa394c59cd6d818bdfdbab4028b83b02caadaff0ffd433faf4c9a7a", size = 7040087, upload-time = "2026-01-02T09:11:54.822Z" },
+    { url = "https://files.pythonhosted.org/packages/88/09/c99950c075a0e9053d8e880595926302575bc742b1b47fe1bbcc8d388d50/pillow-12.1.0-cp313-cp313-win_arm64.whl", hash = "sha256:9212d6b86917a2300669511ed094a9406888362e085f2431a7da985a6b124f45", size = 2452470, upload-time = "2026-01-02T09:11:56.522Z" },
+    { url = "https://files.pythonhosted.org/packages/b5/ba/970b7d85ba01f348dee4d65412476321d40ee04dcb51cd3735b9dc94eb58/pillow-12.1.0-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:00162e9ca6d22b7c3ee8e61faa3c3253cd19b6a37f126cad04f2f88b306f557d", size = 5264816, upload-time = "2026-01-02T09:11:58.227Z" },
+    { url = "https://files.pythonhosted.org/packages/10/60/650f2fb55fdba7a510d836202aa52f0baac633e50ab1cf18415d332188fb/pillow-12.1.0-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:7d6daa89a00b58c37cb1747ec9fb7ac3bc5ffd5949f5888657dfddde6d1312e0", size = 4660472, upload-time = "2026-01-02T09:12:00.798Z" },
+    { url = "https://files.pythonhosted.org/packages/2b/c0/5273a99478956a099d533c4f46cbaa19fd69d606624f4334b85e50987a08/pillow-12.1.0-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:e2479c7f02f9d505682dc47df8c0ea1fc5e264c4d1629a5d63fe3e2334b89554", size = 6268974, upload-time = "2026-01-02T09:12:02.572Z" },
+    { url = "https://files.pythonhosted.org/packages/b4/26/0bf714bc2e73d5267887d47931d53c4ceeceea6978148ed2ab2a4e6463c4/pillow-12.1.0-cp313-cp313t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:f188d580bd870cda1e15183790d1cc2fa78f666e76077d103edf048eed9c356e", size = 8073070, upload-time = "2026-01-02T09:12:04.75Z" },
+    { url = "https://files.pythonhosted.org/packages/43/cf/1ea826200de111a9d65724c54f927f3111dc5ae297f294b370a670c17786/pillow-12.1.0-cp313-cp313t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:0fde7ec5538ab5095cc02df38ee99b0443ff0e1c847a045554cf5f9af1f4aa82", size = 6380176, upload-time = "2026-01-02T09:12:06.626Z" },
+    { url = "https://files.pythonhosted.org/packages/03/e0/7938dd2b2013373fd85d96e0f38d62b7a5a262af21ac274250c7ca7847c9/pillow-12.1.0-cp313-cp313t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:0ed07dca4a8464bada6139ab38f5382f83e5f111698caf3191cb8dbf27d908b4", size = 7067061, upload-time = "2026-01-02T09:12:08.624Z" },
+    { url = "https://files.pythonhosted.org/packages/86/ad/a2aa97d37272a929a98437a8c0ac37b3cf012f4f8721e1bd5154699b2518/pillow-12.1.0-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:f45bd71d1fa5e5749587613037b172e0b3b23159d1c00ef2fc920da6f470e6f0", size = 6491824, upload-time = "2026-01-02T09:12:10.488Z" },
+    { url = "https://files.pythonhosted.org/packages/a4/44/80e46611b288d51b115826f136fb3465653c28f491068a72d3da49b54cd4/pillow-12.1.0-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:277518bf4fe74aa91489e1b20577473b19ee70fb97c374aa50830b279f25841b", size = 7190911, upload-time = "2026-01-02T09:12:12.772Z" },
+    { url = "https://files.pythonhosted.org/packages/86/77/eacc62356b4cf81abe99ff9dbc7402750044aed02cfd6a503f7c6fc11f3e/pillow-12.1.0-cp313-cp313t-win32.whl", hash = "sha256:7315f9137087c4e0ee73a761b163fc9aa3b19f5f606a7fc08d83fd3e4379af65", size = 6336445, upload-time = "2026-01-02T09:12:14.775Z" },
+    { url = "https://files.pythonhosted.org/packages/e7/3c/57d81d0b74d218706dafccb87a87ea44262c43eef98eb3b164fd000e0491/pillow-12.1.0-cp313-cp313t-win_amd64.whl", hash = "sha256:0ddedfaa8b5f0b4ffbc2fa87b556dc59f6bb4ecb14a53b33f9189713ae8053c0", size = 7045354, upload-time = "2026-01-02T09:12:16.599Z" },
+    { url = "https://files.pythonhosted.org/packages/ac/82/8b9b97bba2e3576a340f93b044a3a3a09841170ab4c1eb0d5c93469fd32f/pillow-12.1.0-cp313-cp313t-win_arm64.whl", hash = "sha256:80941e6d573197a0c28f394753de529bb436b1ca990ed6e765cf42426abc39f8", size = 2454547, upload-time = "2026-01-02T09:12:18.704Z" },
+    { url = "https://files.pythonhosted.org/packages/8b/bc/224b1d98cffd7164b14707c91aac83c07b047fbd8f58eba4066a3e53746a/pillow-12.1.0-pp311-pypy311_pp73-macosx_10_15_x86_64.whl", hash = "sha256:ca94b6aac0d7af2a10ba08c0f888b3d5114439b6b3ef39968378723622fed377", size = 5228605, upload-time = "2026-01-02T09:13:14.084Z" },
+    { url = "https://files.pythonhosted.org/packages/0c/ca/49ca7769c4550107de049ed85208240ba0f330b3f2e316f24534795702ce/pillow-12.1.0-pp311-pypy311_pp73-macosx_11_0_arm64.whl", hash = "sha256:351889afef0f485b84078ea40fe33727a0492b9af3904661b0abbafee0355b72", size = 4622245, upload-time = "2026-01-02T09:13:15.964Z" },
+    { url = "https://files.pythonhosted.org/packages/73/48/fac807ce82e5955bcc2718642b94b1bd22a82a6d452aea31cbb678cddf12/pillow-12.1.0-pp311-pypy311_pp73-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:bb0984b30e973f7e2884362b7d23d0a348c7143ee559f38ef3eaab640144204c", size = 5247593, upload-time = "2026-01-02T09:13:17.913Z" },
+    { url = "https://files.pythonhosted.org/packages/d2/95/3e0742fe358c4664aed4fd05d5f5373dcdad0b27af52aa0972568541e3f4/pillow-12.1.0-pp311-pypy311_pp73-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:84cabc7095dd535ca934d57e9ce2a72ffd216e435a84acb06b2277b1de2689bd", size = 6989008, upload-time = "2026-01-02T09:13:20.083Z" },
+    { url = "https://files.pythonhosted.org/packages/5a/74/fe2ac378e4e202e56d50540d92e1ef4ff34ed687f3c60f6a121bcf99437e/pillow-12.1.0-pp311-pypy311_pp73-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:53d8b764726d3af1a138dd353116f774e3862ec7e3794e0c8781e30db0f35dfc", size = 5313824, upload-time = "2026-01-02T09:13:22.405Z" },
+    { url = "https://files.pythonhosted.org/packages/f3/77/2a60dee1adee4e2655ac328dd05c02a955c1cd683b9f1b82ec3feb44727c/pillow-12.1.0-pp311-pypy311_pp73-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:5da841d81b1a05ef940a8567da92decaa15bc4d7dedb540a8c219ad83d91808a", size = 5963278, upload-time = "2026-01-02T09:13:24.706Z" },
+    { url = "https://files.pythonhosted.org/packages/2d/71/64e9b1c7f04ae0027f788a248e6297d7fcc29571371fe7d45495a78172c0/pillow-12.1.0-pp311-pypy311_pp73-win_amd64.whl", hash = "sha256:75af0b4c229ac519b155028fa1be632d812a519abba9b46b20e50c6caa184f19", size = 7029809, upload-time = "2026-01-02T09:13:26.541Z" },
+]
+
+[[package]]
+name = "platformdirs"
+version = "4.5.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/cf/86/0248f086a84f01b37aaec0fa567b397df1a119f73c16f6c7a9aac73ea309/platformdirs-4.5.1.tar.gz", hash = "sha256:61d5cdcc6065745cdd94f0f878977f8de9437be93de97c1c12f853c9c0cdcbda", size = 21715, upload-time = "2025-12-05T13:52:58.638Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/cb/28/3bfe2fa5a7b9c46fe7e13c97bda14c895fb10fa2ebf1d0abb90e0cea7ee1/platformdirs-4.5.1-py3-none-any.whl", hash = "sha256:d03afa3963c806a9bed9d5125c8f4cb2fdaf74a55ab60e5d59b3fde758104d31", size = 18731, upload-time = "2025-12-05T13:52:56.823Z" },
+]
+
+[[package]]
+name = "pluggy"
+version = "1.6.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/f9/e2/3e91f31a7d2b083fe6ef3fa267035b518369d9511ffab804f839851d2779/pluggy-1.6.0.tar.gz", hash = "sha256:7dcc130b76258d33b90f61b658791dede3486c3e6bfb003ee5c9bfb396dd22f3", size = 69412, upload-time = "2025-05-15T12:30:07.975Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/54/20/4d324d65cc6d9205fabedc306948156824eb9f0ee1633355a8f7ec5c66bf/pluggy-1.6.0-py3-none-any.whl", hash = "sha256:e920276dd6813095e9377c0bc5566d94c932c33b27a3e3945d8389c374dd4746", size = 20538, upload-time = "2025-05-15T12:30:06.134Z" },
+]
+
+[[package]]
+name = "pre-commit"
+version = "4.5.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "cfgv" },
+    { name = "identify" },
+    { name = "nodeenv" },
+    { name = "pyyaml" },
+    { name = "virtualenv" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/40/f1/6d86a29246dfd2e9b6237f0b5823717f60cad94d47ddc26afa916d21f525/pre_commit-4.5.1.tar.gz", hash = "sha256:eb545fcff725875197837263e977ea257a402056661f09dae08e4b149b030a61", size = 198232, upload-time = "2025-12-16T21:14:33.552Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/5d/19/fd3ef348460c80af7bb4669ea7926651d1f95c23ff2df18b9d24bab4f3fa/pre_commit-4.5.1-py2.py3-none-any.whl", hash = "sha256:3b3afd891e97337708c1674210f8eba659b52a38ea5f822ff142d10786221f77", size = 226437, upload-time = "2025-12-16T21:14:32.409Z" },
+]
+
+[[package]]
+name = "prompt-toolkit"
+version = "3.0.52"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "wcwidth" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/a1/96/06e01a7b38dce6fe1db213e061a4602dd6032a8a97ef6c1a862537732421/prompt_toolkit-3.0.52.tar.gz", hash = "sha256:28cde192929c8e7321de85de1ddbe736f1375148b02f2e17edd840042b1be855", size = 434198, upload-time = "2025-08-27T15:24:02.057Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/84/03/0d3ce49e2505ae70cf43bc5bb3033955d2fc9f932163e84dc0779cc47f48/prompt_toolkit-3.0.52-py3-none-any.whl", hash = "sha256:9aac639a3bbd33284347de5ad8d68ecc044b91a762dc39b7c21095fcd6a19955", size = 391431, upload-time = "2025-08-27T15:23:59.498Z" },
+]
+
+[[package]]
+name = "psutil"
+version = "7.2.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/73/cb/09e5184fb5fc0358d110fc3ca7f6b1d033800734d34cac10f4136cfac10e/psutil-7.2.1.tar.gz", hash = "sha256:f7583aec590485b43ca601dd9cea0dcd65bd7bb21d30ef4ddbf4ea6b5ed1bdd3", size = 490253, upload-time = "2025-12-29T08:26:00.169Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/77/8e/f0c242053a368c2aa89584ecd1b054a18683f13d6e5a318fc9ec36582c94/psutil-7.2.1-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:ba9f33bb525b14c3ea563b2fd521a84d2fa214ec59e3e6a2858f78d0844dd60d", size = 129624, upload-time = "2025-12-29T08:26:04.255Z" },
+    { url = "https://files.pythonhosted.org/packages/26/97/a58a4968f8990617decee234258a2b4fc7cd9e35668387646c1963e69f26/psutil-7.2.1-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:81442dac7abfc2f4f4385ea9e12ddf5a796721c0f6133260687fec5c3780fa49", size = 130132, upload-time = "2025-12-29T08:26:06.228Z" },
+    { url = "https://files.pythonhosted.org/packages/db/6d/ed44901e830739af5f72a85fa7ec5ff1edea7f81bfbf4875e409007149bd/psutil-7.2.1-cp313-cp313t-manylinux2010_x86_64.manylinux_2_12_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:ea46c0d060491051d39f0d2cff4f98d5c72b288289f57a21556cc7d504db37fc", size = 180612, upload-time = "2025-12-29T08:26:08.276Z" },
+    { url = "https://files.pythonhosted.org/packages/c7/65/b628f8459bca4efbfae50d4bf3feaab803de9a160b9d5f3bd9295a33f0c2/psutil-7.2.1-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:35630d5af80d5d0d49cfc4d64c1c13838baf6717a13effb35869a5919b854cdf", size = 183201, upload-time = "2025-12-29T08:26:10.622Z" },
+    { url = "https://files.pythonhosted.org/packages/fb/23/851cadc9764edcc18f0effe7d0bf69f727d4cf2442deb4a9f78d4e4f30f2/psutil-7.2.1-cp313-cp313t-win_amd64.whl", hash = "sha256:923f8653416604e356073e6e0bccbe7c09990acef442def2f5640dd0faa9689f", size = 139081, upload-time = "2025-12-29T08:26:12.483Z" },
+    { url = "https://files.pythonhosted.org/packages/59/82/d63e8494ec5758029f31c6cb06d7d161175d8281e91d011a4a441c8a43b5/psutil-7.2.1-cp313-cp313t-win_arm64.whl", hash = "sha256:cfbe6b40ca48019a51827f20d830887b3107a74a79b01ceb8cc8de4ccb17b672", size = 134767, upload-time = "2025-12-29T08:26:14.528Z" },
+    { url = "https://files.pythonhosted.org/packages/c5/cf/5180eb8c8bdf6a503c6919f1da28328bd1e6b3b1b5b9d5b01ae64f019616/psutil-7.2.1-cp36-abi3-macosx_10_9_x86_64.whl", hash = "sha256:b2e953fcfaedcfbc952b44744f22d16575d3aa78eb4f51ae74165b4e96e55f42", size = 128137, upload-time = "2025-12-29T08:26:27.759Z" },
+    { url = "https://files.pythonhosted.org/packages/c5/2c/78e4a789306a92ade5000da4f5de3255202c534acdadc3aac7b5458fadef/psutil-7.2.1-cp36-abi3-macosx_11_0_arm64.whl", hash = "sha256:05cc68dbb8c174828624062e73078e7e35406f4ca2d0866c272c2410d8ef06d1", size = 128947, upload-time = "2025-12-29T08:26:29.548Z" },
+    { url = "https://files.pythonhosted.org/packages/29/f8/40e01c350ad9a2b3cb4e6adbcc8a83b17ee50dd5792102b6142385937db5/psutil-7.2.1-cp36-abi3-manylinux2010_x86_64.manylinux_2_12_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:5e38404ca2bb30ed7267a46c02f06ff842e92da3bb8c5bfdadbd35a5722314d8", size = 154694, upload-time = "2025-12-29T08:26:32.147Z" },
+    { url = "https://files.pythonhosted.org/packages/06/e4/b751cdf839c011a9714a783f120e6a86b7494eb70044d7d81a25a5cd295f/psutil-7.2.1-cp36-abi3-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ab2b98c9fc19f13f59628d94df5cc4cc4844bc572467d113a8b517d634e362c6", size = 156136, upload-time = "2025-12-29T08:26:34.079Z" },
+    { url = "https://files.pythonhosted.org/packages/44/ad/bbf6595a8134ee1e94a4487af3f132cef7fce43aef4a93b49912a48c3af7/psutil-7.2.1-cp36-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:f78baafb38436d5a128f837fab2d92c276dfb48af01a240b861ae02b2413ada8", size = 148108, upload-time = "2025-12-29T08:26:36.225Z" },
+    { url = "https://files.pythonhosted.org/packages/1c/15/dd6fd869753ce82ff64dcbc18356093471a5a5adf4f77ed1f805d473d859/psutil-7.2.1-cp36-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:99a4cd17a5fdd1f3d014396502daa70b5ec21bf4ffe38393e152f8e449757d67", size = 147402, upload-time = "2025-12-29T08:26:39.21Z" },
+    { url = "https://files.pythonhosted.org/packages/34/68/d9317542e3f2b180c4306e3f45d3c922d7e86d8ce39f941bb9e2e9d8599e/psutil-7.2.1-cp37-abi3-win_amd64.whl", hash = "sha256:b1b0671619343aa71c20ff9767eced0483e4fc9e1f489d50923738caf6a03c17", size = 136938, upload-time = "2025-12-29T08:26:41.036Z" },
+    { url = "https://files.pythonhosted.org/packages/3e/73/2ce007f4198c80fcf2cb24c169884f833fe93fbc03d55d302627b094ee91/psutil-7.2.1-cp37-abi3-win_arm64.whl", hash = "sha256:0d67c1822c355aa6f7314d92018fb4268a76668a536f133599b91edd48759442", size = 133836, upload-time = "2025-12-29T08:26:43.086Z" },
+]
+
+[[package]]
+name = "ptyprocess"
+version = "0.7.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/20/e5/16ff212c1e452235a90aeb09066144d0c5a6a8c0834397e03f5224495c4e/ptyprocess-0.7.0.tar.gz", hash = "sha256:5c5d0a3b48ceee0b48485e0c26037c0acd7d29765ca3fbb5cb3831d347423220", size = 70762, upload-time = "2020-12-28T15:15:30.155Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/22/a6/858897256d0deac81a172289110f31629fc4cee19b6f01283303e18c8db3/ptyprocess-0.7.0-py2.py3-none-any.whl", hash = "sha256:4b41f3967fce3af57cc7e94b888626c18bf37a083e3651ca8feeb66d492fef35", size = 13993, upload-time = "2020-12-28T15:15:28.35Z" },
+]
+
+[[package]]
+name = "pure-eval"
+version = "0.2.3"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/cd/05/0a34433a064256a578f1783a10da6df098ceaa4a57bbeaa96a6c0352786b/pure_eval-0.2.3.tar.gz", hash = "sha256:5f4e983f40564c576c7c8635ae88db5956bb2229d7e9237d03b3c0b0190eaf42", size = 19752, upload-time = "2024-07-21T12:58:21.801Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/8e/37/efad0257dc6e593a18957422533ff0f87ede7c9c6ea010a2177d738fb82f/pure_eval-0.2.3-py3-none-any.whl", hash = "sha256:1db8e35b67b3d218d818ae653e27f06c3aa420901fa7b081ca98cbedc874e0d0", size = 11842, upload-time = "2024-07-21T12:58:20.04Z" },
+]
+
+[[package]]
+name = "pycparser"
+version = "2.23"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/fe/cf/d2d3b9f5699fb1e4615c8e32ff220203e43b248e1dfcc6736ad9057731ca/pycparser-2.23.tar.gz", hash = "sha256:78816d4f24add8f10a06d6f05b4d424ad9e96cfebf68a4ddc99c65c0720d00c2", size = 173734, upload-time = "2025-09-09T13:23:47.91Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/a0/e3/59cd50310fc9b59512193629e1984c1f95e5c8ae6e5d8c69532ccc65a7fe/pycparser-2.23-py3-none-any.whl", hash = "sha256:e5c6e8d3fbad53479cab09ac03729e0a9faf2bee3db8208a550daf5af81a5934", size = 118140, upload-time = "2025-09-09T13:23:46.651Z" },
+]
+
+[[package]]
+name = "pydot"
+version = "4.0.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "pyparsing" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/50/35/b17cb89ff865484c6a20ef46bf9d95a5f07328292578de0b295f4a6beec2/pydot-4.0.1.tar.gz", hash = "sha256:c2148f681c4a33e08bf0e26a9e5f8e4099a82e0e2a068098f32ce86577364ad5", size = 162594, upload-time = "2025-06-17T20:09:56.454Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/7e/32/a7125fb28c4261a627f999d5fb4afff25b523800faed2c30979949d6facd/pydot-4.0.1-py3-none-any.whl", hash = "sha256:869c0efadd2708c0be1f916eb669f3d664ca684bc57ffb7ecc08e70d5e93fee6", size = 37087, upload-time = "2025-06-17T20:09:55.25Z" },
+]
+
+[[package]]
+name = "pygments"
+version = "2.19.2"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/b0/77/a5b8c569bf593b0140bde72ea885a803b82086995367bf2037de0159d924/pygments-2.19.2.tar.gz", hash = "sha256:636cb2477cec7f8952536970bc533bc43743542f70392ae026374600add5b887", size = 4968631, upload-time = "2025-06-21T13:39:12.283Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/c7/21/705964c7812476f378728bdf590ca4b771ec72385c533964653c68e86bdc/pygments-2.19.2-py3-none-any.whl", hash = "sha256:86540386c03d588bb81d44bc3928634ff26449851e99741617ecb9037ee5ec0b", size = 1225217, upload-time = "2025-06-21T13:39:07.939Z" },
+]
+
+[[package]]
+name = "pylatexenc"
+version = "2.10"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/5d/ab/34ec41718af73c00119d0351b7a2531d2ebddb51833a36448fc7b862be60/pylatexenc-2.10.tar.gz", hash = "sha256:3dd8fd84eb46dc30bee1e23eaab8d8fb5a7f507347b23e5f38ad9675c84f40d3", size = 162597, upload-time = "2021-04-06T07:56:07.854Z" }
+
+[[package]]
+name = "pyparsing"
+version = "3.3.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/33/c1/1d9de9aeaa1b89b0186e5fe23294ff6517fce1bc69149185577cd31016b2/pyparsing-3.3.1.tar.gz", hash = "sha256:47fad0f17ac1e2cad3de3b458570fbc9b03560aa029ed5e16ee5554da9a2251c", size = 1550512, upload-time = "2025-12-23T03:14:04.391Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/8b/40/2614036cdd416452f5bf98ec037f38a1afb17f327cb8e6b652d4729e0af8/pyparsing-3.3.1-py3-none-any.whl", hash = "sha256:023b5e7e5520ad96642e2c6db4cb683d3970bd640cdf7115049a6e9c3682df82", size = 121793, upload-time = "2025-12-23T03:14:02.103Z" },
+]
+
+[[package]]
+name = "pytest"
+version = "8.4.2"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "colorama", marker = "sys_platform == 'win32'" },
+    { name = "iniconfig" },
+    { name = "packaging" },
+    { name = "pluggy" },
+    { name = "pygments" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/a3/5c/00a0e072241553e1a7496d638deababa67c5058571567b92a7eaa258397c/pytest-8.4.2.tar.gz", hash = "sha256:86c0d0b93306b961d58d62a4db4879f27fe25513d4b969df351abdddb3c30e01", size = 1519618, upload-time = "2025-09-04T14:34:22.711Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/a8/a4/20da314d277121d6534b3a980b29035dcd51e6744bd79075a6ce8fa4eb8d/pytest-8.4.2-py3-none-any.whl", hash = "sha256:872f880de3fc3a5bdc88a11b39c9710c3497a547cfa9320bc3c5e62fbf272e79", size = 365750, upload-time = "2025-09-04T14:34:20.226Z" },
+]
+
+[[package]]
+name = "pytest-datadir"
+version = "1.8.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "pytest" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/b4/46/db060b291999ca048edd06d6fa9ee95945d088edc38b1172c59eeb46ec45/pytest_datadir-1.8.0.tar.gz", hash = "sha256:7a15faed76cebe87cc91941dd1920a9a38eba56a09c11e9ddf1434d28a0f78eb", size = 11848, upload-time = "2025-07-30T13:52:12.518Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/8f/7a/33895863aec26ac3bb5068a73583f935680d6ab6af2a9567d409430c3ee1/pytest_datadir-1.8.0-py3-none-any.whl", hash = "sha256:5c677bc097d907ac71ca418109adc3abe34cf0bddfe6cf78aecfbabd96a15cf0", size = 6512, upload-time = "2025-07-30T13:52:11.525Z" },
+]
+
+[[package]]
+name = "python-dateutil"
+version = "2.9.0.post0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "six" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/66/c0/0c8b6ad9f17a802ee498c46e004a0eb49bc148f2fd230864601a86dcf6db/python-dateutil-2.9.0.post0.tar.gz", hash = "sha256:37dd54208da7e1cd875388217d5e00ebd4179249f90fb72437e91a35459a0ad3", size = 342432, upload-time = "2024-03-01T18:36:20.211Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/ec/57/56b9bcc3c9c6a792fcbaf139543cee77261f3651ca9da0c93f5c1221264b/python_dateutil-2.9.0.post0-py2.py3-none-any.whl", hash = "sha256:a8b2bc7bffae282281c8140a97d3aa9c14da0b136dfe83f850eea9a5f7470427", size = 229892, upload-time = "2024-03-01T18:36:18.57Z" },
+]
+
+[[package]]
+name = "pyyaml"
+version = "6.0.3"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/05/8e/961c0007c59b8dd7729d542c61a4d537767a59645b82a0b521206e1e25c2/pyyaml-6.0.3.tar.gz", hash = "sha256:d76623373421df22fb4cf8817020cbb7ef15c725b9d5e45f17e189bfc384190f", size = 130960, upload-time = "2025-09-25T21:33:16.546Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/6d/16/a95b6757765b7b031c9374925bb718d55e0a9ba8a1b6a12d25962ea44347/pyyaml-6.0.3-cp311-cp311-macosx_10_13_x86_64.whl", hash = "sha256:44edc647873928551a01e7a563d7452ccdebee747728c1080d881d68af7b997e", size = 185826, upload-time = "2025-09-25T21:31:58.655Z" },
+    { url = "https://files.pythonhosted.org/packages/16/19/13de8e4377ed53079ee996e1ab0a9c33ec2faf808a4647b7b4c0d46dd239/pyyaml-6.0.3-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:652cb6edd41e718550aad172851962662ff2681490a8a711af6a4d288dd96824", size = 175577, upload-time = "2025-09-25T21:32:00.088Z" },
+    { url = "https://files.pythonhosted.org/packages/0c/62/d2eb46264d4b157dae1275b573017abec435397aa59cbcdab6fc978a8af4/pyyaml-6.0.3-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:10892704fc220243f5305762e276552a0395f7beb4dbf9b14ec8fd43b57f126c", size = 775556, upload-time = "2025-09-25T21:32:01.31Z" },
+    { url = "https://files.pythonhosted.org/packages/10/cb/16c3f2cf3266edd25aaa00d6c4350381c8b012ed6f5276675b9eba8d9ff4/pyyaml-6.0.3-cp311-cp311-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:850774a7879607d3a6f50d36d04f00ee69e7fc816450e5f7e58d7f17f1ae5c00", size = 882114, upload-time = "2025-09-25T21:32:03.376Z" },
+    { url = "https://files.pythonhosted.org/packages/71/60/917329f640924b18ff085ab889a11c763e0b573da888e8404ff486657602/pyyaml-6.0.3-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:b8bb0864c5a28024fac8a632c443c87c5aa6f215c0b126c449ae1a150412f31d", size = 806638, upload-time = "2025-09-25T21:32:04.553Z" },
+    { url = "https://files.pythonhosted.org/packages/dd/6f/529b0f316a9fd167281a6c3826b5583e6192dba792dd55e3203d3f8e655a/pyyaml-6.0.3-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:1d37d57ad971609cf3c53ba6a7e365e40660e3be0e5175fa9f2365a379d6095a", size = 767463, upload-time = "2025-09-25T21:32:06.152Z" },
+    { url = "https://files.pythonhosted.org/packages/f2/6a/b627b4e0c1dd03718543519ffb2f1deea4a1e6d42fbab8021936a4d22589/pyyaml-6.0.3-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:37503bfbfc9d2c40b344d06b2199cf0e96e97957ab1c1b546fd4f87e53e5d3e4", size = 794986, upload-time = "2025-09-25T21:32:07.367Z" },
+    { url = "https://files.pythonhosted.org/packages/45/91/47a6e1c42d9ee337c4839208f30d9f09caa9f720ec7582917b264defc875/pyyaml-6.0.3-cp311-cp311-win32.whl", hash = "sha256:8098f252adfa6c80ab48096053f512f2321f0b998f98150cea9bd23d83e1467b", size = 142543, upload-time = "2025-09-25T21:32:08.95Z" },
+    { url = "https://files.pythonhosted.org/packages/da/e3/ea007450a105ae919a72393cb06f122f288ef60bba2dc64b26e2646fa315/pyyaml-6.0.3-cp311-cp311-win_amd64.whl", hash = "sha256:9f3bfb4965eb874431221a3ff3fdcddc7e74e3b07799e0e84ca4a0f867d449bf", size = 158763, upload-time = "2025-09-25T21:32:09.96Z" },
+    { url = "https://files.pythonhosted.org/packages/d1/33/422b98d2195232ca1826284a76852ad5a86fe23e31b009c9886b2d0fb8b2/pyyaml-6.0.3-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:7f047e29dcae44602496db43be01ad42fc6f1cc0d8cd6c83d342306c32270196", size = 182063, upload-time = "2025-09-25T21:32:11.445Z" },
+    { url = "https://files.pythonhosted.org/packages/89/a0/6cf41a19a1f2f3feab0e9c0b74134aa2ce6849093d5517a0c550fe37a648/pyyaml-6.0.3-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:fc09d0aa354569bc501d4e787133afc08552722d3ab34836a80547331bb5d4a0", size = 173973, upload-time = "2025-09-25T21:32:12.492Z" },
+    { url = "https://files.pythonhosted.org/packages/ed/23/7a778b6bd0b9a8039df8b1b1d80e2e2ad78aa04171592c8a5c43a56a6af4/pyyaml-6.0.3-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:9149cad251584d5fb4981be1ecde53a1ca46c891a79788c0df828d2f166bda28", size = 775116, upload-time = "2025-09-25T21:32:13.652Z" },
+    { url = "https://files.pythonhosted.org/packages/65/30/d7353c338e12baef4ecc1b09e877c1970bd3382789c159b4f89d6a70dc09/pyyaml-6.0.3-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:5fdec68f91a0c6739b380c83b951e2c72ac0197ace422360e6d5a959d8d97b2c", size = 844011, upload-time = "2025-09-25T21:32:15.21Z" },
+    { url = "https://files.pythonhosted.org/packages/8b/9d/b3589d3877982d4f2329302ef98a8026e7f4443c765c46cfecc8858c6b4b/pyyaml-6.0.3-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:ba1cc08a7ccde2d2ec775841541641e4548226580ab850948cbfda66a1befcdc", size = 807870, upload-time = "2025-09-25T21:32:16.431Z" },
+    { url = "https://files.pythonhosted.org/packages/05/c0/b3be26a015601b822b97d9149ff8cb5ead58c66f981e04fedf4e762f4bd4/pyyaml-6.0.3-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:8dc52c23056b9ddd46818a57b78404882310fb473d63f17b07d5c40421e47f8e", size = 761089, upload-time = "2025-09-25T21:32:17.56Z" },
+    { url = "https://files.pythonhosted.org/packages/be/8e/98435a21d1d4b46590d5459a22d88128103f8da4c2d4cb8f14f2a96504e1/pyyaml-6.0.3-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:41715c910c881bc081f1e8872880d3c650acf13dfa8214bad49ed4cede7c34ea", size = 790181, upload-time = "2025-09-25T21:32:18.834Z" },
+    { url = "https://files.pythonhosted.org/packages/74/93/7baea19427dcfbe1e5a372d81473250b379f04b1bd3c4c5ff825e2327202/pyyaml-6.0.3-cp312-cp312-win32.whl", hash = "sha256:96b533f0e99f6579b3d4d4995707cf36df9100d67e0c8303a0c55b27b5f99bc5", size = 137658, upload-time = "2025-09-25T21:32:20.209Z" },
+    { url = "https://files.pythonhosted.org/packages/86/bf/899e81e4cce32febab4fb42bb97dcdf66bc135272882d1987881a4b519e9/pyyaml-6.0.3-cp312-cp312-win_amd64.whl", hash = "sha256:5fcd34e47f6e0b794d17de1b4ff496c00986e1c83f7ab2fb8fcfe9616ff7477b", size = 154003, upload-time = "2025-09-25T21:32:21.167Z" },
+    { url = "https://files.pythonhosted.org/packages/1a/08/67bd04656199bbb51dbed1439b7f27601dfb576fb864099c7ef0c3e55531/pyyaml-6.0.3-cp312-cp312-win_arm64.whl", hash = "sha256:64386e5e707d03a7e172c0701abfb7e10f0fb753ee1d773128192742712a98fd", size = 140344, upload-time = "2025-09-25T21:32:22.617Z" },
+    { url = "https://files.pythonhosted.org/packages/d1/11/0fd08f8192109f7169db964b5707a2f1e8b745d4e239b784a5a1dd80d1db/pyyaml-6.0.3-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:8da9669d359f02c0b91ccc01cac4a67f16afec0dac22c2ad09f46bee0697eba8", size = 181669, upload-time = "2025-09-25T21:32:23.673Z" },
+    { url = "https://files.pythonhosted.org/packages/b1/16/95309993f1d3748cd644e02e38b75d50cbc0d9561d21f390a76242ce073f/pyyaml-6.0.3-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:2283a07e2c21a2aa78d9c4442724ec1eb15f5e42a723b99cb3d822d48f5f7ad1", size = 173252, upload-time = "2025-09-25T21:32:25.149Z" },
+    { url = "https://files.pythonhosted.org/packages/50/31/b20f376d3f810b9b2371e72ef5adb33879b25edb7a6d072cb7ca0c486398/pyyaml-6.0.3-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ee2922902c45ae8ccada2c5b501ab86c36525b883eff4255313a253a3160861c", size = 767081, upload-time = "2025-09-25T21:32:26.575Z" },
+    { url = "https://files.pythonhosted.org/packages/49/1e/a55ca81e949270d5d4432fbbd19dfea5321eda7c41a849d443dc92fd1ff7/pyyaml-6.0.3-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:a33284e20b78bd4a18c8c2282d549d10bc8408a2a7ff57653c0cf0b9be0afce5", size = 841159, upload-time = "2025-09-25T21:32:27.727Z" },
+    { url = "https://files.pythonhosted.org/packages/74/27/e5b8f34d02d9995b80abcef563ea1f8b56d20134d8f4e5e81733b1feceb2/pyyaml-6.0.3-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:0f29edc409a6392443abf94b9cf89ce99889a1dd5376d94316ae5145dfedd5d6", size = 801626, upload-time = "2025-09-25T21:32:28.878Z" },
+    { url = "https://files.pythonhosted.org/packages/f9/11/ba845c23988798f40e52ba45f34849aa8a1f2d4af4b798588010792ebad6/pyyaml-6.0.3-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:f7057c9a337546edc7973c0d3ba84ddcdf0daa14533c2065749c9075001090e6", size = 753613, upload-time = "2025-09-25T21:32:30.178Z" },
+    { url = "https://files.pythonhosted.org/packages/3d/e0/7966e1a7bfc0a45bf0a7fb6b98ea03fc9b8d84fa7f2229e9659680b69ee3/pyyaml-6.0.3-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:eda16858a3cab07b80edaf74336ece1f986ba330fdb8ee0d6c0d68fe82bc96be", size = 794115, upload-time = "2025-09-25T21:32:31.353Z" },
+    { url = "https://files.pythonhosted.org/packages/de/94/980b50a6531b3019e45ddeada0626d45fa85cbe22300844a7983285bed3b/pyyaml-6.0.3-cp313-cp313-win32.whl", hash = "sha256:d0eae10f8159e8fdad514efdc92d74fd8d682c933a6dd088030f3834bc8e6b26", size = 137427, upload-time = "2025-09-25T21:32:32.58Z" },
+    { url = "https://files.pythonhosted.org/packages/97/c9/39d5b874e8b28845e4ec2202b5da735d0199dbe5b8fb85f91398814a9a46/pyyaml-6.0.3-cp313-cp313-win_amd64.whl", hash = "sha256:79005a0d97d5ddabfeeea4cf676af11e647e41d81c9a7722a193022accdb6b7c", size = 154090, upload-time = "2025-09-25T21:32:33.659Z" },
+    { url = "https://files.pythonhosted.org/packages/73/e8/2bdf3ca2090f68bb3d75b44da7bbc71843b19c9f2b9cb9b0f4ab7a5a4329/pyyaml-6.0.3-cp313-cp313-win_arm64.whl", hash = "sha256:5498cd1645aa724a7c71c8f378eb29ebe23da2fc0d7a08071d89469bf1d2defb", size = 140246, upload-time = "2025-09-25T21:32:34.663Z" },
+]
+
+[[package]]
+name = "pyzmq"
+version = "27.1.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "cffi", marker = "implementation_name == 'pypy'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/04/0b/3c9baedbdf613ecaa7aa07027780b8867f57b6293b6ee50de316c9f3222b/pyzmq-27.1.0.tar.gz", hash = "sha256:ac0765e3d44455adb6ddbf4417dcce460fc40a05978c08efdf2948072f6db540", size = 281750, upload-time = "2025-09-08T23:10:18.157Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/06/5d/305323ba86b284e6fcb0d842d6adaa2999035f70f8c38a9b6d21ad28c3d4/pyzmq-27.1.0-cp311-cp311-macosx_10_15_universal2.whl", hash = "sha256:226b091818d461a3bef763805e75685e478ac17e9008f49fce2d3e52b3d58b86", size = 1333328, upload-time = "2025-09-08T23:07:45.946Z" },
+    { url = "https://files.pythonhosted.org/packages/bd/a0/fc7e78a23748ad5443ac3275943457e8452da67fda347e05260261108cbc/pyzmq-27.1.0-cp311-cp311-manylinux2014_i686.manylinux_2_17_i686.whl", hash = "sha256:0790a0161c281ca9723f804871b4027f2e8b5a528d357c8952d08cd1a9c15581", size = 908803, upload-time = "2025-09-08T23:07:47.551Z" },
+    { url = "https://files.pythonhosted.org/packages/7e/22/37d15eb05f3bdfa4abea6f6d96eb3bb58585fbd3e4e0ded4e743bc650c97/pyzmq-27.1.0-cp311-cp311-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:c895a6f35476b0c3a54e3eb6ccf41bf3018de937016e6e18748317f25d4e925f", size = 668836, upload-time = "2025-09-08T23:07:49.436Z" },
+    { url = "https://files.pythonhosted.org/packages/b1/c4/2a6fe5111a01005fc7af3878259ce17684fabb8852815eda6225620f3c59/pyzmq-27.1.0-cp311-cp311-manylinux_2_26_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:5bbf8d3630bf96550b3be8e1fc0fea5cbdc8d5466c1192887bd94869da17a63e", size = 857038, upload-time = "2025-09-08T23:07:51.234Z" },
+    { url = "https://files.pythonhosted.org/packages/cb/eb/bfdcb41d0db9cd233d6fb22dc131583774135505ada800ebf14dfb0a7c40/pyzmq-27.1.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:15c8bd0fe0dabf808e2d7a681398c4e5ded70a551ab47482067a572c054c8e2e", size = 1657531, upload-time = "2025-09-08T23:07:52.795Z" },
+    { url = "https://files.pythonhosted.org/packages/ab/21/e3180ca269ed4a0de5c34417dfe71a8ae80421198be83ee619a8a485b0c7/pyzmq-27.1.0-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:bafcb3dd171b4ae9f19ee6380dfc71ce0390fefaf26b504c0e5f628d7c8c54f2", size = 2034786, upload-time = "2025-09-08T23:07:55.047Z" },
+    { url = "https://files.pythonhosted.org/packages/3b/b1/5e21d0b517434b7f33588ff76c177c5a167858cc38ef740608898cd329f2/pyzmq-27.1.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:e829529fcaa09937189178115c49c504e69289abd39967cd8a4c215761373394", size = 1894220, upload-time = "2025-09-08T23:07:57.172Z" },
+    { url = "https://files.pythonhosted.org/packages/03/f2/44913a6ff6941905efc24a1acf3d3cb6146b636c546c7406c38c49c403d4/pyzmq-27.1.0-cp311-cp311-win32.whl", hash = "sha256:6df079c47d5902af6db298ec92151db82ecb557af663098b92f2508c398bb54f", size = 567155, upload-time = "2025-09-08T23:07:59.05Z" },
+    { url = "https://files.pythonhosted.org/packages/23/6d/d8d92a0eb270a925c9b4dd039c0b4dc10abc2fcbc48331788824ef113935/pyzmq-27.1.0-cp311-cp311-win_amd64.whl", hash = "sha256:190cbf120fbc0fc4957b56866830def56628934a9d112aec0e2507aa6a032b97", size = 633428, upload-time = "2025-09-08T23:08:00.663Z" },
+    { url = "https://files.pythonhosted.org/packages/ae/14/01afebc96c5abbbd713ecfc7469cfb1bc801c819a74ed5c9fad9a48801cb/pyzmq-27.1.0-cp311-cp311-win_arm64.whl", hash = "sha256:eca6b47df11a132d1745eb3b5b5e557a7dae2c303277aa0e69c6ba91b8736e07", size = 559497, upload-time = "2025-09-08T23:08:02.15Z" },
+    { url = "https://files.pythonhosted.org/packages/92/e7/038aab64a946d535901103da16b953c8c9cc9c961dadcbf3609ed6428d23/pyzmq-27.1.0-cp312-abi3-macosx_10_15_universal2.whl", hash = "sha256:452631b640340c928fa343801b0d07eb0c3789a5ffa843f6e1a9cee0ba4eb4fc", size = 1306279, upload-time = "2025-09-08T23:08:03.807Z" },
+    { url = "https://files.pythonhosted.org/packages/e8/5e/c3c49fdd0f535ef45eefcc16934648e9e59dace4a37ee88fc53f6cd8e641/pyzmq-27.1.0-cp312-abi3-manylinux2014_i686.manylinux_2_17_i686.whl", hash = "sha256:1c179799b118e554b66da67d88ed66cd37a169f1f23b5d9f0a231b4e8d44a113", size = 895645, upload-time = "2025-09-08T23:08:05.301Z" },
+    { url = "https://files.pythonhosted.org/packages/f8/e5/b0b2504cb4e903a74dcf1ebae157f9e20ebb6ea76095f6cfffea28c42ecd/pyzmq-27.1.0-cp312-abi3-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:3837439b7f99e60312f0c926a6ad437b067356dc2bc2ec96eb395fd0fe804233", size = 652574, upload-time = "2025-09-08T23:08:06.828Z" },
+    { url = "https://files.pythonhosted.org/packages/f8/9b/c108cdb55560eaf253f0cbdb61b29971e9fb34d9c3499b0e96e4e60ed8a5/pyzmq-27.1.0-cp312-abi3-manylinux_2_26_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:43ad9a73e3da1fab5b0e7e13402f0b2fb934ae1c876c51d0afff0e7c052eca31", size = 840995, upload-time = "2025-09-08T23:08:08.396Z" },
+    { url = "https://files.pythonhosted.org/packages/c2/bb/b79798ca177b9eb0825b4c9998c6af8cd2a7f15a6a1a4272c1d1a21d382f/pyzmq-27.1.0-cp312-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:0de3028d69d4cdc475bfe47a6128eb38d8bc0e8f4d69646adfbcd840facbac28", size = 1642070, upload-time = "2025-09-08T23:08:09.989Z" },
+    { url = "https://files.pythonhosted.org/packages/9c/80/2df2e7977c4ede24c79ae39dcef3899bfc5f34d1ca7a5b24f182c9b7a9ca/pyzmq-27.1.0-cp312-abi3-musllinux_1_2_i686.whl", hash = "sha256:cf44a7763aea9298c0aa7dbf859f87ed7012de8bda0f3977b6fb1d96745df856", size = 2021121, upload-time = "2025-09-08T23:08:11.907Z" },
+    { url = "https://files.pythonhosted.org/packages/46/bd/2d45ad24f5f5ae7e8d01525eb76786fa7557136555cac7d929880519e33a/pyzmq-27.1.0-cp312-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:f30f395a9e6fbca195400ce833c731e7b64c3919aa481af4d88c3759e0cb7496", size = 1878550, upload-time = "2025-09-08T23:08:13.513Z" },
+    { url = "https://files.pythonhosted.org/packages/e6/2f/104c0a3c778d7c2ab8190e9db4f62f0b6957b53c9d87db77c284b69f33ea/pyzmq-27.1.0-cp312-abi3-win32.whl", hash = "sha256:250e5436a4ba13885494412b3da5d518cd0d3a278a1ae640e113c073a5f88edd", size = 559184, upload-time = "2025-09-08T23:08:15.163Z" },
+    { url = "https://files.pythonhosted.org/packages/fc/7f/a21b20d577e4100c6a41795842028235998a643b1ad406a6d4163ea8f53e/pyzmq-27.1.0-cp312-abi3-win_amd64.whl", hash = "sha256:9ce490cf1d2ca2ad84733aa1d69ce6855372cb5ce9223802450c9b2a7cba0ccf", size = 619480, upload-time = "2025-09-08T23:08:17.192Z" },
+    { url = "https://files.pythonhosted.org/packages/78/c2/c012beae5f76b72f007a9e91ee9401cb88c51d0f83c6257a03e785c81cc2/pyzmq-27.1.0-cp312-abi3-win_arm64.whl", hash = "sha256:75a2f36223f0d535a0c919e23615fc85a1e23b71f40c7eb43d7b1dedb4d8f15f", size = 552993, upload-time = "2025-09-08T23:08:18.926Z" },
+    { url = "https://files.pythonhosted.org/packages/60/cb/84a13459c51da6cec1b7b1dc1a47e6db6da50b77ad7fd9c145842750a011/pyzmq-27.1.0-cp313-cp313-android_24_arm64_v8a.whl", hash = "sha256:93ad4b0855a664229559e45c8d23797ceac03183c7b6f5b4428152a6b06684a5", size = 1122436, upload-time = "2025-09-08T23:08:20.801Z" },
+    { url = "https://files.pythonhosted.org/packages/dc/b6/94414759a69a26c3dd674570a81813c46a078767d931a6c70ad29fc585cb/pyzmq-27.1.0-cp313-cp313-android_24_x86_64.whl", hash = "sha256:fbb4f2400bfda24f12f009cba62ad5734148569ff4949b1b6ec3b519444342e6", size = 1156301, upload-time = "2025-09-08T23:08:22.47Z" },
+    { url = "https://files.pythonhosted.org/packages/a5/ad/15906493fd40c316377fd8a8f6b1f93104f97a752667763c9b9c1b71d42d/pyzmq-27.1.0-cp313-cp313t-macosx_10_15_universal2.whl", hash = "sha256:e343d067f7b151cfe4eb3bb796a7752c9d369eed007b91231e817071d2c2fec7", size = 1341197, upload-time = "2025-09-08T23:08:24.286Z" },
+    { url = "https://files.pythonhosted.org/packages/14/1d/d343f3ce13db53a54cb8946594e567410b2125394dafcc0268d8dda027e0/pyzmq-27.1.0-cp313-cp313t-manylinux2014_i686.manylinux_2_17_i686.whl", hash = "sha256:08363b2011dec81c354d694bdecaef4770e0ae96b9afea70b3f47b973655cc05", size = 897275, upload-time = "2025-09-08T23:08:26.063Z" },
+    { url = "https://files.pythonhosted.org/packages/69/2d/d83dd6d7ca929a2fc67d2c3005415cdf322af7751d773524809f9e585129/pyzmq-27.1.0-cp313-cp313t-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:d54530c8c8b5b8ddb3318f481297441af102517602b569146185fa10b63f4fa9", size = 660469, upload-time = "2025-09-08T23:08:27.623Z" },
+    { url = "https://files.pythonhosted.org/packages/3e/cd/9822a7af117f4bc0f1952dbe9ef8358eb50a24928efd5edf54210b850259/pyzmq-27.1.0-cp313-cp313t-manylinux_2_26_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:6f3afa12c392f0a44a2414056d730eebc33ec0926aae92b5ad5cf26ebb6cc128", size = 847961, upload-time = "2025-09-08T23:08:29.672Z" },
+    { url = "https://files.pythonhosted.org/packages/9a/12/f003e824a19ed73be15542f172fd0ec4ad0b60cf37436652c93b9df7c585/pyzmq-27.1.0-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:c65047adafe573ff023b3187bb93faa583151627bc9c51fc4fb2c561ed689d39", size = 1650282, upload-time = "2025-09-08T23:08:31.349Z" },
+    { url = "https://files.pythonhosted.org/packages/d5/4a/e82d788ed58e9a23995cee70dbc20c9aded3d13a92d30d57ec2291f1e8a3/pyzmq-27.1.0-cp313-cp313t-musllinux_1_2_i686.whl", hash = "sha256:90e6e9441c946a8b0a667356f7078d96411391a3b8f80980315455574177ec97", size = 2024468, upload-time = "2025-09-08T23:08:33.543Z" },
+    { url = "https://files.pythonhosted.org/packages/d9/94/2da0a60841f757481e402b34bf4c8bf57fa54a5466b965de791b1e6f747d/pyzmq-27.1.0-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:add071b2d25f84e8189aaf0882d39a285b42fa3853016ebab234a5e78c7a43db", size = 1885394, upload-time = "2025-09-08T23:08:35.51Z" },
+    { url = "https://files.pythonhosted.org/packages/4f/6f/55c10e2e49ad52d080dc24e37adb215e5b0d64990b57598abc2e3f01725b/pyzmq-27.1.0-cp313-cp313t-win32.whl", hash = "sha256:7ccc0700cfdf7bd487bea8d850ec38f204478681ea02a582a8da8171b7f90a1c", size = 574964, upload-time = "2025-09-08T23:08:37.178Z" },
+    { url = "https://files.pythonhosted.org/packages/87/4d/2534970ba63dd7c522d8ca80fb92777f362c0f321900667c615e2067cb29/pyzmq-27.1.0-cp313-cp313t-win_amd64.whl", hash = "sha256:8085a9fba668216b9b4323be338ee5437a235fe275b9d1610e422ccc279733e2", size = 641029, upload-time = "2025-09-08T23:08:40.595Z" },
+    { url = "https://files.pythonhosted.org/packages/f6/fa/f8aea7a28b0641f31d40dea42d7ef003fded31e184ef47db696bc74cd610/pyzmq-27.1.0-cp313-cp313t-win_arm64.whl", hash = "sha256:6bb54ca21bcfe361e445256c15eedf083f153811c37be87e0514934d6913061e", size = 561541, upload-time = "2025-09-08T23:08:42.668Z" },
+    { url = "https://files.pythonhosted.org/packages/4c/c6/c4dcdecdbaa70969ee1fdced6d7b8f60cfabe64d25361f27ac4665a70620/pyzmq-27.1.0-pp311-pypy311_pp73-macosx_10_15_x86_64.whl", hash = "sha256:18770c8d3563715387139060d37859c02ce40718d1faf299abddcdcc6a649066", size = 836265, upload-time = "2025-09-08T23:09:49.376Z" },
+    { url = "https://files.pythonhosted.org/packages/3e/79/f38c92eeaeb03a2ccc2ba9866f0439593bb08c5e3b714ac1d553e5c96e25/pyzmq-27.1.0-pp311-pypy311_pp73-manylinux2014_i686.manylinux_2_17_i686.whl", hash = "sha256:ac25465d42f92e990f8d8b0546b01c391ad431c3bf447683fdc40565941d0604", size = 800208, upload-time = "2025-09-08T23:09:51.073Z" },
+    { url = "https://files.pythonhosted.org/packages/49/0e/3f0d0d335c6b3abb9b7b723776d0b21fa7f3a6c819a0db6097059aada160/pyzmq-27.1.0-pp311-pypy311_pp73-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:53b40f8ae006f2734ee7608d59ed661419f087521edbfc2149c3932e9c14808c", size = 567747, upload-time = "2025-09-08T23:09:52.698Z" },
+    { url = "https://files.pythonhosted.org/packages/a1/cf/f2b3784d536250ffd4be70e049f3b60981235d70c6e8ce7e3ef21e1adb25/pyzmq-27.1.0-pp311-pypy311_pp73-manylinux_2_26_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:f605d884e7c8be8fe1aa94e0a783bf3f591b84c24e4bc4f3e7564c82ac25e271", size = 747371, upload-time = "2025-09-08T23:09:54.563Z" },
+    { url = "https://files.pythonhosted.org/packages/01/1b/5dbe84eefc86f48473947e2f41711aded97eecef1231f4558f1f02713c12/pyzmq-27.1.0-pp311-pypy311_pp73-win_amd64.whl", hash = "sha256:c9f7f6e13dff2e44a6afeaf2cf54cee5929ad64afaf4d40b50f93c58fc687355", size = 544862, upload-time = "2025-09-08T23:09:56.509Z" },
+]
+
+[[package]]
+name = "ruff"
+version = "0.14.4"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/df/55/cccfca45157a2031dcbb5a462a67f7cf27f8b37d4b3b1cd7438f0f5c1df6/ruff-0.14.4.tar.gz", hash = "sha256:f459a49fe1085a749f15414ca76f61595f1a2cc8778ed7c279b6ca2e1fd19df3", size = 5587844, upload-time = "2025-11-06T22:07:45.033Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/17/b9/67240254166ae1eaa38dec32265e9153ac53645a6c6670ed36ad00722af8/ruff-0.14.4-py3-none-linux_armv6l.whl", hash = "sha256:e6604613ffbcf2297cd5dcba0e0ac9bd0c11dc026442dfbb614504e87c349518", size = 12606781, upload-time = "2025-11-06T22:07:01.841Z" },
+    { url = "https://files.pythonhosted.org/packages/46/c8/09b3ab245d8652eafe5256ab59718641429f68681ee713ff06c5c549f156/ruff-0.14.4-py3-none-macosx_10_12_x86_64.whl", hash = "sha256:d99c0b52b6f0598acede45ee78288e5e9b4409d1ce7f661f0fa36d4cbeadf9a4", size = 12946765, upload-time = "2025-11-06T22:07:05.858Z" },
+    { url = "https://files.pythonhosted.org/packages/14/bb/1564b000219144bf5eed2359edc94c3590dd49d510751dad26202c18a17d/ruff-0.14.4-py3-none-macosx_11_0_arm64.whl", hash = "sha256:9358d490ec030f1b51d048a7fd6ead418ed0826daf6149e95e30aa67c168af33", size = 11928120, upload-time = "2025-11-06T22:07:08.023Z" },
+    { url = "https://files.pythonhosted.org/packages/a3/92/d5f1770e9988cc0742fefaa351e840d9aef04ec24ae1be36f333f96d5704/ruff-0.14.4-py3-none-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:81b40d27924f1f02dfa827b9c0712a13c0e4b108421665322218fc38caf615c2", size = 12370877, upload-time = "2025-11-06T22:07:10.015Z" },
+    { url = "https://files.pythonhosted.org/packages/e2/29/e9282efa55f1973d109faf839a63235575519c8ad278cc87a182a366810e/ruff-0.14.4-py3-none-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:f5e649052a294fe00818650712083cddc6cc02744afaf37202c65df9ea52efa5", size = 12408538, upload-time = "2025-11-06T22:07:13.085Z" },
+    { url = "https://files.pythonhosted.org/packages/8e/01/930ed6ecfce130144b32d77d8d69f5c610e6d23e6857927150adf5d7379a/ruff-0.14.4-py3-none-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:aa082a8f878deeba955531f975881828fd6afd90dfa757c2b0808aadb437136e", size = 13141942, upload-time = "2025-11-06T22:07:15.386Z" },
+    { url = "https://files.pythonhosted.org/packages/6a/46/a9c89b42b231a9f487233f17a89cbef9d5acd538d9488687a02ad288fa6b/ruff-0.14.4-py3-none-manylinux_2_17_ppc64.manylinux2014_ppc64.whl", hash = "sha256:1043c6811c2419e39011890f14d0a30470f19d47d197c4858b2787dfa698f6c8", size = 14544306, upload-time = "2025-11-06T22:07:17.631Z" },
+    { url = "https://files.pythonhosted.org/packages/78/96/9c6cf86491f2a6d52758b830b89b78c2ae61e8ca66b86bf5a20af73d20e6/ruff-0.14.4-py3-none-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:a9f3a936ac27fb7c2a93e4f4b943a662775879ac579a433291a6f69428722649", size = 14210427, upload-time = "2025-11-06T22:07:19.832Z" },
+    { url = "https://files.pythonhosted.org/packages/71/f4/0666fe7769a54f63e66404e8ff698de1dcde733e12e2fd1c9c6efb689cb5/ruff-0.14.4-py3-none-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:95643ffd209ce78bc113266b88fba3d39e0461f0cbc8b55fb92505030fb4a850", size = 13658488, upload-time = "2025-11-06T22:07:22.32Z" },
+    { url = "https://files.pythonhosted.org/packages/ee/79/6ad4dda2cfd55e41ac9ed6d73ef9ab9475b1eef69f3a85957210c74ba12c/ruff-0.14.4-py3-none-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:456daa2fa1021bc86ca857f43fe29d5d8b3f0e55e9f90c58c317c1dcc2afc7b5", size = 13354908, upload-time = "2025-11-06T22:07:24.347Z" },
+    { url = "https://files.pythonhosted.org/packages/b5/60/f0b6990f740bb15c1588601d19d21bcc1bd5de4330a07222041678a8e04f/ruff-0.14.4-py3-none-manylinux_2_31_riscv64.whl", hash = "sha256:f911bba769e4a9f51af6e70037bb72b70b45a16db5ce73e1f72aefe6f6d62132", size = 13587803, upload-time = "2025-11-06T22:07:26.327Z" },
+    { url = "https://files.pythonhosted.org/packages/c9/da/eaaada586f80068728338e0ef7f29ab3e4a08a692f92eb901a4f06bbff24/ruff-0.14.4-py3-none-musllinux_1_2_aarch64.whl", hash = "sha256:76158a7369b3979fa878612c623a7e5430c18b2fd1c73b214945c2d06337db67", size = 12279654, upload-time = "2025-11-06T22:07:28.46Z" },
+    { url = "https://files.pythonhosted.org/packages/66/d4/b1d0e82cf9bf8aed10a6d45be47b3f402730aa2c438164424783ac88c0ed/ruff-0.14.4-py3-none-musllinux_1_2_armv7l.whl", hash = "sha256:f3b8f3b442d2b14c246e7aeca2e75915159e06a3540e2f4bed9f50d062d24469", size = 12357520, upload-time = "2025-11-06T22:07:31.468Z" },
+    { url = "https://files.pythonhosted.org/packages/04/f4/53e2b42cc82804617e5c7950b7079d79996c27e99c4652131c6a1100657f/ruff-0.14.4-py3-none-musllinux_1_2_i686.whl", hash = "sha256:c62da9a06779deecf4d17ed04939ae8b31b517643b26370c3be1d26f3ef7dbde", size = 12719431, upload-time = "2025-11-06T22:07:33.831Z" },
+    { url = "https://files.pythonhosted.org/packages/a2/94/80e3d74ed9a72d64e94a7b7706b1c1ebaa315ef2076fd33581f6a1cd2f95/ruff-0.14.4-py3-none-musllinux_1_2_x86_64.whl", hash = "sha256:5a443a83a1506c684e98acb8cb55abaf3ef725078be40237463dae4463366349", size = 13464394, upload-time = "2025-11-06T22:07:35.905Z" },
+    { url = "https://files.pythonhosted.org/packages/54/1a/a49f071f04c42345c793d22f6cf5e0920095e286119ee53a64a3a3004825/ruff-0.14.4-py3-none-win32.whl", hash = "sha256:643b69cb63cd996f1fc7229da726d07ac307eae442dd8974dbc7cf22c1e18fff", size = 12493429, upload-time = "2025-11-06T22:07:38.43Z" },
+    { url = "https://files.pythonhosted.org/packages/bc/22/e58c43e641145a2b670328fb98bc384e20679b5774258b1e540207580266/ruff-0.14.4-py3-none-win_amd64.whl", hash = "sha256:26673da283b96fe35fa0c939bf8411abec47111644aa9f7cfbd3c573fb125d2c", size = 13635380, upload-time = "2025-11-06T22:07:40.496Z" },
+    { url = "https://files.pythonhosted.org/packages/30/bd/4168a751ddbbf43e86544b4de8b5c3b7be8d7167a2a5cb977d274e04f0a1/ruff-0.14.4-py3-none-win_arm64.whl", hash = "sha256:dd09c292479596b0e6fec8cd95c65c3a6dc68e9ad17b8f2382130f87ff6a75bb", size = 12663065, upload-time = "2025-11-06T22:07:42.603Z" },
+]
+
+[[package]]
+name = "six"
+version = "1.17.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/94/e7/b2c673351809dca68a0e064b6af791aa332cf192da575fd474ed7d6f16a2/six-1.17.0.tar.gz", hash = "sha256:ff70335d468e7eb6ec65b95b99d3a2836546063f63acc5171de367e834932a81", size = 34031, upload-time = "2024-12-04T17:35:28.174Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/b7/ce/149a00dd41f10bc29e5921b496af8b574d8413afcd5e30dfa0ed46c2cc5e/six-1.17.0-py2.py3-none-any.whl", hash = "sha256:4721f391ed90541fddacab5acf947aa0d3dc7d27b2e1e8eda2be8970586c3274", size = 11050, upload-time = "2024-12-04T17:35:26.475Z" },
+]
+
+[[package]]
+name = "stack-data"
+version = "0.6.3"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "asttokens" },
+    { name = "executing" },
+    { name = "pure-eval" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/28/e3/55dcc2cfbc3ca9c29519eb6884dd1415ecb53b0e934862d3559ddcb7e20b/stack_data-0.6.3.tar.gz", hash = "sha256:836a778de4fec4dcd1dcd89ed8abff8a221f58308462e1c4aa2a3cf30148f0b9", size = 44707, upload-time = "2023-09-30T13:58:05.479Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/f1/7b/ce1eafaf1a76852e2ec9b22edecf1daa58175c090266e9f6c64afcd81d91/stack_data-0.6.3-py3-none-any.whl", hash = "sha256:d5558e0c25a4cb0853cddad3d77da9891a08cb85dd9f9f91b9f8cd66e511e695", size = 24521, upload-time = "2023-09-30T13:58:03.53Z" },
+]
+
+[[package]]
+name = "tornado"
+version = "6.5.4"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/37/1d/0a336abf618272d53f62ebe274f712e213f5a03c0b2339575430b8362ef2/tornado-6.5.4.tar.gz", hash = "sha256:a22fa9047405d03260b483980635f0b041989d8bcc9a313f8fe18b411d84b1d7", size = 513632, upload-time = "2025-12-15T19:21:03.836Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/ab/a9/e94a9d5224107d7ce3cc1fab8d5dc97f5ea351ccc6322ee4fb661da94e35/tornado-6.5.4-cp39-abi3-macosx_10_9_universal2.whl", hash = "sha256:d6241c1a16b1c9e4cc28148b1cda97dd1c6cb4fb7068ac1bedc610768dff0ba9", size = 443909, upload-time = "2025-12-15T19:20:48.382Z" },
+    { url = "https://files.pythonhosted.org/packages/db/7e/f7b8d8c4453f305a51f80dbb49014257bb7d28ccb4bbb8dd328ea995ecad/tornado-6.5.4-cp39-abi3-macosx_10_9_x86_64.whl", hash = "sha256:2d50f63dda1d2cac3ae1fa23d254e16b5e38153758470e9956cbc3d813d40843", size = 442163, upload-time = "2025-12-15T19:20:49.791Z" },
+    { url = "https://files.pythonhosted.org/packages/ba/b5/206f82d51e1bfa940ba366a8d2f83904b15942c45a78dd978b599870ab44/tornado-6.5.4-cp39-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d1cf66105dc6acb5af613c054955b8137e34a03698aa53272dbda4afe252be17", size = 445746, upload-time = "2025-12-15T19:20:51.491Z" },
+    { url = "https://files.pythonhosted.org/packages/8e/9d/1a3338e0bd30ada6ad4356c13a0a6c35fbc859063fa7eddb309183364ac1/tornado-6.5.4-cp39-abi3-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:50ff0a58b0dc97939d29da29cd624da010e7f804746621c78d14b80238669335", size = 445083, upload-time = "2025-12-15T19:20:52.778Z" },
+    { url = "https://files.pythonhosted.org/packages/50/d4/e51d52047e7eb9a582da59f32125d17c0482d065afd5d3bc435ff2120dc5/tornado-6.5.4-cp39-abi3-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:e5fb5e04efa54cf0baabdd10061eb4148e0be137166146fff835745f59ab9f7f", size = 445315, upload-time = "2025-12-15T19:20:53.996Z" },
+    { url = "https://files.pythonhosted.org/packages/27/07/2273972f69ca63dbc139694a3fc4684edec3ea3f9efabf77ed32483b875c/tornado-6.5.4-cp39-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:9c86b1643b33a4cd415f8d0fe53045f913bf07b4a3ef646b735a6a86047dda84", size = 446003, upload-time = "2025-12-15T19:20:56.101Z" },
+    { url = "https://files.pythonhosted.org/packages/d1/83/41c52e47502bf7260044413b6770d1a48dda2f0246f95ee1384a3cd9c44a/tornado-6.5.4-cp39-abi3-musllinux_1_2_i686.whl", hash = "sha256:6eb82872335a53dd063a4f10917b3efd28270b56a33db69009606a0312660a6f", size = 445412, upload-time = "2025-12-15T19:20:57.398Z" },
+    { url = "https://files.pythonhosted.org/packages/10/c7/bc96917f06cbee182d44735d4ecde9c432e25b84f4c2086143013e7b9e52/tornado-6.5.4-cp39-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:6076d5dda368c9328ff41ab5d9dd3608e695e8225d1cd0fd1e006f05da3635a8", size = 445392, upload-time = "2025-12-15T19:20:58.692Z" },
+    { url = "https://files.pythonhosted.org/packages/0c/1a/d7592328d037d36f2d2462f4bc1fbb383eec9278bc786c1b111cbbd44cfa/tornado-6.5.4-cp39-abi3-win32.whl", hash = "sha256:1768110f2411d5cd281bac0a090f707223ce77fd110424361092859e089b38d1", size = 446481, upload-time = "2025-12-15T19:21:00.008Z" },
+    { url = "https://files.pythonhosted.org/packages/d6/6d/c69be695a0a64fd37a97db12355a035a6d90f79067a3cf936ec2b1dc38cd/tornado-6.5.4-cp39-abi3-win_amd64.whl", hash = "sha256:fa07d31e0cd85c60713f2b995da613588aa03e1303d75705dca6af8babc18ddc", size = 446886, upload-time = "2025-12-15T19:21:01.287Z" },
+    { url = "https://files.pythonhosted.org/packages/50/49/8dc3fd90902f70084bd2cd059d576ddb4f8bb44c2c7c0e33a11422acb17e/tornado-6.5.4-cp39-abi3-win_arm64.whl", hash = "sha256:053e6e16701eb6cbe641f308f4c1a9541f91b6261991160391bfc342e8a551a1", size = 445910, upload-time = "2025-12-15T19:21:02.571Z" },
+]
+
+[[package]]
+name = "tqdm"
+version = "4.67.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "colorama", marker = "sys_platform == 'win32'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/a8/4b/29b4ef32e036bb34e4ab51796dd745cdba7ed47ad142a9f4a1eb8e0c744d/tqdm-4.67.1.tar.gz", hash = "sha256:f8aef9c52c08c13a65f30ea34f4e5aac3fd1a34959879d7e59e63027286627f2", size = 169737, upload-time = "2024-11-24T20:12:22.481Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/d0/30/dc54f88dd4a2b5dc8a0279bdd7270e735851848b762aeb1c1184ed1f6b14/tqdm-4.67.1-py3-none-any.whl", hash = "sha256:26445eca388f82e72884e0d580d5464cd801a3ea01e63e5601bdff9ba6a48de2", size = 78540, upload-time = "2024-11-24T20:12:19.698Z" },
+]
+
+[[package]]
+name = "traitlets"
+version = "5.14.3"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/eb/79/72064e6a701c2183016abbbfedaba506d81e30e232a68c9f0d6f6fcd1574/traitlets-5.14.3.tar.gz", hash = "sha256:9ed0579d3502c94b4b3732ac120375cda96f923114522847de4b3bb98b96b6b7", size = 161621, upload-time = "2024-04-19T11:11:49.746Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/00/c0/8f5d070730d7836adc9c9b6408dec68c6ced86b304a9b26a14df072a6e8c/traitlets-5.14.3-py3-none-any.whl", hash = "sha256:b74e89e397b1ed28cc831db7aea759ba6640cb3de13090ca145426688ff1ac4f", size = 85359, upload-time = "2024-04-19T11:11:46.763Z" },
+]
+
+[[package]]
+name = "typing-extensions"
+version = "4.15.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/72/94/1a15dd82efb362ac84269196e94cf00f187f7ed21c242792a923cdb1c61f/typing_extensions-4.15.0.tar.gz", hash = "sha256:0cea48d173cc12fa28ecabc3b837ea3cf6f38c6d1136f85cbaaf598984861466", size = 109391, upload-time = "2025-08-25T13:49:26.313Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/18/67/36e9267722cc04a6b9f15c7f3441c2363321a3ea07da7ae0c0707beb2a9c/typing_extensions-4.15.0-py3-none-any.whl", hash = "sha256:f0fa19c6845758ab08074a0cfa8b7aecb71c999ca73d62883bc25cc018c4e548", size = 44614, upload-time = "2025-08-25T13:49:24.86Z" },
+]
+
+[[package]]
+name = "virtualenv"
+version = "20.36.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "distlib" },
+    { name = "filelock" },
+    { name = "platformdirs" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/aa/a3/4d310fa5f00863544e1d0f4de93bddec248499ccf97d4791bc3122c9d4f3/virtualenv-20.36.1.tar.gz", hash = "sha256:8befb5c81842c641f8ee658481e42641c68b5eab3521d8e092d18320902466ba", size = 6032239, upload-time = "2026-01-09T18:21:01.296Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/6a/2a/dc2228b2888f51192c7dc766106cd475f1b768c10caaf9727659726f7391/virtualenv-20.36.1-py3-none-any.whl", hash = "sha256:575a8d6b124ef88f6f51d56d656132389f961062a9177016a50e4f507bbcc19f", size = 6008258, upload-time = "2026-01-09T18:20:59.425Z" },
+]
+
+[[package]]
+name = "wcwidth"
+version = "0.2.14"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/24/30/6b0809f4510673dc723187aeaf24c7f5459922d01e2f794277a3dfb90345/wcwidth-0.2.14.tar.gz", hash = "sha256:4d478375d31bc5395a3c55c40ccdf3354688364cd61c4f6adacaa9215d0b3605", size = 102293, upload-time = "2025-09-22T16:29:53.023Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/af/b5/123f13c975e9f27ab9c0770f514345bd406d0e8d3b7a0723af9d43f710af/wcwidth-0.2.14-py2.py3-none-any.whl", hash = "sha256:a7bb560c8aee30f9957e5f9895805edd20602f2d7f720186dfd906e82b4982e1", size = 37286, upload-time = "2025-09-22T16:29:51.641Z" },
+]