Fix CI: diagnostics message, clang-tidy, and MinGW section limit

- unit-custom-number-types.cpp: with JSON_DIAGNOSTICS, the BSON out_of_range.407 messages carry the /v path of wrap(); silence misc-redundant-expression on the __int128 static_assert - move the MessagePack tests that use other basic_json specializations from unit-msgpack.cpp to unit-msgpack-custom-types.cpp: the new range checks in binary_writer pushed unit-msgpack.cpp over the 65535 sections the MinGW linker can handle (clang 18 job on Windows) Signed-off-by: Niels Lohmann <mail@nlohmann.me>
Fix CI: build the out_of_range.407 message from string_t and fix a link
2026-10-11 08:57:15 +00:00 · 2026-10-11 10:43:39 +02:00 · 2026-10-11 07:13:26 +02:00 · 2026-10-10 16:55:26 +02:00
130 changed files with 4042 additions and 6896 deletions
@@ -1,3 +0,0 @@
-# generated files are collapsed in diffs and excluded from language statistics
-single_include/** linguist-generated
-nlohmann_json.natvis linguist-generated
@@ -1,5 +1,5 @@
 # JSON for Modern C++ was originally written by Niels Lohmann.
-# Since 2013, over 400 contributors have helped to improve the library.
+# Since 2013, over 250 contributors have helped to improve the library.
 # This CODEOWNERS file is only to make sure that @nlohmann is requested
 # for a code review in case of a pull request.

@@ -98,7 +98,7 @@ $ ctest --test-dir build -j 10
 The test suite should report:

 ```
-100% tests passed, 0 tests failed out of <number of tests>
+100% tests passed, 0 tests failed out of 98
 ```

 #### Add tests
@@ -157,9 +157,8 @@ and each page's title (H1) and declaration by
 ### Amalgamate the source code

 The single-header files
-[`single_include/nlohmann/json.hpp`](https://github.com/nlohmann/json/blob/develop/single_include/nlohmann/json.hpp),
-[`single_include/nlohmann/json_fwd.hpp`](https://github.com/nlohmann/json/blob/develop/single_include/nlohmann/json_fwd.hpp), and
-[`single_include/nlohmann/json_literals.hpp`](https://github.com/nlohmann/json/blob/develop/single_include/nlohmann/json_literals.hpp)
+[`single_include/nlohmann/json.hpp`](https://github.com/nlohmann/json/blob/develop/single_include/nlohmann/json.hpp) and
+[`single_include/nlohmann/json_fwd.hpp`](https://github.com/nlohmann/json/blob/develop/single_include/nlohmann/json_fwd.hpp)
 are **generated** from the source files in the
 [`include/nlohmann` directory](https://github.com/nlohmann/json/tree/develop/include/nlohmann). **Do not** edit the
 files directly; instead, modify the include/nlohmann sources and regenerate the files by executing:
@@ -182,7 +181,7 @@ The amalgamation check in CI fails if any of these generated files is out of dat

 ## Recommended documentation

- The library’s [README file](https://github.com/nlohmann/json/blob/develop/README.md) is an excellent starting point to
+- The library’s [README file](https://github.com/nlohmann/json/blob/master/README.md) is an excellent starting point to
  understand its functionality.
 - The [documentation page](https://json.nlohmann.me) is the reference documentation of the library.
 - [RFC 8259](https://datatracker.ietf.org/doc/html/rfc8259) is the reference for the JavaScript Object Notation (JSON)
@@ -221,9 +220,9 @@ feature macros then allows users to test their code against the library in the n
 ### Break C++11 language conformance

 This library is designed to work with C++11 and later. This means that any
-[supported C++11 compiler](https://github.com/nlohmann/json/blob/develop/README.md#supported-compilers) should compile
+[supported C++11 compiler](https://github.com/nlohmann/json/blob/master/README.md#supported-compilers) should compile
 the library without problems. Some compilers like GCC 4.7 (and earlier), Clang 3.3 (and earlier), or Microsoft Visual
-C++ 2013 and earlier are known not to work due to missing or incomplete C++11 support.
+Studio 13.0 and earlier are known not to work due to missing or incomplete C++11 support.

 Please do not add features that do not work with the mentioned supported compilers. Please guard features from C++14 and
 later against the respective [`JSON_HAS_CPP_14`](https://json.nlohmann.me/api/macros/json_has_cpp_11/) macros.
@@ -239,11 +238,12 @@ extension.
 The following areas really need contribution and are always welcomed:

 - Extending the **continuous integration** toward more exotic compilers such as Android NDK, Intel's Compiler, or the
-  bleeding-edge versions of Clang.
- Improving the efficiency of the **JSON parser**. The current parser is a hand-written iterative parser that keeps an
-  explicit stack instead of recursing, with hand-coded string handling. Speeding up the lexer or the value construction
-  would be appreciated. Parser generators like Bison or ANTLR do not play nice with single-header files -- I really
-  would like to keep the parser inside the `json.hpp` header.
+  bleeding-edge versions Clang.
+- Improving the efficiency of the **JSON parser**. The current parser is implemented as a naive recursive descent parser
+  with hand-coded string handling. More sophisticated approaches like LALR parsers would be really appreciated. That
+  said, parser generators like Bison or ANTLR do not play nice with single-header files -- I really would like to keep
+  the parser inside the `json.hpp` header, and I am not aware of approaches similar to [`re2c`](http://re2c.org) for
+  parsing.
 - Extending and updating existing **benchmarks** to include (the most recent version of) this library. Though efficiency
  is not everything, speed and memory consumption are very important characteristics for C++ developers, so having
  proper comparisons would be interesting.
@@ -52,7 +52,7 @@ body:
        If possible, provide a small and self-contained example that triggers
        the bug. Please understand that we cannot analyze and debug large code
        bases. Please do not paste screenshots here.
-      render: cpp
+      render: Shell
  - type: textarea
    id: output
    attributes:
@@ -79,7 +79,7 @@ body:
      description: >
        Which version of the library did you use? If it is a released version,
        please enter the version number (e.g., 3.12.0). Otherwise, please enter
-        the commit hash. If you got the library from another source than the
+        the commit hash. If you got the library from another source as the
        GitHub repository (e.g., via a package manager), please also state
        this.
    validations:
@@ -21,17 +21,6 @@ labels:
  files:
    - "cmake/.*"

-# other build systems
- label: "CMake"
-  files:
-    - "(meson\\.build|meson_options\\.txt|BUILD\\.bazel|MODULE\\.bazel|Package\\.swift)"
-
- label: "documentation"
-  files:
-    - ".github/ISSUE_TEMPLATE/.*"
-    - ".github/config\\.yml"
-    - ".github/(CONTRIBUTING|SECURITY|CODE_OF_CONDUCT|PULL_REQUEST_TEMPLATE)\\.md"
-
 - label: "CI"
  files:
    - ".github/workflows/.*"
@@ -83,7 +83,8 @@ jobs:
          # byte for byte), so there is nothing to gain from checking out a
          # separate copy, and doing so would make this step fail on a PR
          # that adds support for a new dispatch table until that PR itself
-          # merges to develop.
+          # merges to develop, the same way generate_natvis.py's --version
+          # requirement briefly did.
          TMPDIR=$(mktemp -d ./macro_builder_check.XXXXXX)
          c++ -std=c++11 tools/macro_builder/main.cpp -o "$TMPDIR/macro_builder"
          "$TMPDIR/macro_builder" > "$TMPDIR/paste.hpp"
@@ -116,6 +117,7 @@ jobs:

          python3 $TOOL_DIR/amalgamate.py -c $TOOL_DIR/config_json.json -s .
          python3 $TOOL_DIR/amalgamate.py -c $TOOL_DIR/config_json_fwd.json -s .
+          cp include/nlohmann/json_literals.hpp $INCLUDE_DIR/json_literals.hpp

          # the header list of the Bazel "json" target must match the files in include/
          cmake -P cmake/scripts/gen_bazel_build_file.cmake
@@ -136,13 +138,17 @@ jobs:
          ${{ github.workspace }}/venv/bin/astyle --project=tools/astyle/.astylerc --suffix=none --quiet \
            $(find $SOURCE_DIRS -type f \( -name '*.hpp' -o -name '*.cpp' -o -name '*.cu' \) -not -path 'tests/thirdparty/*' -not -path 'tests/abi/include/nlohmann/*' | sort)

-          # json_literals.hpp is copied verbatim from the (now formatted) include/
-          # directory, like `make amalgamate` does
-          cp include/nlohmann/json_literals.hpp $INCLUDE_DIR/json_literals.hpp
-
      - name: Regenerate nlohmann_json.natvis
        run: |
          cd $MAIN_DIR
+          # Pass --version explicitly so this step also works with the tool
+          # copy from develop before this repository's own generate_natvis.py
+          # learns to derive the version itself: the older script requires
+          # --version, and the newer one accepts it as an explicit override.
+          ABI_MACROS=include/nlohmann/detail/abi_macros.hpp
+          VERSION_MAJOR=$(grep -m1 'define NLOHMANN_JSON_VERSION_MAJOR' $ABI_MACROS | grep -o '[0-9]\+')
+          VERSION_MINOR=$(grep -m1 'define NLOHMANN_JSON_VERSION_MINOR' $ABI_MACROS | grep -o '[0-9]\+')
+          VERSION_PATCH=$(grep -m1 'define NLOHMANN_JSON_VERSION_PATCH' $ABI_MACROS | grep -o '[0-9]\+')
          # The template is what this check verifies the committed natvis
          # file against, so take it from this PR rather than from the
          # develop checkout: generate_natvis.py loads the template from its
@@ -150,7 +156,7 @@ jobs:
          # template could never pass. Like the macro_builder step above,
          # this only renders PR content in a job without credentials.
          cp tools/generate_natvis/nlohmann_json.natvis.j2 $NATVIS_TOOL_DIR/
-          python3 $NATVIS_TOOL_DIR/generate_natvis.py $MAIN_DIR
+          python3 $NATVIS_TOOL_DIR/generate_natvis.py --version "$VERSION_MAJOR.$VERSION_MINOR.$VERSION_PATCH" $MAIN_DIR

      - name: Build patch and check for differences
        id: diff
@@ -159,7 +165,7 @@ jobs:
          mkdir -p ${{ github.workspace }}/patch
          git diff --patch --no-color > ${{ github.workspace }}/patch/amalgamation.patch
          if [ -s ${{ github.workspace }}/patch/amalgamation.patch ]; then
-            echo "The source code has not been amalgamated/formatted correctly, or BUILD.bazel, nlohmann_json.natvis, or the macro_builder tables in macro_scope.hpp are out of date ('make amalgamate BUILD.bazel natvis' fixes all but the tables, see tools/macro_builder/README.md). Diff:"
+            echo "The source code has not been amalgamated/formatted correctly or BUILD.bazel is out of date. Diff:"
            cat ${{ github.workspace }}/patch/amalgamation.patch
            echo "has_diff=true" >> "$GITHUB_OUTPUT"
          else
@@ -96,7 +96,7 @@ jobs:
              issue_number: issue_number,
              owner: context.repo.owner,
              repo: context.repo.repo,
-              body: '## 🔴 Amalgamation check failed! 🔴\nThe source code has not been amalgamated and/or formatted correctly, or `BUILD.bazel`, `nlohmann_json.natvis`, or the macro_builder tables in `macro_scope.hpp` are out of date. `make amalgamate BUILD.bazel natvis` fixes all but the tables (see `tools/macro_builder/README.md`).'
+              body: '## 🔴 Amalgamation check failed! 🔴\nThe source code has not been amalgamated and/or formatted correctly, or `BUILD.bazel` is out of date.'
                    + (hasPatch ? '\n\n📎 A ready-to-apply patch is attached to the [failed workflow run](' + runUrl + ') as the `amalgamation-patch` artifact.'
                                  + ' Download it, then apply it locally from the repository root with:'
                                  + '\n\n```shell\ngit apply amalgamation.patch\n```\n\n'
@@ -15,7 +15,6 @@ on:
      - .github/SECURITY.md
      - cmake/clang_flags.cmake
      - cmake/gcc_flags.cmake
-      - include/nlohmann/detail/abi_macros.hpp
      - tests/fmt_formatter/project/main.cpp
      - tools/astyle/.astylerc
  workflow_dispatch:
@@ -109,7 +109,7 @@ jobs:
    runs-on: ubuntu-latest
    strategy:
      matrix:
-        target: [ci_test_single_header, ci_cppcheck, ci_cpplint, ci_reproducible_tests, ci_non_git_tests, ci_offline_testdata, ci_reuse_compliance, ci_test_valgrind]
+        target: [ci_test_amalgamation, ci_test_single_header, ci_cppcheck, ci_cpplint, ci_reproducible_tests, ci_non_git_tests, ci_offline_testdata, ci_reuse_compliance, ci_test_valgrind]
    steps:
      - name: Harden Runner
        uses: step-security/harden-runner@e14015d583714f6e62063499dc959a02595150a1 # v2.21.1
@@ -117,7 +117,6 @@ jobs:
          egress-policy: audit

      - name: Install Valgrind
-        if: matrix.target == 'ci_test_valgrind'
        run: sudo apt-get update ; sudo apt-get install -y valgrind
      - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
        with:
@@ -280,7 +279,7 @@ jobs:
          persist-credentials: false
      - name: Get latest CMake and ninja
        uses: lukka/get-cmake@fffaaafeea488556c2c12dad60690008bc1caacb # v4.4.2
-      - name: Disable filesystem support (std::filesystem is unusable) for clang 7 / 8 / 9 / 10
+      - name: Set env FORCE_STDCPPFS_FLAG for clang 7 / 8 / 9 / 10
        run: echo "JSON_FORCED_GLOBAL_COMPILE_OPTIONS=-DJSON_HAS_FILESYSTEM=0;-DJSON_HAS_EXPERIMENTAL_FILESYSTEM=0" >> "$GITHUB_ENV"
        if: ${{ matrix.compiler == '7' || matrix.compiler == '8' || matrix.compiler == '9' || matrix.compiler == '10' }}
      - name: Run CMake
@@ -187,7 +187,7 @@ jobs:
      - name: Test
        run: cd build ; ctest -j 10 -C Debug --output-on-failure

-  clang-cl:
+  clang-cl-12:
    runs-on: windows-2022
    strategy:
      matrix:
@@ -217,10 +217,8 @@ jobs:
        uses: lukka/get-cmake@fffaaafeea488556c2c12dad60690008bc1caacb # v4.4.2
        with:
          cmakeVersion: 4.3.4
-      # CMAKE_CXX_FLAGS replaces CMake's MSVC defaults (which include /EHsc), and
-      # ci_module_cpp20 forwards it to the module build, so list /EHsc explicitly
      - name: Run CMake (Debug)
-        run: cmake -S . -B build -G "Visual Studio 17 2022" -DJSON_CI=ON -DCMAKE_CXX_FLAGS="/permissive- /std:c++latest /utf-8 /EHsc /W4 /WX"
+        run: cmake -S . -B build -G "Visual Studio 17 2022" -DJSON_CI=ON -DCMAKE_CXX_FLAGS="/permissive- /std:c++latest /utf-8 /W4 /WX"
      - name: Build
        run: cmake --build build --config Debug --target ci_module_cpp20
        
@@ -27,6 +27,7 @@
 /docs/docset/JSON_for_Modern_C++.tgz
 /docs/docset/docSet.dsidx
 /docs/mkdocs/.cache/
+/docs/mkdocs/docs/__pycache__/
 /docs/mkdocs/hooks/__pycache__/
 /docs/mkdocs/scripts/mermaid/node_modules/
 /docs/mkdocs/site/
@@ -46,17 +47,3 @@ nlohmann_json.spdx

 # Bazel-related
 MODULE.bazel.lock
-
-# backups left by `make check-amalgamation` or the ci_test_amalgamation target if they are interrupted
-/BUILD.bazel~
-/nlohmann_json.natvis~
-/single_include/nlohmann/*.hpp~
-/venv_astyle/
-
-# release outputs of `make release`
-/include.zip
-/include.zip.asc
-/json.tar.xz
-/json.tar.xz.asc
-/release_files/
-/single_include/nlohmann/*.asc
@@ -81,7 +81,6 @@ cc_library(
    hdrs = [
        "single_include/nlohmann/json.hpp",
        "single_include/nlohmann/json_fwd.hpp",
-        "single_include/nlohmann/json_literals.hpp",
    ],
    includes = ["single_include"],
    visibility = ["//visibility:public"],
@@ -8,7 +8,7 @@ authors:
    website: https://nlohmann.me
 title: "JSON for Modern C++"
 version: 3.12.0
-date-released: 2025-04-11
+date-released: 2025-04-07
 license: MIT
 repository-code: "https://github.com/nlohmann/json"
 url: https://json.nlohmann.me
@@ -30,7 +30,7 @@ endif ()
 option(NLOHMANN_JSON_BUILD_MODULES "Build C++ modules support" OFF)

 if(NLOHMANN_JSON_BUILD_MODULES)
-    if(NOT CMAKE_VERSION VERSION_LESS 3.28)
+    if(CMAKE_VERSION VERSION_GREATER_EQUAL 3.28)
        message(STATUS "Building nlohmann.json C++ module")
        add_subdirectory(src/modules)
    else()
@@ -14,7 +14,7 @@ This file describes the source for supporting files; that is, files that are not
 The [GitHub Actions](https://docs.github.com/en/actions) workflows that build, test, and analyze the library. Each file in this folder defines one workflow:

 - `ubuntu.yml`, `macos.yml`, `windows.yml` — build and run the test suite on Linux, macOS, and Windows.
- `check_amalgamation.yml` — verify on pull requests and pushes to `develop` that the generated files (the single-header amalgamation in `single_include`, `BUILD.bazel`, and `nlohmann_json.natvis`) are up to date.
+- `check_amalgamation.yml` — verify that the single-header amalgamation in `single_include` is up to date on pull requests.
 - `comment_check_amalgamation.yml` — comment on a pull request when the amalgamation check failed.
 - `cifuzz.yml` — run short fuzzing sessions via [OSS-Fuzz CIFuzz](https://google.github.io/oss-fuzz/getting-started/continuous-integration/) on pull requests.
 - `codeql-analysis.yml` — run [CodeQL](https://codeql.github.com) code scanning.
@@ -24,9 +24,7 @@ The [GitHub Actions](https://docs.github.com/en/actions) workflows that build, t
 - `dependency-review.yml` — scan dependency changes in pull requests for known vulnerabilities.
 - `labeler.yml` — the "Pull Request Labeler" workflow (see `.github/labeler.yml`).
 - `stale.yml` — comment on and close stale issues and pull requests.
- `publish_documentation.yml` — build and publish the documentation on pushes to the `develop` branch that touch the documentation sources (or the files it embeds).
- `check_docs_links.yml` — check the links of the documentation weekly, as external links can break without any change in this repository.
- `cancel_closed_pr_runs.yml` — cancel unfinished workflow runs of a pull request once it is closed or merged.
+- `publish_documentation.yml` — build and publish the documentation on every merge to the `develop` branch.

 Further documentation:

@@ -268,9 +266,8 @@ meson setup builddir
 ninja -C builddir
 ```

-`meson_options.txt` defines the options, which mirror the names of the CMake options that change the library's target (for example,
-`-DDiagnostics=true`); their defaults may differ (for example, `MultipleHeaders` defaults to `false` in Meson, while
-`JSON_MultipleHeaders` is `ON` in CMake). Meson requires this file next to `meson.build`, so it is also part of `include.zip`. `make check_build_options`
+`meson_options.txt` defines the options, which mirror the CMake options that change the library's target (for example,
+`-DDiagnostics=true`). Meson requires this file next to `meson.build`, so it is also part of `include.zip`. `make check_build_options`
 ([`tools/check_build_options`](tools/check_build_options/README.md)) checks in CI that both files and the pkg-config files
 stay in sync with the CMake options.

@@ -1,6 +1,5 @@
 module(
    name = "nlohmann_json",
-    version = "3.12.0",
    compatibility_level = 1,
 )

@@ -1,4 +1,4 @@
-.PHONY: all amalgamate check-amalgamation check_build_options pretty install_astyle clean ChangeLog.md release update_hedley update_hedley_undef BUILD.bazel natvis macro_builder_check run_benchmarks pvs_studio serve_header reuse spdx
+.PHONY: pretty clean ChangeLog.md release update_hedley update_hedley_undef BUILD.bazel natvis macro_builder_check check_build_options

 ##########################################################################
 # configuration
@@ -41,18 +41,12 @@ all:
 	@echo "BUILD.bazel - regenerate the Bazel BUILD file from the include/nlohmann sources"
 	@echo "ChangeLog.md - generate ChangeLog file"
 	@echo "check-amalgamation - check whether sources have been amalgamated and BUILD.bazel is up to date"
-	@echo "check_build_options - check that the Meson build and the pkg-config files offer the options of the CMake target"
 	@echo "clean - remove built files"
-	@echo "(fuzzers) - see tests/fuzzing.md, or run 'make -C tests fuzzers' to build the AFL fuzzers"
+	@echo "fuzzing - see tests/fuzzing.md for how to build and run the fuzzers"
 	@echo "macro_builder_check - check that macro_scope.hpp matches tools/macro_builder's output"
 	@echo "natvis - regenerate nlohmann_json.natvis from the current ABI tags and version"
 	@echo "pretty - beautify code with Artistic Style"
-	@echo "pvs_studio - run the PVS-Studio static analyzer and open the report"
-	@echo "release - create the release files (include.zip, json.tar.xz, single headers, signatures, hashes)"
-	@echo "reuse - annotate the source files with REUSE license headers and lint them"
 	@echo "run_benchmarks - build and run benchmarks"
-	@echo "serve_header - serve the single header, re-amalgamated on demand (see tools/serve_header)"
-	@echo "spdx - generate the SPDX software bill of materials nlohmann_json.spdx"
 	@echo "update_hedley - download Hedley and regenerate hedley.hpp / hedley_undef.hpp"
 	@echo "update_hedley_undef - rebuild hedley_undef.hpp from the JSON_HEDLEY_* #define names in hedley.hpp"

@@ -114,18 +108,13 @@ $(AMALGAMATED_FWD_FILE): $(SRCS)
 $(AMALGAMATED_LITERALS_FILE): include/nlohmann/json_literals.hpp
 	cp include/nlohmann/json_literals.hpp $(AMALGAMATED_LITERALS_FILE)

-NATVIS_VENV=tools/generate_natvis/venv
-
 # regenerate nlohmann_json.natvis from the ABI tags and version in include/nlohmann/detail/abi_macros.hpp
-# (the dependencies are installed into a virtual environment first)
 natvis:
-	@test -d $(NATVIS_VENV) || python3 -mvenv $(NATVIS_VENV)
-	@$(NATVIS_VENV)/bin/python3 -c 'import jinja2' 2>/dev/null || $(NATVIS_VENV)/bin/pip3 install --quiet -r tools/generate_natvis/requirements.txt
-	$(NATVIS_VENV)/bin/python3 tools/generate_natvis/generate_natvis.py .
+	python3 tools/generate_natvis/generate_natvis.py .

 # regenerate the two tools/macro_builder blocks of $(MACRO_SCOPE_HPP) (see its README.md) and diff against the
 # checked-in header; phony, because it never writes $(MACRO_SCOPE_HPP) itself
-macro_builder_check: install_astyle
+macro_builder_check:
 	@set -e; \
 	TMPDIR=$$(mktemp -d ./macro_builder_check.XXXXXX); \
 	trap 'rm -rf "$$TMPDIR"' EXIT; \
@@ -142,27 +131,27 @@ macro_builder_check: install_astyle
 check_build_options:
 	python3 tools/check_build_options/check_build_options.py .

-# check if the single headers have been amalgamated from the nlohmann sources and if BUILD.bazel and
-# nlohmann_json.natvis are up to date; all checks are run, and the checked-in files are always restored
+# check if file single_include/nlohmann/json.hpp has been amalgamated from the nlohmann sources
 check-amalgamation:
-	@status=0; \
-	banner() { printf '===================================================================\n  %s\n===================================================================\n' "$$1"; }; \
-	for FILE in $(AMALGAMATED_FILE) $(AMALGAMATED_FWD_FILE) $(AMALGAMATED_LITERALS_FILE) BUILD.bazel nlohmann_json.natvis; do \
-	    mv "$$FILE" "$$FILE~" || exit 1; \
-	done; \
-	$(MAKE) amalgamate || status=1; \
-	$(MAKE) BUILD.bazel || status=1; \
-	$(MAKE) natvis || status=1; \
-	for FILE in $(AMALGAMATED_FILE) $(AMALGAMATED_FWD_FILE) $(AMALGAMATED_LITERALS_FILE); do \
-	    diff "$$FILE" "$$FILE~" || { banner "$$FILE is out of date! Amalgamation required! Please read the contribution guidelines in file .github/CONTRIBUTING.md."; status=1; }; \
-	done; \
-	diff BUILD.bazel BUILD.bazel~ || { banner "BUILD.bazel is out of date! Please run 'make BUILD.bazel'."; status=1; }; \
-	diff nlohmann_json.natvis nlohmann_json.natvis~ || { banner "nlohmann_json.natvis is out of date! Please run 'make natvis'."; status=1; }; \
-	for FILE in $(AMALGAMATED_FILE) $(AMALGAMATED_FWD_FILE) $(AMALGAMATED_LITERALS_FILE) BUILD.bazel nlohmann_json.natvis; do \
-	    mv "$$FILE~" "$$FILE"; \
-	done; \
-	$(MAKE) macro_builder_check || status=1; \
-	exit $$status
+	@mv $(AMALGAMATED_FILE) $(AMALGAMATED_FILE)~
+	@mv $(AMALGAMATED_FWD_FILE) $(AMALGAMATED_FWD_FILE)~
+	@mv $(AMALGAMATED_LITERALS_FILE) $(AMALGAMATED_LITERALS_FILE)~
+	@$(MAKE) amalgamate
+	@diff $(AMALGAMATED_FILE) $(AMALGAMATED_FILE)~ || (echo "===================================================================\n  Amalgamation required! Please read the contribution guidelines\n  in file .github/CONTRIBUTING.md.\n===================================================================" ; mv $(AMALGAMATED_FILE)~ $(AMALGAMATED_FILE) ; false)
+	@diff $(AMALGAMATED_FWD_FILE) $(AMALGAMATED_FWD_FILE)~ || (echo "===================================================================\n  Amalgamation required! Please read the contribution guidelines\n  in file .github/CONTRIBUTING.md.\n===================================================================" ; mv $(AMALGAMATED_FWD_FILE)~ $(AMALGAMATED_FWD_FILE) ; false)
+	@diff $(AMALGAMATED_LITERALS_FILE) $(AMALGAMATED_LITERALS_FILE)~ || (echo "===================================================================\n  Amalgamation required! Please read the contribution guidelines\n  in file .github/CONTRIBUTING.md.\n===================================================================" ; mv $(AMALGAMATED_LITERALS_FILE)~ $(AMALGAMATED_LITERALS_FILE) ; false)
+	@mv $(AMALGAMATED_FILE)~ $(AMALGAMATED_FILE)
+	@mv $(AMALGAMATED_FWD_FILE)~ $(AMALGAMATED_FWD_FILE)
+	@mv $(AMALGAMATED_LITERALS_FILE)~ $(AMALGAMATED_LITERALS_FILE)
+	@mv BUILD.bazel BUILD.bazel~
+	@$(MAKE) BUILD.bazel
+	@diff BUILD.bazel BUILD.bazel~ || (echo "===================================================================\n  BUILD.bazel is out of date! Please run 'make BUILD.bazel'.\n===================================================================" ; mv BUILD.bazel~ BUILD.bazel ; false)
+	@mv BUILD.bazel~ BUILD.bazel
+	@mv nlohmann_json.natvis nlohmann_json.natvis~
+	@$(MAKE) natvis
+	@diff nlohmann_json.natvis nlohmann_json.natvis~ || (echo "===================================================================\n  nlohmann_json.natvis is out of date! Please run 'make natvis'.\n===================================================================" ; mv nlohmann_json.natvis~ nlohmann_json.natvis ; false)
+	@mv nlohmann_json.natvis~ nlohmann_json.natvis
+	@$(MAKE) macro_builder_check

 # generate the Bazel BUILD file; phony, because a removed header would not trigger a rebuild
 BUILD.bazel:
@@ -223,8 +212,8 @@ release: include.zip json.tar.xz

 # clean up
 clean:
-	rm -fr *.dSYM tests/*.dSYM tests/parse_*_fuzzer
-	rm -fr cmake-build-benchmarks cmake-build-pvs-studio release_files
+	rm -fr fuzz fuzz-testing *.dSYM tests/*.dSYM
+	rm -fr cmake-build-benchmarks fuzz-testing cmake-build-pvs-studio release_files
 	$(MAKE) clean -Cdocs


@@ -48,7 +48,6 @@
  - [Pkg-config](#pkg-config)
 - [License](#license)
 - [Contact](#contact)
- [Security](#security)
 - [Thanks](#thanks)
 - [Used third-party tools](#used-third-party-tools)
 - [Notes](#notes)
@@ -113,9 +112,9 @@ There is also a [**docset**](https://github.com/Kapeli/Dash-User-Contributions/t

 ## Quick reference

- **Constructors**: [basic_json](https://json.nlohmann.me/api/basic_json/basic_json), [array](https://json.nlohmann.me/api/basic_json/array), [binary](https://json.nlohmann.me/api/basic_json/binary), [object](https://json.nlohmann.me/api/basic_json/object)
+- **Constructors** [basic_json](https://json.nlohmann.me/api/basic_json/basic_json), [array](https://json.nlohmann.me/api/basic_json/array), [binary](https://json.nlohmann.me/api/basic_json/binary), [object](https://json.nlohmann.me/api/basic_json/object)
 - **Object inspection**: [type](https://json.nlohmann.me/api/basic_json/type), [operator value_t](https://json.nlohmann.me/api/basic_json/operator_value_t), [type_name](https://json.nlohmann.me/api/basic_json/type_name), [is_primitive](https://json.nlohmann.me/api/basic_json/is_primitive), [is_structured](https://json.nlohmann.me/api/basic_json/is_structured), [is_null](https://json.nlohmann.me/api/basic_json/is_null), [is_boolean](https://json.nlohmann.me/api/basic_json/is_boolean), [is_number](https://json.nlohmann.me/api/basic_json/is_number), [is_number_integer](https://json.nlohmann.me/api/basic_json/is_number_integer), [is_number_unsigned](https://json.nlohmann.me/api/basic_json/is_number_unsigned), [is_number_float](https://json.nlohmann.me/api/basic_json/is_number_float), [is_object](https://json.nlohmann.me/api/basic_json/is_object), [is_array](https://json.nlohmann.me/api/basic_json/is_array), [is_string](https://json.nlohmann.me/api/basic_json/is_string), [is_binary](https://json.nlohmann.me/api/basic_json/is_binary), [is_discarded](https://json.nlohmann.me/api/basic_json/is_discarded)
- **Value access**: [get](https://json.nlohmann.me/api/basic_json/get), [get_to](https://json.nlohmann.me/api/basic_json/get_to), [get_ptr](https://json.nlohmann.me/api/basic_json/get_ptr), [get_ref](https://json.nlohmann.me/api/basic_json/get_ref), [operator ValueType](https://json.nlohmann.me/api/basic_json/operator_ValueType), [get_binary](https://json.nlohmann.me/api/basic_json/get_binary)
+- **Value access**; [get](https://json.nlohmann.me/api/basic_json/get), [get_to](https://json.nlohmann.me/api/basic_json/get_to), [get_ptr](https://json.nlohmann.me/api/basic_json/get_ptr), [get_ref](https://json.nlohmann.me/api/basic_json/get_ref), [operator ValueType](https://json.nlohmann.me/api/basic_json/operator_ValueType), [get_binary](https://json.nlohmann.me/api/basic_json/get_binary)
 - **Element access**: [at](https://json.nlohmann.me/api/basic_json/at), [operator[]](https://json.nlohmann.me/api/basic_json/operator[]), [value](https://json.nlohmann.me/api/basic_json/value), [front](https://json.nlohmann.me/api/basic_json/front), [back](https://json.nlohmann.me/api/basic_json/back)
 - **Lookup**: [find](https://json.nlohmann.me/api/basic_json/find), [count](https://json.nlohmann.me/api/basic_json/count), [contains](https://json.nlohmann.me/api/basic_json/contains)
 - **Iterators**: [begin](https://json.nlohmann.me/api/basic_json/begin), [cbegin](https://json.nlohmann.me/api/basic_json/cbegin), [end](https://json.nlohmann.me/api/basic_json/end), [cend](https://json.nlohmann.me/api/basic_json/cend), [rbegin](https://json.nlohmann.me/api/basic_json/rbegin), [rend](https://json.nlohmann.me/api/basic_json/rend), [crbegin](https://json.nlohmann.me/api/basic_json/crbegin), [crend](https://json.nlohmann.me/api/basic_json/crend), [items](https://json.nlohmann.me/api/basic_json/items)
@@ -1185,7 +1184,7 @@ binary[1]; // 0xFE
 binary.set_subtype(0x10);

 // serialize to MessagePack
-auto msgpack = json::to_msgpack(j); // 0xD5 (fixext2), 0x10, 0xCA, 0xFE
+auto cbor = json::to_msgpack(j); // 0xD5 (fixext2), 0x10, 0xCA, 0xFE
 ```

 ## Customers
@@ -1221,7 +1220,17 @@ I would be happy to learn about other compilers/versions.
 Please note:

 - GCC 4.8 has a bug [57824](https://gcc.gnu.org/bugzilla/show_bug.cgi?id=57824): multiline raw strings cannot be the arguments to macros. Don't use multiline raw strings directly in macros with this compiler.
- For GCC running on MinGW or Android, the error `'to_string' is not a member of 'std'` (or similarly, for `strtod` or `strtof`) may occur. Note this is not an issue with the code, but rather with the compiler or C++ standard library itself: use a recent toolchain (for Android, a current [NDK](https://developer.android.com/ndk) with the LLVM C++ library `APP_STL := c++_shared`, and for MinGW, a distribution with a complete C++11 standard library). See [this discussion](https://github.com/nlohmann/json/issues/136) for MinGW and [this discussion](https://github.com/nlohmann/json/issues/219) for the old Android NDK using `APP_STL := gnustl_static`.
+- Android defaults to using very old compilers and C++ libraries. To fix this, add the following to your `Application.mk`. This will switch to the LLVM C++ library, the Clang compiler, and enable C++11 and other features disabled by default.
+
+    ```makefile
+    APP_STL := c++_shared
+    NDK_TOOLCHAIN_VERSION := clang3.6
+    APP_CPPFLAGS += -frtti -fexceptions
+    ```
+
+    The code compiles successfully with [Android NDK](https://developer.android.com/ndk/index.html?hl=ml), Revision 9 - 11 (and possibly later) and [CrystaX's Android NDK](https://www.crystax.net/en/android/ndk) version 10.
+
+- For GCC running on MinGW or Android SDK, the error `'to_string' is not a member of 'std'` (or similarly, for `strtod` or `strtof`) may occur. Note this is not an issue with the code, but rather with the compiler itself. On Android, see above to build with a newer environment.  For MinGW, please refer to [this site](https://tehsausage.com/mingw-to-string) and [this discussion](https://github.com/nlohmann/json/issues/136) for information on how to fix this bug. For Android NDK using `APP_STL := gnustl_static`, please refer to [this discussion](https://github.com/nlohmann/json/issues/219).

 - Unsupported versions of GCC and Clang are rejected by `#error` directives. This can be switched off by defining `JSON_SKIP_UNSUPPORTED_COMPILER_CHECK`. Note that you can expect no support in this case.

@@ -1387,7 +1396,7 @@ THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR I
 - The class contains a slightly modified version of the Grisu2 algorithm from Florian Loitsch which is licensed under the [MIT License](https://opensource.org/licenses/MIT) (see above). Copyright &copy; 2009 [Florian Loitsch](https://florian.loitsch.com/)
 - The class contains a copy of [Hedley](https://nemequ.github.io/hedley/) from Evan Nemerson which is licensed as [CC0-1.0](https://creativecommons.org/publicdomain/zero/1.0/).
 - The class contains parts of [Google Abseil](https://github.com/abseil/abseil-cpp) which is licensed under the [Apache 2.0 License](https://opensource.org/licenses/Apache-2.0).
- The class contains an adapted version of the Eisel-Lemire algorithm, its table of powers of five, and its digit comparison for long numbers from [fast_float](https://github.com/fastfloat/fast_float) by Daniel Lemire and contributors, which is available under the [MIT License](https://opensource.org/licenses/MIT) (used here), the Apache 2.0 License, and the Boost Software License. Copyright &copy; 2021 The fast_float authors
+- The class contains an adapted version of the Eisel-Lemire algorithm and its table of powers of five from [fast_float](https://github.com/fastfloat/fast_float) by Daniel Lemire and contributors, which is available under the [MIT License](https://opensource.org/licenses/MIT) (used here), the Apache 2.0 License, and the Boost Software License. Copyright &copy; 2021 The fast_float authors

 <img align="right" src="https://git.fsfe.org/reuse/reuse-ci/raw/branch/master/reuse-horizontal.png" alt="REUSE Software">

@@ -1428,416 +1437,436 @@ I deeply appreciate the help of the following people.
 12. [kepkin](https://github.com/kepkin) patiently pushed forward the support for Microsoft Visual Studio.
 13. [gregmarr](https://github.com/gregmarr) simplified the implementation of reverse iterators and helped with numerous hints and improvements. In particular, he pushed forward the implementation of user-defined types.
 14. [Caio Luppi](https://github.com/caiovlp) fixed a bug in the Unicode handling.
-15. [dariomt](https://github.com/dariomt) fixed some typos in the examples and fixed a subtlety in MSVC type support and implemented the `get_ref()` function to get a reference to stored values.
+15. [dariomt](https://github.com/dariomt) fixed some typos in the examples.
 16. [Daniel Frey](https://github.com/d-frey) cleaned up some pointers and implemented exception-safe memory allocation.
 17. [Colin Hirsch](https://github.com/ColinH) took care of a small namespace issue.
 18. [Huu Nguyen](https://github.com/whoshuu) corrected a variable name in the documentation.
 19. [Silverweed](https://github.com/silverweed) overloaded `parse()` to accept an rvalue reference.
-20. [ZahlGraf](https://github.com/ZahlGraf) added a workaround that allows compilation using Android NDK.
-21. [whackashoe](https://github.com/whackashoe) replaced a function that was marked as unsafe by Visual Studio.
-22. [406345](https://github.com/406345) fixed two small warnings.
-23. [Glen Fernandes](https://github.com/glenfe) noted a potential portability problem in the `has_mapped_type` function.
-24. [Corbin Hughes](https://github.com/nibroc) fixed some typos in the contribution guidelines.
-25. [twelsby](https://github.com/twelsby) fixed the array subscript operator, an issue that failed the MSVC build, and floating-point parsing/dumping. He further added support for unsigned integer numbers and implemented better roundtrip support for parsed numbers.
-26. [Volker Diels-Grabsch](https://github.com/vog) fixed a link in the README file.
-27. [msm-](https://github.com/msm-) added support for American Fuzzy Lop.
-28. [Annihil](https://github.com/Annihil) fixed an example in the README file.
-29. [Themercee](https://github.com/Themercee) noted a wrong URL in the README file.
-30. [Lv Zheng](https://github.com/lv-zheng) fixed a namespace issue with `int64_t` and `uint64_t`.
-31. [abc100m](https://github.com/abc100m) analyzed the issues with GCC 4.8 and proposed a [partial solution](https://github.com/nlohmann/json/pull/212).
-32. [zewt](https://github.com/zewt) added useful notes to the README file about Android.
-33. [Róbert Márki](https://github.com/robertmrk) added a fix to use move iterators and improved the integration via CMake.
-34. [Chris Kitching](https://github.com/ChrisKitching) cleaned up the CMake files.
-35. [Tom Needham](https://github.com/06needhamt) fixed a subtle bug with MSVC 2015 which was also proposed by [Michael K.](https://github.com/Epidal).
-36. [Mário Feroldi](https://github.com/thelostt) fixed a small typo.
-37. [duncanwerner](https://github.com/duncanwerner) found a really embarrassing performance regression in the 2.0.0 release.
-38. [Damien](https://github.com/dtoma) fixed one of the last conversion warnings.
-39. [Thomas Braun](https://github.com/t-b) fixed a warning in a test case and adjusted MSVC calls in the CI.
-40. [Théo DELRIEU](https://github.com/theodelrieu) patiently and constructively oversaw the long way toward [iterator-range parsing](https://github.com/nlohmann/json/issues/290). He also implemented the magic behind the serialization/deserialization of user-defined types and split the single header file into smaller chunks.
-41. [Stefan](https://github.com/5tefan) fixed a minor issue in the documentation.
-42. [Vasil Dimov](https://github.com/vasild) fixed the documentation regarding conversions from `std::multiset`.
-43. [ChristophJud](https://github.com/ChristophJud) overworked the CMake files to ease project inclusion.
-44. [Vladimir Petrigo](https://github.com/vpetrigo) made a SFINAE hack more readable and added Visual Studio 17 to the build matrix.
-45. [Denis Andrejew](https://github.com/seeekr) fixed a grammar issue in the README file.
-46. [Pierre-Antoine Lacaze](https://github.com/palacaze) found a subtle bug in the `dump()` function.
-47. [TurpentineDistillery](https://github.com/TurpentineDistillery) pointed to [`std::locale::classic()`](https://en.cppreference.com/w/cpp/locale/locale/classic) to avoid too much locale joggling, found some nice performance improvements in the parser, improved the benchmarking code, and realized locale-independent number parsing and printing.
-48. [cgzones](https://github.com/cgzones) had an idea how to fix the Coverity scan.
-49. [Jared Grubb](https://github.com/jaredgrubb) silenced a nasty documentation warning and supported the implementation of user-defined types.
-50. [Yixin Zhang](https://github.com/qwename) fixed an integer overflow check.
-51. [Bosswestfalen](https://github.com/Bosswestfalen) merged two iterator classes into a smaller one.
-52. [Daniel599](https://github.com/Daniel599) helped to get Travis to execute the tests with Clang's sanitizers and allowed to use more algorithms with the `items()` function.
-53. [Jonathan Lee](https://github.com/vjon) fixed an example in the README file.
-54. [gnzlbg](https://github.com/gnzlbg) supported the implementation of user-defined types.
-55. [Alexej Harm](https://github.com/qis) helped to get the user-defined types working with Visual Studio.
-56. [EnricoBilla](https://github.com/EnricoBilla) noted a typo in an example.
-57. [Martin Hořeňovský](https://github.com/horenmar) found a way for a 2x speedup for the compilation time of the test suite.
-58. [ukhegg](https://github.com/ukhegg) proposed an improvement for the examples section.
-59. [rswanson-ihi](https://github.com/rswanson-ihi) noted a typo in the README.
-60. [Mihai Stan](https://github.com/stanmihai4) fixed a bug in the comparison with `nullptr`s.
-61. [Tushar Maheshwari](https://github.com/tusharpm) added [cotire](https://github.com/sakra/cotire) support to speed up the compilation.
-62. [TedLyngmo](https://github.com/TedLyngmo) noted a typo in the README, removed unnecessary bit arithmetic, and fixed some `-Weffc++` warnings.
-63. [Krzysztof Woś](https://github.com/krzysztofwos) made exceptions more visible.
-64. [ftillier](https://github.com/ftillier) fixed a compiler warning.
-65. [tinloaf](https://github.com/tinloaf) made sure all pushed warnings are properly popped.
-66. [Fytch](https://github.com/Fytch) found a bug in the documentation.
-67. [Jay Sistar](https://github.com/Type1J) implemented a Meson build description.
-68. [Henry Lee](https://github.com/HenryRLee) fixed a warning in ICC and improved the iterator implementation.
-69. [Vincent Thiery](https://github.com/vthiery) maintains a package for the Conan package manager.
-70. [Steffen](https://github.com/koemeet) fixed a potential issue with MSVC and `std::min`.
-71. [Mike Tzou](https://github.com/Chocobo1) fixed some typos.
-72. [amrcode](https://github.com/amrcode) noted misleading documentation about comparison of floats.
-73. [Oleg Endo](https://github.com/olegendo) reduced the memory consumption by replacing `<iostream>` with `<iosfwd>`.
-74. [dan-42](https://github.com/dan-42) cleaned up the CMake files to simplify including/reusing of the library.
-75. [Nikita Ofitserov](https://github.com/himikof) allowed for moving values from initializer lists.
-76. [Greg Hurrell](https://github.com/wincent) fixed a typo.
-77. [Dmitry Kukovinets](https://github.com/DmitryKuk) fixed a typo.
-78. [kbthomp1](https://github.com/kbthomp1) fixed an issue related to the Intel OSX compiler.
-79. [Markus Werle](https://github.com/daixtrose) fixed a typo.
-80. [WebProdPP](https://github.com/WebProdPP) fixed a subtle error in a precondition check.
-81. [Alex](https://github.com/leha-bot) noted an error in a code sample.
-82. [Tom de Geus](https://github.com/tdegeus) reported some warnings with ICC and helped to fix them.
-83. [Perry Kundert](https://github.com/pjkundert) simplified reading from input streams.
-84. [Sonu Lohani](https://github.com/sonulohani) fixed a small compilation error, fixed the compilation with MSVC 2015 in debug mode and fixed a warning.
-85. [Jamie Seward](https://github.com/jseward) fixed all MSVC warnings and avoided unnecessary string copies in `find()` and `count()`.
-86. [Nate Vargas](https://github.com/eld00d) added a Doxygen tag file.
-87. [pvleuven](https://github.com/pvleuven) helped to fix a warning in ICC.
-88. [Pavel](https://github.com/crea7or) helped to fix some warnings in MSVC.
-89. [Mitja](https://github.com/Itja) fixed some typos.
-90. [Jorrit Wronski](https://github.com/jowr) updated the Hunter package links.
-91. [Matthias Möller](https://github.com/TinyTinni) added a `.natvis` for the MSVC debug view and removed the dependency from `std::stringstream`.
-92. [bogemic](https://github.com/bogemic) fixed some C++17 deprecation warnings.
-93. [Eren Okka](https://github.com/erengy) fixed some MSVC warnings.
-94. [abolz](https://github.com/abolz) integrated the Grisu2 algorithm for proper floating-point formatting, allowing more roundtrip checks to succeed.
-95. [Vadim Evard](https://github.com/Pipeliner) fixed a Markdown issue in the README.
-96. [zerodefect](https://github.com/zerodefect) fixed a compiler warning.
-97. [Kert](https://github.com/kaidokert) allowed to template the string type in the serialization and added the possibility to override the exceptional behavior.
-98. [mark-99](https://github.com/mark-99) helped fix an ICC error.
-99. [Patrik Huber](https://github.com/patrikhuber) fixed links in the README file.
-100. [johnfb](https://github.com/johnfb) found a bug in the implementation of CBOR's indefinite length strings.
-101. [Paul Fultz II](https://github.com/pfultz2) added a note on the cget package manager.
-102. [Wilson Lin](https://github.com/wla80) made the integration section of the README more concise.
-103. [RalfBielig](https://github.com/ralfbielig) detected and fixed a memory leak in the parser callback.
-104. [agrianius](https://github.com/agrianius) allowed dumping JSON to an alternative string type and added code to use alternative string implementations.
-105. [Kevin Tonon](https://github.com/ktonon) overworked the C++11 compiler checks in CMake.
-106. [Axel Huebl](https://github.com/ax3l) simplified a CMake check and added support for the [Spack package manager](https://spack.io).
-107. [Carlos O'Ryan](https://github.com/coryan) fixed a typo.
-108. [James Upjohn](https://github.com/jupjohn) fixed a version number in the compilers section.
-109. [Chuck Atkins](https://github.com/chuckatkins) adjusted the CMake files to the CMake packaging guidelines and provided documentation for the CMake integration.
-110. [Jan Schöppach](https://github.com/dns13) fixed a typo.
-111. [martin-mfg](https://github.com/martin-mfg) fixed a typo.
-112. [Julius Rakow](https://github.com/juliusrakow) fixed the Meson include directory and fixed the links to [cppreference.com](https://cppreference.com).
-113. [grembo](https://github.com/grembo) fixed the test suite and re-enabled several test cases.
-114. [Hyeon Kim](https://github.com/simnalamburt) introduced the macro `JSON_INTERNAL_CATCH` to control the exception handling inside the library and fixed an issue with a double macro definition.
-115. [thyu](https://github.com/thyu) fixed a compiler warning.
-116. [David Guthrie](https://github.com/LEgregius) fixed a subtle compilation error with Clang 3.4.2.
-117. [Dennis Fischer](https://github.com/dennisfischer) allowed to call `find_package` without installing the library.
-118. [Ben Berman](https://github.com/rivertam) made some error messages more understandable.
-119. [zakalibit](https://github.com/zakalibit) fixed a compilation problem with the Intel C++ compiler.
-120. [mandreyel](https://github.com/mandreyel) fixed a compilation problem.
-121. [Kostiantyn Ponomarenko](https://github.com/koponomarenko) added version and license information to the Meson build file.
-122. [Henry Schreiner](https://github.com/henryiii) added support for GCC 4.8.
-123. [knilch](https://github.com/knilch0r) made sure the test suite does not stall when run in the wrong directory.
-124. [Antonio Borondo](https://github.com/antonioborondo) fixed an MSVC 2017 warning.
-125. [Dan Gendreau](https://github.com/dgendreau) implemented the `NLOHMANN_JSON_SERIALIZE_ENUM` macro to quickly define an enum/JSON mapping.
-126. [efp](https://github.com/efp) added line and column information to parse errors.
-127. [julian-becker](https://github.com/julian-becker) added BSON support.
-128. [Pratik Chowdhury](https://github.com/pratikpc) added support for structured bindings.
-129. [David Avedissian](https://github.com/davedissian) added support for Clang 5.0.1 (PS4 version).
-130. [Jonathan Dumaresq](https://github.com/dumarjo) implemented an input adapter to read from `FILE*`.
-131. [kjpus](https://github.com/kjpus) fixed a link in the documentation.
-132. [Manvendra Singh](https://github.com/manu-chroma) fixed a typo in the documentation.
-133. [ziggurat29](https://github.com/ziggurat29) fixed an MSVC warning.
-134. [Sylvain Corlay](https://github.com/SylvainCorlay) added code to avoid an issue with MSVC.
-135. [mefyl](https://github.com/mefyl) fixed a bug when JSON was parsed from an input stream.
-136. [Millian Poquet](https://github.com/mpoquet) allowed to install the library via Meson.
-137. [Michael Behrns-Miller](https://github.com/moodboom) found an issue with a missing namespace.
-138. [Nasztanovics Ferenc](https://github.com/naszta) fixed a compilation issue with libc 2.12.
-139. [Andreas Schwab](https://github.com/andreas-schwab) fixed the endian conversion.
-140. [Mark-Dunning](https://github.com/Mark-Dunning) fixed a warning in MSVC.
-141. [Gareth Sylvester-Bradley](https://github.com/garethsb-sony) added `operator/` for JSON Pointers and fixed a compilation issue with MSVC.
-142. [John-Mark](https://github.com/johnmarkwayve) noted a missing header.
-143. [Vitaly Zaitsev](https://github.com/xvitaly) fixed compilation with GCC 9.0.
-144. [Laurent Stacul](https://github.com/stac47) fixed compilation with GCC 9.0.
-145. [Ivor Wanders](https://github.com/iwanders) helped to reduce the CMake requirement to version 3.1 and fixed the examples to catch exception by `const&`.
-146. [njlr](https://github.com/njlr) updated the Buckaroo instructions.
-147. [Lion](https://github.com/lieff) fixed a compilation issue with GCC 7 on CentOS.
-148. [Isaac Nickaein](https://github.com/nickaein) improved the integer serialization performance and implemented the `contains()` function.
-149. [past-due](https://github.com/past-due) suppressed an unfixable warning.
-150. [Elvis Oric](https://github.com/elvisoric) improved Meson support.
-151. [Matěj Plch](https://github.com/Afforix) fixed an example in the README.
-152. [Mark Beckwith](https://github.com/wythe) fixed two typos.
-153. [scinart](https://github.com/scinart) fixed a bug in the serializer.
-154. [Patrick Boettcher](https://github.com/pboettch) implemented `push_back()` and `pop_back()` for JSON Pointers.
-155. [Bruno Oliveira](https://github.com/nicoddemus) added support for Conda.
-156. [Michele Caini](https://github.com/skypjack) fixed links in the README.
-157. [Hani](https://github.com/hnkb) documented how to install the library with NuGet.
-158. [yann-morin-1998](https://github.com/yann-morin-1998) helped to reduce the CMake requirement to version 3.1.
-159. [Konstantin Podsvirov](https://github.com/podsvirov) maintains a package for the MSYS2 software distro and fixed the MSYS2 package documentation.
-160. [remyabel](https://github.com/remyabel2) added GNUInstallDirs to the CMake files.
-161. [Taylor Howard](https://github.com/taylorhoward92) fixed a unit test.
-162. [Gabe Ron](https://github.com/Macr0Nerd) implemented the `to_string` method.
-163. [Watal M. Iwasaki](https://github.com/heavywatal) fixed a Clang warning.
-164. [Viktor Kirilov](https://github.com/onqtam) switched the unit tests from [Catch](https://github.com/philsquared/Catch) to [doctest](https://github.com/doctest/doctest)
-165. [Juncheng E](https://github.com/ejcjason) fixed a typo.
-166. [tete17](https://github.com/tete17) fixed a bug in the `contains` function.
-167. [Xav83](https://github.com/Xav83) fixed some cppcheck warnings.
-168. [0xflotus](https://github.com/0xflotus) fixed some typos.
-169. [Christian Deneke](https://github.com/chris0x44) added a const version of `json_pointer::back`.
-170. [Julien Hamaide](https://github.com/crazyjul) made the `items()` function work with custom string types.
-171. [Evan Nemerson](https://github.com/nemequ) updated fixed a bug in Hedley and updated this library accordingly.
-172. [Florian Pigorsch](https://github.com/flopp) fixed a lot of typos.
-173. [Camille Bégué](https://github.com/cbegue) fixed an issue in the conversion from  `std::pair` and `std::tuple` to `json`.
-174. [Anthony VH](https://github.com/AnthonyVH) fixed a compile error in an enum deserialization.
-175. [Yuriy Vountesmery](https://github.com/ua-code-dragon) noted a subtle bug in a preprocessor check.
-176. [Chen](https://github.com/dota17) fixed numerous issues in the library.
-177. [Antony Kellermann](https://github.com/aokellermann) added a CI step for GCC 10.1.
-178. [Alex](https://github.com/gistrec) fixed an MSVC warning.
-179. [Rainer](https://github.com/rvjr) proposed an improvement in the floating-point serialization in CBOR.
-180. [Francois Chabot](https://github.com/FrancoisChabot) made performance improvements in the input adapters.
-181. [Arthur Sonzogni](https://github.com/ArthurSonzogni) documented how the library can be included via `FetchContent`.
-182. [Rimas Misevičius](https://github.com/rmisev) fixed an error message.
-183. [Alexander Myasnikov](https://github.com/alexandermyasnikov) fixed some examples and a link in the README.
-184. [Hubert Chathi](https://github.com/uhoreg) made CMake's version config file architecture-independent.
-185. [OmnipotentEntity](https://github.com/OmnipotentEntity) implemented the binary values for CBOR, MessagePack, BSON, and UBJSON.
-186. [ArtemSarmini](https://github.com/ArtemSarmini) fixed a compilation issue with GCC 10 and fixed a leak.
-187. [Evgenii Sopov](https://github.com/sea5kg) integrated the library to the wsjcpp package manager.
-188. [Sergey Linev](https://github.com/linev) fixed a compiler warning.
-189. [Miguel Magalhães](https://github.com/magamig) fixed the year in the copyright.
-190. [Alexander “weej” Jones](https://github.com/alex-weej) fixed an example in the README.
-191. [Antoine Cœur](https://github.com/Coeur) fixed some typos in the documentation.
-192. [jothepro](https://github.com/jothepro) updated links to the Hunter package.
-193. [Dave Lee](https://github.com/kastiglione) fixed a link in the README.
-194. [Joël Lamotte](https://github.com/Klaim) added instruction for using Build2's package manager.
-195. [Paul Jurczak](https://github.com/pauljurczak) fixed an example in the README.
-196. [Carlos Gomes Martinho](https://github.com/gocarlos) updated the Conan package source.
-197. [Tridacnid](https://github.com/Tridacnid) improved the CMake tests.
-198. [Michael](https://github.com/MBalszun) fixed MSVC warnings.
-199. [Quentin Barbarat](https://github.com/quentin-dev) fixed an example in the documentation.
-200. [XyFreak](https://github.com/XyFreak) fixed a compiler warning.
-201. [TotalCaesar659](https://github.com/TotalCaesar659) fixed links in the README and updated the links in the documentation to use HTTPS.
-202. [Tanuj Garg](https://github.com/tanuj208) improved the fuzzer coverage for UBSAN input.
-203. [AODQ](https://github.com/AODQ) fixed a compiler warning.
-204. [jwittbrodt](https://github.com/jwittbrodt) made `NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE` inline.
-205. [pfeatherstone](https://github.com/pfeatherstone) improved the upper bound of arguments of the `NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE`/`NLOHMANN_DEFINE_TYPE_INTRUSIVE` macros.
-206. [Jan Procházka](https://github.com/jprochazk) fixed a bug in the CBOR parser for binary and string values.
-207. [T0b1-iOS](https://github.com/T0b1-iOS) fixed a bug in the new hash implementation.
-208. [Matthew Bauer](https://github.com/matthewbauer) adjusted the CBOR writer to create tags for binary subtypes.
-209. [gatopeich](https://github.com/gatopeich) implemented an ordered map container for `nlohmann::ordered_json`.
-210. [Érico Nogueira Rolim](https://github.com/ericonr) added support for pkg-config.
-211. [KonanM](https://github.com/KonanM) proposed an implementation for the `NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE`/`NLOHMANN_DEFINE_TYPE_INTRUSIVE` macros.
-212. [Guillaume Racicot](https://github.com/gracicot) implemented `string_view` support and allowed C++20 support.
-213. [Alex Reinking](https://github.com/alexreinking) improved CMake support for `FetchContent`.
-214. [Hannes Domani](https://github.com/ssbssa) provided a GDB pretty printer.
-215. Lars Wirzenius reviewed the README file.
-216. [Jun Jie](https://github.com/ongjunjie) fixed a compiler path in the CMake scripts.
-217. [Ronak Buch](https://github.com/rbuch) fixed typos in the documentation.
-218. [Alexander Karzhenkov](https://github.com/karzhenkov) fixed a move constructor and the Travis builds.
-219. [Leonardo Lima](https://github.com/leozz37) added CPM.Cmake support.
-220. [Joseph Blackman](https://github.com/jbzdarkid) fixed a warning.
-221. [Yaroslav](https://github.com/YarikTH) updated doctest and implemented unit tests.
-222. [Martin Stump](https://github.com/globberwops) fixed a bug in the CMake files.
-223. [Jaakko Moisio](https://github.com/jasujm) fixed a bug in the input adapters.
-224. [bl-ue](https://github.com/bl-ue) fixed some Markdown issues in the README file.
-225. [William A. Wieselquist](https://github.com/wawiesel) fixed an example from the README.
-226. [abbaswasim](https://github.com/abbaswasim) fixed an example from the README.
-227. [Remy Jette](https://github.com/remyjette) fixed a warning.
-228. [Fraser](https://github.com/frasermarlow) fixed the documentation.
-229. [Ben Beasley](https://github.com/musicinmybrain) updated doctest.
-230. [Doron Behar](https://github.com/doronbehar) fixed pkg-config.pc.
-231. [raduteo](https://github.com/raduteo) fixed a warning.
-232. [David Pfahler](https://github.com/theShmoo) added the possibility to compile the library without I/O support.
-233. [Morten Fyhn Amundsen](https://github.com/mortenfyhn) fixed a typo.
-234. [jpl-mac](https://github.com/jpl-mac) allowed treating the library as a system header in CMake.
-235. [Jason Dsouza](https://github.com/jasmcaus) fixed the indentation of the CMake file.
-236. [offa](https://github.com/offa) added a link to Conan Center to the documentation.
-237. [Rafail Giavrimis](https://github.com/grafail) fixed the Google Benchmark default branch.
-238. [Louis Dionne](https://github.com/ldionne) fixed a conversion operator.
-239. [justanotheranonymoususer](https://github.com/justanotheranonymoususer) made the examples in the README more consistent.
-240. [Finkman](https://github.com/Finkman) suppressed some `-Wfloat-equal` warnings and fixed the debug pretty-printer.
-241. [Ferry Huberts](https://github.com/fhuberts) fixed `-Wswitch-enum` warnings and fixed a typo.
-242. [Arseniy Terekhin](https://github.com/senyai) made the GDB pretty-printer robust against unset variable names.
-243. [Amir Masoud Abdol](https://github.com/amirmasoudabdol) updated the Homebrew command as nlohmann/json is now in homebrew-core.
-244. [Hallot](https://github.com/Hallot) fixed some `-Wextra-semi-stmt warnings`.
-245. [Giovanni Cerretani](https://github.com/gcerretani) fixed `-Wunused` warnings on `JSON_DIAGNOSTICS` and fixed a check for `std::filesystem`.
-246. [Bogdan Popescu](https://github.com/Kapeli) hosts the [docset](https://github.com/Kapeli/Dash-User-Contributions/tree/master/docsets/JSON_for_Modern_C%2B%2B) for offline documentation viewers.
-247. [Carl Smedstad](https://github.com/carlsmedstad) fixed an assertion error when using `JSON_DIAGNOSTICS`.
-248. [miikka75](https://github.com/miikka75) provided an important fix to compile C++17 code with Clang 9.
-249. [Maarten Becker](https://github.com/kernie) fixed a warning for shadowed variables.
-250. [Cristi Vîjdea](https://github.com/axnsan12) fixed typos in the `operator[]` documentation.
-251. [Alex Beregszaszi](https://github.com/axic) fixed spelling mistakes in comments.
-252. [Dirk Stolle](https://github.com/striezel) fixed typos in the documentation.
-253. [Daniel Albuschat](https://github.com/daniel-kun) corrected the parameter name in the `parse` documentation.
-254. [Prince Mendiratta](https://github.com/Prince-Mendiratta) fixed a link to the FAQ.
-255. [Florian Albrechtskirchinger](https://github.com/falbrechtskirchinger) implemented `std::string_view` support for object keys and made dozens of other improvements.
-256. [Qianqian Fang](https://github.com/fangq) implemented the Binary JData (BJData) format.
-257. [pketelsen](https://github.com/pketelsen) added macros `NLOHMANN_DEFINE_TYPE_INTRUSIVE_WITH_DEFAULT` and `NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE_WITH_DEFAULT`.
-258. [DarkZeros](https://github.com/DarkZeros) adjusted to code to not clash with Arduino defines.
-259. [flagarde](https://github.com/flagarde) fixed the output of `meta()` for MSVC.
-260. [Dimitris Apostolou](https://github.com/rex4539) fixed a typo.
-261. [Michael Nosthoff](https://github.com/heinemml) fixed a typo.
-262. [JungHoon Lee](https://github.com/jhnlee) fixed a typo.
-263. [Faruk D.](https://github.com/fdiblen) fixed the CITATION.CFF file.
-264. [Andrea Cocito](https://github.com/puffetto) added a clarification on macro usage to the documentation.
-265. [Krzysiek Karbowiak](https://github.com/kkarbowiak) refactored the tests to use `CHECK_THROWS_WITH_AS`.
-266. [Chaoqi Zhang](https://github.com/prncoprs) fixed a typo.
-267. [ivanovmp](https://github.com/ivanovmp) fixed a whitespace error.
-268. [KsaNL](https://github.com/KsaNL) fixed a build error when including `<windows.h>`.
-269. [Andrea Pappacoda](https://github.com/Tachi107) moved `.pc` and `.cmake` files to `share` directory.
-270. [Wolf Vollprecht](https://github.com/wolfv) added the `patch_inplace` function.
-271. [Jake Zimmerman](https://github.com/jez) highlighted common usage patterns in the README file.
-272. [NN](https://github.com/NN---) added the Visual Studio output directory to `.gitignore`.
-273. [Romain Reignier](https://github.com/romainreignier) improved the performance of the vector output adapter.
-274. [Mike](https://github.com/Mike-Leo-Smith) fixed the `std::iterator_traits`.
-275. [Richard Hozák](https://github.com/richardhozak) added macro `JSON_NO_ENUM` to disable default enum conversions.
-276. [vakokako](https://github.com/vakokako) fixed tests when compiling with C++20.
-277. [Alexander “weej” Jones](https://github.com/alexweej) fixed an example in the README.
-278. [Eli Schwartz](https://github.com/eli-schwartz) added more files to the `include.zip` archive.
-279. [Kevin Lu](https://github.com/kevinlul) fixed a compilation issue when typedefs with certain names were present.
-280. [Trevor Hickey](https://github.com/luxe) improved the description of an example.
-281. [Jef LeCompte](https://github.com/jef) updated the year in the README file.
-282. [Alexandre Hamez](https://github.com/ahamez) fixed a warning.
-283. [Maninderpal Badhan](https://github.com/mbadhan) fixed a typo.
-284. [kevin--](https://github.com/kevin--) added a note to an example in the README file.
-285. [I](https://github.com/wx257osn2) fixed a typo.
-286. [Gregorio Litenstein](https://github.com/Lord-Kamina) fixed the Clang detection.
-287. [Andreas Smas](https://github.com/andoma) added a Doozer badge.
-288. [WanCW](https://github.com/wancw) fixed the string conversion with Clang.
-289. [zhaohuaxishi](https://github.com/zhaohuaxishi) fixed a Doxygen error.
-290. [emvivre](https://github.com/emvivre) removed an invalid parameter from CMake.
-291. [Tobias Hermann](https://github.com/Dobiasd) fixed a link in the README file.
-292. [Michael](https://github.com/traits) fixed a warning.
-293. [Ryan Mulder](https://github.com/ryanjmulder) added `ensure_ascii` to the `dump` function.
-294. [Muri Nicanor](https://github.com/murinicanor) fixed the `sed` discovery in the Makefile.
-295. [David Avedissian](https://github.com/dgavedissian) implemented SFINAE-friendly `iterator_traits`.
-296. [AQNOUCH Mohammed](https://github.com/aqnouch) fixed a typo in the README.
-297. [Gareth Sylvester-Bradley](https://github.com/garethsb) added `operator/=` and `operator/` to construct JSON pointers.
-298. [Michael Macnair](https://github.com/mykter) added support for afl-fuzz testing.
-299. [Berkus Decker](https://github.com/berkus) fixed a typo in the README.
-300. [Illia Polishchuk](https://github.com/ilqvya) improved the CMake testing.
-301. [Ikko Ashimine](https://github.com/eltociear) fixed two typos.
-302. [Raphael Grimm](https://github.com/barcode) added the possibility to define a custom base class.
-303. [tocic](https://github.com/tocic) fixed typos in the documentation.
-304. [Vertexwahn](https://github.com/Vertexwahn) added Bazel build support.
-305. [DavidKorczynski](https://github.com/DavidKorczynski) added a CIFuzz CI GitHub action.
-306. [Florian Segginger](https://github.com/floriansegginger) bumped the years in the README.
-307. [haadfida](https://github.com/haadfida) cleaned up the badges of used services.
-308. [Arsen Arsenović](https://github.com/ArsenArsen) fixed a build error.
-309. [theevilone45](https://github.com/theevilone45) fixed a typo in a CMake file.
-310. [Sergei Trofimovich](https://github.com/trofi) fixed the custom allocator support.
-311. [Joyce](https://github.com/joycebrum) fixed some security issues in the GitHub workflows.
-312. [Nicolas Jakob](https://github.com/njakob) add vcpkg version badge.
-313. [Tomerkm](https://github.com/Tomerkm) added tests.
-314. [No.](https://github.com/tusooa) fixed the use of `get<>` calls.
-315. [taro](https://github.com/tarolling) fixed a typo in the `CODEOWNERS` file.
-316. [Felix Yan](https://github.com/felixonmars) fixed a typo in the README.
-317. [HO-COOH](https://github.com/HO-COOH) fixed a parenthesis in the documentation.
-318. [miny1233](https://github.com/miny1233) fixed a parenthesis in the documentation.
-319. [tomalakgeretkal](https://github.com/tomalakgeretkal) fixed a compilation error.
-320. [alferov](https://github.com/ALF-ONE) fixed a compilation error and fixed a version in the documentation.
-321. [Craig Scott](https://github.com/craigscott-crascit) fixed a deprecation warning in CMake.
-322. [Vyacheslav Zhdanovskiy](https://github.com/ZeronSix) added macros for serialization-only types.
-323. [Mathieu Westphal](https://github.com/mwestphal) fixed typos.
-324. [scribam](https://github.com/scribam) fixed the MinGW workflow.
-325. [Aleksei Sapitskii](https://github.com/aleksproger) added support for Apple's Swift Package Manager.
-326. [Benjamin Buch](https://github.com/bebuch) fixed the installation path in CMake.
-327. [Colby Haskell](https://github.com/colbychaskell) clarified the parse error message in case a file cannot be opened.
-328. [Juan Carlos Arevalo Baeza](https://github.com/TheJCAB) fixed the enum conversion.
-329. [ss](https://github.com/serge-s) fixed the amalgamation call.
-330. [AniketDhemare](https://github.com/AniketDhemare) fixed a version in the documentation.
-331. [Philip Müller](https://github.com/philip-paul-mueller) fixed an example.
-332. [Leila Shcheglova](https://github.com/LeilaShcheglova) fixed a warning in a test.
-333. [Alex Prabhat Bara](https://github.com/alexprabhat99) fixed a function name in the documentation.
-334. [laterlaugh](https://github.com/laterlaugh) fixed some typos.
-335. [Yuanhao Jia](https://github.com/MrJia1997) fixed the GDB pretty printer.
-336. [Fallen_Breath](https://github.com/Fallen-Breath) fixed an example for JSON Pointer.
-337. [Nikhil Idiculla](https://github.com/tsnl) fixed some typos.
-338. [Griffin Myers](https://github.com/gmyers18) updated the Natvis file.
-339. [thetimr](https://github.com/thetimr) fixed a typo in the documentation.
-340. [Balazs Erseki](https://github.com/zerocukor287) fixed a URL in the contribution guidelines.
-341. [Niccolò Iardella](https://github.com/rotolof) added `NLOHMANN_DEFINE_DERIVED_TYPE_*` macros.
-342. [Borislav Stanimirov](https://github.com/iboB) allowed overriding the CMake target name.
-343. [Captain Crutches](https://github.com/captaincrutches) made `iterator_proxy_value` a `std::forward_iterator`.
-344. [Fredrik Sandhei](https://github.com/fsandhei) added type conversion support for `std::optional`.
-345. [jh96](https://github.com/jordan-hoang) added exceptions when `nullptr` is passed to `parse`.
-346. [Stuart Gorman](https://github.com/StuartGorman) fixed number parsing when `EINTR` set in `errno`.
-347. [Dylan Baker](https://github.com/dcbaker) generated a pkg-config file that follows the pkg-config conventions.
-348. [Tianyi Chen](https://github.com/TianyiChen) optimized the binary `get_number` implementation.
-349. [peng-wang-cn](https://github.com/peng-wang-cn) added type conversion support for multidimensional arrays.
-350. [Einars Netlis-Galejs](https://github.com/EinarsNG) added `ONLY_SERIALIZE` for `NLOHMANN_DEFINE_DERIVED_TYPE_*` macros.
-351. [Marcel](https://github.com/mering) removed `alwayslink=True` Bazel flag.
-352. [Harinath Nampally](https://github.com/hnampally) added diagnostic positions to exceptions.
-353. [Nissim Armand Ben Danan](https://github.com/NissimBendanan) fixed `NLOHMANN_DEFINE_TYPE_INTRUSIVE_WITH_DEFAULT` with an empty JSON instance.
-354. [Michael Valladolid](https://github.com/codenut) added support for BSON uint64 serialization/deserialization.
-355. [Nikhil](https://github.com/nikhilreddydev) updated the documentation.
-356. [Nebojša Cvetković](https://github.com/nebkat) added support for BJDATA optimized binary array type.
-357. [Sushrut Shringarputale](https://github.com/sushshring) added support for diagnostic positions. 
-358. [kimci86](https://github.com/kimci86) templated to `NLOHMANN_DEFINE_TYPE` macros to also support `ordered_json`.
-359. [Richard Topchii](https://github.com/richardtop) added support for VisionOS in the Swift Package Manager.
-360. [Robert Chisholm](https://github.com/Robadob) fixed a typo.
-361. [zjyhjqs](https://github.com/zjyhjqs) added CPack support.
-362. [bitFiedler](https://github.com/bitFiedler) made GDB pretty printer work with Python 3.8.
-363. [Gianfranco Costamagna](https://github.com/LocutusOfBorg) fixed a compiler warning.
-364. [risa2000](https://github.com/risa2000) made `std::filesystem::path` conversion to/from UTF-8 encoded string explicit.
-365. [AM](https://github.com/maqnouch) fixed typos in the README.
-366. [dmenendez-gruposantander](https://github.com/dmenendez-gruposantander) fixed typos in the comments of the examples.
-367. [Mihai Stan](https://github.com/mstan-xx) fixed comparisons against the literal `0`.
-368. [Matt Gumbel](https://github.com/intelmatt) fixed some `-Weffc++` warnings.
-369. [vimpunk](https://github.com/vimpunk) moved a lambda out of an unevaluated context to support older compilers.
-370. [Chris Harris](https://github.com/cjh1) fixed the compilation with GCC 4.8.
-371. [Palmer Dabbelt](https://github.com/palmer-dabbelt) generated and installed a pkg-config file.
-372. [Gus Pozuelo](https://github.com/ap-viavi) made `ordered_map` compatible with GCC 5.5, Clang 3.6, and Xcode 9.
-373. [AK](https://github.com/Lioncky) fixed an MSVC build error caused by the `min`/`max` macros from `windows.h`.
-374. [Sergiu Deitsch](https://github.com/sergiud) provided a fallback for missing `char8_t` support.
-375. [Xiaochuan Ye](https://github.com/XueSongTap) fixed `from_msgpack` for `std::byte` input by specializing `std::char_traits`.
-376. [Ville Vesilehto](https://github.com/thevilledev) fixed an overflow in the BJData size calculation and rejected overflowing negative integers in CBOR.
-377. [NmPassTHFan](https://github.com/nmpassthf) replaced the deprecated `std::is_trivial` for C++26.
-378. [Chris Ever](https://github.com/chirsz-ever) added the `ignore_trailing_commas` parser option.
-379. [Kuan-Fu Wu](https://github.com/kfwu1999) fixed the example code for `json_pointer` initialization.
-380. [David Kilzer](https://github.com/ddkilzer) added a missing header to the input adapters.
-381. [Miko](https://github.com/mikomikotaishi) added proper C++20 module support, simplified the module API, and fixed missing exports.
-382. [hitgirl](https://github.com/hitgil) fixed the CMake configuration when cross-compiling.
-383. [Devon Thomas](https://github.com/ThomaDevOSU) mentioned the Artistic Style formatting in the contribution guidelines.
-384. [Erik Hu](https://github.com/Erikhu1) made Coveralls upload errors non-fatal in the CI.
-385. [co63oc](https://github.com/co63oc) fixed typos.
-386. [DmitriBogdanov](https://github.com/DmitriBogdanov) fixed broken package manager links in the documentation.
-387. [Bander](https://github.com/banderzhm) improved the MSVC compatibility of the C++ modules.
-388. [Andy Choi](https://github.com/ccpong) removed an unnecessary `template` keyword before `get` in the README and the documentation.
-389. [SamareshSingh](https://github.com/ssam18) fixed single-element brace initialization to copy/move instead of wrapping in an array, fixed the `WITH_DEFAULT` macros for `ordered_map`, and handled moved events in `serve_header.py`.
-390. [Aditya](https://github.com/Lumowhisp) improved the documentation of the documentation generation.
-391. [cheese1](https://github.com/cheese1) clarified the README.
-392. [KhloodElhossiny](https://github.com/khloodelhossiny) enabled `std::string_view` keys in `operator[]`.
-393. [Charles Cabergs](https://github.com/cacharle) fixed a `-Wtautological-constant-out-of-range-compare` warning.
-394. [EALePain](https://github.com/EALePain) made the `std::tuple` conversion work with reference types such as `std::tie`.
-395. [koala_oishi](https://github.com/chibi-dogs) fixed grammatical wording in the README.
-396. [riccardoori11](https://github.com/riccardoori11) fixed a typo in the documentation.
-397. [Swastik Bose](https://github.com/VasuBhakt) fixed the parent pointers after `update()` with `JSON_DIAGNOSTICS` and fixed the Doxygen autolinking of requirements.
-398. [trdesilva](https://github.com/trdesilva) added `front`, `pop_front`, and `push_front` to `json_pointer`.
-399. [Akhilesh Arora](https://github.com/akhilesharora) fixed an incomplete-type error with `ordered_json`.
-400. [Hariom Phulre](https://github.com/hariomphulre) fixed the C++20 modules compilation with GCC.
-401. [Kirill Lokotkov](https://github.com/RUSLoker) fixed printing `long double` values.
-402. [George Sedov](https://github.com/radistmorse) added the `NLOHMANN_DEFINE_TYPE_*_WITH_NAMES` macros.
-403. [Caillin Nugent](https://github.com/nugentcaillin) added the `NLOHMANN_JSON_SERIALIZE_ENUM_STRICT` macro.
-404. [Cosmin D.](https://github.com/drcosmin) fixed `std::filesystem::path` conversions and added an MSVC workaround for `std::unique_ptr`.
-405. [Paul Dreik](https://github.com/pauldreik) fixed a test relying on implementation-specific behavior.
-406. [Daniel Falk](https://github.com/daniel-falk) added missing copyright notices to the SBOM.
-407. [Federico Sfriso](https://github.com/federicosfriso05-dotcom) added support for constructing JSON values from C++20 range views.
-408. [Luke Banicevic](https://github.com/banaboi) fixed corrupt BSON output for lengths exceeding `INT32_MAX`, cleaned up the BSON writer, and improved the documentation.
-409. [Patrick Armstrong](https://github.com/Patrick10199) updated the CBOR references and the half-precision float assertions.
-410. [Yash Bavadiya](https://github.com/xevrion) added checks to all BSON reads.
-411. [hum4nBeing](https://github.com/hum4nBeing) fixed the overflow handling of high-precision numbers in UBJSON.
-412. [tomatotomata](https://github.com/tomatotomata) added checks for reading CBOR tagged subtypes.
-413. [YingqiDuan](https://github.com/YingqiDuan) documented the BSON interoperability.
-414. [KBS](https://github.com/youdie006) documented the standards compliance and the strictness of `parse()` and `operator>>`.
-415. [Petr Bělohlávek](https://github.com/petrbel) added Clang 21 and 22 to the CI.
-416. [Dmitry Rantovov](https://github.com/darkdi) fixed the placement of a CBOR documentation block.
-417. [ljcjclljc](https://github.com/ljcjclljc) fixed the comparison of large unsigned integers with signed integers.
-418. [Sahil Kamate](https://github.com/sahilkamate03) fixed the handling of CBOR tags 0-5 and 21-23.
-419. [Krishnanand G](https://github.com/Krishnanand-G) made the UBJSON writer reject `use_type` without `use_size`.
-420. [whn](https://github.com/Whning0513) documented the lenient BSON input handling and corrected the complexity of `to_bson`.
-421. [elix3r](https://github.com/22elix3r) fixed `update()` with `merge_objects` when merging a primitive into an object.
-422. [Avionic Harshit](https://github.com/avionicharshit-byte) made `diff()` linear when an array shrinks.
-423. [Qatadaha Bin Matloob](https://github.com/qatcod) fixed comparisons between integers and floats and fixed unparsable BJData output.
-424. [Wu Shuwen](https://github.com/dajiaohuang) removed an unused include.
+20. [dariomt](https://github.com/dariomt) fixed a subtlety in MSVC type support and implemented the `get_ref()` function to get a reference to stored values.
+21. [ZahlGraf](https://github.com/ZahlGraf) added a workaround that allows compilation using Android NDK.
+22. [whackashoe](https://github.com/whackashoe) replaced a function that was marked as unsafe by Visual Studio.
+23. [406345](https://github.com/406345) fixed two small warnings.
+24. [Glen Fernandes](https://github.com/glenfe) noted a potential portability problem in the `has_mapped_type` function.
+25. [Corbin Hughes](https://github.com/nibroc) fixed some typos in the contribution guidelines.
+26. [twelsby](https://github.com/twelsby) fixed the array subscript operator, an issue that failed the MSVC build, and floating-point parsing/dumping. He further added support for unsigned integer numbers and implemented better roundtrip support for parsed numbers.
+27. [Volker Diels-Grabsch](https://github.com/vog) fixed a link in the README file.
+28. [msm-](https://github.com/msm-) added support for American Fuzzy Lop.
+29. [Annihil](https://github.com/Annihil) fixed an example in the README file.
+30. [Themercee](https://github.com/Themercee) noted a wrong URL in the README file.
+31. [Lv Zheng](https://github.com/lv-zheng) fixed a namespace issue with `int64_t` and `uint64_t`.
+32. [abc100m](https://github.com/abc100m) analyzed the issues with GCC 4.8 and proposed a [partial solution](https://github.com/nlohmann/json/pull/212).
+33. [zewt](https://github.com/zewt) added useful notes to the README file about Android.
+34. [Róbert Márki](https://github.com/robertmrk) added a fix to use move iterators and improved the integration via CMake.
+35. [Chris Kitching](https://github.com/ChrisKitching) cleaned up the CMake files.
+36. [Tom Needham](https://github.com/06needhamt) fixed a subtle bug with MSVC 2015 which was also proposed by [Michael K.](https://github.com/Epidal).
+37. [Mário Feroldi](https://github.com/thelostt) fixed a small typo.
+38. [duncanwerner](https://github.com/duncanwerner) found a really embarrassing performance regression in the 2.0.0 release.
+39. [Damien](https://github.com/dtoma) fixed one of the last conversion warnings.
+40. [Thomas Braun](https://github.com/t-b) fixed a warning in a test case and adjusted MSVC calls in the CI.
+41. [Théo DELRIEU](https://github.com/theodelrieu) patiently and constructively oversaw the long way toward [iterator-range parsing](https://github.com/nlohmann/json/issues/290). He also implemented the magic behind the serialization/deserialization of user-defined types and split the single header file into smaller chunks.
+42. [Stefan](https://github.com/5tefan) fixed a minor issue in the documentation.
+43. [Vasil Dimov](https://github.com/vasild) fixed the documentation regarding conversions from `std::multiset`.
+44. [ChristophJud](https://github.com/ChristophJud) overworked the CMake files to ease project inclusion.
+45. [Vladimir Petrigo](https://github.com/vpetrigo) made a SFINAE hack more readable and added Visual Studio 17 to the build matrix.
+46. [Denis Andrejew](https://github.com/seeekr) fixed a grammar issue in the README file.
+47. [Pierre-Antoine Lacaze](https://github.com/palacaze) found a subtle bug in the `dump()` function.
+48. [TurpentineDistillery](https://github.com/TurpentineDistillery) pointed to [`std::locale::classic()`](https://en.cppreference.com/w/cpp/locale/locale/classic) to avoid too much locale joggling, found some nice performance improvements in the parser, improved the benchmarking code, and realized locale-independent number parsing and printing.
+49. [cgzones](https://github.com/cgzones) had an idea how to fix the Coverity scan.
+50. [Jared Grubb](https://github.com/jaredgrubb) silenced a nasty documentation warning.
+51. [Yixin Zhang](https://github.com/qwename) fixed an integer overflow check.
+52. [Bosswestfalen](https://github.com/Bosswestfalen) merged two iterator classes into a smaller one.
+53. [Daniel599](https://github.com/Daniel599) helped to get Travis to execute the tests with Clang's sanitizers.
+54. [Jonathan Lee](https://github.com/vjon) fixed an example in the README file.
+55. [gnzlbg](https://github.com/gnzlbg) supported the implementation of user-defined types.
+56. [Alexej Harm](https://github.com/qis) helped to get the user-defined types working with Visual Studio.
+57. [Jared Grubb](https://github.com/jaredgrubb) supported the implementation of user-defined types.
+58. [EnricoBilla](https://github.com/EnricoBilla) noted a typo in an example.
+59. [Martin Hořeňovský](https://github.com/horenmar) found a way for a 2x speedup for the compilation time of the test suite.
+60. [ukhegg](https://github.com/ukhegg) proposed an improvement for the examples section.
+61. [rswanson-ihi](https://github.com/rswanson-ihi) noted a typo in the README.
+62. [Mihai Stan](https://github.com/stanmihai4) fixed a bug in the comparison with `nullptr`s.
+63. [Tushar Maheshwari](https://github.com/tusharpm) added [cotire](https://github.com/sakra/cotire) support to speed up the compilation.
+64. [TedLyngmo](https://github.com/TedLyngmo) noted a typo in the README, removed unnecessary bit arithmetic, and fixed some `-Weffc++` warnings.
+65. [Krzysztof Woś](https://github.com/krzysztofwos) made exceptions more visible.
+66. [ftillier](https://github.com/ftillier) fixed a compiler warning.
+67. [tinloaf](https://github.com/tinloaf) made sure all pushed warnings are properly popped.
+68. [Fytch](https://github.com/Fytch) found a bug in the documentation.
+69. [Jay Sistar](https://github.com/Type1J) implemented a Meson build description.
+70. [Henry Lee](https://github.com/HenryRLee) fixed a warning in ICC and improved the iterator implementation.
+71. [Vincent Thiery](https://github.com/vthiery) maintains a package for the Conan package manager.
+72. [Steffen](https://github.com/koemeet) fixed a potential issue with MSVC and `std::min`.
+73. [Mike Tzou](https://github.com/Chocobo1) fixed some typos.
+74. [amrcode](https://github.com/amrcode) noted misleading documentation about comparison of floats.
+75. [Oleg Endo](https://github.com/olegendo) reduced the memory consumption by replacing `<iostream>` with `<iosfwd>`.
+76. [dan-42](https://github.com/dan-42) cleaned up the CMake files to simplify including/reusing of the library.
+77. [Nikita Ofitserov](https://github.com/himikof) allowed for moving values from initializer lists.
+78. [Greg Hurrell](https://github.com/wincent) fixed a typo.
+79. [Dmitry Kukovinets](https://github.com/DmitryKuk) fixed a typo.
+80. [kbthomp1](https://github.com/kbthomp1) fixed an issue related to the Intel OSX compiler.
+81. [Markus Werle](https://github.com/daixtrose) fixed a typo.
+82. [WebProdPP](https://github.com/WebProdPP) fixed a subtle error in a precondition check.
+83. [Alex](https://github.com/leha-bot) noted an error in a code sample.
+84. [Tom de Geus](https://github.com/tdegeus) reported some warnings with ICC and helped to fix them.
+85. [Perry Kundert](https://github.com/pjkundert) simplified reading from input streams.
+86. [Sonu Lohani](https://github.com/sonulohani) fixed a small compilation error.
+87. [Jamie Seward](https://github.com/jseward) fixed all MSVC warnings.
+88. [Nate Vargas](https://github.com/eld00d) added a Doxygen tag file.
+89. [pvleuven](https://github.com/pvleuven) helped to fix a warning in ICC.
+90. [Pavel](https://github.com/crea7or) helped to fix some warnings in MSVC.
+91. [Jamie Seward](https://github.com/jseward) avoided unnecessary string copies in `find()` and `count()`.
+92. [Mitja](https://github.com/Itja) fixed some typos.
+93. [Jorrit Wronski](https://github.com/jowr) updated the Hunter package links.
+94. [Matthias Möller](https://github.com/TinyTinni) added a `.natvis` for the MSVC debug view.
+95. [bogemic](https://github.com/bogemic) fixed some C++17 deprecation warnings.
+96. [Eren Okka](https://github.com/erengy) fixed some MSVC warnings.
+97. [abolz](https://github.com/abolz) integrated the Grisu2 algorithm for proper floating-point formatting, allowing more roundtrip checks to succeed.
+98. [Vadim Evard](https://github.com/Pipeliner) fixed a Markdown issue in the README.
+99. [zerodefect](https://github.com/zerodefect) fixed a compiler warning.
+100. [Kert](https://github.com/kaidokert) allowed to template the string type in the serialization and added the possibility to override the exceptional behavior.
+101. [mark-99](https://github.com/mark-99) helped fix an ICC error.
+102. [Patrik Huber](https://github.com/patrikhuber) fixed links in the README file.
+103. [johnfb](https://github.com/johnfb) found a bug in the implementation of CBOR's indefinite length strings.
+104. [Paul Fultz II](https://github.com/pfultz2) added a note on the cget package manager.
+105. [Wilson Lin](https://github.com/wla80) made the integration section of the README more concise.
+106. [RalfBielig](https://github.com/ralfbielig) detected and fixed a memory leak in the parser callback.
+107. [agrianius](https://github.com/agrianius) allowed dumping JSON to an alternative string type.
+108. [Kevin Tonon](https://github.com/ktonon) overworked the C++11 compiler checks in CMake.
+109. [Axel Huebl](https://github.com/ax3l) simplified a CMake check and added support for the [Spack package manager](https://spack.io).
+110. [Carlos O'Ryan](https://github.com/coryan) fixed a typo.
+111. [James Upjohn](https://github.com/jupjohn) fixed a version number in the compilers section.
+112. [Chuck Atkins](https://github.com/chuckatkins) adjusted the CMake files to the CMake packaging guidelines and provided documentation for the CMake integration.
+113. [Jan Schöppach](https://github.com/dns13) fixed a typo.
+114. [martin-mfg](https://github.com/martin-mfg) fixed a typo.
+115. [Matthias Möller](https://github.com/TinyTinni) removed the dependency from `std::stringstream`.
+116. [agrianius](https://github.com/agrianius) added code to use alternative string implementations.
+117. [Daniel599](https://github.com/Daniel599) allowed to use more algorithms with the `items()` function.
+118. [Julius Rakow](https://github.com/juliusrakow) fixed the Meson include directory and fixed the links to [cppreference.com](https://cppreference.com).
+119. [Sonu Lohani](https://github.com/sonulohani) fixed the compilation with MSVC 2015 in debug mode.
+120. [grembo](https://github.com/grembo) fixed the test suite and re-enabled several test cases.
+121. [Hyeon Kim](https://github.com/simnalamburt) introduced the macro `JSON_INTERNAL_CATCH` to control the exception handling inside the library.
+122. [thyu](https://github.com/thyu) fixed a compiler warning.
+123. [David Guthrie](https://github.com/LEgregius) fixed a subtle compilation error with Clang 3.4.2.
+124. [Dennis Fischer](https://github.com/dennisfischer) allowed to call `find_package` without installing the library.
+125. [Hyeon Kim](https://github.com/simnalamburt) fixed an issue with a double macro definition.
+126. [Ben Berman](https://github.com/rivertam) made some error messages more understandable.
+127. [zakalibit](https://github.com/zakalibit) fixed a compilation problem with the Intel C++ compiler.
+128. [mandreyel](https://github.com/mandreyel) fixed a compilation problem.
+129. [Kostiantyn Ponomarenko](https://github.com/koponomarenko) added version and license information to the Meson build file.
+130. [Henry Schreiner](https://github.com/henryiii) added support for GCC 4.8.
+131. [knilch](https://github.com/knilch0r) made sure the test suite does not stall when run in the wrong directory.
+132. [Antonio Borondo](https://github.com/antonioborondo) fixed an MSVC 2017 warning.
+133. [Dan Gendreau](https://github.com/dgendreau) implemented the `NLOHMANN_JSON_SERIALIZE_ENUM` macro to quickly define an enum/JSON mapping.
+134. [efp](https://github.com/efp) added line and column information to parse errors.
+135. [julian-becker](https://github.com/julian-becker) added BSON support.
+136. [Pratik Chowdhury](https://github.com/pratikpc) added support for structured bindings.
+137. [David Avedissian](https://github.com/davedissian) added support for Clang 5.0.1 (PS4 version).
+138. [Jonathan Dumaresq](https://github.com/dumarjo) implemented an input adapter to read from `FILE*`.
+139. [kjpus](https://github.com/kjpus) fixed a link in the documentation.
+140. [Manvendra Singh](https://github.com/manu-chroma) fixed a typo in the documentation.
+141. [ziggurat29](https://github.com/ziggurat29) fixed an MSVC warning.
+142. [Sylvain Corlay](https://github.com/SylvainCorlay) added code to avoid an issue with MSVC.
+143. [mefyl](https://github.com/mefyl) fixed a bug when JSON was parsed from an input stream.
+144. [Millian Poquet](https://github.com/mpoquet) allowed to install the library via Meson.
+145. [Michael Behrns-Miller](https://github.com/moodboom) found an issue with a missing namespace.
+146. [Nasztanovics Ferenc](https://github.com/naszta) fixed a compilation issue with libc 2.12.
+147. [Andreas Schwab](https://github.com/andreas-schwab) fixed the endian conversion.
+148. [Mark-Dunning](https://github.com/Mark-Dunning) fixed a warning in MSVC.
+149. [Gareth Sylvester-Bradley](https://github.com/garethsb-sony) added `operator/` for JSON Pointers.
+150. [John-Mark](https://github.com/johnmarkwayve) noted a missing header.
+151. [Vitaly Zaitsev](https://github.com/xvitaly) fixed compilation with GCC 9.0.
+152. [Laurent Stacul](https://github.com/stac47) fixed compilation with GCC 9.0.
+153. [Ivor Wanders](https://github.com/iwanders) helped to reduce the CMake requirement to version 3.1.
+154. [njlr](https://github.com/njlr) updated the Buckaroo instructions.
+155. [Lion](https://github.com/lieff) fixed a compilation issue with GCC 7 on CentOS.
+156. [Isaac Nickaein](https://github.com/nickaein) improved the integer serialization performance and implemented the `contains()` function.
+157. [past-due](https://github.com/past-due) suppressed an unfixable warning.
+158. [Elvis Oric](https://github.com/elvisoric) improved Meson support.
+159. [Matěj Plch](https://github.com/Afforix) fixed an example in the README.
+160. [Mark Beckwith](https://github.com/wythe) fixed a typo.
+161. [scinart](https://github.com/scinart) fixed a bug in the serializer.
+162. [Patrick Boettcher](https://github.com/pboettch) implemented `push_back()` and `pop_back()` for JSON Pointers.
+163. [Bruno Oliveira](https://github.com/nicoddemus) added support for Conda.
+164. [Michele Caini](https://github.com/skypjack) fixed links in the README.
+165. [Hani](https://github.com/hnkb) documented how to install the library with NuGet.
+166. [Mark Beckwith](https://github.com/wythe) fixed a typo.
+167. [yann-morin-1998](https://github.com/yann-morin-1998) helped to reduce the CMake requirement to version 3.1.
+168. [Konstantin Podsvirov](https://github.com/podsvirov) maintains a package for the MSYS2 software distro.
+169. [remyabel](https://github.com/remyabel2) added GNUInstallDirs to the CMake files.
+170. [Taylor Howard](https://github.com/taylorhoward92) fixed a unit test.
+171. [Gabe Ron](https://github.com/Macr0Nerd) implemented the `to_string` method.
+172. [Watal M. Iwasaki](https://github.com/heavywatal) fixed a Clang warning.
+173. [Viktor Kirilov](https://github.com/onqtam) switched the unit tests from [Catch](https://github.com/philsquared/Catch) to [doctest](https://github.com/onqtam/doctest)
+174. [Juncheng E](https://github.com/ejcjason) fixed a typo.
+175. [tete17](https://github.com/tete17) fixed a bug in the `contains` function.
+176. [Xav83](https://github.com/Xav83) fixed some cppcheck warnings.
+177. [0xflotus](https://github.com/0xflotus) fixed some typos.
+178. [Christian Deneke](https://github.com/chris0x44) added a const version of `json_pointer::back`.
+179. [Julien Hamaide](https://github.com/crazyjul) made the `items()` function work with custom string types.
+180. [Evan Nemerson](https://github.com/nemequ) updated fixed a bug in Hedley and updated this library accordingly.
+181. [Florian Pigorsch](https://github.com/flopp) fixed a lot of typos.
+182. [Camille Bégué](https://github.com/cbegue) fixed an issue in the conversion from  `std::pair` and `std::tuple` to `json`.
+183. [Anthony VH](https://github.com/AnthonyVH) fixed a compile error in an enum deserialization.
+184. [Yuriy Vountesmery](https://github.com/ua-code-dragon) noted a subtle bug in a preprocessor check.
+185. [Chen](https://github.com/dota17) fixed numerous issues in the library.
+186. [Antony Kellermann](https://github.com/aokellermann) added a CI step for GCC 10.1.
+187. [Alex](https://github.com/gistrec) fixed an MSVC warning.
+188. [Rainer](https://github.com/rvjr) proposed an improvement in the floating-point serialization in CBOR.
+189. [Francois Chabot](https://github.com/FrancoisChabot) made performance improvements in the input adapters.
+190. [Arthur Sonzogni](https://github.com/ArthurSonzogni) documented how the library can be included via `FetchContent`.
+191. [Rimas Misevičius](https://github.com/rmisev) fixed an error message.
+192. [Alexander Myasnikov](https://github.com/alexandermyasnikov) fixed some examples and a link in the README.
+193. [Hubert Chathi](https://github.com/uhoreg) made CMake's version config file architecture-independent.
+194. [OmnipotentEntity](https://github.com/OmnipotentEntity) implemented the binary values for CBOR, MessagePack, BSON, and UBJSON.
+195. [ArtemSarmini](https://github.com/ArtemSarmini) fixed a compilation issue with GCC 10 and fixed a leak.
+196. [Evgenii Sopov](https://github.com/sea5kg) integrated the library to the wsjcpp package manager.
+197. [Sergey Linev](https://github.com/linev) fixed a compiler warning.
+198. [Miguel Magalhães](https://github.com/magamig) fixed the year in the copyright.
+199. [Gareth Sylvester-Bradley](https://github.com/garethsb-sony) fixed a compilation issue with MSVC.
+200. [Alexander “weej” Jones](https://github.com/alex-weej) fixed an example in the README.
+201. [Antoine Cœur](https://github.com/Coeur) fixed some typos in the documentation.
+202. [jothepro](https://github.com/jothepro) updated links to the Hunter package.
+203. [Dave Lee](https://github.com/kastiglione) fixed a link in the README.
+204. [Joël Lamotte](https://github.com/Klaim) added instruction for using Build2's package manager.
+205. [Paul Jurczak](https://github.com/pauljurczak) fixed an example in the README.
+206. [Sonu Lohani](https://github.com/sonulohani) fixed a warning.
+207. [Carlos Gomes Martinho](https://github.com/gocarlos) updated the Conan package source.
+208. [Konstantin Podsvirov](https://github.com/podsvirov) fixed the MSYS2 package documentation.
+209. [Tridacnid](https://github.com/Tridacnid) improved the CMake tests.
+210. [Michael](https://github.com/MBalszun) fixed MSVC warnings.
+211. [Quentin Barbarat](https://github.com/quentin-dev) fixed an example in the documentation.
+212. [XyFreak](https://github.com/XyFreak) fixed a compiler warning.
+213. [TotalCaesar659](https://github.com/TotalCaesar659) fixed links in the README.
+214. [Tanuj Garg](https://github.com/tanuj208) improved the fuzzer coverage for UBSAN input.
+215. [AODQ](https://github.com/AODQ) fixed a compiler warning.
+216. [jwittbrodt](https://github.com/jwittbrodt) made `NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE` inline.
+217. [pfeatherstone](https://github.com/pfeatherstone) improved the upper bound of arguments of the `NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE`/`NLOHMANN_DEFINE_TYPE_INTRUSIVE` macros.
+218. [Jan Procházka](https://github.com/jprochazk) fixed a bug in the CBOR parser for binary and string values.
+219. [T0b1-iOS](https://github.com/T0b1-iOS) fixed a bug in the new hash implementation.
+220. [Matthew Bauer](https://github.com/matthewbauer) adjusted the CBOR writer to create tags for binary subtypes.
+221. [gatopeich](https://github.com/gatopeich) implemented an ordered map container for `nlohmann::ordered_json`.
+222. [Érico Nogueira Rolim](https://github.com/ericonr) added support for pkg-config.
+223. [KonanM](https://github.com/KonanM) proposed an implementation for the `NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE`/`NLOHMANN_DEFINE_TYPE_INTRUSIVE` macros.
+224. [Guillaume Racicot](https://github.com/gracicot) implemented `string_view` support and allowed C++20 support.
+225. [Alex Reinking](https://github.com/alexreinking) improved CMake support for `FetchContent`.
+226. [Hannes Domani](https://github.com/ssbssa) provided a GDB pretty printer.
+227. Lars Wirzenius reviewed the README file.
+228. [Jun Jie](https://github.com/ongjunjie) fixed a compiler path in the CMake scripts.
+229. [Ronak Buch](https://github.com/rbuch) fixed typos in the documentation.
+230. [Alexander Karzhenkov](https://github.com/karzhenkov) fixed a move constructor and the Travis builds.
+231. [Leonardo Lima](https://github.com/leozz37) added CPM.Cmake support.
+232. [Joseph Blackman](https://github.com/jbzdarkid) fixed a warning.
+233. [Yaroslav](https://github.com/YarikTH) updated doctest and implemented unit tests.
+234. [Martin Stump](https://github.com/globberwops) fixed a bug in the CMake files.
+235. [Jaakko Moisio](https://github.com/jasujm) fixed a bug in the input adapters.
+236. [bl-ue](https://github.com/bl-ue) fixed some Markdown issues in the README file.
+237. [William A. Wieselquist](https://github.com/wawiesel) fixed an example from the README.
+238. [abbaswasim](https://github.com/abbaswasim) fixed an example from the README.
+239. [Remy Jette](https://github.com/remyjette) fixed a warning.
+240. [Fraser](https://github.com/frasermarlow) fixed the documentation.
+241. [Ben Beasley](https://github.com/musicinmybrain) updated doctest.
+242. [Doron Behar](https://github.com/doronbehar) fixed pkg-config.pc.
+243. [raduteo](https://github.com/raduteo) fixed a warning.
+244. [David Pfahler](https://github.com/theShmoo) added the possibility to compile the library without I/O support.
+245. [Morten Fyhn Amundsen](https://github.com/mortenfyhn) fixed a typo.
+246. [jpl-mac](https://github.com/jpl-mac) allowed treating the library as a system header in CMake.
+247. [Jason Dsouza](https://github.com/jasmcaus) fixed the indentation of the CMake file.
+248. [offa](https://github.com/offa) added a link to Conan Center to the documentation.
+249. [TotalCaesar659](https://github.com/TotalCaesar659) updated the links in the documentation to use HTTPS.
+250. [Rafail Giavrimis](https://github.com/grafail) fixed the Google Benchmark default branch.
+251. [Louis Dionne](https://github.com/ldionne) fixed a conversion operator.
+252. [justanotheranonymoususer](https://github.com/justanotheranonymoususer) made the examples in the README more consistent.
+253. [Finkman](https://github.com/Finkman) suppressed some `-Wfloat-equal` warnings.
+254. [Ferry Huberts](https://github.com/fhuberts) fixed `-Wswitch-enum` warnings.
+255. [Arseniy Terekhin](https://github.com/senyai) made the GDB pretty-printer robust against unset variable names.
+256. [Amir Masoud Abdol](https://github.com/amirmasoudabdol) updated the Homebrew command as nlohmann/json is now in homebrew-core.
+257. [Hallot](https://github.com/Hallot) fixed some `-Wextra-semi-stmt warnings`.
+258. [Giovanni Cerretani](https://github.com/gcerretani) fixed `-Wunused` warnings on `JSON_DIAGNOSTICS`.
+259. [Bogdan Popescu](https://github.com/Kapeli) hosts the [docset](https://github.com/Kapeli/Dash-User-Contributions/tree/master/docsets/JSON_for_Modern_C%2B%2B) for offline documentation viewers.
+260. [Carl Smedstad](https://github.com/carlsmedstad) fixed an assertion error when using `JSON_DIAGNOSTICS`.
+261. [miikka75](https://github.com/miikka75) provided an important fix to compile C++17 code with Clang 9.
+262. [Maarten Becker](https://github.com/kernie) fixed a warning for shadowed variables.
+263. [Cristi Vîjdea](https://github.com/axnsan12) fixed typos in the `operator[]` documentation.
+264. [Alex Beregszaszi](https://github.com/axic) fixed spelling mistakes in comments.
+265. [Dirk Stolle](https://github.com/striezel) fixed typos in documentation.
+266. [Daniel Albuschat](https://github.com/daniel-kun) corrected the parameter name in the `parse` documentation.
+267. [Prince Mendiratta](https://github.com/Prince-Mendiratta) fixed a link to the FAQ.
+268. [Florian Albrechtskirchinger](https://github.com/falbrechtskirchinger) implemented `std::string_view` support for object keys and made dozens of other improvements.
+269. [Qianqian Fang](https://github.com/fangq) implemented the Binary JData (BJData) format.
+270. [pketelsen](https://github.com/pketelsen) added macros `NLOHMANN_DEFINE_TYPE_INTRUSIVE_WITH_DEFAULT` and `NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE_WITH_DEFAULT`.
+271. [DarkZeros](https://github.com/DarkZeros) adjusted to code to not clash with Arduino defines.
+272. [flagarde](https://github.com/flagarde) fixed the output of `meta()` for MSVC.
+273. [Giovanni Cerretani](https://github.com/gcerretani) fixed a check for `std::filesystem`.
+274. [Dimitris Apostolou](https://github.com/rex4539) fixed a typo.
+275. [Ferry Huberts](https://github.com/fhuberts) fixed a typo.
+276. [Michael Nosthoff](https://github.com/heinemml) fixed a typo.
+277. [JungHoon Lee](https://github.com/jhnlee) fixed a typo.
+278. [Faruk D.](https://github.com/fdiblen) fixed the CITATION.CFF file.
+279. [Andrea Cocito](https://github.com/puffetto) added a clarification on macro usage to the documentation.
+280. [Krzysiek Karbowiak](https://github.com/kkarbowiak) refactored the tests to use `CHECK_THROWS_WITH_AS`.
+281. [Chaoqi Zhang](https://github.com/prncoprs) fixed a typo.
+282. [ivanovmp](https://github.com/ivanovmp) fixed a whitespace error.
+283. [KsaNL](https://github.com/KsaNL) fixed a build error when including `<windows.h>`.
+284. [Andrea Pappacoda](https://github.com/Tachi107) moved `.pc` and `.cmake` files to `share` directory.
+285. [Wolf Vollprecht](https://github.com/wolfv) added the `patch_inplace` function.
+286. [Jake Zimmerman](https://github.com/jez) highlighted common usage patterns in the README file.
+287. [NN](https://github.com/NN---) added the Visual Studio output directory to `.gitignore`.
+288. [Romain Reignier](https://github.com/romainreignier) improved the performance of the vector output adapter.
+289. [Mike](https://github.com/Mike-Leo-Smith) fixed the `std::iterator_traits`.
+290. [Richard Hozák](https://github.com/richardhozak) added macro `JSON_NO_ENUM` to disable default enum conversions.
+291. [vakokako](https://github.com/vakokako) fixed tests when compiling with C++20.
+292. [Alexander “weej” Jones](https://github.com/alexweej) fixed an example in the README.
+293. [Eli Schwartz](https://github.com/eli-schwartz) added more files to the `include.zip` archive.
+294. [Kevin Lu](https://github.com/kevinlul) fixed a compilation issue when typedefs with certain names were present.
+295. [Trevor Hickey](https://github.com/luxe) improved the description of an example.
+296. [Jef LeCompte](https://github.com/jef) updated the year in the README file.
+297. [Alexandre Hamez](https://github.com/ahamez) fixed a warning.
+298. [Maninderpal Badhan](https://github.com/mbadhan) fixed a typo.
+299. [kevin--](https://github.com/kevin--) added a note to an example in the README file.
+300. [I](https://github.com/wx257osn2) fixed a typo.
+301. [Gregorio Litenstein](https://github.com/Lord-Kamina) fixed the Clang detection.
+302. [Andreas Smas](https://github.com/andoma) added a Doozer badge.
+303. [WanCW](https://github.com/wancw) fixed the string conversion with Clang.
+304. [zhaohuaxishi](https://github.com/zhaohuaxishi) fixed a Doxygen error.
+305. [emvivre](https://github.com/emvivre) removed an invalid parameter from CMake.
+306. [Tobias Hermann](https://github.com/Dobiasd) fixed a link in the README file.
+307. [Michael](https://github.com/traits) fixed a warning.
+308. [Ryan Mulder](https://github.com/ryanjmulder) added `ensure_ascii` to the `dump` function.
+309. [Muri Nicanor](https://github.com/murinicanor) fixed the `sed` discovery in the Makefile.
+310. [David Avedissian](https://github.com/dgavedissian) implemented SFINAE-friendly `iterator_traits`.
+311. [AQNOUCH Mohammed](https://github.com/aqnouch) fixed a typo in the README.
+312. [Gareth Sylvester-Bradley](https://github.com/garethsb) added `operator/=` and `operator/` to construct JSON pointers.
+313. [Michael Macnair](https://github.com/mykter) added support for afl-fuzz testing.
+314. [Berkus Decker](https://github.com/berkus) fixed a typo in the README.
+315. [Illia Polishchuk](https://github.com/ilqvya) improved the CMake testing.
+316. [Ikko Ashimine](https://github.com/eltociear) fixed a typo.
+317. [Raphael Grimm](https://github.com/barcode) added the possibility to define a custom base class.
+318. [tocic](https://github.com/tocic) fixed typos in the documentation.
+319. [Vertexwahn](https://github.com/Vertexwahn) added Bazel build support.
+320. [Dirk Stolle](https://github.com/striezel) fixed typos in the documentation.
+321. [DavidKorczynski](https://github.com/DavidKorczynski) added a CIFuzz CI GitHub action.
+322. [Finkman](https://github.com/Finkman) fixed the debug pretty-printer.
+323. [Florian Segginger](https://github.com/floriansegginger) bumped the years in the README.
+324. [haadfida](https://github.com/haadfida) cleaned up the badges of used services.
+325. [Arsen Arsenović](https://github.com/ArsenArsen) fixed a build error.
+326. [theevilone45](https://github.com/theevilone45) fixed a typo in a CMake file.
+327. [Sergei Trofimovich](https://github.com/trofi) fixed the custom allocator support.
+328. [Joyce](https://github.com/joycebrum) fixed some security issues in the GitHub workflows.
+329. [Nicolas Jakob](https://github.com/njakob) add vcpkg version badge.
+330. [Tomerkm](https://github.com/Tomerkm) added tests.
+331. [No.](https://github.com/tusooa) fixed the use of `get<>` calls.
+332. [taro](https://github.com/tarolling) fixed a typo in the `CODEOWNERS` file.
+333. [Ikko Eltociear Ashimine](https://github.com/eltociear) fixed a typo.
+334. [Felix Yan](https://github.com/felixonmars) fixed a typo in the README.
+335. [HO-COOH](https://github.com/HO-COOH) fixed a parenthesis in the documentation.
+336. [Ivor Wanders](https://github.com/iwanders) fixed the examples to catch exception by `const&`.
+337. [miny1233](https://github.com/miny1233) fixed a parenthesis in the documentation.
+338. [tomalakgeretkal](https://github.com/tomalakgeretkal) fixed a compilation error.
+339. [alferov](https://github.com/ALF-ONE) fixed a compilation error.
+340. [Craig Scott](https://github.com/craigscott-crascit) fixed a deprecation warning in CMake.
+341. [Vyacheslav Zhdanovskiy](https://github.com/ZeronSix) added macros for serialization-only types.
+342. [Mathieu Westphal](https://github.com/mwestphal) fixed typos.
+343. [scribam](https://github.com/scribam) fixed the MinGW workflow.
+344. [Aleksei Sapitskii](https://github.com/aleksproger) added support for Apple's Swift Package Manager.
+345. [Benjamin Buch](https://github.com/bebuch) fixed the installation path in CMake.
+346. [Colby Haskell](https://github.com/colbychaskell) clarified the parse error message in case a file cannot be opened.
+347. [Juan Carlos Arevalo Baeza](https://github.com/TheJCAB) fixed the enum conversion.
+348. [alferov](https://github.com/ALF-ONE) fixed a version in the documentation.
+349. [ss](https://github.com/serge-s) fixed the amalgamation call.
+350. [AniketDhemare](https://github.com/AniketDhemare) fixed a version in the documentation.
+351. [Philip Müller](https://github.com/philip-paul-mueller) fixed an example.
+352. [Leila Shcheglova](https://github.com/LeilaShcheglova) fixed a warning in a test.
+353. [Alex Prabhat Bara](https://github.com/alexprabhat99) fixed a function name in the documentation.
+354. [laterlaugh](https://github.com/laterlaugh) fixed some typos.
+355. [Yuanhao Jia](https://github.com/MrJia1997) fixed the GDB pretty printer.
+356. [Fallen_Breath](https://github.com/Fallen-Breath) fixed an example for JSON Pointer.
+357. [Nikhil Idiculla](https://github.com/tsnl) fixed some typos.
+358. [Griffin Myers](https://github.com/gmyers18) updated the Natvis file.
+359. [thetimr](https://github.com/thetimr) fixed a typo in the documentation.
+360. [Balazs Erseki](https://github.com/zerocukor287) fixed a URL in the contribution guidelines.
+361. [Niccolò Iardella](https://github.com/rotolof) added `NLOHMANN_DEFINE_DERIVED_TYPE_*` macros.
+362. [Borislav Stanimirov](https://github.com/iboB) allowed overriding the CMake target name.
+363. [Captain Crutches](https://github.com/captaincrutches) made `iterator_proxy_value` a `std::forward_iterator`.
+364. [Fredrik Sandhei](https://github.com/fsandhei) added type conversion support for `std::optional`.
+365. [jh96](https://github.com/jordan-hoang) added exceptions when `nullptr` is passed to `parse`.
+366. [Stuart Gorman](https://github.com/StuartGorman) fixed number parsing when `EINTR` set in `errno`.
+367. [Dylan Baker](https://github.com/dcbaker) generated a pkg-config file that follows the pkg-config conventions.
+368. [Tianyi Chen](https://github.com/TianyiChen) optimized the binary `get_number` implementation.
+369. [peng-wang-cn](https://github.com/peng-wang-cn) added type conversion support for multidimensional arrays.
+370. [Einars Netlis-Galejs](https://github.com/EinarsNG) added `ONLY_SERIALIZE` for `NLOHMANN_DEFINE_DERIVED_TYPE_*` macros.
+371. [Marcel](https://github.com/mering) removed `alwayslink=True` Bazel flag.
+372. [Harinath Nampally](https://github.com/hnampally) added diagnostic positions to exceptions.
+373. [Nissim Armand Ben Danan](https://github.com/NissimBendanan) fixed `NLOHMANN_DEFINE_TYPE_INTRUSIVE_WITH_DEFAULT` with an empty JSON instance.
+374. [Michael Valladolid](https://github.com/codenut) added support for BSON uint64 serialization/deserialization.
+375. [Nikhil](https://github.com/nikhilreddydev) updated the documentation.
+376. [Nebojša Cvetković](https://github.com/nebkat) added support for BJDATA optimized binary array type.
+377. [Sushrut Shringarputale](https://github.com/sushshring) added support for diagnostic positions. 
+378. [kimci86](https://github.com/kimci86) templated to `NLOHMANN_DEFINE_TYPE` macros to also support `ordered_json`.
+379. [Richard Topchii](https://github.com/richardtop) added support for VisionOS in the Swift Package Manager.
+380. [Robert Chisholm](https://github.com/Robadob) fixed a typo.
+381. [zjyhjqs](https://github.com/zjyhjqs) added CPack support.
+382. [bitFiedler](https://github.com/bitFiedler) made GDB pretty printer work with Python 3.8.
+383. [Gianfranco Costamagna](https://github.com/LocutusOfBorg) fixed a compiler warning.
+384. [risa2000](https://github.com/risa2000) made `std::filesystem::path` conversion to/from UTF-8 encoded string explicit.
+385. [AM](https://github.com/maqnouch) fixed typos in the README.
+386. [dmenendez-gruposantander](https://github.com/dmenendez-gruposantander) fixed typos in the comments of the examples.
+387. [Mihai Stan](https://github.com/mstan-xx) fixed comparisons against the literal `0`.
+388. [Matt Gumbel](https://github.com/intelmatt) fixed some `-Weffc++` warnings.
+389. [vimpunk](https://github.com/vimpunk) moved a lambda out of an unevaluated context to support older compilers.
+390. [Chris Harris](https://github.com/cjh1) fixed the compilation with GCC 4.8.
+391. [Palmer Dabbelt](https://github.com/palmer-dabbelt) generated and installed a pkg-config file.
+392. [Gus Pozuelo](https://github.com/ap-viavi) made `ordered_map` compatible with GCC 5.5, Clang 3.6, and Xcode 9.
+393. [AK](https://github.com/Lioncky) fixed an MSVC build error caused by the `min`/`max` macros from `windows.h`.
+394. [Sergiu Deitsch](https://github.com/sergiud) provided a fallback for missing `char8_t` support.
+395. [Xiaochuan Ye](https://github.com/XueSongTap) fixed `from_msgpack` for `std::byte` input by specializing `std::char_traits`.
+396. [Ville Vesilehto](https://github.com/thevilledev) fixed an overflow in the BJData size calculation and rejected overflowing negative integers in CBOR.
+397. [NmPassTHFan](https://github.com/nmpassthf) replaced the deprecated `std::is_trivial` for C++26.
+398. [Chris Ever](https://github.com/chirsz-ever) added the `ignore_trailing_commas` parser option.
+399. [Kuan-Fu Wu](https://github.com/kfwu1999) fixed the example code for `json_pointer` initialization.
+400. [David Kilzer](https://github.com/ddkilzer) added a missing header to the input adapters.
+401. [Miko](https://github.com/mikomikotaishi) added proper C++20 module support, simplified the module API, and fixed missing exports.
+402. [hitgirl](https://github.com/hitgil) fixed the CMake configuration when cross-compiling.
+403. [Devon Thomas](https://github.com/ThomaDevOSU) mentioned the Artistic Style formatting in the contribution guidelines.
+404. [Erik Hu](https://github.com/Erikhu1) made Coveralls upload errors non-fatal in the CI.
+405. [co63oc](https://github.com/co63oc) fixed typos.
+406. [DmitriBogdanov](https://github.com/DmitriBogdanov) fixed broken package manager links in the documentation.
+407. [Bander](https://github.com/banderzhm) improved the MSVC compatibility of the C++ modules.
+408. [Andy Choi](https://github.com/ccpong) removed an unnecessary `template` keyword before `get` in the README and the documentation.
+409. [SamareshSingh](https://github.com/ssam18) fixed single-element brace initialization to copy/move instead of wrapping in an array, fixed the `WITH_DEFAULT` macros for `ordered_map`, and handled moved events in `serve_header.py`.
+410. [Aditya](https://github.com/Lumowhisp) improved the documentation of the documentation generation.
+411. [cheese1](https://github.com/cheese1) clarified the README.
+412. [KhloodElhossiny](https://github.com/khloodelhossiny) enabled `std::string_view` keys in `operator[]`.
+413. [Charles Cabergs](https://github.com/cacharle) fixed a `-Wtautological-constant-out-of-range-compare` warning.
+414. [EALePain](https://github.com/EALePain) made the `std::tuple` conversion work with reference types such as `std::tie`.
+415. [koala_oishi](https://github.com/chibi-dogs) fixed grammatical wording in the README.
+416. [riccardoori11](https://github.com/riccardoori11) fixed a typo in the documentation.
+417. [Swastik Bose](https://github.com/VasuBhakt) fixed the parent pointers after `update()` with `JSON_DIAGNOSTICS` and fixed the Doxygen autolinking of requirements.
+418. [trdesilva](https://github.com/trdesilva) added `front`, `pop_front`, and `push_front` to `json_pointer`.
+419. [Akhilesh Arora](https://github.com/akhilesharora) fixed an incomplete-type error with `ordered_json`.
+420. [Hariom Phulre](https://github.com/hariomphulre) fixed the C++20 modules compilation with GCC.
+421. [Kirill Lokotkov](https://github.com/RUSLoker) fixed printing `long double` values.
+422. [George Sedov](https://github.com/radistmorse) added the `NLOHMANN_DEFINE_TYPE_*_WITH_NAMES` macros.
+423. [Caillin Nugent](https://github.com/nugentcaillin) added the `NLOHMANN_JSON_SERIALIZE_ENUM_STRICT` macro.
+424. [Cosmin D.](https://github.com/drcosmin) fixed `std::filesystem::path` conversions and added an MSVC workaround for `std::unique_ptr`.
+425. [Paul Dreik](https://github.com/pauldreik) fixed a test relying on implementation-specific behavior.
+426. [Daniel Falk](https://github.com/daniel-falk) added missing copyright notices to the SBOM.
+427. [Federico Sfriso](https://github.com/federicosfriso05-dotcom) added support for constructing JSON values from C++20 range views.
+428. [Luke Banicevic](https://github.com/banaboi) fixed corrupt BSON output for lengths exceeding `INT32_MAX`, cleaned up the BSON writer, and improved the documentation.
+429. [Patrick Armstrong](https://github.com/Patrick10199) updated the CBOR references and the half-precision float assertions.
+430. [Yash Bavadiya](https://github.com/xevrion) added checks to all BSON reads.
+431. [hum4nBeing](https://github.com/hum4nBeing) fixed the overflow handling of high-precision numbers in UBJSON.
+432. [tomatotomata](https://github.com/tomatotomata) added checks for reading CBOR tagged subtypes.
+433. [YingqiDuan](https://github.com/YingqiDuan) documented the BSON interoperability.
+434. [KBS](https://github.com/youdie006) documented the standards compliance and the strictness of `parse()` and `operator>>`.
+435. [Petr Bělohlávek](https://github.com/petrbel) added Clang 21 and 22 to the CI.
+436. [Dmitry Rantovov](https://github.com/darkdi) fixed the placement of a CBOR documentation block.
+437. [ljcjclljc](https://github.com/ljcjclljc) fixed the comparison of large unsigned integers with signed integers.
+438. [Sahil Kamate](https://github.com/sahilkamate03) fixed the handling of CBOR tags 0-5 and 21-23.
+439. [Krishnanand G](https://github.com/Krishnanand-G) made the UBJSON writer reject `use_type` without `use_size`.
+440. [whn](https://github.com/Whning0513) documented the lenient BSON input handling and corrected the complexity of `to_bson`.
+441. [elix3r](https://github.com/22elix3r) fixed `update()` with `merge_objects` when merging a primitive into an object.
+442. [Avionic Harshit](https://github.com/avionicharshit-byte) made `diff()` linear when an array shrinks.
+443. [Qatadaha Bin Matloob](https://github.com/qatcod) fixed comparisons between integers and floats and fixed unparsable BJData output.
+444. [Wu Shuwen](https://github.com/dajiaohuang) removed an unused include.

 Thanks a lot for helping out! Please [let me know](mailto:mail@nlohmann.me) if I forgot someone.

@@ -1850,28 +1879,21 @@ The library itself consists of a single header file licensed under the MIT licen
 - [**AppVeyor**](https://www.appveyor.com) for [continuous integration](https://ci.appveyor.com/project/nlohmann/json) on Windows
 - [**Artistic Style**](https://astyle.sourceforge.net) for automatic source code indentation
 - [**Clang**](https://clang.llvm.org) for compilation with code sanitizers
- [**Clang-Tidy**](https://clang.llvm.org/extra/clang-tidy/) for static analysis and style checks
 - [**CMake**](https://cmake.org) for build automation
 - [**Codacy**](https://www.codacy.com) for further [code analysis](https://app.codacy.com/gh/nlohmann/json/dashboard)
- [**CodeQL**](https://codeql.github.com) for code scanning
 - [**Coveralls**](https://coveralls.io) to measure [code coverage](https://coveralls.io/github/nlohmann/json)
 - [**Coverity Scan**](https://scan.coverity.com) for [static analysis](https://scan.coverity.com/projects/nlohmann-json)
 - [**cppcheck**](https://cppcheck.sourceforge.io) for static analysis
- [**cpplint**](https://github.com/cpplint/cpplint) for style checks
- [**doctest**](https://github.com/doctest/doctest) for the unit tests
- [**Flawfinder**](https://dwheeler.com/flawfinder/) for static analysis
- [**GitHub Changelog Generator**](https://github.com/github-changelog-generator/github-changelog-generator) to generate the [ChangeLog](https://github.com/nlohmann/json/blob/develop/ChangeLog.md)
+- [**doctest**](https://github.com/onqtam/doctest) for the unit tests
+- [**GitHub Changelog Generator**](https://github.com/skywinder/github-changelog-generator) to generate the [ChangeLog](https://github.com/nlohmann/json/blob/develop/ChangeLog.md)
 - [**Google Benchmark**](https://github.com/google/benchmark) to implement the benchmarks
 - [**Hedley**](https://nemequ.github.io/hedley/) to avoid re-inventing several compiler-agnostic feature macros
- [**include-what-you-use**](https://include-what-you-use.org) to check the included headers
- [**Infer**](https://fbinfer.com) for static analysis
 - [**lcov**](https://github.com/linux-test-project/lcov) to process coverage information and create an HTML view
 - [**libFuzzer**](https://llvm.org/docs/LibFuzzer.html) to implement fuzz testing for OSS-Fuzz
 - [**Material for MkDocs**](https://squidfunk.github.io/mkdocs-material/) for the style of the documentation site
 - [**MkDocs**](https://www.mkdocs.org) for the documentation site
 - [**OSS-Fuzz**](https://github.com/google/oss-fuzz) for continuous fuzz testing of the library ([project repository](https://github.com/google/oss-fuzz/tree/master/projects/json))
 - [**Probot**](https://probot.github.io) for automating maintainer tasks such as closing stale issues, requesting missing information, or detecting toxic comments.
- [**Semgrep**](https://semgrep.dev) for static analysis
 - [**Valgrind**](https://valgrind.org) to check for correct memory management

 ## Notes
@@ -1965,10 +1987,10 @@ If the testdata is not found, several test suites will fail like this:

 ```
 ===============================================================================
-json/tests/src/make_test_data_available.hpp:26:
+json/tests/src/make_test_data_available.hpp:21:
 TEST CASE:  check test suite is downloaded

-json/tests/src/make_test_data_available.hpp:28: FATAL ERROR: REQUIRE( utils::check_testsuite_downloaded() ) is NOT correct!
+json/tests/src/make_test_data_available.hpp:23: FATAL ERROR: REQUIRE( utils::check_testsuite_downloaded() ) is NOT correct!
  values: REQUIRE( false )
  logged: Test data not found in 'json/cmake-build-debug/json_test_data'.
          Please execute target 'download_test_data' before running this test suite.
@@ -1979,10 +2001,10 @@ json/tests/src/make_test_data_available.hpp:28: FATAL ERROR: REQUIRE( utils::che

 In case you have downloaded the library rather than checked out the code via Git, test `cmake_fetch_content_configure` will fail. Please execute `ctest -LE git_required` to skip these tests. See [issue #2189](https://github.com/nlohmann/json/issues/2189) for more information.

-Some tests require network access to execute properly. They are labeled as `git_required`. Please execute `ctest -LE git_required` to skip these tests. See [issue #4851](https://github.com/nlohmann/json/issues/4851) for more information.
+Some tests are requiring network to be properly execute. They are labeled as `git_required`. Please execute `ctest -LE git_required` to skip these tests. See [issue #4851](https://github.com/nlohmann/json/issues/4851) for more information.

 Some tests change the installed files and hence make the whole process not reproducible. Please execute `ctest -LE not_reproducible` to skip these tests. See [issue #2324](https://github.com/nlohmann/json/issues/2324) for more information. Furthermore, assertions must be switched off to ensure reproducible builds (see [discussion 4494](https://github.com/nlohmann/json/discussions/4494)).

-Note you need to call `ctest -LE "not_reproducible|git_required"` to exclude both labels. See [issue #2596](https://github.com/nlohmann/json/issues/2596) for more information.
+Note you need to call `cmake -LE "not_reproducible|git_required"` to exclude both labels. See [issue #2596](https://github.com/nlohmann/json/issues/2596) for more information.

 As Intel compilers use unsafe floating point optimization by default, the unit tests may fail. Use flag [`/fp:precise`](https://www.intel.com/content/www/us/en/docs/cpp-compiler/developer-guide-reference/2021-8/fp-model-fp.html) then.
@@ -10,10 +10,10 @@ SPDX-FileCopyrightText = "2013-2026 Niels Lohmann <https://nlohmann.me>"
 SPDX-License-Identifier = "MIT"

 [[annotations]]
-path = "include/nlohmann/thirdparty/hedley/hedley.hpp"
+path = "include/nlohmann/thirdparty/hedley.hpp"
 precedence = "aggregate"
 SPDX-FileCopyrightText = "2016-2021 Evan Nemerson <evan@nemerson.com>"
-SPDX-License-Identifier = "CC0-1.0"
+SPDX-License-Identifier = "CC0"

 [[annotations]]
 path = "include/nlohmann/detail/meta/cpp_future.hpp"
@@ -50,9 +50,3 @@ path = "tools/gdb_pretty_printer/**"
 precedence = "aggregate"
 SPDX-FileCopyrightText = "2020 Hannes Domani <https://github.com/ssbssa>"
 SPDX-License-Identifier = "MIT"
-
-[[annotations]]
-path = "docs/docset/icon*.png"
-precedence = "override"
-SPDX-FileCopyrightText = "JSON logo (public domain), https://commons.wikimedia.org/wiki/File:JSON_vector_logo.svg"
-SPDX-License-Identifier = "CC0-1.0"
@@ -5,14 +5,15 @@ set(N 10)
 # Needed tools.
 ###############################################################################

+include(FindPython3)
 find_package(Python3 COMPONENTS Interpreter)

-find_program(CLANG_TOOL NAMES clang++ clang++-HEAD clang++-22 clang++-21 clang++-20 clang++-19 clang++-18 clang++-17 clang++-16 clang++-15 clang++-14 clang++-13 clang++-12 clang++-11)
+find_program(CLANG_TOOL NAMES clang++-HEAD clang++ clang++-22 clang++-21 clang++-20 clang++-19 clang++-18 clang++-17 clang++-16 clang++-15 clang++-14 clang++-13 clang++-12 clang++-11 clang++)
 execute_process(COMMAND ${CLANG_TOOL} --version OUTPUT_VARIABLE CLANG_TOOL_VERSION ERROR_VARIABLE CLANG_TOOL_VERSION)
 string(REGEX MATCH "[0-9]+(\\.[0-9]+)+" CLANG_TOOL_VERSION "${CLANG_TOOL_VERSION}")
 message(STATUS "🔖 Clang ${CLANG_TOOL_VERSION} (${CLANG_TOOL})")

-find_program(CLANG_TIDY_TOOL NAMES clang-tidy clang-tidy-22 clang-tidy-21 clang-tidy-20 clang-tidy-19 clang-tidy-18 clang-tidy-17 clang-tidy-16 clang-tidy-15 clang-tidy-14 clang-tidy-13 clang-tidy-12 clang-tidy-11)
+find_program(CLANG_TIDY_TOOL NAMES clang-tidy-22 clang-tidy-21 clang-tidy-20 clang-tidy-19 clang-tidy-18 clang-tidy-17 clang-tidy-16 clang-tidy-15 clang-tidy-14 clang-tidy-13 clang-tidy-12 clang-tidy-11 clang-tidy)
 execute_process(COMMAND ${CLANG_TIDY_TOOL} --version OUTPUT_VARIABLE CLANG_TIDY_TOOL_VERSION ERROR_VARIABLE CLANG_TIDY_TOOL_VERSION)
 string(REGEX MATCH "[0-9]+(\\.[0-9]+)+" CLANG_TIDY_TOOL_VERSION "${CLANG_TIDY_TOOL_VERSION}")
 message(STATUS "🔖 Clang-Tidy ${CLANG_TIDY_TOOL_VERSION} (${CLANG_TIDY_TOOL})")
@@ -68,7 +69,9 @@ string(REGEX MATCH "[0-9]+(\\.[0-9]+)+" VALGRIND_TOOL_VERSION "${VALGRIND_TOOL_V
 message(STATUS "🔖 Valgrind ${VALGRIND_TOOL_VERSION} (${VALGRIND_TOOL})")

 find_program(GENHTML_TOOL NAMES genhtml)
-find_program(SCAN_BUILD_TOOL NAMES scan-build scan-build-22 scan-build-21 scan-build-20 scan-build-19 scan-build-18 scan-build-17 scan-build-16 scan-build-15 scan-build-14 scan-build-13 scan-build-12 scan-build-11)
+find_program(PLOG_CONVERTER_TOOL NAMES plog-converter)
+find_program(PVS_STUDIO_ANALYZER_TOOL NAMES pvs-studio-analyzer)
+find_program(SCAN_BUILD_TOOL NAMES scan-build-15 scan-build-14 scan-build-13 scan-build-12 scan-build-11 scan-build)

 # the individual source files
 file(GLOB_RECURSE SRC_FILES ${PROJECT_SOURCE_DIR}/include/nlohmann/*.hpp)
@@ -364,7 +367,7 @@ add_custom_target(ci_test_coverage
    COMMAND ${LCOV_TOOL} --directory . --capture --output-file json.info --rc branch_coverage=1 --rc geninfo_unexecuted_blocks=1 --ignore-errors mismatch --ignore-errors unused
    COMMAND ${LCOV_TOOL} -e json.info ${SRC_FILES} --output-file json.info.filtered --rc branch_coverage=1 --ignore-errors unused
    COMMAND ${CMAKE_SOURCE_DIR}/tests/thirdparty/imapdl/filterbr.py json.info.filtered > json.info.filtered.noexcept
-    COMMAND ${GENHTML_TOOL} --title "JSON for Modern C++" --legend --demangle-cpp --output-directory html --show-details --branch-coverage json.info.filtered.noexcept
+    COMMAND genhtml --title "JSON for Modern C++" --legend --demangle-cpp --output-directory html --show-details --branch-coverage json.info.filtered.noexcept

    COMMENT "Compile and test with coverage"
 )
@@ -389,8 +392,8 @@ add_custom_target(ci_test_clang_sanitizer
 # Check if header is amalgamated and sources are properly indented.
 ###############################################################################

-# Same file set as .github/workflows/check_amalgamation.yml, so this CMake target (which can be run locally) is held
-# to the same standard as the workflow (which runs for pull requests and for pushes to develop/master/release/*).
+# Same file set as .github/workflows/check_amalgamation.yml, so a direct push to develop/master/release/*
+# (which only this CMake target checks, not the pull_request-only workflow) is held to the same standard.
 file(GLOB_RECURSE INDENT_FILES
    ${PROJECT_SOURCE_DIR}/docs/mkdocs/docs/examples/*.hpp
    ${PROJECT_SOURCE_DIR}/docs/mkdocs/docs/examples/*.cpp
@@ -420,7 +423,7 @@ add_custom_target(ci_test_amalgamation
    COMMAND ${Python3_EXECUTABLE} ${tool_dir}/amalgamate.py -c ${tool_dir}/config_json.json -s .
    COMMAND ${Python3_EXECUTABLE} ${tool_dir}/amalgamate.py -c ${tool_dir}/config_json_fwd.json -s .
    COMMAND cp ${PROJECT_SOURCE_DIR}/include/nlohmann/json_literals.hpp ${include_dir}/json_literals.hpp
-    COMMAND venv_astyle/bin/astyle --project=tools/astyle/.astylerc --suffix=none ${include_dir}/json.hpp ${include_dir}/json_fwd.hpp ${include_dir}/json_literals.hpp
+    COMMAND venv_astyle/bin/astyle --project=tools/astyle/.astylerc --suffix=none ${include_dir}/json.hpp ${include_dir}/json_fwd.hpp
    COMMAND ${CMAKE_COMMAND} -P ${PROJECT_SOURCE_DIR}/cmake/scripts/gen_bazel_build_file.cmake

    COMMAND diff ${include_dir}/json.hpp~ ${include_dir}/json.hpp
@@ -431,8 +434,6 @@ add_custom_target(ci_test_amalgamation
    COMMAND venv_astyle/bin/astyle --project=tools/astyle/.astylerc --suffix=orig ${INDENT_FILES}
    COMMAND for FILE in `find . -name '*.orig'`\; do false \; done

-    COMMAND rm -f ${include_dir}/json.hpp~ ${include_dir}/json_fwd.hpp~ ${include_dir}/json_literals.hpp~ ${PROJECT_SOURCE_DIR}/BUILD.bazel~
-
    WORKING_DIRECTORY ${PROJECT_SOURCE_DIR}
    COMMENT "Check amalgamation, formatting, and BUILD.bazel"
 )
@@ -718,7 +719,7 @@ ci_get_cmake(4.0.0  CMAKE_4_0_0_BINARY)

 # the tests require CMake 3.13 or later, so they are excluded for CMake 3.5.0
 set(JSON_CMAKE_FLAGS_3_5_0 JSON_Diagnostics JSON_Diagnostic_Positions JSON_GlobalUDLs JSON_ImplicitConversions JSON_DisableEnumSerialization
-    JSON_DisableTupleReferenceConversion JSON_LegacyDiscardedValueComparison JSON_Install JSON_MultipleHeaders JSON_SystemInclude JSON_Valgrind
+    JSON_LegacyDiscardedValueComparison JSON_Install JSON_MultipleHeaders JSON_SystemInclude JSON_Valgrind
    JSON_StrictNulHandling JSON_StrictBinaryUTF8 JSON_DeleteDeprecatedFunctions)
 set(JSON_CMAKE_FLAGS_3_31_6 JSON_BuildTests ${JSON_CMAKE_FLAGS_3_5_0})
 set(JSON_CMAKE_FLAGS_4_0_0 JSON_BuildTests ${JSON_CMAKE_FLAGS_3_5_0})
@@ -775,14 +776,17 @@ add_custom_target(ci_cmake_flags
 # Use more installed compilers.
 ###############################################################################

-foreach(COMPILER g++-4.8 g++-4.9 g++-5 g++-6)
+foreach(COMPILER g++-4.8 g++-4.9 g++-5 g++-6 g++-7 g++-8 g++-9 g++-10 g++-11 clang++-3.5 clang++-3.6 clang++-3.7 clang++-3.8 clang++-3.9 clang++-4.0 clang++-5.0 clang++-6.0 clang++-7 clang++-8 clang++-9 clang++-10 clang++-11 clang++-12 clang++-13 clang++-14 clang++-15 clang++-16 clang++-17 clang++-18 clang++-19 clang++-20)
    find_program(COMPILER_TOOL NAMES ${COMPILER})
    if (COMPILER_TOOL)
+        unset(ADDITIONAL_FLAGS)
+
        add_custom_target(ci_test_compiler_${COMPILER}
            COMMAND CXX=${COMPILER} ${CMAKE_COMMAND}
                -DCMAKE_BUILD_TYPE=Debug -GNinja
                -DJSON_BuildTests=ON -DJSON_FastTests=ON
                -S${PROJECT_SOURCE_DIR} -B${PROJECT_BINARY_DIR}/build_compiler_${COMPILER}
+                ${ADDITIONAL_FLAGS}
            COMMAND ${CMAKE_COMMAND} --build ${PROJECT_BINARY_DIR}/build_compiler_${COMPILER}
            COMMAND cd ${PROJECT_BINARY_DIR}/build_compiler_${COMPILER} && ${CMAKE_CTEST_COMMAND} --parallel ${N} --output-on-failure
            COMMENT "Compile and test with ${COMPILER}"
@@ -796,6 +800,7 @@ add_custom_target(ci_test_compiler_default
        -DCMAKE_BUILD_TYPE=Debug -GNinja
        -DJSON_BuildTests=ON -DJSON_FastTests=ON
        -S${PROJECT_SOURCE_DIR} -B${PROJECT_BINARY_DIR}/build_compiler_default
+        ${ADDITIONAL_FLAGS}
    COMMAND ${CMAKE_COMMAND} --build ${PROJECT_BINARY_DIR}/build_compiler_default --parallel ${N}
    COMMAND cd ${PROJECT_BINARY_DIR}/build_compiler_default && ${CMAKE_CTEST_COMMAND} --parallel ${N} -LE git_required --output-on-failure
    COMMENT "Compile and test with default C++ compiler"
@@ -818,12 +823,10 @@ add_custom_target(ci_cuda_example

 add_custom_target(ci_module_cpp20
    COMMAND ${CMAKE_COMMAND}
-        -DCMAKE_BUILD_TYPE=Debug -GNinja
+        -DCMAKE_BUILD_TYPE=Debug -GNinja 
        -DJSON_CI=ON -DNLOHMANN_JSON_BUILD_MODULES=ON -DJSON_Install=ON
-        "-DCMAKE_CXX_FLAGS=${CMAKE_CXX_FLAGS}"
        -S${PROJECT_SOURCE_DIR}/tests/module_cpp20 -B${PROJECT_BINARY_DIR}/ci_module_cpp20
    COMMAND ${CMAKE_COMMAND} --build ${PROJECT_BINARY_DIR}/ci_module_cpp20
-    VERBATIM
 )

 ###############################################################################
@@ -49,7 +49,6 @@ cc_library(
    hdrs = [
        "single_include/nlohmann/json.hpp",
        "single_include/nlohmann/json_fwd.hpp",
-        "single_include/nlohmann/json_literals.hpp",
    ],
    includes = ["single_include"],
    visibility = ["//visibility:public"],
@@ -7,12 +7,12 @@ This URL provides the most recent documentation and also applies to previous ver
 functions is not removed; instead, it is marked as deprecated.

 If you want to view the documentation for a specific tag or commit hash, you can generate it locally as follows (example
-using tag `v3.12.0`):
+using tag `v3.10.2`):

 ```shell
 git clone https://github.com/nlohmann/json.git
 cd json
-git checkout v3.12.0
+git checkout v3.10.2
 make install_venv serve -C docs/mkdocs
 ```

@@ -241,6 +241,4 @@ Strong exception safety: if an exception occurs, the original value stays intact
 3. Added in version 3.11.0. Fixed in version 3.13.0 to consistently accept `std::string_view`-convertible keys, as
   already supported by [`operator[]`](operator[].md), [`value`](value.md), [`find`](find.md), and other lookup
   functions.
-4. Added in version 2.0.0. Throws [`parse_error.109`](../../home/exceptions.md#jsonexceptionparse_error109) instead of
-[`out_of_range.404`](../../home/exceptions.md#jsonexceptionout_of_range404) for a one-character array index that is not
-a digit (e.g., `/x`) in version 3.13.0, as it already did for longer ones.
+4. Added in version 2.0.0.
@@ -10,10 +10,6 @@ bool contains(KeyType&& key) const;

 // (3)
 bool contains(const json_pointer& ptr) const;
-
-// (4)
-template<typename T>
-bool contains(T) const = delete;
 ```

 1. Check whether an element exists in a JSON object with a key equivalent to `key`. If the element is not found or the 
@@ -21,9 +17,6 @@ bool contains(T) const = delete;
 2. See 1. This overload is only available if `KeyType` is comparable with `#!cpp typename object_t::key_type` and
   `#!cpp typename object_comparator_t::is_transparent` denotes a type.
 3. Check whether the given JSON pointer `ptr` can be resolved in the current JSON value.
-4. Deleted: this overload is only available if `T` is an integral type and is declared as deleted, so that a call with
-   an integer `key` (for example, `#!cpp j.contains(0)`) fails to compile. Otherwise, the integer literal `0` would convert to
-   a null `#!cpp const char*` and, from there, to the key type, causing undefined behavior at runtime.

 ## Template parameters

@@ -46,7 +39,6 @@ bool contains(T) const = delete;
   is not an object, `#!cpp false` is returned.
 2. See 1.
 3. `#!cpp true` if the JSON pointer can be resolved to a stored value, `#!cpp false` otherwise.
-4. Deleted; a call with an integral argument does not compile.

 ## Exception safety

@@ -57,7 +49,6 @@ Strong exception safety: if an exception occurs, the original value stays intact
 1. The function does not throw exceptions.
 2. The function does not throw exceptions.
 3. The function does not throw exceptions.
-4. Deleted; a call with an integral argument does not compile.

 ## Complexity

@@ -7,19 +7,12 @@ size_type count(const typename object_t::key_type& key) const;
 // (2)
 template<typename KeyType>
 size_type count(KeyType&& key) const;
-
-// (3)
-template<typename T>
-size_type count(T) const = delete;
 ```

 1. Returns the number of elements with key `key`. If `ObjectType` is the default `std::map` type, the return value will
   always be `0` (`key` was not found) or `1` (`key` was found).
 2. See 1. This overload is only available if `KeyType` is comparable with `#!cpp typename object_t::key_type` and
   `#!cpp typename object_comparator_t::is_transparent` denotes a type.
-3. Deleted: this overload is only available if `T` is an integral type and is declared as deleted, so that a call with
-   an integer `key` (for example, `#!cpp j.count(0)`) fails to compile. Otherwise, the integer literal `0` would convert to
-   a null `#!cpp const char*` and, from there, to the key type, causing undefined behavior at runtime.

 ## Template parameters

@@ -37,8 +37,8 @@ ignore
 :   ignore invalid UTF-8 sequences; all valid bytes are copied to the output unchanged, and invalid bytes are dropped

 keep
-:   keep invalid UTF-8 sequences unchanged; only meaningful for the binary formats mentioned above, since
-    [`dump`](dump.md) itself must produce text, and `keep` there writes the ill-formed bytes to the output as is, so the
+:   keep invalid UTF-8 sequences unchanged; only meaningful for the binary formats mentioned above, since [`dump`]
+    (dump.md) itself must produce text, and `keep` there writes the ill-formed bytes to the output as is, so the
    result is then not valid UTF-8 (but still equals the input bytes exactly, including around any well-formed
    characters, which are still escaped as usual)

@@ -10,21 +10,12 @@ template<typename KeyType>
 iterator find(KeyType&& key);
 template<typename KeyType>
 const_iterator find(KeyType&& key) const;
-
-// (3)
-template<typename T>
-iterator find(T) = delete;
-template<typename T>
-const_iterator find(T) const = delete;
 ```

 1. Finds an element in a JSON object with a key equivalent to `key`. If the element is not found or the
   JSON value is not an object, `end()` is returned.
 2. See 1. This overload is only available if `KeyType` is comparable with `#!cpp typename object_t::key_type` and
   `#!cpp typename object_comparator_t::is_transparent` denotes a type.
-3. Deleted: this overload is only available if `T` is an integral type and is declared as deleted, so that a call with
-   an integer `key` (for example, `#!cpp j.find(0)`) fails to compile. Otherwise, the integer literal `0` would convert to
-   a null `#!cpp const char*` and, from there, to the key type, causing undefined behavior at runtime.

 ## Template parameters

@@ -124,8 +124,7 @@ Linear in the size of the input.
 !!! warning "Deprecation"

    - Overload (2) replaces calls to `from_bjdata` with a pointer and a length as first two parameters, which has been
-      deprecated in version 3.13.0. In version 4.0.0, this overload
-      will be deleted (`= delete`) rather than removed. Please replace all calls like
+      deprecated in version 3.13.0. This overload will be removed in version 4.0.0. Please replace all calls like
      `#!cpp from_bjdata(ptr, len, ...);` with `#!cpp from_bjdata(ptr, ptr+len, ...);`.

    You should be warned by your compiler with a `-Wdeprecated-declarations` warning if you are using a deprecated
@@ -110,8 +110,7 @@ Linear in the size of the input.
 !!! warning "Deprecation"

    - Overload (2) replaces calls to `from_bon8` with a pointer and a length as first two parameters, which has been
-      deprecated in version 3.13.0. In version 4.0.0, this overload
-      will be deleted (`= delete`) rather than removed. Please replace all calls like
+      deprecated in version 3.13.0. This overload will be removed in version 4.0.0. Please replace all calls like
      `#!cpp from_bon8(ptr, len, ...);` with `#!cpp from_bon8(ptr, ptr+len, ...);`.

    You should be warned by your compiler with a `-Wdeprecated-declarations` warning if you are using a deprecated
@@ -126,8 +126,7 @@ Linear in the size of the input.
 !!! warning "Deprecation"

    - Overload (2) replaces calls to `from_bson` with a pointer and a length as first two parameters, which has been
-      deprecated in version 3.8.0. In version 4.0.0, this overload
-      will be deleted (`= delete`) rather than removed. Please replace all calls like
+      deprecated in version 3.8.0. This overload will be removed in version 4.0.0. Please replace all calls like
      `#!cpp from_bson(ptr, len, ...);` with `#!cpp from_bson(ptr, ptr+len, ...);`.
    - Overload (2) replaces calls to `from_bson` with a pair of iterators as their first parameter, which has been
      deprecated in version 3.8.0. This overload will be removed in version 4.0.0. Please replace all calls like
@@ -135,8 +135,7 @@ Linear in the size of the input.
 !!! warning "Deprecation"

    - Overload (2) replaces calls to `from_cbor` with a pointer and a length as first two parameters, which has been
-      deprecated in version 3.8.0. In version 4.0.0, this overload
-      will be deleted (`= delete`) rather than removed. Please replace all calls like
+      deprecated in version 3.8.0. This overload will be removed in version 4.0.0. Please replace all calls like
      `#!cpp from_cbor(ptr, len, ...);` with `#!cpp from_cbor(ptr, ptr+len, ...);`.
    - Overload (2) replaces calls to `from_cbor` with a pair of iterators as their first parameter, which has been
      deprecated in version 3.8.0. This overload will be removed in version 4.0.0. Please replace all calls like
@@ -127,8 +127,7 @@ Linear in the size of the input.
 !!! warning "Deprecation"

    - Overload (2) replaces calls to `from_msgpack` with a pointer and a length as first two parameters, which has been
-      deprecated in version 3.8.0. In version 4.0.0, this overload
-      will be deleted (`= delete`) rather than removed. Please replace all calls like
+      deprecated in version 3.8.0. This overload will be removed in version 4.0.0. Please replace all calls like
      `#!cpp from_msgpack(ptr, len, ...);` with `#!cpp from_msgpack(ptr, ptr+len, ...);`.
    - Overload (2) replaces calls to `from_msgpack` with a pair of iterators as their first parameter, which has been
      deprecated in version 3.8.0. This overload will be removed in version 4.0.0. Please replace all calls like
@@ -125,8 +125,7 @@ Linear in the size of the input.
 !!! warning "Deprecation"

    - Overload (2) replaces calls to `from_ubjson` with a pointer and a length as first two parameters, which has been
-      deprecated in version 3.8.0. In version 4.0.0, this overload
-      will be deleted (`= delete`) rather than removed. Please replace all calls like
+      deprecated in version 3.8.0. This overload will be removed in version 4.0.0. Please replace all calls like
      `#!cpp from_ubjson(ptr, len, ...);` with `#!cpp from_ubjson(ptr, ptr+len, ...);`.
    - Overload (2) replaces calls to `from_ubjson` with a pair of iterators as their first parameter, which has been
      deprecated in version 3.8.0. This overload will be removed in version 4.0.0. Please replace all calls like
@@ -62,5 +62,5 @@ same name. Hidden members remain accessible via [`as_base_class`](as_base_class.

 ## Version history

- Added in version 3.11.3.
+- Added in version 3.12.0.
 - Made a public member type in version 3.13.0; it was private before, so it could not be named outside the class.
@@ -23,10 +23,9 @@ type to use.
 ## Template parameters

 `NumberFloatType`
-:   the type to store floating-point numbers. The type must be `#!cpp float`, `#!cpp double`, or
-    `#!cpp long double`. The parser converts `#!cpp float`, `#!cpp double`, and a `#!cpp long double` that is IEEE 754
-    binary64 itself. It converts other `#!cpp long double` formats with `#!cpp std::from_chars` where available, or
-    with `#!cpp std::strtold` otherwise. Serialization falls back to `#!cpp std::snprintf`. The
+:   the type to store floating-point numbers. Parsing and serialization are implemented in terms of
+    `#!cpp std::strtof`/`#!cpp std::strtod`/`#!cpp std::strtold` and `#!cpp std::snprintf`, so the type must be
+    `#!cpp float`, `#!cpp double`, or `#!cpp long double`. The
    [binary formats](../../features/binary_formats/index.md) additionally require `#!cpp float` or `#!cpp double`,
    because they have no encoding for `#!cpp long double`. See
    [Template Parameter Requirements](../../features/types/template_parameters.md#numberfloattype).
@@ -26,7 +26,8 @@ To store objects in C++, a type is defined by the template parameters described

 `StringType`
 :   the type of the keys or names (e.g., `std::string`). The comparison function `std::less<StringType>` is used to
-    order elements inside the container.
+    order elements inside the container. `object_t::key_type` must be implicitly convertible to `string_t` (required by the
+    binary formats).

 `AllocatorType`
 :   the allocator to use for objects (e.g., `std::allocator`)
@@ -286,6 +286,4 @@ Strong exception safety: if an exception occurs, the original value stays intact
 3. Added in version 3.11.0. Fixed in version 3.13.0 to consistently accept `std::string_view`-convertible keys, as
   already supported by [`at`](at.md), [`value`](value.md), [`find`](find.md), and other lookup functions.
 4. Added in version 2.0.0. A missing array index in the const version is guarded by a runtime assertion since
-   version 3.13.0. Throws [`parse_error.109`](../../home/exceptions.md#jsonexceptionparse_error109) instead of
-[`out_of_range.404`](../../home/exceptions.md#jsonexceptionout_of_range404) for a one-character array index that is not
-a digit (e.g., `/x`) in version 3.13.0, as it already did for longer ones.
+   version 3.13.0.
@@ -112,6 +112,3 @@ is thrown. In any case, the original value is not changed: the patch is applied
  location has a non-object/non-array parent in version 3.13.0.
 - Added [`out_of_range.414`](../../home/exceptions.md#jsonexceptionout_of_range414) and rejected a "move" operation whose "from" location is a proper
  prefix of its "path" location instead of silently producing a corrupted result in version 3.13.0.
- Throws [`parse_error.109`](../../home/exceptions.md#jsonexceptionparse_error109) instead of
-  [`out_of_range.404`](../../home/exceptions.md#jsonexceptionout_of_range404) for a one-character array index that is
-  not a digit (e.g., `/x`) in version 3.13.0, as it already did for longer ones.
@@ -110,6 +110,3 @@ function throws an exception.
  location has a non-object/non-array parent in version 3.13.0.
 - Added [`out_of_range.414`](../../home/exceptions.md#jsonexceptionout_of_range414) and rejected a "move" operation whose "from" location is a proper
  prefix of its "path" location instead of silently producing a corrupted result in version 3.13.0.
- Throws [`parse_error.109`](../../home/exceptions.md#jsonexceptionparse_error109) instead of
-  [`out_of_range.404`](../../home/exceptions.md#jsonexceptionout_of_range404) for a one-character array index that is
-  not a digit (e.g., `/x`) in version 3.13.0, as it already did for longer ones.
@@ -123,4 +123,6 @@ Linear in the size of the JSON value `j`.
  that is not valid UTF-8 unchanged, as before; `strict` (the default if
  [`JSON_STRICT_BINARY_UTF8`](../macros/json_strict_binary_utf8.md) is enabled) throws `type_error.316`.
 - Throws `type_error.321` for a discarded value since version 3.13.0; previously, a discarded value nested in an
-  array or object was silently skipped, producing invalid BJData.
+  array or object was silently skipped, producing invalid BJData.
+- Writes unsigned integers wider than 64 bits as high-precision numbers since version 3.13.0; previously, they were
+  silently truncated to 64 bits.
@@ -37,12 +37,11 @@ With (2), the bytes written before the exception remain in the output adapter.

 ## Exceptions

- Throws [out_of_range.407](../../home/exceptions.md#jsonexceptionout_of_range407) if `j` contains an unsigned integer
-  above 9223372036854775807, which BON8 cannot represent
+- Throws [out_of_range.407](../../home/exceptions.md#jsonexceptionout_of_range407) if `j` contains an integer outside
+  the range of int64 (an unsigned integer above 9223372036854775807, or, with a number type wider than 64 bits, any
+  integer beyond int64), which BON8 cannot represent
 - Throws [type_error.316](../../home/exceptions.md#jsonexceptiontype_error316) if `j` contains a string that is not
  valid UTF-8
- Throws [type_error.321](../../home/exceptions.md#jsonexceptiontype_error321) if `j` or a value nested in it is
-  discarded; example: `"cannot serialize discarded value to BON8"`

 ## Complexity

@@ -47,6 +47,10 @@ Strong guarantee: if an exception is thrown, there are no changes in the JSON va

 - Throws [`type_error.317`](../../home/exceptions.md#jsonexceptiontype_error317) if the top-level type of the JSON value
  is not an object; example: `"to serialize to BSON, top-level type must be object, but is string"`
+- Throws [`out_of_range.407`](../../home/exceptions.md#jsonexceptionout_of_range407) if `j` contains a signed integer
+  outside the range of int64 or an unsigned integer outside the range of uint64, which is only possible with a number
+  type wider than 64 bits; example:
+  `"integer number 9223372036854775808 cannot be represented by BSON as it does not fit int64"`
 - Throws [`out_of_range.409`](../../home/exceptions.md#jsonexceptionout_of_range409) if a key in the JSON object contains
  a null byte (code point U+0000); example: `"BSON key cannot contain code point U+0000 (at byte 2)"`
 - Throws [`out_of_range.412`](../../home/exceptions.md#jsonexceptionout_of_range412) if the length of a document, array,
@@ -119,3 +123,5 @@ pass before anything is written.
  that is not valid UTF-8 unchanged, as before; `strict` (the default if
  [`JSON_STRICT_BINARY_UTF8`](../macros/json_strict_binary_utf8.md) is enabled) throws `type_error.316` before anything
  is written.
+- Throws `out_of_range.407` for integers that do not fit 64 bits since version 3.13.0; previously, integers of a
+  number type wider than 64 bits were silently truncated.
@@ -46,6 +46,9 @@ Strong guarantee: if an exception is thrown, there are no changes in the JSON va

 ## Exceptions

+- Throws [`out_of_range.407`](../../home/exceptions.md#jsonexceptionout_of_range407) if `j` contains an integer
+  outside [-2^64, 2^64-1], which is only possible with a number type wider than 64 bits; example:
+  `"integer number 18446744073709551616 cannot be represented by CBOR as it does not fit [-2^64, 2^64-1]"`
 - Throws [type_error.316](../../home/exceptions.md#jsonexceptiontype_error316) if a string or object key in `j` is
  not valid UTF-8 and `error_handler` is `strict` (the default only if
  [`JSON_STRICT_BINARY_UTF8`](../macros/json_strict_binary_utf8.md) is enabled)
@@ -90,3 +93,5 @@ Linear in the size of the JSON value `j`.
  [`JSON_STRICT_BINARY_UTF8`](../macros/json_strict_binary_utf8.md) is enabled) throws `type_error.316`.
 - Throws `type_error.321` for a discarded value since version 3.13.0; previously, a discarded value nested in an
  array or object was silently skipped, producing invalid CBOR.
+- Throws `out_of_range.407` for integers that do not fit 64 bits since version 3.13.0; previously, integers of a
+  number type wider than 64 bits were silently truncated.
@@ -46,6 +46,9 @@ Strong guarantee: if an exception is thrown, there are no changes in the JSON va

 ## Exceptions

+- Throws [`out_of_range.407`](../../home/exceptions.md#jsonexceptionout_of_range407) if `j` contains an integer
+  outside [-2^63, 2^64-1], which is only possible with a number type wider than 64 bits; example:
+  `"integer number 18446744073709551616 cannot be represented by MessagePack as it does not fit [-2^63, 2^64-1]"`
 - Throws [`out_of_range.412`](../../home/exceptions.md#jsonexceptionout_of_range412) if the length of a string, binary
  value, array, or object exceeds 4294967295, the maximum MessagePack can store; example:
  `"MessagePack length 4294967296 exceeds maximum of 4294967295"`
@@ -112,3 +115,5 @@ Linear in the size of the JSON value `j`.
  `number_unsigned_t`.
 - Throws `type_error.321` for a discarded value since version 3.13.0; previously, a discarded value nested in an
  array or object was silently skipped, producing invalid MessagePack.
+- Throws `out_of_range.407` for integers that do not fit 64 bits since version 3.13.0; previously, integers of a
+  number type wider than 64 bits were silently truncated.
@@ -36,9 +36,8 @@ The function can throw the following exceptions:
 - Throws [`parse_error.109`](../../home/exceptions.md#jsonexceptionparse_error109) if an array index in a key is not a
  number; example: `"array index 'one' is not a number"`
 - Throws [`out_of_range.404`](../../home/exceptions.md#jsonexceptionout_of_range404) if a level becomes an array
-  (because one of its keys is `0`) and another key at that level begins with a digit but is not a valid array index
-  (such as `1a`), or is `-`; example:
-  `"unresolved reference token '-'"`
+  (because one of its keys is `0`) and another key at that level cannot be an array index; example:
+  `"unresolved reference token 'x'"`

 ## Complexity

@@ -81,6 +80,3 @@ Apart from these two cases, for a JSON value `j`, the following is always true:

 - Added in version 2.0.0.
 - Made the array/object decision independent of the object's iteration order in version 3.13.0.
- Throws [`parse_error.109`](../../home/exceptions.md#jsonexceptionparse_error109) instead of
-  [`out_of_range.404`](../../home/exceptions.md#jsonexceptionout_of_range404) for a one-character array index that is
-  not a digit (e.g., `/x`) in version 3.13.0, as it already did for longer ones.
@@ -119,14 +119,6 @@ changes to any JSON value.

 ## Notes

-!!! warning "`null` members are not missing"
-
-    The default value is used only if the key (or JSON Pointer) does not exist. A member that exists but is
-    `#!json null` is converted like any other value, so `#!cpp j.value("k", 0)` throws a
-    [`type_error.302`](../../home/exceptions.md#jsonexceptiontype_error302) if `"k"` is `#!json null`. See
-    [Access with default value](../../features/element_access/default_value.md)
-    for alternatives.
-
 !!! warning "Return type"

    The value function is a template, and the return type of the function is determined by the type of the provided
@@ -235,6 +227,4 @@ changes to any JSON value.
   [`operator[]`](operator[].md), [`at`](at.md), [`find`](find.md), and other lookup functions.
 3. Added in version 2.0.2. Extended to work with arrays in version 3.13.0, including fixing an issue where resolving
   `ptr` through an array unexpectedly threw `out_of_range` instead of returning the resolved element (or
-   `default_value`, as documented). Throws [`parse_error.109`](../../home/exceptions.md#jsonexceptionparse_error109)
-   instead of returning `default_value` for a one-character array index that is not a digit (e.g., `/x`) in version
-   3.13.0, as it already did for longer ones.
+   `default_value`, as documented).
@@ -27,7 +27,6 @@ header. See also the [macro overview page](../../features/macros.md).

 - [**JSON_HAS_CPP_11**<br>**JSON_HAS_CPP_14**<br>**JSON_HAS_CPP_17**<br>**JSON_HAS_CPP_20**](json_has_cpp_11.md) - set supported C++ standard
 - [**JSON_HAS_FILESYSTEM**<br>**JSON_HAS_EXPERIMENTAL_FILESYSTEM**](json_has_filesystem.md) - control `std::filesystem` support
- [**JSON_HAS_RANGE_VIEW_CONVERSION**](json_has_range_view_conversion.md) - control construction from `std::ranges` views
 - [**JSON_HAS_RANGES**](json_has_ranges.md) - control `std::ranges` support
 - [**JSON_HAS_STATIC_RTTI**](json_has_static_rtti.md) - control RTTI (run time type information) support
 - [**JSON_HAS_STD_FORMAT**](json_has_std_format.md) - control `std::format`/`std::formatter` support
@@ -49,6 +49,6 @@ The default value is detected based on preprocessor macros such as `#!cpp __cplu

 ## Version history

- Added in version 3.10.0.
+- Added in version 3.10.5.
 - Added `JSON_HAS_CPP_23` in version 3.12.0.
 - Added `JSON_HAS_CPP_26` in version 3.13.0.
@@ -1,43 +0,0 @@
-# JSON_HAS_RANGE_VIEW_CONVERSION
-
-```cpp
-#define JSON_HAS_RANGE_VIEW_CONVERSION /* value */
-```
-
-This macro indicates whether a JSON array can be constructed directly from a C++20 range view (`std::ranges::view`),
-such as the result of `std::views::filter` or `std::views::transform`. Possible values are `1` when supported or `0`
-when unsupported.
-
-## Default definition
-
-The default value is `1` if [`JSON_HAS_RANGES`](json_has_ranges.md) is `1` and the compiler is not MinGW (that is,
-`#!cpp __MINGW32__` is not defined), and `0` otherwise.
-
-When the macro is not defined, the library will define it to its default value.
-
-!!! info "Known compiler/stdlib exclusions"
-
-    - **MinGW** -- disabled, because its `std::ranges` support is incomplete ([issue #4916](https://github.com/nlohmann/json/issues/4916)).
-    - All toolchains for which [`JSON_HAS_RANGES`](json_has_ranges.md#default-definition) is disabled.
-
-## Examples
-
-??? example
-
-    The code below forces the library to disable the conversion from range views:
-
-    ```cpp
-    #define JSON_HAS_RANGE_VIEW_CONVERSION 0
-    #include <nlohmann/json.hpp>
-
-    ...
-    ```
-
-## See also
-
- [JSON_HAS_RANGES](json_has_ranges.md) - control `std::ranges` support
- [Constructing from a C++20 range view](../../features/conversions.md#putting-values-in) - usage of the feature
-
-## Version history
-
- Added in version 3.13.0.
@@ -20,7 +20,7 @@ When the macro is not defined, the library will define it to its default value.
    
    - **GCC 11.1.0** — disabled (the shipped `<ranges>` header has a syntax error; [issue #4440](https://github.com/nlohmann/json/issues/4440))
    - **libstdc++ < 11** — disabled (incomplete C++20 ranges support; [issue #4440](https://github.com/nlohmann/json/issues/4440))
-    - **Clang < 16 with libstdc++** — disabled (incomplete ranges support; [issue #5161](https://github.com/nlohmann/json/issues/5161))
+    - **Clang < 16 with libstdc++** — disabled (incomplete ranges support; [issue #4440](https://github.com/nlohmann/json/issues/4440))
    - **libc++ < 160000** — disabled (incomplete C++20 ranges support; [issue #4440](https://github.com/nlohmann/json/issues/4440))
    - **nvcc (CUDA) 12.0.x and 12.1.x** — disabled (the `enable_borrowed_range` variable-template syntax triggers a parse error
      under these two toolkit versions; fixed in CUDA 12.2; [issue #3907](https://github.com/nlohmann/json/issues/3907))
@@ -44,12 +44,9 @@ When the macro is not defined, the library will define it to its default value.

 - [JSON_HAS_CPP_11 / JSON_HAS_CPP_14 / JSON_HAS_CPP_17 / JSON_HAS_CPP_20 / JSON_HAS_CPP_23 /
  JSON_HAS_CPP_26](json_has_cpp_11.md) - set supported C++ standard
- [JSON_HAS_RANGE_VIEW_CONVERSION](json_has_range_view_conversion.md) - control construction from `std::ranges` views
 - [JSON_HAS_STD_FORMAT](json_has_std_format.md) - a similar feature-detection macro, for `std::format`/`std::formatter`
  support

 ## Version history

 - Added in version 3.11.0.
- Added the exclusions for libstdc++ < 11, Clang < 16 with libstdc++, libc++ < 16, and nvcc (CUDA) 12.0.x and 12.1.x in
-  version 3.13.0. Before, only GCC 11.1.0 was excluded.
@@ -20,10 +20,7 @@ The macro does not affect:
 - The binary readers ([`from_cbor`](../basic_json/from_cbor.md), [`from_msgpack`](../basic_json/from_msgpack.md),
  [`from_ubjson`](../basic_json/from_ubjson.md), [`from_bjdata`](../basic_json/from_bjdata.md),
  [`from_bson`](../basic_json/from_bson.md)): none of these formats requires a decoder to reject ill-formed UTF-8, so
-  by default they return the bytes unchanged (`error_handler_t::keep`), independent of this macro. Pass an
-  `error_handler` argument explicitly to validate or sanitize the strings they read.
- [`from_bon8`](../basic_json/from_bon8.md): BON8 always validates, because the UTF-8 lead bytes mark where a string
-  ends.
+  they always return the bytes unchanged.

 ## Default definition

@@ -190,5 +190,3 @@ void to_json(BasicJsonType& j, const B& b) {
 4. Added in version 3.12.0.
 5. Added in version 3.12.0.
 6. Added in version 3.12.0.
-
-All six macros were changed to allow an empty member list in version 3.13.0.
@@ -186,6 +186,3 @@ See the examples below for the concrete generated code.
 1. Added in version 3.9.0.
 2. Added in version 3.11.0.
 3. Added in version 3.11.3.
-
-All three macros were changed to work with any `basic_json` specialization (not only `nlohmann::json`) in version 3.12.0,
-and to allow an empty member list in version 3.13.0.
@@ -185,6 +185,3 @@ See the examples below for the concrete generated code.
 1. Added in version 3.9.0.
 2. Added in version 3.11.0.
 3. Added in version 3.11.3.
-
-All three macros were changed to work with any `basic_json` specialization (not only `nlohmann::json`) in version 3.12.0,
-and to allow an empty member list in version 3.13.0.
@@ -38,6 +38,4 @@ the library.

 ## Version history

- Added in version 3.11.0. Changed inline namespace name in version 3.11.2. Added the ABI tag `_dp` in
-  version 3.12.0, and the ABI tags `_bics`, `_psp`, `_snul`, `_sbu8`, and `_ekmo` in version 3.13.0; see
-  [`nlohmann` Namespace](../../features/namespace.md#structure).
+- Added in version 3.11.0. Changed inline namespace name in version 3.11.2.
@@ -14,7 +14,7 @@ These macros can be used to open and close the `nlohmann` namespace. See
 ## Default definition

 The default definitions open and close the `nlohmann` namespace. The precise definition of
-`NLOHMANN_JSON_NAMESPACE_BEGIN` varies as described [here](../../features/namespace.md#structure).
+[`NLOHMANN_JSON_NAMESPACE_BEGIN`] varies as described [here](../../features/namespace.md#structure).

 1. Default definition of `NLOHMANN_JSON_NAMESPACE_BEGIN`:

@@ -10,7 +10,7 @@ The library parses, stores, and serializes JSON values in memory. It does not op
 files (it only reads from streams or `std::FILE*` handles that the caller has already opened), does not read environment
 variables, and does not implement cryptography or handle credentials.

-The primary threat is therefore **untrusted input**: JSON text or binary data (BJData, BON8, BSON, CBOR, MessagePack, UBJSON)
+The primary threat is therefore **untrusted input**: JSON text or binary data (BJData, BSON, CBOR, MessagePack, UBJSON)
 that an attacker controls, passed to [`parse`](../api/basic_json/parse.md), [`accept`](../api/basic_json/accept.md),
 [`sax_parse`](../api/basic_json/sax_parse.md), or one of the `from_*` functions such as
 [`from_cbor`](../api/basic_json/from_cbor.md). Such input may try to
@@ -12,7 +12,7 @@ violations will result in a failed build.

 Note: C++20 modules support may hit compiler-specific issues not covered by the general compiler matrix below. See [Modules](../features/modules.md#known-issues) for known issues and workarounds.

-Note: Some modern features (like C++20 ranges or filesystem support) may be disabled on specific broken or incomplete toolchains even when standard feature-test macros indicate support. See [`JSON_HAS_RANGES`](../api/macros/json_has_ranges.md), [`JSON_HAS_RANGE_VIEW_CONVERSION`](../api/macros/json_has_range_view_conversion.md), and [`JSON_HAS_FILESYSTEM`](../api/macros/json_has_filesystem.md) for details on known exclusions.
+Note: Some modern features (like C++20 ranges or filesystem support) may be disabled on specific broken or incomplete toolchains even when standard feature-test macros indicate support. See [`JSON_HAS_RANGES`](../api/macros/json_has_ranges.md) and [`JSON_HAS_FILESYSTEM`](../api/macros/json_has_filesystem.md) for details on known exclusions.

 - [x] The library is compiled with 50+ different C++ compilers with different operating systems and platforms,
  including the oldest versions known to compile the library.
@@ -107,7 +107,7 @@ Note: Some modern features (like C++20 ranges or filesystem support) may be disa
 - [x] The library is compiled with all C++ language revisions (C++11, C++14, C++17, C++20, C++23, and C++26) to detect
  and fix language deprecations early.
 - [x] The library is checked for compiler warnings:
-  - On Clang, `-Weverything` is used with 7 exceptions.
+  - On Clang, `-Weverything` is used with 8 exceptions.

    ??? abstract "Clang warnings"

@@ -347,13 +347,6 @@ struct adl_serializer<boost::optional<T>> {
 NLOHMANN_JSON_NAMESPACE_END
 ```

-!!! tip "`std::optional` needs no serializer"
-
-    Since version 3.12.0, `std::optional<T>` is supported out of the box when compiling with C++17
-    (`std::nullopt` is converted to and from `null`). Do not write an `adl_serializer` for it; this pattern is only
-    needed for types such as `boost::optional` or for custom semantics. See [Conversions](conversions.md) and
-    [Omitting a field when serializing `std::optional`](conversions.md#omitting-a-field-when-serializing-stdoptional).
-
 !!! note "ABI compatibility"

    Use [`NLOHMANN_JSON_NAMESPACE_BEGIN`](../api/macros/nlohmann_json_namespace_begin.md) and `NLOHMANN_JSON_NAMESPACE_END`
@@ -217,8 +217,7 @@ json j = numbers;   // [1,2,3]
    ```

    This requires [`JSON_HAS_RANGES`](../api/macros/json_has_ranges.md) to be enabled and is unavailable on MinGW due
-    to incomplete C++20 ranges support there; see
-    [`JSON_HAS_RANGE_VIEW_CONVERSION`](../api/macros/json_has_range_view_conversion.md).
+    to incomplete C++20 ranges support there.

 ## Your own types

@@ -30,47 +30,6 @@ you want to access and a default value in case there is no value stored with tha
    | `#!cpp j.value("append", false)`            | `#!json true`                                        |
    | `#!cpp j.value("logLevel", "verbose")`      | `#!json "verbose"`                                   |

-## Nested values
-
-To read a value deep inside a document, pass a [JSON Pointer](../json_pointer.md) instead of a key. The default value is
-returned if the value at the pointer does not exist, including the case that an intermediate key is missing. There is
-no need to check each level with [`contains`](../../api/basic_json/contains.md) first.
-
-```cpp
-json j = {{"server", {{"port", 8080}}}, {"list", {10, 20}}};
-
-int port = j.value("/server/port"_json_pointer, 80);        // 8080
-int timeout = j.value("/server/limits/timeout"_json_pointer, 30); // 30 (missing intermediate key)
-int second = j.value("/list/1"_json_pointer, 0);            // 20 (numeric tokens index arrays)
-int third = j.value("/list/5"_json_pointer, 0);             // 0 (index out of range)
-
-bool has_port = j.contains("/server/port"_json_pointer);    // true
-bool has_host = j.contains("/server/host/name"_json_pointer); // false
-```
-
-If the path is only available as a dotted string such as `#!cpp "server.port"`, do not build the pointer by
-concatenating `#!cpp "/"` and the parts: keys containing `/` or `~` would be misinterpreted. Append each part as a
-reference token with [`operator/=`](../../api/json_pointer/operator_slasheq.md) instead. It escapes the token for you.
-
-```cpp
-json::json_pointer to_pointer(const std::string& dotted)
-{
-    json::json_pointer ptr;
-    std::istringstream in(dotted);
-    for (std::string token; std::getline(in, token, '.');)
-    {
-        ptr /= token;
-    }
-    return ptr;
-}
-
-int port = j.value(to_pointer("server.port"), 80);          // 8080
-int first = j.value(to_pointer("list.0"), 0);               // 10
-```
-
-The key `#!cpp "a/b"` yields the pointer `#!cpp "/a~1b"`; the dot-splitting itself is up to the caller, so keys
-containing `.` need a different separator.
-
 ## Notes

 !!! failure "Exceptions"
@@ -78,31 +37,6 @@ containing `.` need a different separator.
    - With string keys, `value` can only be used with objects. For other types, a [`basic_json::type_error`](../../home/exceptions.md#jsonexceptiontype_error306) is thrown.
    - With JSON Pointers, `value` can be used with both objects and arrays. For other types (null, boolean, number, string), a [`basic_json::type_error`](../../home/exceptions.md#jsonexceptiontype_error306) is thrown.

-!!! warning "`null` and mistyped members are not missing"
-
-    `value` returns the default value only if the key is **absent**. If the member exists, it is converted to the type
-    of the default value, even if it is `#!json null`. For `#!json {"k": null}`, the call `#!cpp j.value("k", 0)` throws
-    a [`basic_json::type_error`](../../home/exceptions.md#jsonexceptiontype_error302), and so does a member of another
-    type such as a string where a number is expected. The same holds for JSON Pointers.
-
-    To treat `#!json null` like a missing value, check for it explicitly:
-
-    ```cpp
-    int n = (j.contains("k") && !j["k"].is_null()) ? j["k"].get<int>() : 0;
-    ```
-
-    With C++17, [`get<std::optional<T>>()`](../../api/basic_json/get.md) maps `#!json null` to an empty optional. As
-    [`at`](../../api/basic_json/at.md) throws [`out_of_range`](../../home/exceptions.md#jsonexceptionout_of_range403)
-    for an absent key, use [`find`](../../api/basic_json/find.md) to cover both cases:
-
-    ```cpp
-    std::optional<int> n;                        // empty if "k" is absent or null
-    if (const auto it = j.find("k"); it != j.end())
-    {
-        n = it->get<std::optional<int>>();       // still throws for a non-number such as "text"
-    }
-    ```
-
 !!! warning "Return type"

    The value function is a template, and the return type of the function is determined by the type of the provided
@@ -129,6 +63,3 @@ containing `.` need a different separator.

 - [`value`](../../api/basic_json/value.md) for access with default value
 - documentation on [checked access](checked_access.md)
- documentation on [JSON Pointer](../json_pointer.md)
- [`contains`](../../api/basic_json/contains.md) to check whether a key or JSON Pointer exists
- [`json_pointer::operator/=`](../../api/json_pointer/operator_slasheq.md) to build a pointer token by token
@@ -77,10 +77,6 @@ auto val2 = j.at(json::json_pointer("/nested/three/1"));    // false
 auto val3 = j.value(json::json_pointer("/nested/four"), 0); // 0
 ```

-To read a value with a fallback, use [`value`](../api/basic_json/value.md) with a JSON Pointer; to test for existence,
-use [`contains`](../api/basic_json/contains.md). Neither needs intermediate checks, see
-[Nested values](element_access/default_value.md#nested-values).
-
 !!! note "Creating intermediate levels that don't exist"

    See the [`operator[]` notes](../api/basic_json/operator%5B%5D.md#return-value) for how array vs. object is
@@ -130,8 +126,6 @@ auto j_original = j_flat.unflatten();
 ## See also

 - Class [`json_pointer`](../api/json_pointer/index.md)
- Functions [`value`](../api/basic_json/value.md), [`contains`](../api/basic_json/contains.md), and
-  [`at`](../api/basic_json/at.md) accept JSON Pointers; see [Nested values](element_access/default_value.md#nested-values)
 - Function [`flatten`](../api/basic_json/flatten.md)
 - Function [`unflatten`](../api/basic_json/unflatten.md)
 - [JSON Patch](json_patch.md) - paths inside a patch are JSON Pointers
@@ -82,45 +82,6 @@ To override the built-in check, define `JSON_HAS_FILESYSTEM` or `JSON_HAS_EXPERI

 See [full documentation of `JSON_HAS_FILESYSTEM` and `JSON_HAS_EXPERIMENTAL_FILESYSTEM`](../api/macros/json_has_filesystem.md).

-## `JSON_HAS_RANGES`
-
-The library uses `std::ranges` (and concepts) where available, for example, to parse from C++20 ranges and to
-construct JSON arrays from range views. The library detects whether the standard library supports ranges and
-disables the support on toolchains with an incomplete implementation. To override the built-in check, define
-`JSON_HAS_RANGES` to `1` or `0`.
-
-See [full documentation of `JSON_HAS_RANGES`](../api/macros/json_has_ranges.md).
-
-## `JSON_HAS_RANGE_VIEW_CONVERSION`
-
-When `JSON_HAS_RANGES` is enabled (and the compiler is not MinGW), a JSON array can be constructed directly from a C++20
-range view such as `std::views::filter(...)`. To override the built-in check, define `JSON_HAS_RANGE_VIEW_CONVERSION` to
-`1` or `0`.
-
-See [full documentation of `JSON_HAS_RANGE_VIEW_CONVERSION`](../api/macros/json_has_range_view_conversion.md).
-
-## `JSON_HAS_STATIC_RTTI`
-
-The library detects whether the compiler supports run time type information (RTTI), which it needs, for instance, to
-exclude `std::any` from the candidate types of the implicit conversion on C++17. To override the built-in check, define
-`JSON_HAS_STATIC_RTTI` to `1` or `0`.
-
-See [full documentation of `JSON_HAS_STATIC_RTTI`](../api/macros/json_has_static_rtti.md).
-
-## `JSON_HAS_STD_FORMAT`
-
-When compiling with C++20 and a standard library that provides `<format>`, the library provides a `std::formatter`
-specialization for JSON values. To override the built-in check, define `JSON_HAS_STD_FORMAT` to `1` or `0`.
-
-See [full documentation of `JSON_HAS_STD_FORMAT`](../api/macros/json_has_std_format.md).
-
-## `JSON_HAS_THREE_WAY_COMPARISON`
-
-When the compiler and standard library support 3-way comparison (the spaceship operator `<=>`), the library provides it
-for JSON values. To override the built-in check, define `JSON_HAS_THREE_WAY_COMPARISON` to `1` or `0`.
-
-See [full documentation of `JSON_HAS_THREE_WAY_COMPARISON`](../api/macros/json_has_three_way_comparison.md).
-
 ## `JSON_NOEXCEPTION`

 Exceptions can be switched off by defining the symbol `JSON_NOEXCEPTION`.
@@ -9,13 +9,6 @@ syntax that closely mimics the document being modified. Unlike [JSON Patch](json
 express every kind of change (e.g., it cannot reorder array elements or remove a specific array element), but it is
 easier to read and write for object-shaped documents.

-!!! tip "Not a general deep merge"
-
-    A merge patch is not a general deep merge: a `#!json null` value in the patch deletes the key from the target.
-    To merge two objects recursively (e.g., defaults and user settings), use
-    [`update`](../api/basic_json/update.md) with `merge_objects` set to `#!cpp true`; see
-    [Merging objects](modifying_values.md#merging-objects).
-
 ??? example

    The following code shows how a JSON Merge Patch is applied to a JSON document.
@@ -35,4 +28,3 @@ easier to read and write for object-shaped documents.
 - [JSON Patch and Diff](json_patch.md) - a more expressive alternative that describes a sequence of operations
 - [JSON Pointer](json_pointer.md) - the addressing scheme used by JSON Patch
 - Function [`merge_patch`](../api/basic_json/merge_patch.md)
- Function [`update`](../api/basic_json/update.md) - merge objects, optionally recursively
@@ -35,12 +35,8 @@ the insertion happened — useful for "add if absent" semantics.

 ## Merging objects

-To merge one object into another, [`update`](../api/basic_json/update.md) copies all members from another object
-(similar to Python's `dict.update`). This is the idiomatic way to combine two objects. It has two modes:
-
- By default, the merge is shallow: existing keys are overwritten, even if both values are objects.
- With `merge_objects = #!cpp true`, keys whose values are objects in both JSON values are merged recursively.
-  Everything else is overwritten. In particular, arrays are replaced, not concatenated.
+To merge one object into another, [`update`](../api/basic_json/update.md) copies all members from another object,
+overwriting existing keys (similar to Python's `dict.update`). This is the idiomatic way to combine two objects.

 ??? example

@@ -54,22 +50,9 @@ To merge one object into another, [`update`](../api/basic_json/update.md) copies
    --8<-- "examples/update.output"
    ```

-A common use of the recursive mode is combining defaults with user settings. Nested defaults that the user did not set
-are kept:
-
-```cpp
-json defaults = {{"log", {{"level", "info"}, {"file", "app.log"}}}, {"retries", 3}};
-json user_settings = {{"log", {{"level", "debug"}}}};
-
-json config = defaults;
-config.update(user_settings, true);
-// {"log":{"file":"app.log","level":"debug"},"retries":3}
-```
-
-[JSON Merge Patch](merge_patch.md) ([RFC 7386](https://tools.ietf.org/html/rfc7386)) also merges objects recursively,
-but it is a different tool: a `#!json null` in the patch means "remove this key". It is meant for applying merge patch
-documents (e.g., received via HTTP PATCH). To merge configuration-like objects, use `#!cpp update(..., true)`. To apply
-a sequence of well-defined edit operations, see [JSON Patch](json_patch.md).
+For a recursive merge that follows [RFC 7386](https://tools.ietf.org/html/rfc7386), see
+[JSON Merge Patch](merge_patch.md). To apply a sequence of well-defined edit operations, see
+[JSON Patch](json_patch.md).

 ## Removing elements

@@ -89,7 +72,6 @@ a.erase(1);             // [1,3,4]  (erase by index)

 - [`push_back`](../api/basic_json/push_back.md) / [`emplace_back`](../api/basic_json/emplace_back.md) - append to an array
 - [`emplace`](../api/basic_json/emplace.md) - insert into an object if the key is absent
- [`update`](../api/basic_json/update.md) - merge objects (shallow, or recursive with `merge_objects`)
- [`merge_patch`](../api/basic_json/merge_patch.md) - apply an RFC 7386 merge patch
+- [`update`](../api/basic_json/update.md) - merge objects
 - [`erase`](../api/basic_json/erase.md) / [`clear`](../api/basic_json/clear.md) - remove elements
 - [JSON Patch and Diff](json_patch.md) and [JSON Merge Patch](merge_patch.md) - structured modifications
@@ -101,9 +101,3 @@ follows:

 - Introduced inline namespace (`json_v3_11_0[_abi-tag]*`) in version 3.11.0.
 - Changed structure of inline namespace in version 3.11.2.
- Added ABI tag `_dp` ([`JSON_DIAGNOSTIC_POSITIONS`](../api/macros/json_diagnostic_positions.md)) in version 3.12.0.
- Added ABI tags `_bics` ([`JSON_BRACE_INIT_COPY_SEMANTICS`](../api/macros/json_brace_init_copy_semantics.md)), `_psp`
-  ([`JSON_PRECISE_STREAM_POSITION`](../api/macros/json_precise_stream_position.md)), `_snul`
-  ([`JSON_STRICT_NUL_HANDLING`](../api/macros/json_strict_nul_handling.md)), `_sbu8`
-  ([`JSON_STRICT_BINARY_UTF8`](../api/macros/json_strict_binary_utf8.md)), and `_ekmo`
-  ([`JSON_USE_OBJECTS_FOR_ENUM_KEYED_MAPS`](../api/macros/json_use_objects_for_enum_keyed_maps.md)) in version 3.13.0.
@@ -82,13 +82,12 @@ flowchart TD

    - Numbers with a decimal digit or scientific notation are always stored as `#!c double`.
    - The number types can be changed, see [Template number types](#template-number-types). 
-    - The library converts integers and floating-point numbers itself, independent of the locale. Floating-point
-      numbers are correctly rounded (to nearest, ties to even). Only a `#!c long double` that is not IEEE 754 binary64
-      (e.g., the 80-bit x87 format) is converted with `#!cpp std::from_chars` where available, or else with
-      [`std::strtold`](https://en.cppreference.com/w/cpp/string/byte/strtof). For that call, the library temporarily
-      replaces the `.` with the decimal point of the current locale (which may be longer than one byte, e.g., in
-      `fa_IR.UTF-8`), so the result does not depend on the locale either. Changing the locale in another thread during
-      parsing is undefined behavior of the C library, though. Before version 3.13.0, the conversion was realized by
+    - Integers are converted by the library's own digit parser. Floating-point numbers are converted with
+      [`std::from_chars`](https://en.cppreference.com/w/cpp/utility/from_chars) if the library is compiled with C++17
+      and the standard library supports it, then with an exact fast path for `#!c double` values with few significant
+      digits, and otherwise with the locale-aware
+      [`std::strtod`](https://en.cppreference.com/w/cpp/string/byte/strtof) (`std::strtof`/`std::strtold` for the
+      other floating-point types). Before version 3.13.0, the conversion was realized by
      [`std::strtoull`](https://en.cppreference.com/w/cpp/string/byte/strtoul),
      [`std::strtoll`](https://en.cppreference.com/w/cpp/string/byte/strtol), and `std::strtod`, respectively.

@@ -101,10 +100,10 @@ flowchart TD
 ### Number limits

 - Any 64-bit signed or unsigned integer can be stored without loss of precision.
- Numbers exceeding the limits of `#!c double` (i.e., numbers whose rounded value is not satisfying
+- Numbers exceeding the limits of `#!c double` (i.e., numbers that after conversion via
+[`std::strtod`](https://en.cppreference.com/w/cpp/string/byte/strtof) are not satisfying
 [`std::isfinite`](https://en.cppreference.com/w/cpp/numeric/math/isfinite) such as `#!c 1E400`) will throw exception
-[`json.exception.out_of_range.406`](../../home/exceptions.md#jsonexceptionout_of_range406) during parsing. Numbers too
-small for `#!c double` (such as `#!c 1E-400`) become zero, with the sign of the number.
+[`json.exception.out_of_range.406`](../../home/exceptions.md#jsonexceptionout_of_range406) during parsing.
 - Floating-point numbers are rounded to the next number representable as `double`. For instance
 `#!c 3.141592653589793238462643383279` is stored as [`0x400921fb54442d18`](https://float.exposed/0x400921fb54442d18).
 This is the same behavior as the code `#!c double x = 3.141592653589793238462643383279;`.
@@ -30,9 +30,9 @@ Requirements are split into two groups:
    diagnosed with dedicated error messages, and violating most of them results in a compiler error somewhere inside
    the library. Four violations are not caught at compile time at all:

-    - A [`StringType`](#stringtype) whose `data()` is not null-terminated compiles and silently misparses numbers
-      stored as a `#!cpp long double` that is not IEEE 754 binary64 (e.g., the 80-bit x87 format), because the lexer
-      hands the buffer to `#!cpp std::strtold`.
+    - A [`StringType`](#stringtype) whose `data()` is not null-terminated compiles and can silently misparse
+      floating-point numbers, because the lexer may hand the buffer to `#!cpp std::strtod`, which reads up to the
+      terminating null character.
    - A stateful [`AllocatorType`](#allocatortype) compiles and silently ignores its state: allocation, deallocation,
      and [`get_allocator()`](../../api/basic_json/get_allocator.md) each use a different default-constructed instance.
    - The two [cross-specialization conversions](#cross-specialization-conversions) below. These abort on an assertion
@@ -353,21 +353,16 @@ using array_t = ArrayType<basic_json, AllocatorType<basic_json>>;
 ### Always required

 - A member type `value_type` that is one byte wide and `char`-compatible. The library stores and processes UTF-8
-  encoded `char` data and passes `data()` to functions that take a `#!cpp const char*`, such as `#!cpp std::strtold`
-  (only used to parse a `#!cpp long double` that is not IEEE 754 binary64, see
-  [`NumberFloatType`](#numberfloattype)).
+  encoded `char` data and passes `data()` to functions that take a `#!cpp const char*`, such as `#!cpp std::strtod`.
  `#!cpp std::wstring`, `#!cpp std::u16string`, and `#!cpp std::u32string` are **not** valid choices; see the FAQ on
  [wide string handling](../../home/faq.md#wide-string-handling).
 - Constructors: default, copy, move, from `#!cpp const char*` (which must not be `#!cpp explicit`), from
  `#!cpp (const char*, size_type)`, and from `#!cpp (size_type, char)`; and copy or move assignment.
 - Member functions `size()`, `clear()`, `resize(n, c)`, `data()`, `push_back(char)`, and `operator[]`
  (const and non-const, returning references). `c_str()` and `back()` are **not** required.
- `data()` must return a pointer to a contiguous, **null-terminated** buffer. `#!cpp float`, `#!cpp double`, and a
-  `#!cpp long double` that is IEEE 754 binary64 are converted by the library itself and do not depend on this. For any
-  other `NumberFloatType` (a `#!cpp long double` of another format), the parser falls back to `#!cpp std::strtold` when
-  `#!cpp std::from_chars` is not available or declines the token, and `std::strtold` reads up to the null character. A type whose `data()`
-  is not null-terminated does not fail to compile; with such a `NumberFloatType` it can silently misparse
-  floating-point numbers.
+- `data()` must return a pointer to a contiguous, **null-terminated** buffer -- the parser may hand it to
+  `#!cpp std::strtod`, which reads up to the null character. A type whose `data()` is not null-terminated does not
+  fail to compile; it can silently misparse floating-point numbers.
 - `append(const char*, size_type)`, used by [`dump`](../../api/basic_json/dump.md), and `append(const StringType&)`,
  used by the CBOR reader for indefinite-length strings. The library's internal string concatenation additionally has
  to append a `#!cpp char` and a `#!cpp const char*`; for each it selects between `append(arg)`, `#!cpp operator+=`,
@@ -546,10 +541,9 @@ therefore silently changes parse results rather than raising an error. See

 `NumberFloatType` must be one of `#!cpp float`, `#!cpp double`, or `#!cpp long double`:

- The [parser](../parsing/index.md) converts number literals to `#!cpp float`, `#!cpp double`, and a
-  `#!cpp long double` that is IEEE 754 binary64 itself; other `#!cpp long double` formats are converted with
-  `#!cpp std::from_chars` where available, or with `#!cpp std::strtold`. The library provides overloads for exactly
-  these three types.
+- The [parser](../parsing/index.md) converts number literals with `#!cpp std::from_chars` or, as a fallback, with
+  `#!cpp std::strtof`, `#!cpp std::strtod`, or `#!cpp std::strtold`; the library provides overloads for exactly these
+  three types.
 - [`dump`](../../api/basic_json/dump.md) falls back to `#!cpp std::snprintf` with the `%g` and `%Lg` conversion
  specifiers, for which the library likewise provides only `#!cpp double` and `#!cpp long double` overloads
  (`#!cpp float` is promoted to `#!cpp double`).
@@ -34,7 +34,7 @@ flowchart LR

 - **JSON text** is read by an [input adapter](#input-adapters), tokenized by the lexer, and turned into SAX events by
  the parser.
- **Binary formats** (BJData, BON8, BSON, CBOR, MessagePack, UBJSON) are read by an input adapter and turned into the same SAX
+- **Binary formats** (BJData, BSON, CBOR, MessagePack, UBJSON) are read by an input adapter and turned into the same SAX
  events by the `binary_reader`.
 - A [SAX consumer](#sax-interface) receives the events. The one used by [`parse`](../api/basic_json/parse.md) builds a
  `basic_json` value tree.
@@ -6,7 +6,7 @@ There are myriads of [JSON](https://json.org) libraries out there, and each may

 - **Trivial integration**. Our whole code consists of a single header file [`json.hpp`](https://github.com/nlohmann/json/blob/develop/single_include/nlohmann/json.hpp). That's it. No library, no subproject, no dependencies, no complex build system. The class is written in vanilla C++11. All in all, everything should require no adjustment of your compiler flags or project settings.

- **Serious testing**. Our class is heavily [unit-tested](https://github.com/nlohmann/json/tree/develop/tests/src) and covers [100%](https://coveralls.io/r/nlohmann/json) of the code, including all exceptional behavior. Furthermore, we checked with [Valgrind](https://valgrind.org) and the [Clang Sanitizers](https://clang.llvm.org/docs/index.html) that there are no memory leaks. [Google OSS-Fuzz](https://github.com/google/oss-fuzz/tree/master/projects/json) additionally runs fuzz tests against all parsers 24/7, effectively executing billions of tests so far. To maintain high quality, the project is following the [OpenSSF Best Practices](https://www.bestpractices.dev/projects/289).
+- **Serious testing**. Our class is heavily [unit-tested](https://github.com/nlohmann/json/tree/develop/tests/src) and covers [100%](https://coveralls.io/r/nlohmann/json) of the code, including all exceptional behavior. Furthermore, we checked with [Valgrind](http://valgrind.org) and the [Clang Sanitizers](https://clang.llvm.org/docs/index.html) that there are no memory leaks. [Google OSS-Fuzz](https://github.com/google/oss-fuzz/tree/master/projects/json) additionally runs fuzz tests against all parsers 24/7, effectively executing billions of tests so far. To maintain high quality, the project is following the [OpenSSF Best Practices](https://www.bestpractices.dev/projects/289).

 Other aspects were not so important to us:

@@ -14,4 +14,4 @@ Other aspects were not so important to us:

 - **Speed**. There are certainly [faster JSON libraries](https://github.com/miloyip/nativejson-benchmark#parsing-time) out there. However, if your goal is to speed up your development by adding JSON support with a single header, then this library is the way to go. If you know how to use a `std::vector` or `std::map`, you are already set.

-See the [contribution guidelines](https://github.com/nlohmann/json/blob/develop/.github/CONTRIBUTING.md#please-dont) for more information.
+See the [contribution guidelines](https://github.com/nlohmann/json/blob/master/.github/CONTRIBUTING.md#please-dont) for more information.
@@ -104,7 +104,7 @@ See [documentation of `JSON_DIAGNOSTICS`](../api/macros/json_diagnostics.md) for
 ## Parse errors

 The library throws this exception when a parse error occurs. Parse errors
-can occur during the deserialization of JSON text or of one of the binary formats (BJData, BON8, BSON, CBOR, MessagePack, UBJSON), as well
+can occur during the deserialization of JSON text, CBOR, MessagePack, as well
 as when using JSON Patch.

 Exceptions have ids 1xx.
@@ -190,7 +190,7 @@ This error indicates a syntax error while deserializing a JSON text. The error m
 !!! tip

    - Make sure the input is correctly read. Try to write the input to standard output to check if, for instance, the input file was successfully opened.
-    - Paste the input to a JSON validator like <https://jsonlint.com> or a tool like [jq](https://jqlang.github.io/jq/).
+    - Paste the input to a JSON validator like <http://jsonlint.com> or a tool like [jq](https://stedolan.github.io/jq/).

 ### json.exception.parse_error.102

@@ -278,9 +278,7 @@ In a JSON Pointer, only `~0` and `~1` are valid escape sequences.

 ### json.exception.parse_error.109

-A JSON Pointer array index must be a number. This exception is thrown for an array index that does not begin with a
-digit, except for `-` and the empty reference token, which throw [`out_of_range.404`](#jsonexceptionout_of_range404)
-where they cannot be resolved.
+A JSON Pointer array index must be a number.

 !!! failure "Example messages"

@@ -291,11 +289,6 @@ where they cannot be resolved.
    [json.exception.parse_error.109] parse error: array index '+1' is not a number
    ```

-!!! note
-
-    Before version 3.13.0, a one-character array index that is not a digit (e.g., `x`) threw
-    [`out_of_range.404`](#jsonexceptionout_of_range404) instead.
-
 ### json.exception.parse_error.110

 When parsing a [binary format](../features/binary_formats/index.md), the byte vector ends before the complete value has
@@ -817,7 +810,7 @@ does not list an enumerator and it is therefore converted like the first listed
 A discarded value (one created by [`parse()`](../api/basic_json/parse.md) with a callback that returns `false` for the
 value, or by default-constructing a [`basic_json`](../api/basic_json/index.md) with
 [`value_t::discarded`](../api/basic_json/value_t.md)) was passed to a binary serialization function, either directly or
-nested in an array or object. There is no way to represent a discarded value in CBOR, MessagePack, UBJSON, BJData, BSON, or BON8.
+nested in an array or object. There is no way to represent a discarded value in CBOR, MessagePack, UBJSON, BJData, or BSON.

 !!! failure "Example message"

@@ -878,8 +871,7 @@ The provided key was not found in the JSON object.

 ### json.exception.out_of_range.404

-A reference token in a JSON Pointer could not be resolved, for instance an array index that begins with a digit but
-contains other characters (e.g., `1a`), or `-` where it cannot be used.
+A reference token in a JSON Pointer could not be resolved.

 !!! failure "Example message"

@@ -914,14 +906,34 @@ double-precision number when `number_float_t` is `#!cpp float`.

 ### json.exception.out_of_range.407

-This exception previously indicated that the UBJSON and BSON binary formats did not support integer numbers greater than
-9223372036854775807 due to limitations in the implemented mapping. However, these limitations have since been resolved,
-and this exception no longer occurs.
+An integer number cannot be represented by the binary format it is serialized to:

-!!! success "Exception cannot occur any more"
+- [BON8](../features/binary_formats/bon8.md) only stores integers that fit into int64.
+- [CBOR](../features/binary_formats/cbor.md), [MessagePack](../features/binary_formats/messagepack.md), and
+  [BSON](../features/binary_formats/bson.md) store integers in at most 64 bits. With the default number types, every
+  integer fits, but a [`number_integer_t`](../api/basic_json/number_integer_t.md) or
+  [`number_unsigned_t`](../api/basic_json/number_unsigned_t.md) wider than 64 bits (e.g., `__int128`) can hold values
+  outside the range of the format: [-2^64, 2^64-1] for CBOR, [-2^63, 2^64-1] for MessagePack, and the range of int64
+  (signed integers) or uint64 (unsigned integers) for BSON.

-    - Since version 3.9.0, integer numbers beyond int64 are serialized as high-precision UBJSON numbers.
-    - Since version 3.12.0, integer numbers beyond int64 are serialized as uint64 BSON numbers.
+[UBJSON](../features/binary_formats/ubjson.md) and [BJData](../features/binary_formats/bjdata.md) never throw this
+exception, because they serialize integers beyond 64 bits as high-precision numbers.
+
+!!! failure "Example messages"
+
+    ```
+    integer number 9223372036854775808 cannot be represented by BON8 as it does not fit int64
+    ```
+    ```
+    integer number 1267650600228229401496703205376 cannot be represented by CBOR as it does not fit [-2^64, 2^64-1]
+    ```
+
+!!! note
+
+    Before version 3.13.0, CBOR, MessagePack, and BSON silently truncated integers wider than 64 bits, and BJData
+    truncated unsigned integers wider than 64 bits. This exception was previously thrown by UBJSON and BSON for
+    integers greater than 9223372036854775807; since version 3.9.0, such integers are serialized as high-precision
+    UBJSON numbers, and since version 3.12.0 as uint64 BSON numbers.

 ### json.exception.out_of_range.408

@@ -20,4 +20,4 @@ The class contains a slightly modified version of the Grisu2 algorithm from Flor

 The class contains a copy of [Hedley](https://nemequ.github.io/hedley/) from Evan Nemerson which is licensed as [CC0-1.0](https://creativecommons.org/publicdomain/zero/1.0/).

-The class contains an adapted version of the Eisel-Lemire algorithm, its table of powers of five, and its digit comparison for long numbers from [fast_float](https://github.com/fastfloat/fast_float) by Daniel Lemire and contributors, which is available under the [MIT License](https://opensource.org/licenses/MIT) (used here), the Apache 2.0 License, and the Boost Software License. Copyright &copy; 2021 The fast_float authors
+The class contains an adapted version of the Eisel-Lemire algorithm and its table of powers of five from [fast_float](https://github.com/fastfloat/fast_float) by Daniel Lemire and contributors, which is available under the [MIT License](https://opensource.org/licenses/MIT) (used here), the Apache 2.0 License, and the Boost Software License. Copyright &copy; 2021 The fast_float authors
@@ -26,7 +26,7 @@ Fixes bugs found in 3.11.3 and adds several features. All changes are backward-c
  [BJData](../features/binary_formats/bjdata.md) draft 3 and unsigned 64-bit integers for
  [BSON](../features/binary_formats/bson.md).
 - Adds multidimensional C-array conversion and UTF-8 encoded `std::filesystem::path` conversions, and
-  raises the minimum [CMake](../integration/cmake.md) version to 3.5 and supports CMake 4.0.
+  lowers the minimum [CMake](../integration/cmake.md) version to allow CMake 4.0.

 [Full release notes](https://github.com/nlohmann/json/releases/tag/v3.12.0).

@@ -2,8 +2,8 @@ cmake_minimum_required(VERSION 3.15)

 include("cmake/HunterGate.cmake")
 HunterGate(
-    URL "https://github.com/cpp-pm/hunter/archive/v0.26.12.tar.gz"
-    SHA1 "6498c5d0dec25d7fffb2b0574ebaf265179b894d"
+    URL "https://github.com/cpp-pm/hunter/archive/v0.23.297.tar.gz"
+    SHA1 "3319fe6a3b08090df7df98dee75134d68e2ef5a3"
 )

 project(json_example)
@@ -2,30 +2,12 @@

 # Creates a `<path>.md` sibling of each HTML output (for example,
 # `features/comments/` becomes `features/comments.md`) so agents and tools can
-# fetch the raw Markdown directly instead of parsing rendered HTML. The
-# `--8<-- "path"` lines of pymdownx.snippets are expanded with the extension's
-# own preprocessor and the settings from mkdocs.yml, so the copies contain the
-# included example code and files instead of the include directives.
+# fetch the raw Markdown directly instead of parsing rendered HTML.

-import io
 import os
-
-import markdown
-from pymdownx.snippets import SnippetMissingError
+import shutil

 _pages = []
-_snippets = None
-
-
-def on_config(config):
-    global _snippets
-    md = markdown.Markdown(
-        extensions=["pymdownx.snippets"],
-        extension_configs={"pymdownx.snippets": config["mdx_configs"].get("pymdownx.snippets", {})},
-    )
-    _snippets = md.preprocessors["snippet"]
-    _snippets.auto_append = []  # the glossary is only needed to render abbreviations
-    return config


 def on_files(files, config):
@@ -40,11 +22,4 @@ def on_post_build(config):
        url = file.url.rstrip("/")
        target = os.path.join(site_dir, (url or "index") + ".md")
        os.makedirs(os.path.dirname(target), exist_ok=True)
-        with io.open(file.abs_src_path, encoding="utf-8", newline="") as source:
-            text = source.read()
-        try:
-            text = "\n".join(_snippets.run(text.split("\n")))
-        except (SnippetMissingError, OSError):
-            pass  # keep the include directives; the regular build reports the missing file
-        with io.open(target, "w", encoding="utf-8", newline="") as copy:
-            copy.write(text)
+        shutil.copyfile(file.abs_src_path, target)
@@ -1,7 +1,7 @@
 <!-- https://squidfunk.github.io/mkdocs-material/reference/tooltips/#adding-a-glossary -->

 *[ADL]: Argument-dependent lookup
-*[API]: Application Programming Interface
+*[API]: Application Programming Interfaces
 *[ASCII]: American Standard Code for Information Interchange
 *[BDFL]: Benevolent Dictator for Life
 *[BJData]: Binary JData
@@ -299,7 +299,6 @@ nav:
          - 'JSON_DISABLE_TUPLE_REFERENCE_CONVERSION': api/macros/json_disable_tuple_reference_conversion.md
          - 'JSON_HAS_CPP_11, JSON_HAS_CPP_14, JSON_HAS_CPP_17, JSON_HAS_CPP_20, JSON_HAS_CPP_23, JSON_HAS_CPP_26': api/macros/json_has_cpp_11.md
          - 'JSON_HAS_EXPERIMENTAL_FILESYSTEM, JSON_HAS_FILESYSTEM': api/macros/json_has_filesystem.md
-          - 'JSON_HAS_RANGE_VIEW_CONVERSION': api/macros/json_has_range_view_conversion.md
          - 'JSON_HAS_RANGES': api/macros/json_has_ranges.md
          - 'JSON_HAS_STATIC_RTTI': api/macros/json_has_static_rtti.md
          - 'JSON_HAS_STD_FORMAT': api/macros/json_has_std_format.md
@@ -9,9 +9,8 @@
 #pragma once

 #include <cstdint> // uint64_t
-#include <cstring> // memcpy
-#if defined(_MSC_VER) && (defined(_M_X64) || defined(_M_ARM64)) && (!defined(__SIZEOF_INT128__) || (!defined(__GNUC__) && !defined(__clang__)))
-    #include <intrin0.h> // __umulh, _umul128, _BitScanForward64, _BitScanReverse64
+#if !defined(__SIZEOF_INT128__) && defined(_MSC_VER) && (defined(_M_X64) || defined(_M_ARM64))
+    #include <intrin0.h> // __umulh, _umul128
 #endif

 #include <nlohmann/detail/abi_macros.hpp>
@@ -29,10 +28,6 @@ inline int count_leading_zeros(std::uint64_t x) noexcept
 {
 #if defined(__GNUC__) || defined(__clang__)
    return __builtin_clzll(x);
-#elif defined(_MSC_VER) && (defined(_M_X64) || defined(_M_ARM64))
-    unsigned long index = 0; // NOLINT(runtime/int): the type _BitScan*64 takes
-    _BitScanReverse64(&index, x);
-    return 63 - static_cast<int>(index);
 #else
    int n = 0;
    for (int shift = 32; shift != 0; shift >>= 1)
@@ -47,29 +42,6 @@ inline int count_leading_zeros(std::uint64_t x) noexcept
 #endif
 }

-/// number of trailing zero bits of x (x != 0)
-inline int count_trailing_zeros(std::uint64_t x) noexcept
-{
-#if defined(__GNUC__) || defined(__clang__)
-    return __builtin_ctzll(x);
-#elif defined(_MSC_VER) && (defined(_M_X64) || defined(_M_ARM64))
-    unsigned long index = 0; // NOLINT(runtime/int): the type _BitScan*64 takes
-    _BitScanForward64(&index, x);
-    return static_cast<int>(index);
-#else
-    int n = 0;
-    for (int shift = 32; shift != 0; shift >>= 1)
-    {
-        if ((x << (64 - shift)) == 0)
-        {
-            n += shift;
-            x >>= shift;
-        }
-    }
-    return n;
-#endif
-}
-
 /// the 128-bit product of two 64-bit numbers
 struct uint128_parts
 {
@@ -103,26 +75,15 @@ inline uint128_parts full_multiplication(std::uint64_t a, std::uint64_t b) noexc
 #endif
 }

-/// eight bytes as a little-endian word (a single load on little-endian targets)
-inline std::uint64_t read_eight_bytes(const unsigned char* b) noexcept
+/// eight bytes as a little-endian word (compilers fold this into one load on
+/// little-endian targets)
+inline std::uint64_t read_eight_bytes(const char* p) noexcept
 {
-#if defined(_MSC_VER) || defined(__x86_64__) || defined(__i386__) || (defined(__BYTE_ORDER__) && defined(__ORDER_LITTLE_ENDIAN__) && __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__)
-    // the byte order already matches (all MSVC targets are little-endian)
-    std::uint64_t result = 0;
-    std::memcpy(&result, b, sizeof(result));
-    return result;
-#else
+    const auto* b = reinterpret_cast<const unsigned char*>(p); // NOLINT(cppcoreguidelines-pro-type-reinterpret-cast)
    return static_cast<std::uint64_t>(b[0]) | (static_cast<std::uint64_t>(b[1]) << 8u)
           | (static_cast<std::uint64_t>(b[2]) << 16u) | (static_cast<std::uint64_t>(b[3]) << 24u)
           | (static_cast<std::uint64_t>(b[4]) << 32u) | (static_cast<std::uint64_t>(b[5]) << 40u)
           | (static_cast<std::uint64_t>(b[6]) << 48u) | (static_cast<std::uint64_t>(b[7]) << 56u);
-#endif
-}
-
-/// eight bytes as a little-endian word
-inline std::uint64_t read_eight_bytes(const char* p) noexcept
-{
-    return read_eight_bytes(reinterpret_cast<const unsigned char*>(p)); // NOLINT(cppcoreguidelines-pro-type-reinterpret-cast)
 }

 }  // namespace detail
@@ -48,7 +48,7 @@ inline void from_json(const BasicJsonType& j, typename std::nullptr_t& n)
 {
    if (JSON_HEDLEY_UNLIKELY(!j.is_null()))
    {
-        throw_type_must_be("null", j);
+        JSON_THROW(type_error::create(302, concat("type must be null, but is ", j.type_name()), &j));
    }
    n = nullptr;
 }
@@ -102,7 +102,7 @@ void get_arithmetic_value(const BasicJsonType& j, ArithmeticType& val)
        case value_t::binary:
        case value_t::discarded:
        default:
-            throw_type_must_be("number", j);
+            JSON_THROW(type_error::create(302, concat("type must be number, but is ", j.type_name()), &j));
    }
 }

@@ -111,7 +111,7 @@ inline void from_json(const BasicJsonType& j, typename BasicJsonType::boolean_t&
 {
    if (JSON_HEDLEY_UNLIKELY(!j.is_boolean()))
    {
-        throw_type_must_be("boolean", j);
+        JSON_THROW(type_error::create(302, concat("type must be boolean, but is ", j.type_name()), &j));
    }
    b = *j.template get_ptr<const typename BasicJsonType::boolean_t*>();
 }
@@ -121,7 +121,7 @@ inline void from_json(const BasicJsonType& j, typename BasicJsonType::string_t&
 {
    if (JSON_HEDLEY_UNLIKELY(!j.is_string()))
    {
-        throw_type_must_be("string", j);
+        JSON_THROW(type_error::create(302, concat("type must be string, but is ", j.type_name()), &j));
    }
    s = *j.template get_ptr<const typename BasicJsonType::string_t*>();
 }
@@ -137,7 +137,7 @@ inline void from_json(const BasicJsonType& j, StringType& s)
 {
    if (JSON_HEDLEY_UNLIKELY(!j.is_string()))
    {
-        throw_type_must_be("string", j);
+        JSON_THROW(type_error::create(302, concat("type must be string, but is ", j.type_name()), &j));
    }

    s = *j.template get_ptr<const typename BasicJsonType::string_t*>();
@@ -183,7 +183,7 @@ inline void from_json(const BasicJsonType& j, std::forward_list<T, Allocator>& l
 {
    if (JSON_HEDLEY_UNLIKELY(!j.is_array()))
    {
-        throw_type_must_be("array", j);
+        JSON_THROW(type_error::create(302, concat("type must be array, but is ", j.type_name()), &j));
    }
    l.clear();
    std::transform(j.rbegin(), j.rend(),
@@ -200,7 +200,7 @@ inline void from_json(const BasicJsonType& j, std::valarray<T>& l)
 {
    if (JSON_HEDLEY_UNLIKELY(!j.is_array()))
    {
-        throw_type_must_be("array", j);
+        JSON_THROW(type_error::create(302, concat("type must be array, but is ", j.type_name()), &j));
    }
    l.resize(j.size());
    std::transform(j.begin(), j.end(), std::begin(l),
@@ -305,7 +305,7 @@ void())
 {
    if (JSON_HEDLEY_UNLIKELY(!j.is_array()))
    {
-        throw_type_must_be("array", j);
+        JSON_THROW(type_error::create(302, concat("type must be array, but is ", j.type_name()), &j));
    }

    from_json_array_impl(j, arr, priority_tag<3> {});
@@ -324,7 +324,7 @@ auto from_json(const BasicJsonType& j, identity_tag<std::array<T, N>> tag)
 {
    if (JSON_HEDLEY_UNLIKELY(!j.is_array()))
    {
-        throw_type_must_be("array", j);
+        JSON_THROW(type_error::create(302, concat("type must be array, but is ", j.type_name()), &j));
    }

    return from_json_inplace_array_impl(j, tag, make_index_sequence<N> {});
@@ -335,7 +335,7 @@ inline void from_json(const BasicJsonType& j, typename BasicJsonType::binary_t&
 {
    if (JSON_HEDLEY_UNLIKELY(!j.is_binary()))
    {
-        throw_type_must_be("binary", j);
+        JSON_THROW(type_error::create(302, concat("type must be binary, but is ", j.type_name()), &j));
    }

    bin = *j.template get_ptr<const typename BasicJsonType::binary_t*>();
@@ -356,7 +356,7 @@ inline void from_json(const BasicJsonType& j, CompatibleArrayType& bin)
    }
    else
    {
-        throw_type_must_be("binary or array", j);
+        JSON_THROW(type_error::create(302, concat("type must be binary or array, but is ", j.type_name()), &j));
    }
 }

@@ -377,7 +377,7 @@ inline void from_json(const BasicJsonType& j, ConstructibleObjectType& obj)
 {
    if (JSON_HEDLEY_UNLIKELY(!j.is_object()))
    {
-        throw_type_must_be("object", j);
+        JSON_THROW(type_error::create(302, concat("type must be object, but is ", j.type_name()), &j));
    }

    ConstructibleObjectType ret;
@@ -432,7 +432,7 @@ inline void from_json(const BasicJsonType& j, ArithmeticType& val)
        case value_t::binary:
        case value_t::discarded:
        default:
-            throw_type_must_be("number", j);
+            JSON_THROW(type_error::create(302, concat("type must be number, but is ", j.type_name()), &j));
    }
 }

@@ -504,7 +504,7 @@ auto from_json(const BasicJsonType& j, TupleRelated&& t)
 {
    if (JSON_HEDLEY_UNLIKELY(!j.is_array()))
    {
-        throw_type_must_be("array", j);
+        JSON_THROW(type_error::create(302, concat("type must be array, but is ", j.type_name()), &j));
    }

    return from_json_tuple_impl(j, std::forward<TupleRelated>(t), priority_tag<3> {});
@@ -517,14 +517,14 @@ void from_json_pair_array_to_map(const BasicJsonType& j, MapType& m)
 {
    if (JSON_HEDLEY_UNLIKELY(!j.is_array()))
    {
-        throw_type_must_be("array", j);
+        JSON_THROW(type_error::create(302, concat("type must be array, but is ", j.type_name()), &j));
    }
    m.clear();
    for (const auto& p : j)
    {
        if (JSON_HEDLEY_UNLIKELY(!p.is_array()))
        {
-            throw_type_must_be("array", p);
+            JSON_THROW(type_error::create(302, concat("type must be array, but is ", p.type_name()), &p));
        }
        m.emplace(p.at(0).template get<typename MapType::key_type>(), p.at(1).template get<typename MapType::mapped_type>());
    }
@@ -591,7 +591,7 @@ inline void from_json(const BasicJsonType& j, std_fs::path& p)
 {
    if (JSON_HEDLEY_UNLIKELY(!j.is_string()))
    {
-        throw_type_must_be("string", j);
+        JSON_THROW(type_error::create(302, concat("type must be string, but is ", j.type_name()), &j));
    }
    const auto& s = *j.template get_ptr<const typename BasicJsonType::string_t*>();
    // Checking for C++20 standard or later can be insufficient in case the
@@ -414,13 +414,13 @@ inline void to_json(BasicJsonType& j, const EnumKeyedMap& map)
        BasicJsonType key = p.first;
        if (JSON_HEDLEY_UNLIKELY(!key.is_string()))
        {
-            throw_type_must_be("string", key);
+            JSON_THROW(type_error::create(302, concat("type must be string, but is ", key.type_name()), &key));
        }

        auto& key_string = *key.template get_ptr<typename BasicJsonType::string_t*>();
        if (JSON_HEDLEY_UNLIKELY(!obj.emplace(key_string, BasicJsonType(p.second)).second))
        {
-            JSON_THROW(type_error::create(exception_id::enum_key_duplicate, concat("duplicate object key '", key_string, "'"), &key));
+            JSON_THROW(type_error::create(318, concat("duplicate object key '", key_string, "'"), &key));
        }
    }
    external_constructor<value_t::object>::construct(j, std::move(obj));
@@ -45,84 +45,6 @@ namespace detail
 // exceptions //
 ////////////////

-/*!
-@brief the ids of the exceptions thrown by the library
-@note The values are part of the public API: they are the `id` member of the
-      exceptions and appear in their `what()` messages.
-@sa https://json.nlohmann.me/home/exceptions/
-*/
-enum class exception_id : int
-{
-    // parse_error
-    syntax_error = 101, ///< unexpected token or invalid literal while parsing JSON
-    patch_not_an_array = 104, ///< a JSON Patch document is not an array of objects
-    patch_invalid_operation = 105, ///< a JSON Patch operation is malformed
-    pointer_index_leading_zero = 106, ///< a JSON Pointer array index has a leading zero
-    pointer_missing_slash = 107, ///< a JSON Pointer does not start with '/'
-    pointer_invalid_escape = 108, ///< a JSON Pointer contains an escape other than ~0 and ~1
-    pointer_index_not_a_number = 109, ///< a JSON Pointer array index is not a number
-    unexpected_end_of_input = 110, ///< a binary input ends early, or has bytes left at its end
-    unexpected_byte = 112, ///< a binary input contains an unexpected byte or invalid length
-    invalid_string_or_size = 113, ///< a binary input contains an invalid string or size specification
-    bson_unsupported_type = 114, ///< a BSON record type is not supported
-    invalid_high_precision_number = 115, ///< a UBJSON/BJData high-precision number cannot be parsed
-    // invalid_iterator
-    iterators_incompatible = 201, ///< the iterators of a range belong to different values
-    iterator_from_other_value = 202, ///< an iterator does not belong to the value it is used with
-    iterator_range_from_other_value = 203, ///< an iterator range does not belong to the value it is used with
-    iterator_range_out_of_range = 204, ///< an iterator range of a primitive value is not [begin, end)
-    iterator_out_of_range = 205, ///< an iterator of a primitive value is not begin()
-    iterator_range_of_null = 206, ///< an iterator range belongs to a null value
-    iterator_key_not_object = 207, ///< key() is called on an iterator of a non-object
-    iterator_subscript_on_object = 208, ///< operator[] is called on an iterator of an object
-    iterator_arithmetic_on_object = 209, ///< an offset operator is used on an iterator of an object
-    insert_range_incompatible = 210, ///< the iterators of an inserted range belong to different values
-    insert_range_into_itself = 211, ///< an inserted range belongs to the value it is inserted into
-    iterators_compare_different_values = 212, ///< iterators of different values are compared
-    iterator_order_on_object = 213, ///< iterators of an object are compared by order
-    iterator_value_unavailable = 214, ///< an iterator does not refer to a value
-    // type_error
-    object_from_non_pairs = 301, ///< an object is created from an initializer list that is not a list of pairs
-    type_mismatch = 302, ///< a value has the wrong type for a conversion
-    incompatible_reference_type = 303, ///< get_ref() is called with a reference type that does not match the value
-    at_wrong_type = 304, ///< at() is called on a value of the wrong type
-    subscript_wrong_type = 305, ///< operator[] is called on a value of the wrong type
-    value_wrong_type = 306, ///< value() is called on a value of the wrong type
-    erase_wrong_type = 307, ///< erase() is called on a value of the wrong type
-    push_back_wrong_type = 308, ///< push_back() or operator+= is called on a value of the wrong type
-    insert_wrong_type = 309, ///< insert() is called on a value of the wrong type
-    swap_wrong_type = 310, ///< swap() is called on a value of the wrong type
-    emplace_wrong_type = 311, ///< emplace() or emplace_back() is called on a value of the wrong type
-    update_wrong_type = 312, ///< update() is called on a value of the wrong type
-    unflatten_invalid_value = 313, ///< unflatten() finds conflicting paths
-    unflatten_not_object = 314, ///< unflatten() is called on a non-object
-    unflatten_value_not_primitive = 315, ///< unflatten() is called on an object with non-primitive values
-    invalid_utf8 = 316, ///< dump() finds a string that is not valid UTF-8
-    type_not_serializable = 317, ///< a value cannot be serialized to the requested binary format
-    enum_key_duplicate = 318, ///< an enum-keyed map has two keys that serialize to the same string
-    discarded_value_used = 321, ///< a discarded value is used
-    // out_of_range
-    array_index_out_of_range = 401, ///< an array index is out of range
-    pointer_past_the_end_index = 402, ///< a JSON Pointer uses the array index '-'
-    key_not_found = 403, ///< an object key is not found
-    pointer_unresolved = 404, ///< a JSON Pointer reference token cannot be resolved
-    patch_on_root = 405, ///< the root of a value has no parent, e.g. for a JSON Patch 'remove' or 'add' at the root
-    number_overflow = 406, ///< a number cannot be stored without overflowing to NaN or INF
-    integer_too_large = 407, ///< an integer cannot be represented in the binary format
-    container_too_large = 408, ///< the size of a container in a binary input exceeds the maximal capacity
-    bson_key_with_null = 409, ///< a BSON key contains U+0000
-    value_out_of_range = 410, ///< an enum value is undefined, or a JSON Pointer array index exceeds size_type
-    patch_add_parent_not_container = 411, ///< the parent of a JSON Patch 'add' target is not a container
-    length_too_large = 412, ///< a length does not fit into the length field of a binary format
-    patch_remove_parent_not_container = 413, ///< the parent of a JSON Patch 'remove' target is not a container
-    patch_move_into_child = 414, ///< a JSON Patch 'move' moves a value into one of its children
-    subtype_out_of_range = 415, ///< a binary subtype does not fit into one byte
-    // other_error
-    internal_error = 500, ///< unreachable code was reached
-    patch_test_failed = 501, ///< a JSON Patch 'test' operation failed
-    size_marker_required = 502  ///< UBJSON/BJData output with type markers requires size markers
-};
-
 /// @brief general exception of the @ref basic_json class
 /// @sa https://json.nlohmann.me/api/basic_json/exception/
 class exception : public std::exception
@@ -273,18 +195,6 @@ class parse_error : public exception
        return {id_, byte_, w.c_str()};
    }

-    template<typename BasicJsonContext, enable_if_t<is_basic_json_context<BasicJsonContext>::value, int> = 0>
-    static parse_error create(exception_id id_, const position_t& pos, const std::string& what_arg, BasicJsonContext context)
-    {
-        return create(static_cast<int>(id_), pos, what_arg, context);
-    }
-
-    template<typename BasicJsonContext, enable_if_t<is_basic_json_context<BasicJsonContext>::value, int> = 0>
-    static parse_error create(exception_id id_, std::size_t byte_, const std::string& what_arg, BasicJsonContext context)
-    {
-        return create(static_cast<int>(id_), byte_, what_arg, context);
-    }
-
    /*!
    @brief byte index of the parse error

@@ -319,12 +229,6 @@ class invalid_iterator : public exception
        return {id_, w.c_str()};
    }

-    template<typename BasicJsonContext, enable_if_t<is_basic_json_context<BasicJsonContext>::value, int> = 0>
-    static invalid_iterator create(exception_id id_, const std::string& what_arg, BasicJsonContext context)
-    {
-        return create(static_cast<int>(id_), what_arg, context);
-    }
-
  private:
    JSON_HEDLEY_NON_NULL(3)
    invalid_iterator(int id_, const char* what_arg)
@@ -343,12 +247,6 @@ class type_error : public exception
        return {id_, w.c_str()};
    }

-    template<typename BasicJsonContext, enable_if_t<is_basic_json_context<BasicJsonContext>::value, int> = 0>
-    static type_error create(exception_id id_, const std::string& what_arg, BasicJsonContext context)
-    {
-        return create(static_cast<int>(id_), what_arg, context);
-    }
-
  private:
    JSON_HEDLEY_NON_NULL(3)
    type_error(int id_, const char* what_arg) : exception(id_, what_arg) {}
@@ -366,12 +264,6 @@ class out_of_range : public exception
        return {id_, w.c_str()};
    }

-    template<typename BasicJsonContext, enable_if_t<is_basic_json_context<BasicJsonContext>::value, int> = 0>
-    static out_of_range create(exception_id id_, const std::string& what_arg, BasicJsonContext context)
-    {
-        return create(static_cast<int>(id_), what_arg, context);
-    }
-
  private:
    JSON_HEDLEY_NON_NULL(3)
    out_of_range(int id_, const char* what_arg) : exception(id_, what_arg) {}
@@ -389,12 +281,6 @@ class other_error : public exception
        return {id_, w.c_str()};
    }

-    template<typename BasicJsonContext, enable_if_t<is_basic_json_context<BasicJsonContext>::value, int> = 0>
-    static other_error create(exception_id id_, const std::string& what_arg, BasicJsonContext context)
-    {
-        return create(static_cast<int>(id_), what_arg, context);
-    }
-
  private:
    JSON_HEDLEY_NON_NULL(3)
    other_error(int id_, const char* what_arg) : exception(id_, what_arg) {}
@@ -421,36 +307,6 @@ void templated_json_throw(ExceptionType exception)
    (void)exception;
 }

-/*!
-@brief throws because @a j does not have the type a conversion expects
-@param[in] expected  the expected type(s), e.g. "array" or "binary or array"
-@param[in] j         the value with the wrong type
-@throw type_error.302 always
-*/
-template<typename BasicJsonType>
-JSON_HEDLEY_NO_RETURN inline void throw_type_must_be(const char* expected, const BasicJsonType& j)
-{
-    static_cast<void>(expected); // unused when JSON_NOEXCEPTION is defined
-    static_cast<void>(j);
-    JSON_THROW(type_error::create(exception_id::type_mismatch, concat("type must be ", expected, ", but is ", j.type_name()), &j));
-}
-
-/*!
-@brief throws because an operation is not supported for the type of @a j
-@param[in] id_        the id of the type_error exception (at_wrong_type..update_wrong_type)
-@param[in] operation  the operation, e.g. "erase()"
-@param[in] j          the value the operation was called on
-@throw type_error always
-*/
-template<typename BasicJsonType>
-JSON_HEDLEY_NO_RETURN inline void throw_cannot_use_with(const exception_id id_, const char* operation, const BasicJsonType& j)
-{
-    static_cast<void>(id_); // unused when JSON_NOEXCEPTION is defined
-    static_cast<void>(operation);
-    static_cast<void>(j);
-    JSON_THROW(type_error::create(id_, concat("cannot use ", operation, " with ", j.type_name()), &j));
-}
-
 }  // namespace detail
 NLOHMANN_JSON_NAMESPACE_END

@@ -12,6 +12,7 @@
 #include <cmath> // ldexp
 #include <cstddef> // size_t
 #include <cstdint> // uint8_t, uint16_t, uint32_t, uint64_t, uintmax_t
+#include <cstdio> // snprintf
 #include <cstring> // memcpy
 #include <iterator> // back_inserter
 #include <limits> // numeric_limits
@@ -195,7 +196,8 @@ class binary_reader

            if (JSON_HEDLEY_UNLIKELY(current != char_traits<char_type>::eof()))
            {
-                return last_byte_error(exception_id::unexpected_end_of_input, concat("expected end of input; last byte: 0x", get_token_string()), "value");
+                return sax->parse_error(chars_read, get_token_string(), parse_error::create(110, chars_read,
+                                        exception_message(concat("expected end of input; last byte: 0x", get_token_string()), "value"), nullptr));
            }
        }

@@ -317,7 +319,8 @@ class binary_reader
    {
        if (JSON_HEDLEY_UNLIKELY(document_size < 0 || static_cast<std::size_t>(document_size) != chars_read - document_start))
        {
-            return last_byte_error(exception_id::unexpected_byte, concat("document size ", std::to_string(document_size), " does not match the number of bytes read (", std::to_string(chars_read - document_start), ")"), "document");
+            return sax->parse_error(chars_read, get_token_string(), parse_error::create(112, chars_read,
+                                    exception_message(concat("document size ", std::to_string(document_size), " does not match the number of bytes read (", std::to_string(chars_read - document_start), ")"), "document"), nullptr));
        }
        return true;
    }
@@ -509,7 +512,9 @@ class binary_reader
    {
        if (JSON_HEDLEY_UNLIKELY(len < 1))
        {
-            return last_byte_error(exception_id::unexpected_byte, concat("string length must be at least 1, is ", std::to_string(len)), "string");
+            auto last_token = get_token_string();
+            return sax->parse_error(chars_read, last_token, parse_error::create(112, chars_read,
+                                    exception_message(concat("string length must be at least 1, is ", std::to_string(len)), "string"), nullptr));
        }

        if (JSON_HEDLEY_UNLIKELY(!get_string(len - static_cast<NumberType>(1), result)))
@@ -519,7 +524,10 @@ class binary_reader

        if (JSON_HEDLEY_UNLIKELY(get() != 0x00))
        {
-            return last_byte_error(exception_id::unexpected_byte, "BSON string is not null-terminated", "string");
+            auto last_token = get_token_string();
+            return sax->parse_error(chars_read, last_token, parse_error::create(112, chars_read,
+                                    exception_message("BSON string is not null-terminated",
+                                            "string"), nullptr));
        }

        return check_string_utf8(result, "string");
@@ -539,7 +547,9 @@ class binary_reader
    {
        if (JSON_HEDLEY_UNLIKELY(len < 0))
        {
-            return last_byte_error(exception_id::unexpected_byte, concat("byte array length cannot be negative, is ", std::to_string(len)), "binary");
+            auto last_token = get_token_string();
+            return sax->parse_error(chars_read, last_token, parse_error::create(112, chars_read,
+                                    exception_message(concat("byte array length cannot be negative, is ", std::to_string(len)), "binary"), nullptr));
        }

        // All BSON binary values have a subtype
@@ -629,9 +639,11 @@ class binary_reader

            default: // anything else is not supported (yet)
            {
-                const std::string cr_str = hex_byte(static_cast<std::uint8_t>(element_type));
+                std::array<char, 3> cr{{}};
+                static_cast<void>((std::snprintf)(cr.data(), cr.size(), "%.2hhX", static_cast<unsigned char>(element_type))); // NOLINT(cppcoreguidelines-pro-type-vararg,hicpp-vararg)
+                const std::string cr_str{cr.data()};
                return sax->parse_error(element_type_parse_position, cr_str,
-                                        parse_error::create(exception_id::bson_unsupported_type, element_type_parse_position, concat("Unsupported BSON record type 0x", cr_str), nullptr));
+                                        parse_error::create(114, element_type_parse_position, concat("Unsupported BSON record type 0x", cr_str), nullptr));
            }
        }
    }
@@ -955,7 +967,9 @@ class binary_reader
            {
                if (tag_handler == cbor_tag_handler_t::error)
                {
-                    return unexpected_byte("invalid byte", "value");
+                    auto last_token = get_token_string();
+                    return sax->parse_error(chars_read, last_token, parse_error::create(112, chars_read,
+                                            exception_message(concat("invalid byte: 0x", last_token), "value"), nullptr));
                }

                // ignore and store: the tag value is already in the head, so
@@ -975,7 +989,9 @@ class binary_reader
                {
                    case cbor_tag_handler_t::error:
                    {
-                        return unexpected_byte("invalid byte", "value");
+                        auto last_token = get_token_string();
+                        return sax->parse_error(chars_read, last_token, parse_error::create(112, chars_read,
+                                                exception_message(concat("invalid byte: 0x", last_token), "value"), nullptr));
                    }

                    case cbor_tag_handler_t::ignore:
@@ -1049,7 +1065,9 @@ class binary_reader

            default: // anything else (0xFF is handled inside the other types)
            {
-                return unexpected_byte("invalid byte", "value");
+                auto last_token = get_token_string();
+                return sax->parse_error(chars_read, last_token, parse_error::create(112, chars_read,
+                                        exception_message(concat("invalid byte: 0x", last_token), "value"), nullptr));
            }
        }
    }
@@ -1062,7 +1080,10 @@ class binary_reader
    */
    bool cbor_indefinite_string_error(const char* type_name, const char* context)
    {
-        return last_byte_error(exception_id::invalid_string_or_size, concat("indefinite-length ", type_name, " is not allowed inside indefinite-length ", type_name, "; last byte: 0x", get_token_string()), context);
+        auto last_token = get_token_string();
+        return sax->parse_error(chars_read, last_token, parse_error::create(113, chars_read,
+                                exception_message(concat("indefinite-length ", type_name,
+                                        " is not allowed inside indefinite-length ", type_name, "; last byte: 0x", last_token), context), nullptr));
    }

    /*!
@@ -1139,7 +1160,9 @@ class binary_reader

            default:
            {
-                return last_byte_error(exception_id::invalid_string_or_size, concat("expected length specification (0x60-0x7B)", inside_indefinite ? "" : " or indefinite string type (0x7F)", "; last byte: 0x", get_token_string()), "string");
+                auto last_token = get_token_string();
+                return sax->parse_error(chars_read, last_token, parse_error::create(113, chars_read,
+                                        exception_message(concat("expected length specification (0x60-0x7B)", inside_indefinite ? "" : " or indefinite string type (0x7F)", "; last byte: 0x", last_token), "string"), nullptr));
            }
        }
    }
@@ -1269,7 +1292,9 @@ class binary_reader
                break;
        }

-        return last_byte_error(exception_id::invalid_string_or_size, concat("only string keys are supported, but found ", found, "; last byte: 0x", get_token_string()), "object key");
+        auto last_token = get_token_string();
+        return sax->parse_error(chars_read, last_token, parse_error::create(113, chars_read,
+                                exception_message(concat("only string keys are supported, but found ", found, "; last byte: 0x", last_token), "object key"), nullptr));
    }

    /*!
@@ -1350,7 +1375,9 @@ class binary_reader

            default:
            {
-                return last_byte_error(exception_id::invalid_string_or_size, concat("expected length specification (0x40-0x5B)", inside_indefinite ? "" : " or indefinite binary array type (0x5F)", "; last byte: 0x", get_token_string()), "binary");
+                auto last_token = get_token_string();
+                return sax->parse_error(chars_read, last_token, parse_error::create(113, chars_read,
+                                        exception_message(concat("expected length specification (0x40-0x5B)", inside_indefinite ? "" : " or indefinite binary array type (0x5F)", "; last byte: 0x", last_token), "binary"), nullptr));
            }
        }
    }
@@ -1496,7 +1523,7 @@ class binary_reader
    {
        if (JSON_HEDLEY_UNLIKELY(!value_in_range_of<std::size_t>(len) || len == detail::unknown_size()))
        {
-            return sax->parse_error(chars_read, get_token_string(), out_of_range::create(exception_id::container_too_large,
+            return sax->parse_error(chars_read, get_token_string(), out_of_range::create(408,
                                    exception_message(concat("excessive ", context, " size"), "size"), nullptr));
        }
        result = conditional_static_cast<std::size_t>(len);
@@ -1984,7 +2011,9 @@ class binary_reader

            default: // anything else
            {
-                return unexpected_byte("invalid byte", "value");
+                auto last_token = get_token_string();
+                return sax->parse_error(chars_read, last_token, parse_error::create(112, chars_read,
+                                        exception_message(concat("invalid byte: 0x", last_token), "value"), nullptr));
            }
        }
    }
@@ -2065,7 +2094,9 @@ class binary_reader

            default:
            {
-                return last_byte_error(exception_id::invalid_string_or_size, concat("expected length specification (0xA0-0xBF, 0xD9-0xDB); last byte: 0x", get_token_string()), "string");
+                auto last_token = get_token_string();
+                return sax->parse_error(chars_read, last_token, parse_error::create(113, chars_read,
+                                        exception_message(concat("expected length specification (0xA0-0xBF, 0xD9-0xDB); last byte: 0x", last_token), "string"), nullptr));
            }
        }
    }
@@ -2157,7 +2188,9 @@ class binary_reader
                break;
        }

-        return last_byte_error(exception_id::invalid_string_or_size, concat("only string keys are supported, but found ", found, "; last byte: 0x", get_token_string()), "object key");
+        auto last_token = get_token_string();
+        return sax->parse_error(chars_read, last_token, parse_error::create(113, chars_read,
+                                exception_message(concat("only string keys are supported, but found ", found, "; last byte: 0x", last_token), "object key"), nullptr));
    }

    /*!
@@ -2466,7 +2499,8 @@ class binary_reader
    {
        if (JSON_HEDLEY_UNLIKELY(len < 0))
        {
-            return last_byte_error(exception_id::invalid_string_or_size, "string length must not be negative", "string");
+            return sax->parse_error(chars_read, get_token_string(), parse_error::create(113, chars_read,
+                                    exception_message("string length must not be negative", "string"), nullptr));
        }
        return true;
    }
@@ -2566,7 +2600,18 @@ class binary_reader
            default:
                break;
        }
-        return length_type_error("", "string");
+        auto last_token = get_token_string();
+        std::string message;
+
+        if (input_format != input_format_t::bjdata)
+        {
+            message = "expected length type specification (U, i, I, l, L); last byte: 0x" + last_token;
+        }
+        else
+        {
+            message = "expected length type specification (U, i, u, I, m, l, M, L); last byte: 0x" + last_token;
+        }
+        return sax->parse_error(chars_read, last_token, parse_error::create(113, chars_read, exception_message(message, "string"), nullptr));
    }

    /*!
@@ -2651,11 +2696,12 @@ class binary_reader
        }
        if (JSON_HEDLEY_UNLIKELY(number < 0))
        {
-            return last_byte_error(exception_id::invalid_string_or_size, "count in an optimized container must be positive", "size");
+            return sax->parse_error(chars_read, get_token_string(), parse_error::create(113, chars_read,
+                                    exception_message("count in an optimized container must be positive", "size"), nullptr));
        }
        if (JSON_HEDLEY_UNLIKELY(!value_in_range_of<std::size_t>(number)))
        {
-            return sax->parse_error(chars_read, get_token_string(), out_of_range::create(exception_id::container_too_large,
+            return sax->parse_error(chars_read, get_token_string(), out_of_range::create(408,
                                    exception_message("integer value overflow", "size"), nullptr));
        }
        result = static_cast<std::size_t>(number); // NOLINT(bugprone-signed-char-misuse,cert-str34-c): number is not a char
@@ -2753,7 +2799,7 @@ class binary_reader
                }
                if (!value_in_range_of<std::size_t>(number))
                {
-                    return sax->parse_error(chars_read, get_token_string(), out_of_range::create(exception_id::container_too_large,
+                    return sax->parse_error(chars_read, get_token_string(), out_of_range::create(408,
                                            exception_message("integer value overflow", "size"), nullptr));
                }
                result = detail::conditional_static_cast<std::size_t>(number);
@@ -2768,7 +2814,7 @@ class binary_reader
                }
                if (is_ndarray) // ndarray dimensional vector can only contain integers and cannot embed another array
                {
-                    return last_byte_error(exception_id::invalid_string_or_size, "ndarray dimensional vector is not allowed", "size");
+                    return sax->parse_error(chars_read, get_token_string(), parse_error::create(113, chars_read, exception_message("ndarray dimensional vector is not allowed", "size"), nullptr));
                }
                std::vector<size_t> dim;
                if (JSON_HEDLEY_UNLIKELY(!get_ubjson_ndarray_size(dim)))
@@ -2804,7 +2850,9 @@ class binary_reader
                        const char* type_name = bjd_type_name(ndarray_dtype);
                        if (JSON_HEDLEY_UNLIKELY(type_name == nullptr))
                        {
-                            return unexpected_byte("invalid byte", "type");
+                            auto last_token = get_token_string();
+                            return sax->parse_error(chars_read, last_token, parse_error::create(112, chars_read,
+                                                    exception_message("invalid byte: 0x" + last_token, "type"), nullptr));
                        }

                        string_t type_key = "_ArrayType_";
@@ -2832,7 +2880,7 @@ class binary_reader
                        // or SIZE_MAX.
                        if (JSON_HEDLEY_UNLIKELY(result > (std::numeric_limits<std::size_t>::max)() / i))
                        {
-                            return sax->parse_error(chars_read, get_token_string(), out_of_range::create(exception_id::container_too_large, exception_message("excessive ndarray size caused overflow", "size"), nullptr));
+                            return sax->parse_error(chars_read, get_token_string(), out_of_range::create(408, exception_message("excessive ndarray size caused overflow", "size"), nullptr));
                        }
                        result *= i;
                        // the pre-check above already rules out result becoming 0
@@ -2841,7 +2889,7 @@ class binary_reader
                        // unknown-size container (see get_ubjson_size_type())
                        if (result == npos)
                        {
-                            return sax->parse_error(chars_read, get_token_string(), out_of_range::create(exception_id::container_too_large, exception_message("excessive ndarray size caused overflow", "size"), nullptr));
+                            return sax->parse_error(chars_read, get_token_string(), out_of_range::create(408, exception_message("excessive ndarray size caused overflow", "size"), nullptr));
                        }
                        if (JSON_HEDLEY_UNLIKELY(!emit_unsigned(i)))
                        {
@@ -2858,7 +2906,18 @@ class binary_reader
            default:
                break;
        }
-        return length_type_error(" after '#'", "size");
+        auto last_token = get_token_string();
+        std::string message;
+
+        if (input_format != input_format_t::bjdata)
+        {
+            message = "expected length type specification (U, i, I, l, L) after '#'; last byte: 0x" + last_token;
+        }
+        else
+        {
+            message = "expected length type specification (U, i, u, I, m, l, M, L) after '#'; last byte: 0x" + last_token;
+        }
+        return sax->parse_error(chars_read, last_token, parse_error::create(113, chars_read, exception_message(message, "size"), nullptr));
    }

    /*!
@@ -2891,7 +2950,9 @@ class binary_reader
            if (input_format == input_format_t::bjdata
                    && JSON_HEDLEY_UNLIKELY(is_bjd_excluded_optimized_type(result.second)))
            {
-                return last_byte_error(exception_id::unexpected_byte, concat("marker 0x", get_token_string(), " is not a permitted optimized array type"), "type");
+                auto last_token = get_token_string();
+                return sax->parse_error(chars_read, last_token, parse_error::create(112, chars_read,
+                                        exception_message(concat("marker 0x", last_token, " is not a permitted optimized array type"), "type"), nullptr));
            }

            if (JSON_HEDLEY_UNLIKELY(!unexpect_eof("type")))
@@ -2906,7 +2967,9 @@ class binary_reader
                {
                    return false;
                }
-                return last_byte_error(exception_id::unexpected_byte, concat("expected '#' after type information; last byte: 0x", get_token_string()), "size");
+                auto last_token = get_token_string();
+                return sax->parse_error(chars_read, last_token, parse_error::create(112, chars_read,
+                                        exception_message(concat("expected '#' after type information; last byte: 0x", last_token), "size"), nullptr));
            }

            const bool is_error = get_ubjson_size_value(result.first, is_ndarray, 0, result.second);
@@ -2925,7 +2988,8 @@ class binary_reader
            const bool is_error = get_ubjson_size_value(result.first, is_ndarray);
            if (input_format == input_format_t::bjdata && is_ndarray && !inside_ndarray)
            {
-                return last_byte_error(exception_id::unexpected_byte, "ndarray requires both type and size", "size");
+                return sax->parse_error(chars_read, get_token_string(), parse_error::create(112, chars_read,
+                                        exception_message("ndarray requires both type and size", "size"), nullptr));
            }
            return is_error;
        }
@@ -3057,7 +3121,9 @@ class binary_reader
                }
                if (JSON_HEDLEY_UNLIKELY(current > 127))
                {
-                    return last_byte_error(exception_id::invalid_string_or_size, concat("byte after 'C' must be in range 0x00..0x7F; last byte: 0x", get_token_string()), "char");
+                    auto last_token = get_token_string();
+                    return sax->parse_error(chars_read, last_token, parse_error::create(113, chars_read,
+                                            exception_message(concat("byte after 'C' must be in range 0x00..0x7F; last byte: 0x", last_token), "char"), nullptr));
                }
                string_t s(1, static_cast<typename string_t::value_type>(current));
                return sax->string(s);
@@ -3078,7 +3144,8 @@ class binary_reader
            default: // anything else
                break;
        }
-        return unexpected_byte("invalid byte", "value");
+        auto last_token = get_token_string();
+        return sax->parse_error(chars_read, last_token, parse_error::create(112, chars_read, exception_message("invalid byte: 0x" + last_token, "value"), nullptr));
    }

    /*!
@@ -3141,7 +3208,7 @@ class binary_reader
            if (JSON_HEDLEY_UNLIKELY((size_and_type.second == 'Z' || size_and_type.second == 'T' || size_and_type.second == 'F')
                                     && size_and_type.first > max_valueless_container_size))
            {
-                return sax->parse_error(chars_read, get_token_string(), out_of_range::create(exception_id::container_too_large,
+                return sax->parse_error(chars_read, get_token_string(), out_of_range::create(408,
                                        exception_message("excessive array size", "size"), nullptr));
            }

@@ -3177,7 +3244,9 @@ class binary_reader
        // do not accept ND-array size in objects in BJData
        if (input_format == input_format_t::bjdata && size_and_type.first != npos && (size_and_type.second & (1 << 8)) != 0)
        {
-            return last_byte_error(exception_id::unexpected_byte, "BJData object does not support ND-array size in optimized format", "object");
+            auto last_token = get_token_string();
+            return sax->parse_error(chars_read, last_token, parse_error::create(112, chars_read,
+                                    exception_message("BJData object does not support ND-array size in optimized format", "object"), nullptr));
        }

        if (size_and_type.first != npos)
@@ -3214,7 +3283,7 @@ class binary_reader
            // the lexer would stop at a NUL and accept the digits before it
            if (JSON_HEDLEY_UNLIKELY(current == '\0'))
            {
-                return sax->parse_error(chars_read, "00", parse_error::create(exception_id::invalid_high_precision_number, chars_read,
+                return sax->parse_error(chars_read, "00", parse_error::create(115, chars_read,
                                        exception_message("invalid number text; last byte: 0x00", "high-precision number"), nullptr));
            }
            number_vector.push_back(static_cast<char>(current));
@@ -3231,7 +3300,7 @@ class binary_reader

        if (JSON_HEDLEY_UNLIKELY(result_remainder != token_type::end_of_input))
        {
-            return sax->parse_error(chars_read, number_string, parse_error::create(exception_id::invalid_high_precision_number, chars_read,
+            return sax->parse_error(chars_read, number_string, parse_error::create(115, chars_read,
                                    exception_message(concat("invalid number text: ", number_lexer.get_token_string()), "high-precision number"), nullptr));
        }

@@ -3249,7 +3318,7 @@ class binary_reader
                    return sax->parse_error(
                               chars_read,
                               number_string,
-                               out_of_range::create(exception_id::number_overflow, concat("number overflow parsing '", number_string, '\''), nullptr));
+                               out_of_range::create(406, concat("number overflow parsing '", number_string, '\''), nullptr));
                }
                // number_string is a std::string, while the SAX interface takes a
                // string_t; convert explicitly, as the two are only implicitly
@@ -3271,7 +3340,7 @@ class binary_reader
            case token_type::end_of_input:
            case token_type::literal_or_value:
            default:
-                return sax->parse_error(chars_read, number_string, parse_error::create(exception_id::invalid_high_precision_number, chars_read,
+                return sax->parse_error(chars_read, number_string, parse_error::create(115, chars_read,
                                        exception_message(concat("invalid number text: ", number_lexer.get_token_string()), "high-precision number"), nullptr));
        }
    }
@@ -3330,6 +3399,20 @@ class binary_reader
        return 0x80 <= c && c <= 0xBF;
    }

+    /*!
+    @brief report a parse error at the last read byte
+
+    @param[in] detail   a detailed error message
+    @param[in] context  further context information
+    @return false
+    */
+    bool bon8_error(const std::string& detail, const char* context)
+    {
+        auto last_token = get_token_string();
+        return sax->parse_error(chars_read, last_token, parse_error::create(112, chars_read,
+                                exception_message(concat(detail, ": 0x", last_token), context), nullptr));
+    }
+
    /*!
    @brief read a BON8 value and everything nested inside it

@@ -3545,7 +3628,7 @@ class binary_reader
        }

        // 0xFE: end of container where a value is expected
-        return unexpected_byte("invalid byte", "value");
+        return bon8_error("invalid byte", "value");
    }

    /*!
@@ -3672,7 +3755,7 @@ class binary_reader
            current = byte;
        }

-        return unexpected_byte("expected a string; last byte", "key");
+        return bon8_error("expected a string; last byte", "key");
    }

    /*!
@@ -3795,7 +3878,7 @@ class binary_reader

            if (JSON_HEDLEY_UNLIKELY(!valid_second))
            {
-                return unexpected_byte("invalid UTF-8 byte", "string");
+                return bon8_error("invalid UTF-8 byte", "string");
            }

            result.push_back(static_cast<typename string_t::value_type>(byte));
@@ -3809,7 +3892,7 @@ class binary_reader
                }
                if (JSON_HEDLEY_UNLIKELY(!is_bon8_continuation(current)))
                {
-                    return unexpected_byte("invalid UTF-8 byte", "string");
+                    return bon8_error("invalid UTF-8 byte", "string");
                }
                result.push_back(static_cast<typename string_t::value_type>(current));
            }
@@ -3854,7 +3937,7 @@ class binary_reader
        {
            // in case of failure, advance position by 1 to report the failing location
            ++chars_read;
-            sax->parse_error(chars_read, "<end of file>", parse_error::create(exception_id::unexpected_end_of_input, chars_read, exception_message("unexpected end of input", context), nullptr));
+            sax->parse_error(chars_read, "<end of file>", parse_error::create(110, chars_read, exception_message("unexpected end of input", context), nullptr));
            return false;
        }
        return true;
@@ -4008,7 +4091,7 @@ class binary_reader
        if (JSON_HEDLEY_UNLIKELY(std::isfinite(number) && !std::isfinite(result)))
        {
            return sax->parse_error(chars_read, get_token_string(),
-                                    out_of_range::create(exception_id::number_overflow, exception_message("number overflow", "value"), nullptr));
+                                    out_of_range::create(406, exception_message("number overflow", "value"), nullptr));
        }
        return sax->number_float(result, "");
    }
@@ -4128,7 +4211,9 @@ class binary_reader

        if (error_handler == error_handler_t::strict)
        {
-            return last_byte_error(exception_id::invalid_string_or_size, "invalid string: ill-formed UTF-8 byte", context);
+            auto last_token = get_token_string();
+            return sax->parse_error(chars_read, last_token, parse_error::create(113, chars_read,
+                                    exception_message("invalid string: ill-formed UTF-8 byte", context), nullptr));
        }

        result = sanitize_utf8(result, error_handler);
@@ -4224,53 +4309,19 @@ class binary_reader
        if (JSON_HEDLEY_UNLIKELY(current == char_traits<char_type>::eof()))
        {
            return sax->parse_error(chars_read, "<end of file>",
-                                    parse_error::create(exception_id::unexpected_end_of_input, chars_read, exception_message("unexpected end of input", context), nullptr));
+                                    parse_error::create(110, chars_read, exception_message("unexpected end of input", context), nullptr));
        }
        return true;
    }

-    /*!
-    @brief reports a parse error at the last read byte
-    @param[in] id_      the id of the parse_error exception
-    @param[in] detail   a detailed error message
-    @param[in] context  further context information
-    @return the result of the SAX parser's parse_error()
-    */
-    bool last_byte_error(const exception_id id_, const std::string& detail, const std::string& context) const
-    {
-        return sax->parse_error(chars_read, get_token_string(), parse_error::create(id_, chars_read, exception_message(detail, context), nullptr));
-    }
-
-    /*!
-    @brief reports the last read byte as unexpected (parse_error.112)
-    @param[in] detail   what is wrong with the byte, e.g. "invalid byte"
-    @param[in] context  further context information
-    @return the result of the SAX parser's parse_error()
-    */
-    bool unexpected_byte(const char* detail, const std::string& context) const
-    {
-        return last_byte_error(exception_id::unexpected_byte, concat(detail, ": 0x", get_token_string()), context);
-    }
-
-    /*!
-    @brief reports that the last read byte is not a UBJSON/BJData length type (parse_error.113)
-    @param[in] position  where the length type was expected, e.g. " after '#'"
-    @param[in] context   further context information
-    @return the result of the SAX parser's parse_error()
-    */
-    bool length_type_error(const char* position, const char* context) const
-    {
-        const char* types = input_format == input_format_t::bjdata ? "U, i, u, I, m, l, M, L" : "U, i, I, l, L";
-        return last_byte_error(exception_id::invalid_string_or_size,
-                               concat("expected length type specification (", types, ")", position, "; last byte: 0x", get_token_string()), context);
-    }
-
    /*!
    @return a string representation of the last read byte
    */
    std::string get_token_string() const
    {
-        return hex_byte(static_cast<std::uint8_t>(current));
+        std::array<char, 3> cr{{}};
+        static_cast<void>((std::snprintf)(cr.data(), cr.size(), "%.2hhX", static_cast<unsigned char>(current))); // NOLINT(cppcoreguidelines-pro-type-vararg,hicpp-vararg)
+        return std::string{cr.data()};
    }

    /*!
@@ -581,7 +581,7 @@ class wide_string_input_adapter
    template<class T>
    JSON_HEDLEY_NO_RETURN std::size_t get_elements(T* /*dest*/, std::size_t /*count*/ = 1)
    {
-        JSON_THROW(parse_error::create(exception_id::unexpected_byte, 1, "wide string type cannot be interpreted as binary data", nullptr));
+        JSON_THROW(parse_error::create(112, 1, "wide string type cannot be interpreted as binary data", nullptr));
    }

  private:
@@ -793,7 +793,7 @@ inline file_input_adapter input_adapter(std::FILE* file)
 {
    if (file == nullptr)
    {
-        JSON_THROW(parse_error::create(exception_id::syntax_error, 0, "attempting to parse an empty input; check that your input string or stream contains the expected JSON", nullptr));
+        JSON_THROW(parse_error::create(101, 0, "attempting to parse an empty input; check that your input string or stream contains the expected JSON", nullptr));
    }
    return file_input_adapter(file);
 }
@@ -802,7 +802,7 @@ inline input_stream_adapter input_adapter(std::istream& stream)
 {
    if (stream.rdbuf() == nullptr)
    {
-        JSON_THROW(parse_error::create(exception_id::syntax_error, 0, "attempting to parse an empty input; check that your input string or stream contains the expected JSON", nullptr));
+        JSON_THROW(parse_error::create(101, 0, "attempting to parse an empty input; check that your input string or stream contains the expected JSON", nullptr));
    }
    return input_stream_adapter(stream);
 }
@@ -827,7 +827,7 @@ contiguous_bytes_input_adapter input_adapter(CharT b)
 {
    if (b == nullptr)
    {
-        JSON_THROW(parse_error::create(exception_id::syntax_error, 0, "attempting to parse an empty input; check that your input string or stream contains the expected JSON", nullptr));
+        JSON_THROW(parse_error::create(101, 0, "attempting to parse an empty input; check that your input string or stream contains the expected JSON", nullptr));
    }
    auto length = std::strlen(reinterpret_cast<const char*>(b));
    const auto* ptr = reinterpret_cast<const char*>(b);
@@ -176,27 +176,6 @@ template<typename ArrayType>
 inline void reserve_array(ArrayType& /*arr*/, std::size_t /*len*/, priority_tag<0> /*unused*/)
 {}

-/*!
-@brief reports an object or array whose announced size exceeds max_size()
-
-Shared by json_sax_dom_parser and json_sax_dom_callback_parser.
-
-@param[in] sax   the SAX parser to report the error to
-@param[in] len   the number of elements announced by the input, or unknown_size()
-@param[in] kind  "object" or "array"
-@param[in] ref   the object or array that was just created
-@return whether parsing should continue (false after reporting out_of_range.408)
-*/
-template<typename SAX, typename BasicJsonType>
-bool check_container_size(SAX& sax, std::size_t len, const char* kind, BasicJsonType* ref)
-{
-    if (JSON_HEDLEY_UNLIKELY(len != detail::unknown_size() && len > ref->max_size()))
-    {
-        return sax.parse_error(0, "", out_of_range::create(exception_id::container_too_large, concat("excessive ", kind, " size: ", std::to_string(len)), ref));
-    }
-    return true;
-}
-
 #if JSON_DIAGNOSTIC_POSITIONS
 /*!
@brief set the diagnostic positions of a value the DOM SAX parsers just stored
@@ -206,35 +185,6 @@ befriends this struct, as the position members are private.
 */
 struct diagnostic_positions
 {
-    /*!
-    @param[in,out] v  the object or array whose opening brace or bracket was just read
-    @param[in] lexer  the lexer that read it, or nullptr to leave @a v alone
-    */
-    template<typename BasicJsonType, typename LexerType>
-    static void set_container_start(BasicJsonType& v, LexerType* lexer)
-    {
-        if (lexer)
-        {
-            // Lexer has read the first character of the container, so
-            // subtract 1 from the position to get the correct start position.
-            v.start_position = lexer->get_position() - 1;
-        }
-    }
-
-    /*!
-    @param[in,out] v  the object or array whose closing brace or bracket was just read
-    @param[in] lexer  the lexer that read it, or nullptr to leave @a v alone
-    */
-    template<typename BasicJsonType, typename LexerType>
-    static void set_container_end(BasicJsonType& v, LexerType* lexer)
-    {
-        if (lexer)
-        {
-            // Lexer's position is past the closing brace or bracket, so set that as the end position.
-            v.end_position = lexer->get_position();
-        }
-    }
-
    /*!
    @param[in,out] v  the value that was just parsed
    @param[in] lexer  the lexer that read it, or nullptr to leave @a v alone
@@ -399,11 +349,22 @@ class json_sax_dom_parser
        ref_stack.push_back(handle_value(BasicJsonType::value_t::object));

 #if JSON_DIAGNOSTIC_POSITIONS
+        // Manually set the start position of the object here.
        // Ensure this is after the call to handle_value to ensure correct start position.
-        diagnostic_positions::set_container_start(*ref_stack.back(), m_lexer_ref);
+        if (m_lexer_ref)
+        {
+            // Lexer has read the first character of the object, so
+            // subtract 1 from the position to get the correct start position.
+            ref_stack.back()->start_position = m_lexer_ref->get_position() - 1;
+        }
 #endif

-        return check_container_size(*this, len, "object", ref_stack.back());
+        if (JSON_HEDLEY_UNLIKELY(len != detail::unknown_size() && len > ref_stack.back()->max_size()))
+        {
+            return parse_error(0, "", out_of_range::create(408, concat("excessive object size: ", std::to_string(len)), ref_stack.back()));
+        }
+
+        return true;
    }

    bool key(string_t& val)
@@ -422,7 +383,11 @@ class json_sax_dom_parser
        JSON_ASSERT(ref_stack.back()->is_object());

 #if JSON_DIAGNOSTIC_POSITIONS
-        diagnostic_positions::set_container_end(*ref_stack.back(), m_lexer_ref);
+        if (m_lexer_ref)
+        {
+            // Lexer's position is past the closing brace, so set that as the end position.
+            ref_stack.back()->end_position = m_lexer_ref->get_position();
+        }
 #endif

        ref_stack.back()->set_parents();
@@ -435,13 +400,17 @@ class json_sax_dom_parser
        ref_stack.push_back(handle_value(BasicJsonType::value_t::array));

 #if JSON_DIAGNOSTIC_POSITIONS
+        // Manually set the start position of the array here.
        // Ensure this is after the call to handle_value to ensure correct start position.
-        diagnostic_positions::set_container_start(*ref_stack.back(), m_lexer_ref);
+        if (m_lexer_ref)
+        {
+            ref_stack.back()->start_position = m_lexer_ref->get_position() - 1;
+        }
 #endif

-        if (JSON_HEDLEY_UNLIKELY(!check_container_size(*this, len, "array", ref_stack.back())))
+        if (JSON_HEDLEY_UNLIKELY(len != detail::unknown_size() && len > ref_stack.back()->max_size()))
        {
-            return false;
+            return parse_error(0, "", out_of_range::create(408, concat("excessive array size: ", std::to_string(len)), ref_stack.back()));
        }

        if (len != detail::unknown_size())
@@ -458,7 +427,11 @@ class json_sax_dom_parser
        JSON_ASSERT(ref_stack.back()->is_array());

 #if JSON_DIAGNOSTIC_POSITIONS
-        diagnostic_positions::set_container_end(*ref_stack.back(), m_lexer_ref);
+        if (m_lexer_ref)
+        {
+            // Lexer's position is past the closing bracket, so set that as the end position.
+            ref_stack.back()->end_position = m_lexer_ref->get_position();
+        }
 #endif

        ref_stack.back()->set_parents();
@@ -638,11 +611,21 @@ class json_sax_dom_callback_parser
        {

 #if JSON_DIAGNOSTIC_POSITIONS
+            // Manually set the start position of the object here.
            // Ensure this is after the call to handle_value to ensure correct start position.
-            diagnostic_positions::set_container_start(*ref_stack.back(), m_lexer_ref);
+            if (m_lexer_ref)
+            {
+                // Lexer has read the first character of the object, so
+                // subtract 1 from the position to get the correct start position.
+                ref_stack.back()->start_position = m_lexer_ref->get_position() - 1;
+            }
 #endif

-            return check_container_size(*this, len, "object", ref_stack.back());
+            // check object limit
+            if (JSON_HEDLEY_UNLIKELY(len != detail::unknown_size() && len > ref_stack.back()->max_size()))
+            {
+                return parse_error(0, "", out_of_range::create(408, concat("excessive object size: ", std::to_string(len)), ref_stack.back()));
+            }
        }
        return true;
    }
@@ -712,7 +695,11 @@ class json_sax_dom_callback_parser
            {

 #if JSON_DIAGNOSTIC_POSITIONS
-                diagnostic_positions::set_container_end(*ref_stack.back(), m_lexer_ref);
+                if (m_lexer_ref)
+                {
+                    // Lexer's position is past the closing brace, so set that as the end position.
+                    ref_stack.back()->end_position = m_lexer_ref->get_position();
+                }
 #endif

                ref_stack.back()->set_parents();
@@ -723,7 +710,13 @@ class json_sax_dom_callback_parser
            }
        }

-        const string_t object_key = pop_container();
+        JSON_ASSERT(!ref_stack.empty());
+        JSON_ASSERT(!keep_stack.empty());
+        JSON_ASSERT(!container_key_stack.empty());
+        ref_stack.pop_back();
+        keep_stack.pop_back();
+        const string_t object_key = std::move(container_key_stack.back());
+        container_key_stack.pop_back();

        if (!ref_stack.empty() && ref_stack.back() && ref_stack.back()->is_structured())
        {
@@ -749,13 +742,20 @@ class json_sax_dom_callback_parser
        {

 #if JSON_DIAGNOSTIC_POSITIONS
+            // Manually set the start position of the array here.
            // Ensure this is after the call to handle_value to ensure correct start position.
-            diagnostic_positions::set_container_start(*ref_stack.back(), m_lexer_ref);
+            if (m_lexer_ref)
+            {
+                // Lexer has read the first character of the array, so
+                // subtract 1 from the position to get the correct start position.
+                ref_stack.back()->start_position = m_lexer_ref->get_position() - 1;
+            }
 #endif

-            if (JSON_HEDLEY_UNLIKELY(!check_container_size(*this, len, "array", ref_stack.back())))
+            // check array limit
+            if (JSON_HEDLEY_UNLIKELY(len != detail::unknown_size() && len > ref_stack.back()->max_size()))
            {
-                return false;
+                return parse_error(0, "", out_of_range::create(408, concat("excessive array size: ", std::to_string(len)), ref_stack.back()));
            }

            if (len != detail::unknown_size())
@@ -779,7 +779,11 @@ class json_sax_dom_callback_parser
            {

 #if JSON_DIAGNOSTIC_POSITIONS
-                diagnostic_positions::set_container_end(*ref_stack.back(), m_lexer_ref);
+                if (m_lexer_ref)
+                {
+                    // Lexer's position is past the closing bracket, so set that as the end position.
+                    ref_stack.back()->end_position = m_lexer_ref->get_position();
+                }
 #endif

                ref_stack.back()->set_parents();
@@ -805,7 +809,13 @@ class json_sax_dom_callback_parser
            }
        }

-        const string_t object_key = pop_container();
+        JSON_ASSERT(!ref_stack.empty());
+        JSON_ASSERT(!keep_stack.empty());
+        JSON_ASSERT(!container_key_stack.empty());
+        ref_stack.pop_back();
+        keep_stack.pop_back();
+        const string_t object_key = std::move(container_key_stack.back());
+        container_key_stack.pop_back();

        // remove discarded value
        if (!ref_stack.empty() && ref_stack.back())
@@ -892,23 +902,6 @@ class json_sax_dom_callback_parser
        return string_t{};
    }

-    /*!
-    @brief leave the object or array that end_object()/end_array() just closed
-    @return the key the container is stored under in its parent (see
-            container_key_stack)
-    */
-    string_t pop_container()
-    {
-        JSON_ASSERT(!ref_stack.empty());
-        JSON_ASSERT(!keep_stack.empty());
-        JSON_ASSERT(!container_key_stack.empty());
-        ref_stack.pop_back();
-        keep_stack.pop_back();
-        string_t object_key = std::move(container_key_stack.back());
-        container_key_stack.pop_back();
-        return object_key;
-    }
-
    /*!
    @brief remove the discarded value the callback rejected from its parent,
    unless it is a duplicate key's slot with a stashed previous value, in
@@ -221,44 +221,6 @@ class lexer : public lexer_base<BasicJsonType>
    // scan functions
    /////////////////////

-    /// contiguous input: try to decode the 4 hex digits following `\\u`
-    /// directly from the input buffer via hex_codepoint(), instead of 4 calls
-    /// to get(). On success, advances the adapter and the position counters
-    /// exactly as those 4 get() calls would (a hex digit is never '\n', so
-    /// only the flat counters move) and leaves @a current holding the last of
-    /// the 4 digits, just as the last such get() would; the codepoint is
-    /// written to @a out. Makes no state change and returns false - for a
-    /// pending unget, fewer than 4 remaining bytes, or any of the 4 bytes not
-    /// being a hex digit - so the caller falls back unchanged to the
-    /// per-character loop, which then reports the same diagnostic (stopping
-    /// at the first invalid digit) as before this optimization.
-    bool get_codepoint_bulk(std::true_type /*bulk*/, int& out)
-    {
-        if (next_unget || ia.bulk_remaining() < 4)
-        {
-            return false;
-        }
-        const char_type* const raw = ia.bulk_data();
-        const int codepoint = hex_codepoint(reinterpret_cast<const unsigned char*>(raw));
-        if (codepoint < 0)
-        {
-            return false;
-        }
-        ia.bulk_skip(4);
-        // a hex digit is never a newline, so only the flat counters advance
-        position.chars_read_total += 4;
-        position.chars_read_current_line += 4;
-        current = char_traits<char_type>::to_int_type(raw[3]);
-        out = codepoint;
-        return true;
-    }
-
-    /// streaming input: no bulk fast path
-    bool get_codepoint_bulk(std::false_type /*bulk*/, int& /*out*/) const noexcept
-    {
-        return false;
-    }
-
    /*!
    @brief get codepoint from 4 hex characters following `\\u`

@@ -278,14 +240,6 @@ class lexer : public lexer_base<BasicJsonType>
    {
        // this function only makes sense after reading `\u`
        JSON_ASSERT(current == 'u');
-
-        // contiguous input: decode all 4 hex digits directly from the buffer
-        int fast_codepoint = 0;
-        if (get_codepoint_bulk(std::integral_constant<bool, bulk_scan> {}, fast_codepoint))
-        {
-            return fast_codepoint;
-        }
-
        int codepoint = 0;

        const auto factors = { 12u, 8u, 4u, 0u };
@@ -1090,11 +1044,9 @@ class lexer : public lexer_base<BasicJsonType>
            token_type::parse_error otherwise

    @note The scanner is independent of the current locale: token_buffer
-          always holds `.`. The conversion of float and double does not use
-          the locale either. Only the std::strtold fallback of
-          convert_number() for long double formats other than binary64
-          depends on it, and it looks up the decimal point right before
-          converting (see detail::convert_float_locale_aware()).
+          always holds `.`. Only the std::strtod fallback of convert_number()
+          depends on the locale, and it looks up the decimal point right
+          before converting (see detail::convert_float_locale_aware()).
    */
    token_type scan_number()  // lgtm [cpp/use-of-goto] `goto` is used in this function to implement the number-parsing state machine described above. By design, any finite input will eventually reach the "done" state or return token_type::parse_error. In each intermediate state, 1 byte of the input is appended to the token_buffer vector, and only the already initialized variables token_buffer, number_type, and error_message are manipulated.
    {
@@ -1107,7 +1059,7 @@ class lexer : public lexer_base<BasicJsonType>

        // offset just past the last mantissa byte in token_buffer (i.e. the
        // index of 'e'/'E', or the whole token when there is no exponent).
-        // convert_number() uses it to split the token; npos means
+        // convert_number() uses it to count significant digits; npos means
        // "not seen an exponent yet" and is resolved at scan_number_done
        std::size_t mantissa_end = std::string::npos;

@@ -1437,8 +1389,8 @@ scan_number_done:
    @param[in] mantissa_end  offset just past the last mantissa byte in
                             token_buffer (the index of 'e'/'E', or
                             token_buffer.size() when there is no exponent);
-                             with decimal_point_position, it locates the parts
-                             of a float token without scanning it again
+                             used to skip Clinger's fast path when it cannot
+                             possibly succeed - see detail::mantissa_fits_clinger()
    */
    token_type convert_number(token_type number_type, std::size_t mantissa_end)
    {
@@ -1492,11 +1444,10 @@ scan_number_done:
        }

        // this code is reached if we parse a floating-point number or if an
-        // integer conversion above overflowed. float and double (and long
-        // double where it is binary64) are converted by the library itself,
-        // correctly rounded and independent of the locale; other long double
-        // formats use std::from_chars when available, otherwise the
-        // locale-aware strtold.
+        // integer conversion above overflowed. Prefer std::from_chars
+        // (Eisel-Lemire, locale-independent, correctly rounded) when available;
+        // otherwise the exact Clinger fast path (double only); otherwise the
+        // locale-aware strtof/strtod/strtold.
        if (convert_float_fast(num_begin, num_end, decimal_point_position, mantissa_end, value_float))
        {
            return token_type::value_float;
@@ -156,7 +156,9 @@ class parser
                // strict mode: next byte must be EOF
                if (get_token() != token_type::end_of_input)
                {
-                    return syntax_error(*sax, exception_message(token_type::end_of_input, "value"));
+                    return sax->parse_error(m_lexer.get_position(),
+                                            m_lexer.get_token_string(),
+                                            parse_error::create(101, m_lexer.get_position(), exception_message(token_type::end_of_input, "value"), nullptr));
                }
            }
            else
@@ -195,7 +197,10 @@ class parser
            // in strict mode, input must be completely read
            if (get_token() != token_type::end_of_input)
            {
-                syntax_error(sdp, exception_message(token_type::end_of_input, "value"));
+                sdp.parse_error(m_lexer.get_position(),
+                                m_lexer.get_token_string(),
+                                parse_error::create(101, m_lexer.get_position(),
+                                                    exception_message(token_type::end_of_input, "value"), nullptr));
            }
        }
        else
@@ -245,7 +250,9 @@ class parser
                        // parse key
                        if (JSON_HEDLEY_UNLIKELY(last_token != token_type::value_string))
                        {
-                            return syntax_error(*sax, exception_message(token_type::value_string, "object key"));
+                            return sax->parse_error(m_lexer.get_position(),
+                                                    m_lexer.get_token_string(),
+                                                    parse_error::create(101, m_lexer.get_position(), exception_message(token_type::value_string, "object key"), nullptr));
                        }
                        if (JSON_HEDLEY_UNLIKELY(!sax->key(m_lexer.get_string())))
                        {
@@ -255,7 +262,9 @@ class parser
                        // parse separator (:)
                        if (JSON_HEDLEY_UNLIKELY(!get_token_expecting(token_type::name_separator)))
                        {
-                            return syntax_error(*sax, exception_message(token_type::name_separator, "object separator"));
+                            return sax->parse_error(m_lexer.get_position(),
+                                                    m_lexer.get_token_string(),
+                                                    parse_error::create(101, m_lexer.get_position(), exception_message(token_type::name_separator, "object separator"), nullptr));
                        }

                        // remember we are now inside an object
@@ -298,7 +307,7 @@ class parser
                        {
                            return sax->parse_error(m_lexer.get_position(),
                                                    m_lexer.get_token_string(),
-                                                    out_of_range::create(exception_id::number_overflow, concat("number overflow parsing '", m_lexer.get_token_string(), '\''), nullptr));
+                                                    out_of_range::create(406, concat("number overflow parsing '", m_lexer.get_token_string(), '\''), nullptr));
                        }

                        if (JSON_HEDLEY_UNLIKELY(!sax->number_float(res, m_lexer.get_string())))
@@ -366,16 +375,23 @@ class parser
                    case token_type::parse_error:
                    {
                        // using "uninitialized" to avoid an "expected" message
-                        return syntax_error(*sax, exception_message(token_type::uninitialized, "value"));
+                        return sax->parse_error(m_lexer.get_position(),
+                                                m_lexer.get_token_string(),
+                                                parse_error::create(101, m_lexer.get_position(), exception_message(token_type::uninitialized, "value"), nullptr));
                    }
                    case token_type::end_of_input:
                    {
                        if (JSON_HEDLEY_UNLIKELY(m_lexer.get_position().chars_read_total == 1))
                        {
-                            return syntax_error(*sax, "attempting to parse an empty input; check that your input string or stream contains the expected JSON");
+                            return sax->parse_error(m_lexer.get_position(),
+                                                    m_lexer.get_token_string(),
+                                                    parse_error::create(101, m_lexer.get_position(),
+                                                            "attempting to parse an empty input; check that your input string or stream contains the expected JSON", nullptr));
                        }

-                        return syntax_error(*sax, exception_message(token_type::literal_or_value, "value"));
+                        return sax->parse_error(m_lexer.get_position(),
+                                                m_lexer.get_token_string(),
+                                                parse_error::create(101, m_lexer.get_position(), exception_message(token_type::literal_or_value, "value"), nullptr));
                    }
                    case token_type::uninitialized:
                    case token_type::end_array:
@@ -385,7 +401,9 @@ class parser
                    case token_type::literal_or_value:
                    default: // the last token was unexpected
                    {
-                        return syntax_error(*sax, exception_message(token_type::literal_or_value, "value"));
+                        return sax->parse_error(m_lexer.get_position(),
+                                                m_lexer.get_token_string(),
+                                                parse_error::create(101, m_lexer.get_position(), exception_message(token_type::literal_or_value, "value"), nullptr));
                    }
                }
            }
@@ -436,7 +454,9 @@ class parser
                    continue;
                }

-                return syntax_error(*sax, exception_message(token_type::end_array, "array"));
+                return sax->parse_error(m_lexer.get_position(),
+                                        m_lexer.get_token_string(),
+                                        parse_error::create(101, m_lexer.get_position(), exception_message(token_type::end_array, "array"), nullptr));
            }

            // states.back() is false -> object
@@ -453,7 +473,9 @@ class parser
                    // parse key
                    if (JSON_HEDLEY_UNLIKELY(last_token != token_type::value_string))
                    {
-                        return syntax_error(*sax, exception_message(token_type::value_string, "object key"));
+                        return sax->parse_error(m_lexer.get_position(),
+                                                m_lexer.get_token_string(),
+                                                parse_error::create(101, m_lexer.get_position(), exception_message(token_type::value_string, "object key"), nullptr));
                    }

                    if (JSON_HEDLEY_UNLIKELY(!sax->key(m_lexer.get_string())))
@@ -464,7 +486,9 @@ class parser
                    // parse separator (:)
                    if (JSON_HEDLEY_UNLIKELY(!get_token_expecting(token_type::name_separator)))
                    {
-                        return syntax_error(*sax, exception_message(token_type::name_separator, "object separator"));
+                        return sax->parse_error(m_lexer.get_position(),
+                                                m_lexer.get_token_string(),
+                                                parse_error::create(101, m_lexer.get_position(), exception_message(token_type::name_separator, "object separator"), nullptr));
                    }

                    // parse values
@@ -492,7 +516,9 @@ class parser
                continue;
            }

-            return syntax_error(*sax, exception_message(token_type::end_object, "object"));
+            return sax->parse_error(m_lexer.get_position(),
+                                    m_lexer.get_token_string(),
+                                    parse_error::create(101, m_lexer.get_position(), exception_message(token_type::end_object, "object"), nullptr));
        }
    }

@@ -509,21 +535,6 @@ class parser
        return (last_token = m_lexer.scan_expecting(expected_type)) == expected_type;
    }

-    /*!
-    @brief reports a syntax error at the current token (parse_error.101)
-    @param[in] sax      the SAX parser to report the error to
-    @param[in] message  the error message
-    @return the result of the SAX parser's parse_error()
-    */
-    template<typename SAX>
-    bool syntax_error(SAX& sax, const std::string& message)
-    {
-        // MSVC 2015 reports C4100 (unreferenced parameter) when SAX::parse_error is static
-        static_cast<void>(sax);
-        return sax.parse_error(m_lexer.get_position(), m_lexer.get_token_string(),
-                               parse_error::create(exception_id::syntax_error, m_lexer.get_position(), message, nullptr));
-    }
-
    std::string exception_message(const token_type expected, const std::string& context)
    {
        std::string error_msg = "syntax error ";
@@ -22,10 +22,6 @@ namespace detail
 constexpr std::int64_t pow5_128_smallest_power = -342;
 constexpr std::int64_t pow5_128_largest_power = 308;

-// every entry of pow5_128() holds two 64-bit halves of 5^q, one per covered power of 5
-static_assert((pow5_128_largest_power - pow5_128_smallest_power + 1) * 2 == 1302,
-              "pow5_128_smallest_power/pow5_128_largest_power must match the size of the pow5_128() table");
-
 /*!
@brief 128-bit approximations of 5^q for q in [-342, 308]

@@ -8,12 +8,10 @@

 #pragma once

-#include <array> // array
 #include <cstddef> // size_t
-#include <cstdint> // uint64_t, uint8_t
+#include <cstdint> // uint64_t
 #include <cstring> // memcpy

-#include <nlohmann/detail/bit_ops.hpp>
 #include <nlohmann/detail/macro_scope.hpp>

 // Optional SIMD backend for bulk UTF-8 validation. This is an opt-in external
@@ -71,12 +69,18 @@ inline std::size_t find_string_special(const unsigned char* data, std::size_t n)
    std::size_t i = 0;
    for (; i + 8 <= n; i += 8)
    {
-        const std::uint64_t special = swar_string_special(read_eight_bytes(data + i));
-        if (special != 0)
+        std::uint64_t word = 0;
+        std::memcpy(&word, data + i, sizeof(word));
+        if (swar_string_special(word) != 0)
        {
-            // the lowest flagged byte is the first special one: the borrows of
-            // the subtractions can only flag bytes above a true hit
-            return i + (static_cast<std::size_t>(count_trailing_zeros(special)) / 8);
+            // a special byte is in this word; locate it (endian-agnostic)
+            for (std::size_t j = 0; j < 8; ++j)
+            {
+                if (is_string_special(data[i + j]))
+                {
+                    return i + j;
+                }
+            }
        }
    }
    for (; i < n; ++i)
@@ -110,7 +114,8 @@ inline std::size_t find_ascii_copyable_run(const unsigned char* data, std::size_
    std::size_t i = 0;
    for (; i + 8 <= n; i += 8)
    {
-        const std::uint64_t v = read_eight_bytes(data + i);
+        std::uint64_t v = 0;
+        std::memcpy(&v, data + i, sizeof(v));
        const std::uint64_t q = v ^ 0x2222222222222222ull; // '"'  (0x22)
        const std::uint64_t b = v ^ 0x5C5C5C5C5C5C5C5Cull; // '\\' (0x5C)
        const std::uint64_t d = v ^ 0x7F7F7F7F7F7F7F7Full; // DEL  (0x7F)
@@ -121,9 +126,7 @@ inline std::size_t find_ascii_copyable_run(const unsigned char* data, std::size_
                                   | (v & high);               // >= 0x80
        if (stop != 0)
        {
-            // the lowest flagged byte is the first one to stop at (see
-            // find_string_special())
-            return i + (static_cast<std::size_t>(count_trailing_zeros(stop)) / 8);
+            break;
        }
    }
    for (; i < n; ++i)
@@ -250,18 +253,12 @@ inline std::size_t scalar_string_bulk_run(const unsigned char* data, std::size_t
        {
            break; // end of buffer, or a quote/escape/control byte
        }
-        // a run of multi-byte sequences (e.g. CJK text) is validated sequence
-        // by sequence without searching for the next special byte in between
-        do
+        const std::size_t seq = validate_one_utf8(data + pos, n - pos);
+        if (seq == 0)
        {
-            const std::size_t seq = validate_one_utf8(data + pos, n - pos);
-            if (seq == 0)
-            {
-                return pos; // ill-formed or truncated: let the byte path diagnose it
-            }
-            pos += seq;
+            break; // ill-formed or truncated: let the byte path diagnose it
        }
-        while (pos < n && data[pos] >= 0x80u);
+        pos += seq;
    }
    return pos;
 }
@@ -276,7 +273,8 @@ inline std::size_t find_string_delimiter(const unsigned char* data, std::size_t
    std::size_t i = 0;
    for (; i + 8 <= n; i += 8)
    {
-        const std::uint64_t v = read_eight_bytes(data + i);
+        std::uint64_t v = 0;
+        std::memcpy(&v, data + i, sizeof(v));
        const std::uint64_t q = v ^ 0x2222222222222222ull;
        const std::uint64_t b = v ^ 0x5C5C5C5C5C5C5C5Cull;
        const std::uint64_t hit = ((q - ones) & ~q & high)
@@ -284,8 +282,14 @@ inline std::size_t find_string_delimiter(const unsigned char* data, std::size_t
                                  | ((v - 0x2020202020202020ull) & ~v & high);
        if (hit != 0)
        {
-            // the lowest flagged byte is the first delimiter (see find_string_special())
-            return i + (static_cast<std::size_t>(count_trailing_zeros(hit)) / 8);
+            for (std::size_t j = 0; j < 8; ++j)
+            {
+                const unsigned char c = data[i + j];
+                if (c == '\"' || c == '\\' || c < 0x20u)
+                {
+                    return i + j;
+                }
+            }
        }
    }
    for (; i < n; ++i)
@@ -316,50 +320,5 @@ inline std::size_t string_bulk_run(const unsigned char* data, std::size_t n) noe
    return scalar_string_bulk_run(data, n);
 }

-// Decode the 4 hex digits at [data, data+4) - the digits following a `\u`
-// escape - into a codepoint 0x0000..0xFFFF via one table lookup per byte
-// (after yyjson's read_hex_u16), or return -1 if any of the 4 bytes is not a
-// hex digit ('0'..'9', 'A'..'F', 'a'..'f'). The caller must already have
-// checked that 4 bytes are available; used by lexer::get_codepoint()'s
-// contiguous fast path. On -1 it falls back to the byte-at-a-time loop, which
-// stops at the first invalid digit, so the reported error and position are
-// unaffected by this fast path.
-inline int hex_codepoint(const unsigned char* data) noexcept
-{
-    static const std::array<std::uint8_t, 256> hex_digit_table = // NOLINT(cppcoreguidelines-avoid-non-const-global-variables)
-    {
-        {
-            0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, // 00..0F
-            0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, // 10..1F
-            0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, // 20..2F
-            0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, // 30..3F ('0'..'9')
-            0xFF, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, // 40..4F ('A'..'F')
-            0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, // 50..5F
-            0xFF, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, // 60..6F ('a'..'f')
-            0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, // 70..7F
-            0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, // 80..8F
-            0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, // 90..9F
-            0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, // A0..AF
-            0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, // B0..BF
-            0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, // C0..CF
-            0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, // D0..DF
-            0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, // E0..EF
-            0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF  // F0..FF
-        }
-    };
-
-    const std::uint8_t d0 = hex_digit_table[data[0]];
-    const std::uint8_t d1 = hex_digit_table[data[1]];
-    const std::uint8_t d2 = hex_digit_table[data[2]];
-    const std::uint8_t d3 = hex_digit_table[data[3]];
-    // every valid digit is <= 0xF; the combined OR only exceeds it if at
-    // least one of the four bytes was not a hex digit (looked up as 0xFF)
-    if ((d0 | d1 | d2 | d3) > 0x0F)
-    {
-        return -1;
-    }
-    return (d0 << 12) | (d1 << 8) | (d2 << 4) | d3;
-}
-
 }  // namespace detail
 NLOHMANN_JSON_NAMESPACE_END
@@ -279,12 +279,6 @@ class iter_impl // NOLINT(cppcoreguidelines-special-member-functions,hicpp-speci
        }
    }

-    /// @throw invalid_iterator.214 always
-    JSON_HEDLEY_NO_RETURN void throw_cannot_get_value() const
-    {
-        JSON_THROW(invalid_iterator::create(exception_id::iterator_value_unavailable, "cannot get value", m_object));
-    }
-
  public:
    /*!
    @brief return a reference to the value pointed to by the iterator
@@ -309,7 +303,7 @@ class iter_impl // NOLINT(cppcoreguidelines-special-member-functions,hicpp-speci
            }

            case value_t::null:
-                throw_cannot_get_value();
+                JSON_THROW(invalid_iterator::create(214, "cannot get value", m_object));

            case value_t::string:
            case value_t::boolean:
@@ -325,7 +319,7 @@ class iter_impl // NOLINT(cppcoreguidelines-special-member-functions,hicpp-speci
                    return *m_object;
                }

-                throw_cannot_get_value();
+                JSON_THROW(invalid_iterator::create(214, "cannot get value", m_object));
            }
        }
    }
@@ -367,7 +361,7 @@ class iter_impl // NOLINT(cppcoreguidelines-special-member-functions,hicpp-speci
                    return m_object;
                }

-                throw_cannot_get_value();
+                JSON_THROW(invalid_iterator::create(214, "cannot get value", m_object));
            }
        }
    }
@@ -484,7 +478,7 @@ class iter_impl // NOLINT(cppcoreguidelines-special-member-functions,hicpp-speci
        // if objects are not the same, the comparison is undefined
        if (JSON_HEDLEY_UNLIKELY(m_object != other.m_object))
        {
-            JSON_THROW(invalid_iterator::create(exception_id::iterators_compare_different_values, "cannot compare iterators of different containers", m_object));
+            JSON_THROW(invalid_iterator::create(212, "cannot compare iterators of different containers", m_object));
        }

        // value-initialized forward iterators can be compared, and must compare equal to other value-initialized iterators of the same type #4493
@@ -533,7 +527,7 @@ class iter_impl // NOLINT(cppcoreguidelines-special-member-functions,hicpp-speci
        // if objects are not the same, the comparison is undefined
        if (JSON_HEDLEY_UNLIKELY(m_object != other.m_object))
        {
-            JSON_THROW(invalid_iterator::create(exception_id::iterators_compare_different_values, "cannot compare iterators of different containers", m_object));
+            JSON_THROW(invalid_iterator::create(212, "cannot compare iterators of different containers", m_object));
        }

        // value-initialized forward iterators can be compared, and must compare equal to other value-initialized iterators of the same type #4493
@@ -546,7 +540,7 @@ class iter_impl // NOLINT(cppcoreguidelines-special-member-functions,hicpp-speci
        switch (m_object->m_data.m_type)
        {
            case value_t::object:
-                JSON_THROW(invalid_iterator::create(exception_id::iterator_order_on_object, "cannot compare order of object iterators", m_object));
+                JSON_THROW(invalid_iterator::create(213, "cannot compare order of object iterators", m_object));

            case value_t::array:
                return (m_it.array_iterator < other.m_it.array_iterator);
@@ -602,7 +596,7 @@ class iter_impl // NOLINT(cppcoreguidelines-special-member-functions,hicpp-speci
        switch (m_object->m_data.m_type)
        {
            case value_t::object:
-                JSON_THROW(invalid_iterator::create(exception_id::iterator_arithmetic_on_object, "cannot use offsets with object iterators", m_object));
+                JSON_THROW(invalid_iterator::create(209, "cannot use offsets with object iterators", m_object));

            case value_t::array:
            {
@@ -681,7 +675,7 @@ class iter_impl // NOLINT(cppcoreguidelines-special-member-functions,hicpp-speci
        switch (m_object->m_data.m_type)
        {
            case value_t::object:
-                JSON_THROW(invalid_iterator::create(exception_id::iterator_arithmetic_on_object, "cannot use offsets with object iterators", m_object));
+                JSON_THROW(invalid_iterator::create(209, "cannot use offsets with object iterators", m_object));

            case value_t::array:
                return m_it.array_iterator - other.m_it.array_iterator;
@@ -710,13 +704,13 @@ class iter_impl // NOLINT(cppcoreguidelines-special-member-functions,hicpp-speci
        switch (m_object->m_data.m_type)
        {
            case value_t::object:
-                JSON_THROW(invalid_iterator::create(exception_id::iterator_subscript_on_object, "cannot use operator[] for object iterators", m_object));
+                JSON_THROW(invalid_iterator::create(208, "cannot use operator[] for object iterators", m_object));

            case value_t::array:
                return *std::next(m_it.array_iterator, n);

            case value_t::null:
-                throw_cannot_get_value();
+                JSON_THROW(invalid_iterator::create(214, "cannot get value", m_object));

            case value_t::string:
            case value_t::boolean:
@@ -732,7 +726,7 @@ class iter_impl // NOLINT(cppcoreguidelines-special-member-functions,hicpp-speci
                    return *m_object;
                }

-                throw_cannot_get_value();
+                JSON_THROW(invalid_iterator::create(214, "cannot get value", m_object));
            }
        }
    }
@@ -750,7 +744,7 @@ class iter_impl // NOLINT(cppcoreguidelines-special-member-functions,hicpp-speci
            return m_it.object_iterator->first;
        }

-        JSON_THROW(invalid_iterator::create(exception_id::iterator_key_not_object, "cannot use key() for non-object iterators", m_object));
+        JSON_THROW(invalid_iterator::create(207, "cannot use key() for non-object iterators", m_object));
    }

    /*!
@@ -166,7 +166,7 @@ class json_pointer
    {
        if (JSON_HEDLEY_UNLIKELY(empty()))
        {
-            throw_no_parent();
+            JSON_THROW(detail::out_of_range::create(405, "JSON pointer has no parent", nullptr));
        }

        reference_tokens.erase(reference_tokens.begin());
@@ -178,7 +178,7 @@ class json_pointer
    {
        if (JSON_HEDLEY_UNLIKELY(empty()))
        {
-            throw_no_parent();
+            JSON_THROW(detail::out_of_range::create(405, "JSON pointer has no parent", nullptr));
        }

        return reference_tokens.front();
@@ -204,7 +204,7 @@ class json_pointer
    {
        if (JSON_HEDLEY_UNLIKELY(empty()))
        {
-            throw_no_parent();
+            JSON_THROW(detail::out_of_range::create(405, "JSON pointer has no parent", nullptr));
        }

        reference_tokens.pop_back();
@@ -216,7 +216,7 @@ class json_pointer
    {
        if (JSON_HEDLEY_UNLIKELY(empty()))
        {
-            throw_no_parent();
+            JSON_THROW(detail::out_of_range::create(405, "JSON pointer has no parent", nullptr));
        }

        return reference_tokens.back();
@@ -244,21 +244,6 @@ class json_pointer
    }

  private:
-    /// @throw out_of_range.405 always
-    JSON_HEDLEY_NO_RETURN static void throw_no_parent()
-    {
-        JSON_THROW(detail::out_of_range::create(detail::exception_id::patch_on_root, "JSON pointer has no parent", nullptr));
-    }
-
-    /// @throw out_of_range.404 always
-    template<typename BasicJsonContext>
-    JSON_HEDLEY_NO_RETURN static void throw_unresolved(const string_t& reference_token, BasicJsonContext context)
-    {
-        static_cast<void>(reference_token); // unused when JSON_NOEXCEPTION is defined
-        static_cast<void>(context);
-        JSON_THROW(detail::out_of_range::create(detail::exception_id::pointer_unresolved, detail::concat("unresolved reference token '", reference_token, "'"), context));
-    }
-
    /*!
    @brief result of @ref parse_array_index

@@ -270,7 +255,7 @@ class json_pointer
    {
        ok,                ///< @a s is a valid, representable array index
        leading_zero,      ///< @a s begins with '0' but has more than one character
-        not_a_number,      ///< @a s is neither empty nor "-" and does not begin with a digit
+        not_a_number,      ///< @a s does not begin with a digit
        unresolved,        ///< @a s could not be converted to an integer
        exceeds_size_type  ///< @a s converts to an integer that exceeds size_type
    };
@@ -297,10 +282,8 @@ class json_pointer
            return array_index_status::leading_zero;
        }

-        // error condition (cf. RFC 6901, Sect. 4); this also covers single-
-        // character tokens, so "/x" and "/xy" fail alike; "-" and the empty
-        // token are left to the conversion below and are reported as unresolved
-        if (JSON_HEDLEY_UNLIKELY(!s.empty() && s != "-" && !(s[0] >= '0' && s[0] <= '9')))
+        // error condition (cf. RFC 6901, Sect. 4)
+        if (JSON_HEDLEY_UNLIKELY(s.size() > 1 && !(s[0] >= '1' && s[0] <= '9')))
        {
            return array_index_status::not_a_number;
        }
@@ -346,13 +329,13 @@ class json_pointer
            // the branches differ in their messages, not after JSON_THROW's expansion
            // NOLINTNEXTLINE(bugprone-branch-clone)
            case array_index_status::leading_zero:
-                JSON_THROW(detail::parse_error::create(detail::exception_id::pointer_index_leading_zero, 0, detail::concat("array index '", s, "' must not begin with '0'"), nullptr));
+                JSON_THROW(detail::parse_error::create(106, 0, detail::concat("array index '", s, "' must not begin with '0'"), nullptr));
            case array_index_status::not_a_number:
-                JSON_THROW(detail::parse_error::create(detail::exception_id::pointer_index_not_a_number, 0, detail::concat("array index '", s, "' is not a number"), nullptr));
+                JSON_THROW(detail::parse_error::create(109, 0, detail::concat("array index '", s, "' is not a number"), nullptr));
            case array_index_status::unresolved:
-                throw_unresolved(s, nullptr);
+                JSON_THROW(detail::out_of_range::create(404, detail::concat("unresolved reference token '", s, "'"), nullptr));
            case array_index_status::exceeds_size_type:
-                JSON_THROW(detail::out_of_range::create(detail::exception_id::value_out_of_range, detail::concat("array index ", s, " exceeds size_type"), nullptr));
+                JSON_THROW(detail::out_of_range::create(410, detail::concat("array index ", s, " exceeds size_type"), nullptr));
            case array_index_status::ok:
            default:
                break;
@@ -366,7 +349,7 @@ class json_pointer
    {
        if (JSON_HEDLEY_UNLIKELY(empty()))
        {
-            throw_no_parent();
+            JSON_THROW(detail::out_of_range::create(405, "JSON pointer has no parent", nullptr));
        }

        json_pointer result = *this;
@@ -503,7 +486,7 @@ class json_pointer
                case detail::value_t::binary:
                case detail::value_t::discarded:
                default:
-                    JSON_THROW(detail::type_error::create(detail::exception_id::unflatten_invalid_value, "invalid value to unflatten", &j));
+                    JSON_THROW(detail::type_error::create(313, "invalid value to unflatten", &j));
            }

            id = tree.find_child(id, reference_token);
@@ -586,7 +569,7 @@ class json_pointer
                case detail::value_t::binary:
                case detail::value_t::discarded:
                default:
-                    throw_unresolved(reference_token, ptr);
+                    JSON_THROW(detail::out_of_range::create(404, detail::concat("unresolved reference token '", reference_token, "'"), ptr));
            }
        }

@@ -618,7 +601,7 @@ class json_pointer
                    if (JSON_HEDLEY_UNLIKELY(reference_token == "-"))
                    {
                        // "-" always fails the range check
-                        JSON_THROW(detail::out_of_range::create(detail::exception_id::pointer_past_the_end_index, detail::concat(
+                        JSON_THROW(detail::out_of_range::create(402, detail::concat(
                                "array index '-' (", std::to_string(ptr->m_data.m_value.array->size()),
                                ") is out of range"), ptr));
                    }
@@ -627,7 +610,7 @@ class json_pointer
                    // Bounds check before access to avoid exception with JSON_NOEXCEPTION
                    if (JSON_HEDLEY_UNLIKELY(idx >= ptr->m_data.m_value.array->size()))
                    {
-                        JSON_THROW(detail::out_of_range::create(detail::exception_id::array_index_out_of_range, detail::concat(
+                        JSON_THROW(detail::out_of_range::create(401, detail::concat(
                                "array index ", std::to_string(idx), " is out of range"), ptr));
                    }
                    ptr = &ptr->operator[](idx);
@@ -643,7 +626,7 @@ class json_pointer
                case detail::value_t::binary:
                case detail::value_t::discarded:
                default:
-                    throw_unresolved(reference_token, ptr);
+                    JSON_THROW(detail::out_of_range::create(404, detail::concat("unresolved reference token '", reference_token, "'"), ptr));
            }
        }

@@ -687,7 +670,7 @@ class json_pointer
                    if (JSON_HEDLEY_UNLIKELY(reference_token == "-"))
                    {
                        // "-" cannot be used for const access
-                        JSON_THROW(detail::out_of_range::create(detail::exception_id::pointer_past_the_end_index, detail::concat("array index '-' (", std::to_string(ptr->m_data.m_value.array->size()), ") is out of range"), ptr));
+                        JSON_THROW(detail::out_of_range::create(402, detail::concat("array index '-' (", std::to_string(ptr->m_data.m_value.array->size()), ") is out of range"), ptr));
                    }

                    // use unchecked array access; the const operator[]
@@ -705,7 +688,7 @@ class json_pointer
                case detail::value_t::binary:
                case detail::value_t::discarded:
                default:
-                    throw_unresolved(reference_token, ptr);
+                    JSON_THROW(detail::out_of_range::create(404, detail::concat("unresolved reference token '", reference_token, "'"), ptr));
            }
        }

@@ -760,9 +743,9 @@ class json_pointer
                        // the branches differ in their messages, not after JSON_THROW's expansion
                        // NOLINTNEXTLINE(bugprone-branch-clone)
                        case array_index_status::leading_zero:
-                            JSON_THROW(detail::parse_error::create(detail::exception_id::pointer_index_leading_zero, 0, detail::concat("array index '", reference_token, "' must not begin with '0'"), nullptr));
+                            JSON_THROW(detail::parse_error::create(106, 0, detail::concat("array index '", reference_token, "' must not begin with '0'"), nullptr));
                        case array_index_status::not_a_number:
-                            JSON_THROW(detail::parse_error::create(detail::exception_id::pointer_index_not_a_number, 0, detail::concat("array index '", reference_token, "' is not a number"), nullptr));
+                            JSON_THROW(detail::parse_error::create(109, 0, detail::concat("array index '", reference_token, "' is not a number"), nullptr));
                        case array_index_status::unresolved:
                        case array_index_status::exceeds_size_type:
                            return nullptr;
@@ -889,7 +872,7 @@ class json_pointer
        // check if a nonempty reference string begins with slash
        if (JSON_HEDLEY_UNLIKELY(reference_string[0] != '/'))
        {
-            JSON_THROW(detail::parse_error::create(detail::exception_id::pointer_missing_slash, 1, detail::concat("JSON pointer must be empty or begin with '/' - was: '", reference_string, "'"), nullptr));
+            JSON_THROW(detail::parse_error::create(107, 1, detail::concat("JSON pointer must be empty or begin with '/' - was: '", reference_string, "'"), nullptr));
        }

        // extract the reference tokens:
@@ -925,7 +908,7 @@ class json_pointer
                                         (reference_token[pos + 1] != '0' &&
                                          reference_token[pos + 1] != '1')))
                {
-                    JSON_THROW(detail::parse_error::create(detail::exception_id::pointer_invalid_escape, 0, "escape character '~' must be followed with '0' or '1'", nullptr));
+                    JSON_THROW(detail::parse_error::create(108, 0, "escape character '~' must be followed with '0' or '1'", nullptr));
                }
            }

@@ -1089,7 +1072,7 @@ class json_pointer
    {
        if (JSON_HEDLEY_UNLIKELY(!value.is_object()))
        {
-            JSON_THROW(detail::type_error::create(detail::exception_id::unflatten_not_object, "only objects can be unflattened", &value));
+            JSON_THROW(detail::type_error::create(314, "only objects can be unflattened", &value));
        }

        BasicJsonType result;
@@ -1113,7 +1096,7 @@ class json_pointer
        {
            if (JSON_HEDLEY_UNLIKELY(!element.second.is_primitive()))
            {
-                JSON_THROW(detail::type_error::create(detail::exception_id::unflatten_value_not_primitive, "values in object must be primitive", &element.second));
+                JSON_THROW(detail::type_error::create(315, "values in object must be primitive", &element.second));
            }

            // Assign the value to the reference pointed to by JSON pointer. Note
@@ -312,7 +312,7 @@
            return ej_pair.first == e;                                                          \
        });                                                                                     \
        if (it != std::end(m)) j = it->second;                                                  \
-        else ::nlohmann::detail::templated_json_throw<nlohmann::detail::out_of_range>(nlohmann::detail::out_of_range::create(nlohmann::detail::exception_id::value_out_of_range,"enum value out of range for " #ENUM_TYPE, nullptr)); \
+        else ::nlohmann::detail::templated_json_throw<nlohmann::detail::out_of_range>(nlohmann::detail::out_of_range::create(410,"enum value out of range for " #ENUM_TYPE, nullptr)); \
    }                                                                                           \
    template<typename BasicJsonType>                                                            \
    inline void from_json(const BasicJsonType& j, ENUM_TYPE& e)                                 \
@@ -327,7 +327,7 @@
            return ej_pair.second == j;                                                         \
        });                                                                                     \
        if (it != std::end(m)) e = it->first;                                                   \
-        else ::nlohmann::detail::templated_json_throw<nlohmann::detail::out_of_range>(nlohmann::detail::out_of_range::create(nlohmann::detail::exception_id::value_out_of_range, nlohmann::detail::concat("enum value out of range for " #ENUM_TYPE ": ", j.dump(-1, ' ', false, nlohmann::detail::error_handler_t::replace)), &j)); \
+        else ::nlohmann::detail::templated_json_throw<nlohmann::detail::out_of_range>(nlohmann::detail::out_of_range::create(410, nlohmann::detail::concat("enum value out of range for " #ENUM_TYPE ": ", j.dump(-1, ' ', false, nlohmann::detail::error_handler_t::replace)), &j)); \
    }

 // Ugly macros to avoid uglier copy-paste when specializing basic_json. They
@@ -172,10 +172,6 @@ struct has_to_json < BasicJsonType, T, enable_if_t < !is_basic_json<T>::value >>
 template<typename T>
 using detect_key_compare = typename T::key_compare;

-// detects whether two values of type T can be compared with operator==
-template<typename T>
-using detect_equal_comparable = decltype(static_cast<bool>(std::declval<const T&>() == std::declval<const T&>()));
-
 // obtains the actual object key comparator: object_t::key_compare if the
 // object type defines it, and default_object_comparator_t otherwise
 //
@@ -157,7 +157,7 @@ class binary_writer
            case value_t::discarded:
            default:
            {
-                JSON_THROW(type_error::create(exception_id::type_not_serializable, concat("to serialize to BSON, top-level type must be object, but is ", j.type_name()), &j));
+                JSON_THROW(type_error::create(317, concat("to serialize to BSON, top-level type must be object, but is ", j.type_name()), &j));
            }
        }
    }
@@ -207,6 +207,10 @@ class binary_writer
            {
                if (j.m_data.m_value.number_integer >= 0)
                {
+                    if (JSON_HEDLEY_UNLIKELY(!integer_fits_max<std::uint64_t>(j.m_data.m_value.number_integer)))
+                    {
+                        throw_integer_out_of_range(j, "CBOR", "[-2^64, 2^64-1]");
+                    }
                    // CBOR does not differentiate between positive signed
                    // integers and unsigned integers
                    write_cbor_head(0x00, static_cast<std::uint64_t>(j.m_data.m_value.number_integer));
@@ -214,6 +218,10 @@ class binary_writer
                else
                {
                    // a negative integer n is encoded as -1 - n
+                    if (JSON_HEDLEY_UNLIKELY(!integer_fits_max<std::uint64_t>(-1 - j.m_data.m_value.number_integer)))
+                    {
+                        throw_integer_out_of_range(j, "CBOR", "[-2^64, 2^64-1]");
+                    }
                    write_cbor_head(0x20, static_cast<std::uint64_t>(-1 - j.m_data.m_value.number_integer));
                }
                break;
@@ -221,7 +229,11 @@ class binary_writer

            case value_t::number_unsigned:
            {
-                write_cbor_head(0x00, j.m_data.m_value.number_unsigned);
+                if (JSON_HEDLEY_UNLIKELY(!integer_fits_max<std::uint64_t>(j.m_data.m_value.number_unsigned)))
+                {
+                    throw_integer_out_of_range(j, "CBOR", "uint64");
+                }
+                write_cbor_head(0x00, static_cast<std::uint64_t>(j.m_data.m_value.number_unsigned));
                break;
            }

@@ -313,6 +325,12 @@ class binary_writer

            case value_t::object:
            {
+                static_assert(
+                    std::is_convertible <
+                    typename BasicJsonType::object_t::key_type,
+                    string_t >::value,
+                    "object_t::key_type must be implicitly convertible to string_t");
+
                // step 1: write control byte and the object size
                write_cbor_head(0xA0, j.m_data.m_value.object->size());

@@ -320,7 +338,7 @@ class binary_writer
                {
                    // el.first is written directly (not via a temporary
                    // basic_json), with the object as diagnostics context
-                    write_cbor_key(el.first, j);
+                    write_cbor_string(el.first, j);
                    write_cbor(el.second, depth + 1);
                }
                break;
@@ -342,7 +360,7 @@ class binary_writer
    {
        if (JSON_HEDLEY_UNLIKELY(!value_in_range_of<std::uint32_t>(length)))
        {
-            JSON_THROW(out_of_range::create(exception_id::length_too_large, concat("MessagePack length ", std::to_string(length), " exceeds maximum of ", std::to_string((std::numeric_limits<std::uint32_t>::max)())), &j));
+            JSON_THROW(out_of_range::create(412, concat("MessagePack length ", std::to_string(length), " exceeds maximum of ", std::to_string((std::numeric_limits<std::uint32_t>::max)())), &j));
        }

        static_cast<void>(j);
@@ -423,12 +441,20 @@ class binary_writer
            {
                if (j.m_data.m_value.number_integer >= 0)
                {
+                    if (JSON_HEDLEY_UNLIKELY(!integer_fits_max<std::uint64_t>(j.m_data.m_value.number_integer)))
+                    {
+                        throw_integer_out_of_range(j, "MessagePack", "[-2^63, 2^64-1]");
+                    }
                    // MessagePack does not differentiate between positive
                    // signed integers and unsigned integers.
                    write_msgpack_unsigned(static_cast<std::uint64_t>(j.m_data.m_value.number_integer));
                }
                else
                {
+                    if (JSON_HEDLEY_UNLIKELY(!integer_fits_min<std::int64_t>(j.m_data.m_value.number_integer)))
+                    {
+                        throw_integer_out_of_range(j, "MessagePack", "[-2^63, 2^64-1]");
+                    }
                    if (j.m_data.m_value.number_integer >= -32)
                    {
                        // negative fixnum
@@ -467,6 +493,10 @@ class binary_writer

            case value_t::number_unsigned:
            {
+                if (JSON_HEDLEY_UNLIKELY(!integer_fits_max<std::uint64_t>(j.m_data.m_value.number_unsigned)))
+                {
+                    throw_integer_out_of_range(j, "MessagePack", "uint64");
+                }
                write_msgpack_unsigned(static_cast<std::uint64_t>(j.m_data.m_value.number_unsigned));
                break;
            }
@@ -569,7 +599,7 @@ class binary_writer
                {
                    if (JSON_HEDLEY_UNLIKELY(j.m_data.m_value.binary->subtype() > (std::numeric_limits<std::uint8_t>::max)()))
                    {
-                        JSON_THROW(out_of_range::create(exception_id::subtype_out_of_range, concat("subtype ", std::to_string(j.m_data.m_value.binary->subtype()), " is too large for the MessagePack ext type (max 255)"), &j));
+                        JSON_THROW(out_of_range::create(415, concat("subtype ", std::to_string(j.m_data.m_value.binary->subtype()), " is too large for the MessagePack ext type (max 255)"), &j));
                    }

                    write_number(static_cast<std::int8_t>(j.m_data.m_value.binary->subtype()));
@@ -585,6 +615,12 @@ class binary_writer

            case value_t::object:
            {
+                static_assert(
+                    std::is_convertible <
+                    typename BasicJsonType::object_t::key_type,
+                    string_t >::value,
+                    "object_t::key_type must be implicitly convertible to string_t");
+
                // step 1: write control byte and the object size
                write_msgpack_object_prefix(j.m_data.m_value.object->size(), j);

@@ -592,7 +628,7 @@ class binary_writer
                {
                    // as in write_cbor, el.first is written directly with the
                    // object as diagnostics context
-                    write_msgpack_key(el.first, j);
+                    write_msgpack_string(el.first, j);
                    write_msgpack(el.second, depth + 1);
                }
                break;
@@ -718,7 +754,7 @@ class binary_writer
                {
                    if (!use_count)
                    {
-                        JSON_THROW(other_error::create(exception_id::size_marker_required, "use_type requires use_size = true", &j));
+                        JSON_THROW(other_error::create(502, "use_type requires use_size = true", &j));
                    }
                    oa.write_character(to_char_type('$'));
                    oa.write_character(bjdata_draft3 ? 'B' : 'U');
@@ -797,8 +833,6 @@ class binary_writer

    /*!
    @param[in] j  JSON value to serialize
-
-    @throw type_error.321 if @a j or a value nested in it is discarded
    */
    void write_bon8(const BasicJsonType& j)
    {
@@ -821,7 +855,85 @@ class binary_writer
    {
        static_cast<void>(j); // unused when JSON_NOEXCEPTION is defined
        static_cast<void>(format_name);
-        JSON_THROW(type_error::create(exception_id::discarded_value_used, concat("cannot serialize discarded value to ", format_name), &j));
+        JSON_THROW(type_error::create(321, concat("cannot serialize discarded value to ", format_name), &j));
+    }
+
+    /*!
+    @brief whether integer @a n does not exceed the maximum of @a TargetType
+
+    The binary formats store integers in at most 64 bits, but number_integer_t
+    and number_unsigned_t may be wider (e.g., __int128). The range of the
+    integer is taken from std::numeric_limits, so a number type whose range
+    fits into @a TargetType is never checked: the function is then constant
+    true, and the default int64_t/uint64_t types pay nothing.
+    */
+    template<typename TargetType, typename NumberType>
+    static constexpr bool integer_fits_max(const NumberType n) noexcept
+    {
+        return integer_fits_max<TargetType>(n, std::integral_constant < bool,
+                                            (std::numeric_limits<NumberType>::digits > std::numeric_limits<TargetType>::digits) > ());
+    }
+
+    template<typename TargetType, typename NumberType>
+    static constexpr bool integer_fits_max(const NumberType /*unused*/, std::false_type /*may_exceed*/) noexcept
+    {
+        return true;
+    }
+
+    template<typename TargetType, typename NumberType>
+    static constexpr bool integer_fits_max(const NumberType n, std::true_type /*may_exceed*/) noexcept
+    {
+        // NumberType has more digits than TargetType, so it can hold its maximum
+        return n <= static_cast<NumberType>((std::numeric_limits<TargetType>::max)());
+    }
+
+    /*!
+    @brief whether integer @a n is not below the minimum of @a TargetType;
+           constant true if NumberType cannot hold such a value
+    */
+    template<typename TargetType, typename NumberType>
+    static constexpr bool integer_fits_min(const NumberType n) noexcept
+    {
+        return integer_fits_min<TargetType>(n, std::integral_constant < bool, std::numeric_limits<NumberType>::is_signed &&
+                                            (!std::numeric_limits<TargetType>::is_signed || std::numeric_limits<NumberType>::digits > std::numeric_limits<TargetType>::digits) > ());
+    }
+
+    template<typename TargetType, typename NumberType>
+    static constexpr bool integer_fits_min(const NumberType /*unused*/, std::false_type /*may_fall_below*/) noexcept
+    {
+        return true;
+    }
+
+    template<typename TargetType, typename NumberType>
+    static constexpr bool integer_fits_min(const NumberType n, std::true_type /*may_fall_below*/) noexcept
+    {
+        // NumberType is signed and either TargetType is unsigned (minimum 0)
+        // or NumberType has more digits, so it can hold the minimum
+        return n >= static_cast<NumberType>((std::numeric_limits<TargetType>::min)());
+    }
+
+    /*!
+    @brief whether integer @a n lies in the range of @a TargetType
+    */
+    template<typename TargetType, typename NumberType>
+    static constexpr bool integer_fits(const NumberType n) noexcept
+    {
+        return integer_fits_min<TargetType>(n) && integer_fits_max<TargetType>(n);
+    }
+
+    /*!
+    @brief throws because the integer @a j is too large for @a format_name
+    @throw out_of_range.407 always
+    */
+    JSON_HEDLEY_NO_RETURN static void throw_integer_out_of_range(const BasicJsonType& j, const char* format_name, const char* range)
+    {
+        // dump() rather than std::to_string(), which has no overload for
+        // integer types wider than 64 bits
+        const auto number = j.dump();
+        static_cast<void>(number); // unused when JSON_NOEXCEPTION is defined
+        static_cast<void>(format_name);
+        static_cast<void>(range);
+        JSON_THROW(out_of_range::create(407, concat("integer number ", number, " cannot be represented by ", format_name, " as it does not fit ", range), &j));
    }

    void write_msgpack_array_prefix(const std::size_t N, const BasicJsonType& j)
@@ -868,9 +980,9 @@ class binary_writer
        }
    }

-    /// @brief a CBOR, MessagePack, or BON8 array or object whose elements
-    ///        @ref write_cbor_iterative, @ref write_msgpack_iterative, or
-    ///        @ref write_bon8_iterative is still writing
+    /// @brief a CBOR or MessagePack array or object whose elements
+    ///        @ref write_cbor_iterative or @ref write_msgpack_iterative is
+    ///        still writing
    struct binary_container_frame
    {
        explicit binary_container_frame(const BasicJsonType* value_) noexcept
@@ -982,7 +1094,7 @@ class binary_writer

                // the key is written directly (not via a temporary basic_json),
                // with the object as diagnostics context, as in write_cbor
-                write_cbor_key(current.object_it->first, *current.value);
+                write_cbor_string(current.object_it->first, *current.value);
                const BasicJsonType* child = &(current.object_it->second);
                ++stack.back().object_it;
                write_cbor_value_or_push(*child, stack);
@@ -1059,7 +1171,7 @@ class binary_writer

                // as in write_cbor_iterative, the key is written directly with
                // the object as diagnostics context
-                write_msgpack_key(current.object_it->first, *current.value);
+                write_msgpack_string(current.object_it->first, *current.value);
                const BasicJsonType* child = &(current.object_it->second);
                ++stack.back().object_it;
                write_msgpack_value_or_push(*child, stack);
@@ -1081,7 +1193,7 @@ class binary_writer
        {
            if (!use_count)
            {
-                JSON_THROW(other_error::create(exception_id::size_marker_required, "use_type requires use_size = true", &j));
+                JSON_THROW(other_error::create(502, "use_type requires use_size = true", &j));
            }
            const CharType first_prefix = ubjson_prefix(j.front(), use_bjdata);
            const bool same_prefix = std::all_of(j.begin() + 1, j.end(),
@@ -1131,7 +1243,7 @@ class binary_writer
        {
            if (!use_count)
            {
-                JSON_THROW(other_error::create(exception_id::size_marker_required, "use_type requires use_size = true", &j));
+                JSON_THROW(other_error::create(502, "use_type requires use_size = true", &j));
            }
            const CharType first_prefix = ubjson_prefix(j.front(), use_bjdata);
            const bool same_prefix = std::all_of(j.begin(), j.end(),
@@ -1348,7 +1460,7 @@ class binary_writer
        const auto it = name.find(static_cast<typename string_t::value_type>(0));
        if (JSON_HEDLEY_UNLIKELY(it != BasicJsonType::string_t::npos))
        {
-            JSON_THROW(out_of_range::create(exception_id::bson_key_with_null, concat("BSON key cannot contain code point U+0000 (at byte ", std::to_string(it), ")"), &j));
+            JSON_THROW(out_of_range::create(409, concat("BSON key cannot contain code point U+0000 (at byte ", std::to_string(it), ")"), &j));
        }

        string_t storage;
@@ -1366,7 +1478,7 @@ class binary_writer
    {
        if (JSON_HEDLEY_UNLIKELY(!value_in_range_of<std::int32_t>(size)))
        {
-            JSON_THROW(out_of_range::create(exception_id::length_too_large, concat("BSON length ", std::to_string(size), " exceeds maximum of ", std::to_string((std::numeric_limits<std::int32_t>::max)())), nullptr));
+            JSON_THROW(out_of_range::create(412, concat("BSON length ", std::to_string(size), " exceeds maximum of ", std::to_string((std::numeric_limits<std::int32_t>::max)())), nullptr));
        }

        return static_cast<std::int32_t>(size);
@@ -1552,7 +1664,7 @@ class binary_writer

        if (value.has_subtype() && JSON_HEDLEY_UNLIKELY(value.subtype() > (std::numeric_limits<std::uint8_t>::max)()))
        {
-            JSON_THROW(out_of_range::create(exception_id::subtype_out_of_range, concat("subtype ", std::to_string(value.subtype()), " is too large for the BSON binary subtype (max 255)"), &j));
+            JSON_THROW(out_of_range::create(415, concat("subtype ", std::to_string(value.subtype()), " is too large for the BSON binary subtype (max 255)"), &j));
        }

        return sizeof(std::int32_t) + value.size() + 1ul;
@@ -1580,6 +1692,8 @@ class binary_writer
            is neither an object nor an array
    @throw out_of_range.415 if @a j is binary with a subtype that does not fit
           into a byte, before anything is written
+    @throw out_of_range.407 if @a j is an integer that does not fit the 64 bits
+           of a BSON integer, before anything is written
    @throw type_error.316 if @a j is a string that is not valid UTF-8, before
           anything is written
    @throw type_error.321 if @a j is discarded
@@ -1598,10 +1712,18 @@ class binary_writer
                return 8ul;

            case value_t::number_integer:
-                return calc_bson_integer_size(j.m_data.m_value.number_integer);
+                if (JSON_HEDLEY_UNLIKELY(!integer_fits<std::int64_t>(j.m_data.m_value.number_integer)))
+                {
+                    throw_integer_out_of_range(j, "BSON", "int64");
+                }
+                return calc_bson_integer_size(static_cast<std::int64_t>(j.m_data.m_value.number_integer));

            case value_t::number_unsigned:
-                return calc_bson_unsigned_size(j.m_data.m_value.number_unsigned);
+                if (JSON_HEDLEY_UNLIKELY(!integer_fits_max<std::uint64_t>(j.m_data.m_value.number_unsigned)))
+                {
+                    throw_integer_out_of_range(j, "BSON", "uint64");
+                }
+                return calc_bson_unsigned_size(static_cast<std::uint64_t>(j.m_data.m_value.number_unsigned));

            case value_t::string:
                return calc_bson_string_size(*j.m_data.m_value.string, j);
@@ -1639,11 +1761,12 @@ class binary_writer
            case value_t::number_float:
                return write_bson_double(name, j.m_data.m_value.number_float);

+            // calc_bson_value_size() checked that integers fit 64 bits
            case value_t::number_integer:
-                return write_bson_integer(name, j.m_data.m_value.number_integer);
+                return write_bson_integer(name, static_cast<std::int64_t>(j.m_data.m_value.number_integer));

            case value_t::number_unsigned:
-                return write_bson_unsigned(name, j.m_data.m_value.number_unsigned);
+                return write_bson_unsigned(name, static_cast<std::uint64_t>(j.m_data.m_value.number_unsigned));

            case value_t::string:
                return write_bson_string(name, *j.m_data.m_value.string);
@@ -1664,21 +1787,6 @@ class binary_writer
        }
    }

-    /*!
-    @brief Writes the head of a BSON element with key @a name whose value is
-           the object or array @a j: its type, key, and @a size
-
-    Called while the key is in scope: an object key is a key_type, which
-    may only convert to a temporary string_t, so it cannot be kept by
-    pointer until after the loop over the entries.
-    */
-    void write_bson_nested_head(const string_t& name, const BasicJsonType& j,
-                                const std::size_t size)
-    {
-        write_bson_entry_header(name, j.is_object() ? 0x03 : 0x04);
-        write_number<std::int32_t>(to_bson_length(size), true);
-    }
-
    /// @brief an object or array of the BSON document being sized or written
    struct bson_frame
    {
@@ -1843,6 +1951,7 @@ class binary_writer
        {
            // write entries until the current object or array is done, or an
            // entry is an object or array itself
+            const string_t* nested_name = nullptr;
            const BasicJsonType* nested = nullptr;
            if (current.value->is_object())
            {
@@ -1853,7 +1962,7 @@ class binary_writer
                    ++current.member;
                    if (el.second.is_structured())
                    {
-                        write_bson_nested_head(el.first, el.second, nested_sizes[next_size++]);
+                        nested_name = &el.first;
                        nested = &el.second;
                    }
                    else
@@ -1872,7 +1981,7 @@ class binary_writer
                    ++current.index;
                    if (el.is_structured())
                    {
-                        write_bson_nested_head(index_name, el, nested_sizes[next_size++]);
+                        nested_name = &index_name;
                        nested = &el;
                    }
                    else
@@ -1884,6 +1993,8 @@ class binary_writer

            if (nested != nullptr)
            {
+                write_bson_entry_header(*nested_name, nested->is_object() ? 0x03 : 0x04);
+                write_number<std::int32_t>(to_bson_length(nested_sizes[next_size++]), true);
                parents.push_back(std::move(current));
                current = bson_frame(nested);
                continue;
@@ -1951,43 +2062,6 @@ class binary_writer
        }
    }

-    /*!
-    @brief write an object key as a CBOR text string
-
-    A key convertible to string_t is written directly. Other key types (only
-    an explicit conversion, or only a to_json overload) go through a temporary
-    basic_json, as in version 3.12.0; the temporary is then the diagnostics
-    context for strict UTF-8 checks.
-    */
-    template<typename Key = typename BasicJsonType::object_t::key_type,
-             enable_if_t<std::is_convertible<Key, string_t>::value, int> = 0>
-    void write_cbor_key(const typename BasicJsonType::object_t::key_type& key, const BasicJsonType& context)
-    {
-        write_cbor_string(key, context);
-    }
-
-    template < typename Key = typename BasicJsonType::object_t::key_type,
-               enable_if_t < !std::is_convertible<Key, string_t>::value, int > = 0 >
-    void write_cbor_key(const typename BasicJsonType::object_t::key_type& key, const BasicJsonType& /*context*/)
-    {
-        write_cbor(BasicJsonType(key));
-    }
-
-    /// @brief write an object key as a MessagePack str, as in @ref write_cbor_key
-    template<typename Key = typename BasicJsonType::object_t::key_type,
-             enable_if_t<std::is_convertible<Key, string_t>::value, int> = 0>
-    void write_msgpack_key(const typename BasicJsonType::object_t::key_type& key, const BasicJsonType& context)
-    {
-        write_msgpack_string(key, context);
-    }
-
-    template < typename Key = typename BasicJsonType::object_t::key_type,
-               enable_if_t < !std::is_convertible<Key, string_t>::value, int > = 0 >
-    void write_msgpack_key(const typename BasicJsonType::object_t::key_type& key, const BasicJsonType& /*context*/)
-    {
-        write_msgpack(BasicJsonType(key));
-    }
-
    /*!
    @brief write a CBOR text string

@@ -2147,7 +2221,7 @@ class binary_writer
        {
            return 'L';
        }
-        if (use_bjdata && std::is_unsigned<NumberType>::value)
+        if (use_bjdata && std::is_unsigned<NumberType>::value && integer_fits_max<std::uint64_t>(n))
        {
            return 'M';
        }
@@ -2272,14 +2346,16 @@ class binary_writer
    @brief checks whether a JSON number fits into @a TargetType
    @param[in] el a JSON number of either the signed or unsigned integer kind
    @return whether @a el's value can be represented by @a TargetType without
-            wrapping, regardless of which of the two kinds it is stored as
+            wrapping, regardless of which of the two kinds it is stored as;
+            false for a value that does not even fit the 64-bit type it is
+            read as (possible for number types wider than 64 bits)
    */
    template<typename TargetType>
    static bool bjdata_ndarray_value_in_range(const BasicJsonType& el)
    {
        return el.is_number_unsigned()
-               ? value_in_range_of<TargetType>(el.template get<std::uint64_t>())
-               : value_in_range_of<TargetType>(el.template get<std::int64_t>());
+               ? integer_fits_max<std::uint64_t>(el.m_data.m_value.number_unsigned) && value_in_range_of<TargetType>(el.template get<std::uint64_t>())
+               : integer_fits<std::int64_t>(el.m_data.m_value.number_integer) && value_in_range_of<TargetType>(el.template get<std::int64_t>());
    }

    /*!
@@ -2511,10 +2587,11 @@ class binary_writer
        for (const auto& el : dims)
        {
            // a dimension is read as an unsigned value below, so anything that
-            // is not a non-negative integer is rejected: a non-integer entry
-            // would pun unrelated bytes as the dimension, and a negative one
-            // would wrap into a nonsensical length
-            if (!el.is_number_integer() || (!el.is_number_unsigned() && el.template get<std::int64_t>() < 0))
+            // is not a non-negative integer in the range of std::uint64_t is
+            // rejected: a non-integer entry would pun unrelated bytes as the
+            // dimension, and a negative or wider one would wrap into a
+            // nonsensical length
+            if (!el.is_number_integer() || !bjdata_ndarray_value_in_range<std::uint64_t>(el))
            {
                return true;
            }
@@ -2609,27 +2686,9 @@ class binary_writer
    @param[in] j                JSON value to serialize
    @param[in,out] string_open  whether the output ends with a non-empty
                                string that has not been terminated with 0xFF
-    @param[in] depth            nesting level of @a j, counted from the
-                                top-level value passed to @ref basic_json::to_bon8
-    @throw type_error.316 if a string value or an object key is not valid
-           UTF-8
-    @throw out_of_range.407 if an unsigned integer does not fit int64
-    @throw type_error.321 if @a j or a value nested in it is discarded
-
-    Values nested deeper than @ref recursion_depth_limit are written by
-    @ref write_bon8_iterative without the call stack.
-
-    @sa @ref write_cbor
-    @sa https://github.com/nlohmann/json/issues/5392
    */
-    void write_bon8_value(const BasicJsonType& j, bool& string_open, const std::size_t depth = 0)
+    void write_bon8_value(const BasicJsonType& j, bool& string_open)
    {
-        if (JSON_HEDLEY_UNLIKELY(depth >= recursion_depth_limit()) && (j.is_array() || j.is_object()))
-        {
-            write_bon8_iterative(j, string_open);
-            return;
-        }
-
        switch (j.type())
        {
            case value_t::null:
@@ -2646,9 +2705,9 @@ class binary_writer

            case value_t::number_unsigned:
            {
-                if (j.m_data.m_value.number_unsigned > static_cast<typename BasicJsonType::number_unsigned_t>((std::numeric_limits<std::int64_t>::max)()))
+                if (JSON_HEDLEY_UNLIKELY(!integer_fits_max<std::int64_t>(j.m_data.m_value.number_unsigned)))
                {
-                    JSON_THROW(out_of_range::create(exception_id::integer_too_large, concat("integer number ", std::to_string(j.m_data.m_value.number_unsigned), " cannot be represented by BON8 as it does not fit int64"), &j));
+                    throw_integer_out_of_range(j, "BON8", "int64");
                }
                write_bon8_integer(static_cast<std::int64_t>(j.m_data.m_value.number_unsigned));
                string_open = false;
@@ -2657,6 +2716,10 @@ class binary_writer

            case value_t::number_integer:
            {
+                if (JSON_HEDLEY_UNLIKELY(!integer_fits<std::int64_t>(j.m_data.m_value.number_integer)))
+                {
+                    throw_integer_out_of_range(j, "BON8", "int64");
+                }
                write_bon8_integer(static_cast<std::int64_t>(j.m_data.m_value.number_integer));
                string_open = false;
                break;
@@ -2683,7 +2746,7 @@ class binary_writer

                for (const auto& el : *j.m_data.m_value.array)
                {
-                    write_bon8_value(el, string_open, depth + 1);
+                    write_bon8_value(el, string_open);
                }

                if (N > 4)
@@ -2702,7 +2765,7 @@ class binary_writer
                for (const auto& el : *j.m_data.m_value.object)
                {
                    write_bon8_string(el.first, string_open, j);
-                    write_bon8_value(el.second, string_open, depth + 1);
+                    write_bon8_value(el.second, string_open);
                }

                if (N > 4)
@@ -2735,84 +2798,7 @@ class binary_writer

            case value_t::discarded:
            default:
-                throw_on_discarded(j, "BON8");
-        }
-    }
-
-    /*!
-    @brief write @a j with @ref write_bon8_value, or write its marker and push
-           a frame for @ref write_bon8_iterative to continue with its elements
-
-    A scalar, and an empty array or object, are written out in full and not
-    pushed.
-
-    @sa @ref write_cbor_value_or_push
-    */
-    void write_bon8_value_or_push(const BasicJsonType& j, bool& string_open, std::vector<binary_container_frame>& stack)
-    {
-        if (j.is_array() || j.is_object())
-        {
-            // arrays use the markers 0x80..0x85, objects 0x86..0x8B; the last
-            // one stands for more than four elements, closed later with 0xFE
-            const auto N = j.size();
-            const std::size_t base = j.is_array() ? 0x80 : 0x86;
-            write_bon8_marker(static_cast<std::uint8_t>(base + (N <= 4 ? N : 5)), string_open);
-            if (N != 0)
-            {
-                stack.emplace_back(&j);
-            }
-            return;
-        }
-
-        write_bon8_value(j, string_open);
-    }
-
-    /*!
-    @brief write out @a root and everything below it without the call stack
-
-    A container with more than four elements is closed with 0xFE once its
-    last element is written, as in @ref write_bon8_value.
-
-    @sa @ref write_cbor_iterative
-    */
-    void write_bon8_iterative(const BasicJsonType& root, bool& string_open)
-    {
-        // only a container with elements is ever pushed; see write_bon8_value_or_push
-        std::vector<binary_container_frame> stack;
-        write_bon8_value_or_push(root, string_open, stack);
-
-        while (!stack.empty())
-        {
-            const binary_container_frame current = stack.back();
-            const bool is_array = current.value->is_array();
-            const bool at_end = is_array
-                                ? current.array_it == current.value->m_data.m_value.array->cend()
-                                : current.object_it == current.value->m_data.m_value.object->cend();
-
-            if (at_end)
-            {
-                if (current.value->size() > 4)
-                {
-                    write_bon8_marker(0xFE, string_open);
-                }
-                stack.pop_back();
-                continue;
-            }
-
-            // read the child before pushing: entering it can move every frame
-            const BasicJsonType* child = nullptr;
-            if (is_array)
-            {
-                child = &(*current.array_it);
-                ++stack.back().array_it;
-            }
-            else
-            {
-                write_bon8_string(current.object_it->first, string_open, *current.value);
-                child = &(current.object_it->second);
-                ++stack.back().object_it;
-            }
-            write_bon8_value_or_push(*child, string_open, stack);
+                break;
        }
    }

@@ -2878,7 +2864,7 @@ class binary_writer
        const std::size_t valid = valid_utf8_prefix(data, s.size());
        if (JSON_HEDLEY_UNLIKELY(valid != s.size()))
        {
-            JSON_THROW(type_error::create(exception_id::invalid_utf8, concat("invalid UTF-8 byte at index ", std::to_string(valid), ": 0x", detail::hex_byte(data[valid])), &context));
+            JSON_THROW(type_error::create(316, concat("invalid UTF-8 byte at index ", std::to_string(valid), ": 0x", detail::hex_byte(data[valid])), &context));
        }
    }

@@ -888,7 +888,7 @@ class serializer
                    {
                        case error_handler_t::strict:
                        {
-                            JSON_THROW(type_error::create(exception_id::invalid_utf8, concat("invalid UTF-8 byte at index ", std::to_string(i), ": 0x", detail::hex_byte(byte)), nullptr));
+                            JSON_THROW(type_error::create(316, concat("invalid UTF-8 byte at index ", std::to_string(i), ": 0x", detail::hex_byte(byte)), nullptr));
                        }

                        case error_handler_t::ignore:
@@ -1021,7 +1021,7 @@ class serializer
            {
                case error_handler_t::strict:
                {
-                    JSON_THROW(type_error::create(exception_id::invalid_utf8, concat("incomplete UTF-8 string; last byte: 0x", detail::hex_byte(static_cast<std::uint8_t>(s[s.size() - 1]))), nullptr));
+                    JSON_THROW(type_error::create(316, concat("incomplete UTF-8 string; last byte: 0x", detail::hex_byte(static_cast<std::uint8_t>(s[s.size() - 1]))), nullptr));
                }

                case error_handler_t::ignore:
@@ -14,7 +14,6 @@
 #include <cstdint> // uint8_t
 #include <limits> // numeric_limits
 #include <string> // string
-#include <type_traits> // is_signed

 #include <nlohmann/detail/macro_scope.hpp>
 #if JSON_HAS_THREE_WAY_COMPARISON
@@ -147,13 +146,16 @@ FloatType compare_integer_with_float(const IntegerType i, const FloatType f) noe

    // values of IntegerType lie in [-bound, bound) when signed and in
    // [0, bound) when unsigned; digits excludes the sign bit, so bound is a
-    // power of two that the float represents exactly
-    const FloatType bound = std::ldexp(static_cast<FloatType>(1), std::numeric_limits<IntegerType>::digits);
+    // power of two that the float represents exactly; the signedness comes
+    // from numeric_limits as well, because std::is_signed is false for class
+    // types such as 128-bit or multiprecision integers
+    using limits = std::numeric_limits<IntegerType>;
+    const FloatType bound = std::ldexp(static_cast<FloatType>(1), limits::digits);
    if (f >= bound)
    {
        return ordered(-1);
    }
-    if (std::is_signed<IntegerType>::value ? (f < -bound) : (f < static_cast<FloatType>(0)))
+    if (limits::is_signed ? (f < -bound) : (f < static_cast<FloatType>(0)))
    {
        return ordered(1);
    }
@@ -639,7 +639,7 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
                    object = nullptr;  // silence warning, see #821
                    if (JSON_HEDLEY_UNLIKELY(t == value_t::null))
                    {
-                        JSON_THROW(other_error::create(detail::exception_id::internal_error, "961c151d2e87f2686a955a9be24d316f1362bf21 3.12.0", nullptr)); // LCOV_EXCL_LINE
+                        JSON_THROW(other_error::create(500, "961c151d2e87f2686a955a9be24d316f1362bf21 3.12.0", nullptr)); // LCOV_EXCL_LINE
                    }
                    break;
                }
@@ -1421,24 +1421,6 @@ public:
        return create<object_t>(first, last);
    }

-    /// @brief compare two object keys for equality, if the key type supports it
-    /// @note object_t only needs operator< for its keys (std::map), so operator==
-    ///       may not exist; the keys are then reported as different, which makes
-    ///       copy_object_level pair the values via object_t::find()
-    template<typename K = typename object_t::key_type,
-             detail::enable_if_t<detail::is_detected<detail::detect_equal_comparable, K>::value, int> = 0>
-    static bool copy_keys_equal(const K& a, const K& b)
-    {
-        return a == b;
-    }
-
-    template < typename K = typename object_t::key_type,
-               detail::enable_if_t < !detail::is_detected<detail::detect_equal_comparable, K>::value, int > = 0 >
-    static bool copy_keys_equal(const K& /*a*/, const K& /*b*/)
-    {
-        return false;
-    }
-
    /// @brief create the copy of the object @a src in @a dst
    /// @note structured values are appended to @a worklist instead
    static void copy_object_level(const basic_json& src, basic_json& dst,
@@ -1471,7 +1453,7 @@ public:
        auto src_it = src_object.cbegin();
        for (auto& element : *dst.m_data.m_value.object)
        {
-            if (JSON_HEDLEY_LIKELY(src_it != src_object.cend() && copy_keys_equal(src_it->first, element.first)))
+            if (JSON_HEDLEY_LIKELY(src_it != src_object.cend() && src_it->first == element.first))
            {
                copy_shallow(src_it->second, element.second, worklist);
                ++src_it;
@@ -2305,7 +2287,7 @@ public:
            // if an object is wanted but impossible, throw an exception
            if (JSON_HEDLEY_UNLIKELY(manual_type == value_t::object && !is_an_object))
            {
-                JSON_THROW(type_error::create(detail::exception_id::object_from_non_pairs, "cannot create object from initializer list", nullptr));
+                JSON_THROW(type_error::create(301, "cannot create object from initializer list", nullptr));
            }
        }

@@ -2425,7 +2407,7 @@ public:
        // make sure the iterator fits the current value
        if (JSON_HEDLEY_UNLIKELY(first.m_object != last.m_object))
        {
-            JSON_THROW(invalid_iterator::create(detail::exception_id::iterators_incompatible, "iterators are not compatible", nullptr));
+            JSON_THROW(invalid_iterator::create(201, "iterators are not compatible", nullptr));
        }

        // copy type from the first iterator
@@ -2444,7 +2426,7 @@ public:
                if (JSON_HEDLEY_UNLIKELY(!first.m_it.primitive_iterator.is_begin()
                                         || !last.m_it.primitive_iterator.is_end()))
                {
-                    JSON_THROW(invalid_iterator::create(detail::exception_id::iterator_range_out_of_range, "iterators out of range", first.m_object));
+                    JSON_THROW(invalid_iterator::create(204, "iterators out of range", first.m_object));
                }
                break;
            }
@@ -2512,7 +2494,7 @@ public:
            case value_t::null:
            case value_t::discarded:
            default:
-                JSON_THROW(invalid_iterator::create(detail::exception_id::iterator_range_of_null, detail::concat("cannot construct with iterators from ", first.m_object->type_name()), first.m_object));
+                JSON_THROW(invalid_iterator::create(206, detail::concat("cannot construct with iterators from ", first.m_object->type_name()), first.m_object));
        }

        set_parents();
@@ -2900,7 +2882,7 @@ public:
            return *ptr;
        }

-        JSON_THROW(type_error::create(detail::exception_id::incompatible_reference_type, detail::concat("incompatible ReferenceType for get_ref, actual type is ", obj.type_name()), &obj));
+        JSON_THROW(type_error::create(303, detail::concat("incompatible ReferenceType for get_ref, actual type is ", obj.type_name()), &obj));
    }

  public:
@@ -3284,7 +3266,7 @@ public:
    {
        if (!is_binary())
        {
-            detail::throw_type_must_be("binary", *this);
+            JSON_THROW(type_error::create(302, detail::concat("type must be binary, but is ", type_name()), this));
        }

        return *get_ptr<binary_t*>();
@@ -3296,7 +3278,7 @@ public:
    {
        if (!is_binary())
        {
-            detail::throw_type_must_be("binary", *this);
+            JSON_THROW(type_error::create(302, detail::concat("type must be binary, but is ", type_name()), this));
        }

        return *get_ptr<const binary_t*>();
@@ -3338,7 +3320,7 @@ public:
        // at only works for objects
        if (JSON_HEDLEY_UNLIKELY(!j.is_object()))
        {
-            detail::throw_cannot_use_with(detail::exception_id::at_wrong_type, "at()", j);
+            JSON_THROW(type_error::create(304, detail::concat("cannot use at() with ", j.type_name()), &j));
        }

        auto it = object_lookup(j, std::forward<KeyType>(key));
@@ -3348,28 +3330,11 @@ public:
            // std::map or ordered_map) never moves from its argument, so key is still
            // valid here regardless of whether KeyType was deduced as an rvalue reference
            // NOLINTNEXTLINE(bugprone-use-after-move,hicpp-invalid-access-moved)
-            JSON_THROW(out_of_range::create(detail::exception_id::key_not_found, detail::concat("key '", key_for_message(key), "' not found"), &j));
+            JSON_THROW(out_of_range::create(403, detail::concat("key '", string_t(key), "' not found"), &j));
        }
        return it->second;
    }

-    /// @brief key as it is passed to detail::concat for an error message
-    /// @note keys with data() and size() (such as string_t itself or a string
-    ///       view) are passed through unchanged, so a miss does not copy them;
-    ///       other keys (such as string literals or key types that only convert
-    ///       to string_t) are converted to string_t
-    template < typename KeyType, detail::enable_if_t < detail::detect_string_can_append_data<string_t, KeyType>::value, int > = 0 >
-    static const KeyType & key_for_message(const KeyType& key)
-    {
-        return key; // NOLINT(bugprone-return-const-ref-from-parameter): the result is only passed to concat() within the full-expression that holds key
-    }
-
-    template < typename KeyType, detail::enable_if_t < !detail::detect_string_can_append_data<string_t, KeyType>::value, int > = 0 >
-    static string_t key_for_message(const KeyType& key)
-    {
-        return string_t(key);
-    }
-
    /// @brief checked array element access used by the at() overloads taking an index
    /// @throw type_error.304 if @a j is not an array
    /// @throw out_of_range.401 if @a idx is out of range
@@ -3380,12 +3345,12 @@ public:
        // at only works for arrays
        if (JSON_HEDLEY_UNLIKELY(!j.is_array()))
        {
-            detail::throw_cannot_use_with(detail::exception_id::at_wrong_type, "at()", j);
+            JSON_THROW(type_error::create(304, detail::concat("cannot use at() with ", j.type_name()), &j));
        }

        if (JSON_HEDLEY_UNLIKELY(idx >= j.m_data.m_value.array->size()))
        {
-            JSON_THROW(out_of_range::create(detail::exception_id::array_index_out_of_range, detail::concat("array index ", std::to_string(idx), " is out of range"), &j));
+            JSON_THROW(out_of_range::create(401, detail::concat("array index ", std::to_string(idx), " is out of range"), &j));
        }

        return (*j.m_data.m_value.array)[idx];
@@ -3418,15 +3383,6 @@ public:
        m_data.m_type = value_t::object;
    }

-    /// @brief throws because operator[] is not supported for the type of this value
-    /// @param[in] argument  the kind of the operator's argument, "numeric" or "string"
-    /// @throw type_error.305 always
-    JSON_HEDLEY_NO_RETURN void throw_subscript_wrong_type(const char* argument) const
-    {
-        detail::throw_cannot_use_with(detail::exception_id::subscript_wrong_type,
-                                      detail::concat("operator[] with a ", argument, " argument").c_str(), *this);
-    }
-
  public:
    ////////////////////
    // element access //
@@ -3531,7 +3487,7 @@ public:
            return m_data.m_value.array->operator[](idx);
        }

-        throw_subscript_wrong_type("numeric");
+        JSON_THROW(type_error::create(305, detail::concat("cannot use operator[] with a numeric argument with ", type_name()), this));
    }

    /// @brief access specified array element
@@ -3545,7 +3501,7 @@ public:
            return m_data.m_value.array->operator[](idx);
        }

-        throw_subscript_wrong_type("numeric");
+        JSON_THROW(type_error::create(305, detail::concat("cannot use operator[] with a numeric argument with ", type_name()), this));
    }

    /// @brief access specified object element
@@ -3565,7 +3521,7 @@ public:
            return set_parent(result.first->second);
        }

-        throw_subscript_wrong_type("string");
+        JSON_THROW(type_error::create(305, detail::concat("cannot use operator[] with a string argument with ", type_name()), this));
    }

    /// @brief access specified object element
@@ -3580,7 +3536,7 @@ public:
            return it->second;
        }

-        throw_subscript_wrong_type("string");
+        JSON_THROW(type_error::create(305, detail::concat("cannot use operator[] with a string argument with ", type_name()), this));
    }

    // these two functions resolve a (const) char * ambiguity affecting Clang and MSVC
@@ -3616,7 +3572,7 @@ public:
            return set_parent(result.first->second);
        }

-        throw_subscript_wrong_type("string");
+        JSON_THROW(type_error::create(305, detail::concat("cannot use operator[] with a string argument with ", type_name()), this));
    }

    /// @brief access specified object element
@@ -3633,7 +3589,7 @@ public:
            return it->second;
        }

-        throw_subscript_wrong_type("string");
+        JSON_THROW(type_error::create(305, detail::concat("cannot use operator[] with a string argument with ", type_name()), this));
    }

  private:
@@ -3657,7 +3613,7 @@ public:
        // value only works for objects
        if (JSON_HEDLEY_UNLIKELY(!is_object()))
        {
-            detail::throw_cannot_use_with(detail::exception_id::value_wrong_type, "value()", *this);
+            JSON_THROW(type_error::create(306, detail::concat("cannot use value() with ", type_name()), this));
        }

        const auto it = find(std::forward<KeyType>(key));
@@ -3672,7 +3628,7 @@ public:
        // value only works for arrays and objects
        if (JSON_HEDLEY_UNLIKELY(!is_structured()))
        {
-            detail::throw_cannot_use_with(detail::exception_id::value_wrong_type, "value()", *this);
+            JSON_THROW(type_error::create(306, detail::concat("cannot use value() with ", type_name()), this));
        }

        return ptr.get_checked_or_null(this);
@@ -3839,7 +3795,7 @@ public:
        // make sure the iterator fits the current value
        if (JSON_HEDLEY_UNLIKELY(this != pos.m_object))
        {
-            JSON_THROW(invalid_iterator::create(detail::exception_id::iterator_from_other_value, "iterator does not fit current value", this));
+            JSON_THROW(invalid_iterator::create(202, "iterator does not fit current value", this));
        }

        IteratorType result = end();
@@ -3855,7 +3811,7 @@ public:
            {
                if (JSON_HEDLEY_UNLIKELY(!pos.m_it.primitive_iterator.is_begin()))
                {
-                    JSON_THROW(invalid_iterator::create(detail::exception_id::iterator_out_of_range, "iterator out of range", this));
+                    JSON_THROW(invalid_iterator::create(205, "iterator out of range", this));
                }

                m_data.m_value.destroy(m_data.m_type);
@@ -3881,7 +3837,7 @@ public:
            case value_t::null:
            case value_t::discarded:
            default:
-                detail::throw_cannot_use_with(detail::exception_id::erase_wrong_type, "erase()", *this);
+                JSON_THROW(type_error::create(307, detail::concat("cannot use erase() with ", type_name()), this));
        }

        return result;
@@ -3897,7 +3853,7 @@ public:
        // make sure the iterator fits the current value
        if (JSON_HEDLEY_UNLIKELY(this != first.m_object || this != last.m_object))
        {
-            JSON_THROW(invalid_iterator::create(detail::exception_id::iterator_range_from_other_value, "iterators do not fit current value", this));
+            JSON_THROW(invalid_iterator::create(203, "iterators do not fit current value", this));
        }

        IteratorType result = end();
@@ -3914,7 +3870,7 @@ public:
                if (JSON_HEDLEY_UNLIKELY(!first.m_it.primitive_iterator.is_begin()
                                         || !last.m_it.primitive_iterator.is_end()))
                {
-                    JSON_THROW(invalid_iterator::create(detail::exception_id::iterator_range_out_of_range, "iterators out of range", this));
+                    JSON_THROW(invalid_iterator::create(204, "iterators out of range", this));
                }

                m_data.m_value.destroy(m_data.m_type);
@@ -3942,7 +3898,7 @@ public:
            case value_t::null:
            case value_t::discarded:
            default:
-                detail::throw_cannot_use_with(detail::exception_id::erase_wrong_type, "erase()", *this);
+                JSON_THROW(type_error::create(307, detail::concat("cannot use erase() with ", type_name()), this));
        }

        return result;
@@ -3956,7 +3912,7 @@ public:
        // this erase only works for objects
        if (JSON_HEDLEY_UNLIKELY(!is_object()))
        {
-            detail::throw_cannot_use_with(detail::exception_id::erase_wrong_type, "erase()", *this);
+            JSON_THROW(type_error::create(307, detail::concat("cannot use erase() with ", type_name()), this));
        }

        const auto erased = m_data.m_value.object->erase(std::forward<KeyType>(key));
@@ -3971,7 +3927,7 @@ public:
        // this erase only works for objects
        if (JSON_HEDLEY_UNLIKELY(!is_object()))
        {
-            detail::throw_cannot_use_with(detail::exception_id::erase_wrong_type, "erase()", *this);
+            JSON_THROW(type_error::create(307, detail::concat("cannot use erase() with ", type_name()), this));
        }

        const auto it = object_lookup(*this, std::forward<KeyType>(key));
@@ -4013,14 +3969,14 @@ public:
        {
            if (JSON_HEDLEY_UNLIKELY(idx >= size()))
            {
-                JSON_THROW(out_of_range::create(detail::exception_id::array_index_out_of_range, detail::concat("array index ", std::to_string(idx), " is out of range"), this));
+                JSON_THROW(out_of_range::create(401, detail::concat("array index ", std::to_string(idx), " is out of range"), this));
            }

            m_data.m_value.array->erase(m_data.m_value.array->begin() + static_cast<difference_type>(idx));
        }
        else
        {
-            detail::throw_cannot_use_with(detail::exception_id::erase_wrong_type, "erase()", *this);
+            JSON_THROW(type_error::create(307, detail::concat("cannot use erase() with ", type_name()), this));
        }
    }

@@ -4509,7 +4465,7 @@ public:
        // push_back only works for null objects or arrays
        if (JSON_HEDLEY_UNLIKELY(!(is_null() || is_array())))
        {
-            detail::throw_cannot_use_with(detail::exception_id::push_back_wrong_type, "push_back()", *this);
+            JSON_THROW(type_error::create(308, detail::concat("cannot use push_back() with ", type_name()), this));
        }

        // transform a null object into an array
@@ -4540,7 +4496,7 @@ public:
        // push_back only works for null objects or arrays
        if (JSON_HEDLEY_UNLIKELY(!(is_null() || is_array())))
        {
-            detail::throw_cannot_use_with(detail::exception_id::push_back_wrong_type, "push_back()", *this);
+            JSON_THROW(type_error::create(308, detail::concat("cannot use push_back() with ", type_name()), this));
        }

        // transform a null object into an array
@@ -4570,7 +4526,7 @@ public:
        // push_back only works for null objects or objects
        if (JSON_HEDLEY_UNLIKELY(!(is_null() || is_object())))
        {
-            detail::throw_cannot_use_with(detail::exception_id::push_back_wrong_type, "push_back()", *this);
+            JSON_THROW(type_error::create(308, detail::concat("cannot use push_back() with ", type_name()), this));
        }

        // transform a null object into an object
@@ -4624,7 +4580,7 @@ public:
        // emplace_back only works for null objects or arrays
        if (JSON_HEDLEY_UNLIKELY(!(is_null() || is_array())))
        {
-            detail::throw_cannot_use_with(detail::exception_id::emplace_wrong_type, "emplace_back()", *this);
+            JSON_THROW(type_error::create(311, detail::concat("cannot use emplace_back() with ", type_name()), this));
        }

        // transform a null object into an array
@@ -4647,7 +4603,7 @@ public:
        // emplace only works for null objects or arrays
        if (JSON_HEDLEY_UNLIKELY(!(is_null() || is_object())))
        {
-            detail::throw_cannot_use_with(detail::exception_id::emplace_wrong_type, "emplace()", *this);
+            JSON_THROW(type_error::create(311, detail::concat("cannot use emplace() with ", type_name()), this));
        }

        // transform a null object into an object
@@ -4699,14 +4655,14 @@ public:
            // check if iterator pos fits to this JSON value
            if (JSON_HEDLEY_UNLIKELY(pos.m_object != this))
            {
-                JSON_THROW(invalid_iterator::create(detail::exception_id::iterator_from_other_value, "iterator does not fit current value", this));
+                JSON_THROW(invalid_iterator::create(202, "iterator does not fit current value", this));
            }

            // insert to array and return iterator
            return insert_iterator(pos, val);
        }

-        detail::throw_cannot_use_with(detail::exception_id::insert_wrong_type, "insert()", *this);
+        JSON_THROW(type_error::create(309, detail::concat("cannot use insert() with ", type_name()), this));
    }

    /// @brief inserts element into array
@@ -4719,7 +4675,7 @@ public:
            // check if iterator pos fits to this JSON value
            if (JSON_HEDLEY_UNLIKELY(pos.m_object != this))
            {
-                JSON_THROW(invalid_iterator::create(detail::exception_id::iterator_from_other_value, "iterator does not fit current value", this));
+                JSON_THROW(invalid_iterator::create(202, "iterator does not fit current value", this));
            }

            // moving into a local first keeps this safe even if val aliases
@@ -4728,7 +4684,7 @@ public:
            return insert_iterator(pos, std::move(tmp));
        }

-        detail::throw_cannot_use_with(detail::exception_id::insert_wrong_type, "insert()", *this);
+        JSON_THROW(type_error::create(309, detail::concat("cannot use insert() with ", type_name()), this));
    }

    /// @brief inserts copies of element into array
@@ -4741,14 +4697,14 @@ public:
            // check if iterator pos fits to this JSON value
            if (JSON_HEDLEY_UNLIKELY(pos.m_object != this))
            {
-                JSON_THROW(invalid_iterator::create(detail::exception_id::iterator_from_other_value, "iterator does not fit current value", this));
+                JSON_THROW(invalid_iterator::create(202, "iterator does not fit current value", this));
            }

            // insert to array and return iterator
            return insert_iterator(pos, cnt, val);
        }

-        detail::throw_cannot_use_with(detail::exception_id::insert_wrong_type, "insert()", *this);
+        JSON_THROW(type_error::create(309, detail::concat("cannot use insert() with ", type_name()), this));
    }

    /// @brief inserts range of elements into array
@@ -4758,30 +4714,30 @@ public:
        // insert only works for arrays
        if (JSON_HEDLEY_UNLIKELY(!is_array()))
        {
-            detail::throw_cannot_use_with(detail::exception_id::insert_wrong_type, "insert()", *this);
+            JSON_THROW(type_error::create(309, detail::concat("cannot use insert() with ", type_name()), this));
        }

        // check if iterator pos fits to this JSON value
        if (JSON_HEDLEY_UNLIKELY(pos.m_object != this))
        {
-            JSON_THROW(invalid_iterator::create(detail::exception_id::iterator_from_other_value, "iterator does not fit current value", this));
+            JSON_THROW(invalid_iterator::create(202, "iterator does not fit current value", this));
        }

        // check if range iterators belong to the same JSON object
        if (JSON_HEDLEY_UNLIKELY(first.m_object != last.m_object))
        {
-            JSON_THROW(invalid_iterator::create(detail::exception_id::insert_range_incompatible, "iterators do not fit", this));
+            JSON_THROW(invalid_iterator::create(210, "iterators do not fit", this));
        }

        if (JSON_HEDLEY_UNLIKELY(first.m_object == this))
        {
-            JSON_THROW(invalid_iterator::create(detail::exception_id::insert_range_into_itself, "passed iterators may not belong to container", this));
+            JSON_THROW(invalid_iterator::create(211, "passed iterators may not belong to container", this));
        }

        // passed iterators must belong to arrays
        if (JSON_HEDLEY_UNLIKELY(!first.m_object->is_array()))
        {
-            JSON_THROW(invalid_iterator::create(detail::exception_id::iterator_from_other_value, "iterators first and last must point to arrays", this));
+            JSON_THROW(invalid_iterator::create(202, "iterators first and last must point to arrays", this));
        }

        // insert to array and return iterator
@@ -4795,13 +4751,13 @@ public:
        // insert only works for arrays
        if (JSON_HEDLEY_UNLIKELY(!is_array()))
        {
-            detail::throw_cannot_use_with(detail::exception_id::insert_wrong_type, "insert()", *this);
+            JSON_THROW(type_error::create(309, detail::concat("cannot use insert() with ", type_name()), this));
        }

        // check if iterator pos fits to this JSON value
        if (JSON_HEDLEY_UNLIKELY(pos.m_object != this))
        {
-            JSON_THROW(invalid_iterator::create(detail::exception_id::iterator_from_other_value, "iterator does not fit current value", this));
+            JSON_THROW(invalid_iterator::create(202, "iterator does not fit current value", this));
        }

        // copy the values first: ilist may refer to elements of this array
@@ -4823,19 +4779,19 @@ public:
        // insert only works for objects
        if (JSON_HEDLEY_UNLIKELY(!is_object()))
        {
-            detail::throw_cannot_use_with(detail::exception_id::insert_wrong_type, "insert()", *this);
+            JSON_THROW(type_error::create(309, detail::concat("cannot use insert() with ", type_name()), this));
        }

        // check if range iterators belong to the same JSON object
        if (JSON_HEDLEY_UNLIKELY(first.m_object != last.m_object))
        {
-            JSON_THROW(invalid_iterator::create(detail::exception_id::insert_range_incompatible, "iterators do not fit", this));
+            JSON_THROW(invalid_iterator::create(210, "iterators do not fit", this));
        }

        // passed iterators must belong to objects
        if (JSON_HEDLEY_UNLIKELY(!first.m_object->is_object()))
        {
-            JSON_THROW(invalid_iterator::create(detail::exception_id::iterator_from_other_value, "iterators first and last must point to objects", this));
+            JSON_THROW(invalid_iterator::create(202, "iterators first and last must point to objects", this));
        }

        m_data.m_value.object->insert(first.m_it.object_iterator, last.m_it.object_iterator);
@@ -4852,7 +4808,7 @@ public:
        // j, not the copy made below)
        if (JSON_HEDLEY_UNLIKELY(!j.is_object()))
        {
-            detail::throw_cannot_use_with(detail::exception_id::update_wrong_type, "update()", j);
+            JSON_THROW(type_error::create(312, detail::concat("cannot use update() with ", j.type_name()), &j));
        }

        // copy first: j may be *this or one of its descendants, and is
@@ -4870,13 +4826,13 @@ public:
        // check if range iterators belong to the same JSON object
        if (JSON_HEDLEY_UNLIKELY(first.m_object != last.m_object))
        {
-            JSON_THROW(invalid_iterator::create(detail::exception_id::insert_range_incompatible, "iterators do not fit", this));
+            JSON_THROW(invalid_iterator::create(210, "iterators do not fit", this));
        }

        // passed iterators must belong to objects
        if (JSON_HEDLEY_UNLIKELY(!first.m_object->is_object()))
        {
-            detail::throw_cannot_use_with(detail::exception_id::update_wrong_type, "update()", *first.m_object);
+            JSON_THROW(type_error::create(312, detail::concat("cannot use update() with ", first.m_object->type_name()), first.m_object));
        }

        // copy first: the range may belong to *this or one of its
@@ -4912,7 +4868,7 @@ public:

        if (JSON_HEDLEY_UNLIKELY(!is_object()))
        {
-            detail::throw_cannot_use_with(detail::exception_id::update_wrong_type, "update()", *this);
+            JSON_THROW(type_error::create(312, detail::concat("cannot use update() with ", type_name()), this));
        }
    }

@@ -5075,7 +5031,7 @@ public:
        }
        else
        {
-            detail::throw_cannot_use_with(detail::exception_id::swap_wrong_type, "swap(array_t&)", *this);
+            JSON_THROW(type_error::create(310, detail::concat("cannot use swap(array_t&) with ", type_name()), this));
        }
    }

@@ -5092,7 +5048,7 @@ public:
        }
        else
        {
-            detail::throw_cannot_use_with(detail::exception_id::swap_wrong_type, "swap(object_t&)", *this);
+            JSON_THROW(type_error::create(310, detail::concat("cannot use swap(object_t&) with ", type_name()), this));
        }
    }

@@ -5108,7 +5064,7 @@ public:
        }
        else
        {
-            detail::throw_cannot_use_with(detail::exception_id::swap_wrong_type, "swap(string_t&)", *this);
+            JSON_THROW(type_error::create(310, detail::concat("cannot use swap(string_t&) with ", type_name()), this));
        }
    }

@@ -5124,7 +5080,7 @@ public:
        }
        else
        {
-            detail::throw_cannot_use_with(detail::exception_id::swap_wrong_type, "swap(binary_t&)", *this);
+            JSON_THROW(type_error::create(310, detail::concat("cannot use swap(binary_t&) with ", type_name()), this));
        }
    }

@@ -5140,7 +5096,7 @@ public:
        }
        else
        {
-            detail::throw_cannot_use_with(detail::exception_id::swap_wrong_type, "swap(binary_t::container_type&)", *this);
+            JSON_THROW(type_error::create(310, detail::concat("cannot use swap(binary_t::container_type&) with ", type_name()), this));
        }
    }

@@ -6602,7 +6558,7 @@ public:
                        if (JSON_HEDLEY_UNLIKELY(idx > parent.size()))
                        {
                            // avoid undefined behavior
-                            JSON_THROW(out_of_range::create(detail::exception_id::array_index_out_of_range, detail::concat("array index ", std::to_string(idx), " is out of range"), &parent));
+                            JSON_THROW(out_of_range::create(401, detail::concat("array index ", std::to_string(idx), " is out of range"), &parent));
                        }

                        // default case: insert add offset
@@ -6621,7 +6577,7 @@ public:
                case value_t::binary:
                case value_t::discarded:
                default:
-                    JSON_THROW(out_of_range::create(detail::exception_id::patch_add_parent_not_container, detail::concat("cannot add value: the JSON Patch 'add' target's parent is of type ", parent.type_name(), ", but must be an object or array"), &parent));
+                    JSON_THROW(out_of_range::create(411, detail::concat("cannot add value: the JSON Patch 'add' target's parent is of type ", parent.type_name(), ", but must be an object or array"), &parent));
            }
        };

@@ -6644,7 +6600,7 @@ public:
                }
                else
                {
-                    JSON_THROW(out_of_range::create(detail::exception_id::key_not_found, detail::concat("key '", last_path, "' not found"), this));
+                    JSON_THROW(out_of_range::create(403, detail::concat("key '", last_path, "' not found"), this));
                }
            }
            else if (parent.is_array())
@@ -6656,7 +6612,7 @@ public:
            {
                // the parent of a "remove" target must be an object or array
                // (see #5396)
-                JSON_THROW(out_of_range::create(detail::exception_id::patch_remove_parent_not_container, detail::concat("cannot remove value: the JSON Patch 'remove' target's parent is of type ", parent.type_name(), ", but must be an object or array"), &parent));
+                JSON_THROW(out_of_range::create(413, detail::concat("cannot remove value: the JSON Patch 'remove' target's parent is of type ", parent.type_name(), ", but must be an object or array"), &parent));
            }
        };

@@ -6687,7 +6643,7 @@ public:
        // type check: top level value must be an array
        if (JSON_HEDLEY_UNLIKELY(!json_patch.is_array()))
        {
-            JSON_THROW(parse_error::create(detail::exception_id::patch_not_an_array, 0, "JSON patch must be an array of objects", &json_patch));
+            JSON_THROW(parse_error::create(104, 0, "JSON patch must be an array of objects", &json_patch));
        }

        // iterate and apply the operations
@@ -6708,14 +6664,14 @@ public:
                if (JSON_HEDLEY_UNLIKELY(it == val.m_data.m_value.object->end()))
                {
                    // NOLINTNEXTLINE(performance-inefficient-string-concatenation)
-                    JSON_THROW(parse_error::create(detail::exception_id::patch_invalid_operation, 0, detail::concat(error_msg, " must have member '", member, "'"), &val));
+                    JSON_THROW(parse_error::create(105, 0, detail::concat(error_msg, " must have member '", member, "'"), &val));
                }

                // check if the result is of type string
                if (JSON_HEDLEY_UNLIKELY(string_type && !it->second.is_string()))
                {
                    // NOLINTNEXTLINE(performance-inefficient-string-concatenation)
-                    JSON_THROW(parse_error::create(detail::exception_id::patch_invalid_operation, 0, detail::concat(error_msg, " must have string member '", member, "'"), &val));
+                    JSON_THROW(parse_error::create(105, 0, detail::concat(error_msg, " must have string member '", member, "'"), &val));
                }

                // no error: return value
@@ -6725,7 +6681,7 @@ public:
            // type check: every element of the array must be an object
            if (JSON_HEDLEY_UNLIKELY(!val.is_object()))
            {
-                JSON_THROW(parse_error::create(detail::exception_id::patch_not_an_array, 0, "JSON patch must be an array of objects", &val));
+                JSON_THROW(parse_error::create(104, 0, "JSON patch must be an array of objects", &val));
            }

            // collect mandatory members
@@ -6761,7 +6717,7 @@ public:

                    if (JSON_HEDLEY_UNLIKELY(is_proper_prefix(from_ptr, ptr)))
                    {
-                        JSON_THROW(out_of_range::create(detail::exception_id::patch_move_into_child, detail::concat("cannot move value: 'from' path '", from_path, "' is a proper prefix of 'path' '", path, "'"), &result));
+                        JSON_THROW(out_of_range::create(414, detail::concat("cannot move value: 'from' path '", from_path, "' is a proper prefix of 'path' '", path, "'"), &result));
                    }

                    // the "from" location must exist - use at()
@@ -6808,7 +6764,7 @@ public:
                    // throw an exception if the test fails
                    if (JSON_HEDLEY_UNLIKELY(!success))
                    {
-                        JSON_THROW(other_error::create(detail::exception_id::patch_test_failed, detail::concat("unsuccessful: ", val.dump()), &val));
+                        JSON_THROW(other_error::create(501, detail::concat("unsuccessful: ", val.dump()), &val));
                    }

                    break;
@@ -6819,7 +6775,7 @@ public:
                {
                    // op must be "add", "remove", "replace", "move", "copy", or
                    // "test"
-                    JSON_THROW(parse_error::create(detail::exception_id::patch_invalid_operation, 0, detail::concat("operation value '", op, "' is invalid"), &val));
+                    JSON_THROW(parse_error::create(105, 0, detail::concat("operation value '", op, "' is invalid"), &val));
                }
            }
        }
@@ -90,19 +90,6 @@ private:
        return self.end();
    }

-    /// @brief shared implementation of the const and non-const at() overloads
-    /// @throw std::out_of_range if @a key is not found
-    template<typename Self, typename KeyType>
-    static auto at_impl(Self& self, const KeyType& key) -> decltype((self.begin()->second))
-    {
-        const auto it = find_impl(self, key);
-        if (it == self.end())
-        {
-            JSON_THROW(std::out_of_range("key not found"));
-        }
-        return it->second;
-    }
-
    /// @brief remove the entry @a it points to, preserving order
    /// @note keys are not movable, so the tail is destroyed and re-constructed in place
    void erase_at(iterator it)
@@ -169,26 +156,46 @@ public:

    T& at(const key_type& key)
    {
-        return at_impl(*this, key);
+        const auto it = find_impl(*this, key);
+        if (it == this->end())
+        {
+            JSON_THROW(std::out_of_range("key not found"));
+        }
+        return it->second;
    }

    template<class KeyType, detail::enable_if_t<
                 detail::is_usable_as_key_type<key_compare, key_type, KeyType>::value, int> = 0>
    T & at(KeyType && key) // NOLINT(cppcoreguidelines-missing-std-forward)
    {
-        return at_impl(*this, key);
+        const auto it = find_impl(*this, key);
+        if (it == this->end())
+        {
+            JSON_THROW(std::out_of_range("key not found"));
+        }
+        return it->second;
    }

    const T& at(const key_type& key) const
    {
-        return at_impl(*this, key);
+        const auto it = find_impl(*this, key);
+        if (it == this->end())
+        {
+            JSON_THROW(std::out_of_range("key not found"));
+        }
+        return it->second;
    }

    template<class KeyType, detail::enable_if_t<
                 detail::is_usable_as_key_type<key_compare, key_type, KeyType>::value, int> = 0>
    const T & at(KeyType && key) const // NOLINT(cppcoreguidelines-missing-std-forward)
    {
-        return at_impl(*this, key);
+        const auto it = find_impl(*this, key);
+        if (it == this->end())
+        {
+            JSON_THROW(std::out_of_range("key not found"));
+        }
+        return it->second;
    }

    size_type erase(const key_type& key)
@@ -240,14 +247,6 @@ public:
        //               ^        ^
        //             first    last

-        // Note on conformance: before C++20, [basic.life]/8 did not allow an
-        // object of a type with a const member (like value_type's const Key)
-        // to transparently replace the destroyed one, so strictly, accessing
-        // it through the vector's existing pointers would have required
-        // std::launder (which does not exist before C++17). C++20 dropped that
-        // condition (P1971R0, NB comment US 041). Compilers have always treated
-        // this pattern as intended, so it is kept deliberately.
-
        // Since we cannot move const Keys, we re-construct them in place.
        // We start at first and re-construct (viz. copy) the elements from
        // the back of the vector. Example for the first iteration:
@@ -1,519 +0,0 @@
-//     __ _____ _____ _____
-//  __|  |   __|     |   | |  JSON for Modern C++ (supporting code)
-// |  |  |__   |  |  | | | |  version 3.12.0
-// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
-//
-// SPDX-FileCopyrightText: 2013-2026 Niels Lohmann <https://nlohmann.me>
-// SPDX-License-Identifier: MIT
-
-#pragma once
-
-#include "doctest_compatibility.h"
-
-#include <nlohmann/json.hpp>
-
-#include <cmath>
-#include <cstddef>
-#include <cstdint>
-#include <map>
-#include <memory>
-#include <string>
-#include <utility>
-#include <vector>
-
-// Object types with a user-defined key type. The key types differ in what they
-// offer to the library: a conversion to std::string (implicit or explicit), a
-// comparison with ==, a to_json overload, or a c_str() member.
-
-namespace custom_key_test
-{
-class key_base
-{
-  public:
-    key_base() = default;
-
-    key_base(const char* value)
-        : m_value(value)
-    {}
-
-    key_base(std::string value)
-        : m_value(std::move(value))
-    {}
-
-    // Required by JSON_DIAGNOSTICS, which reads object keys through data()
-    // when building the path of an exception.
-    const char* data() const noexcept
-    {
-        return m_value.data();
-    }
-
-    friend bool operator<(const key_base& lhs, const key_base& rhs)
-    {
-        return lhs.m_value < rhs.m_value;
-    }
-
-  protected:
-    const std::string& str() const noexcept
-    {
-        return m_value;
-    }
-
-  private:
-    std::string m_value;
-};
-
-// implicit conversion to std::string and operator==
-class key_full : public key_base
-{
-  public:
-    key_full() = default;
-    using key_base::key_base;
-
-    operator std::string() const
-    {
-        return str();
-    }
-
-    friend bool operator==(const key_full& lhs, const key_full& rhs)
-    {
-        return lhs.str() == rhs.str();
-    }
-};
-
-// implicit conversion to std::string, but no operator==
-class key_no_eq : public key_base
-{
-  public:
-    key_no_eq() = default;
-    using key_base::key_base;
-
-    operator std::string() const
-    {
-        return str();
-    }
-};
-
-// explicit conversion to std::string, no operator==
-class key_explicit : public key_base
-{
-  public:
-    key_explicit() = default;
-    using key_base::key_base;
-
-    explicit operator std::string() const
-    {
-        return str();
-    }
-};
-
-// no conversion at all, only a to_json overload, no operator==
-class key_to_json : public key_base
-{
-  public:
-    key_to_json() = default;
-    using key_base::key_base;
-
-    const std::string& value() const
-    {
-        return str();
-    }
-};
-
-template<typename BasicJsonType>
-void to_json(BasicJsonType& j, const key_to_json& k)
-{
-    j = k.value();
-}
-
-// like key_to_json, but with size() and c_str()
-class key_c_str : public key_base
-{
-  public:
-    key_c_str() = default;
-    using key_base::key_base;
-
-    const std::string& value() const
-    {
-        return str();
-    }
-
-    std::size_t size() const
-    {
-        return str().size();
-    }
-
-    const char* c_str() const
-    {
-        return str().c_str();
-    }
-};
-
-template<typename BasicJsonType>
-void to_json(BasicJsonType& j, const key_c_str& k)
-{
-    j = k.value();
-}
-
-// std::map with key type K, ignoring the key type basic_json passes
-template<class K>
-struct object_for
-{
-    template<class Key, class Value, class Compare, class Allocator>
-    using pair_allocator = typename std::allocator_traits<Allocator>::template rebind_alloc<std::pair<const K, Value>>;
-
-    template<class Key, class Value, class Compare, class Allocator>
-    using type = std::map<K, Value, std::less<K>, pair_allocator<Key, Value, Compare, Allocator>>; // NOLINT(modernize-use-transparent-functors)
-};
-
-using json_full = nlohmann::json::with_object_t<object_for<key_full>::type>;
-using json_no_eq = nlohmann::json::with_object_t<object_for<key_no_eq>::type>;
-using json_explicit = nlohmann::json::with_object_t<object_for<key_explicit>::type>;
-using json_to_json = nlohmann::json::with_object_t<object_for<key_to_json>::type>;
-using json_c_str = nlohmann::json::with_object_t<object_for<key_c_str>::type>;
-
-// a key that is long enough to need a length byte in CBOR and MessagePack
-inline const char* long_key_name(std::size_t i, std::string& storage)
-{
-    storage = "a key longer than thirty-one characters " + std::to_string(i);
-    return storage.c_str();
-}
-
-// name of the key at nesting level i of a deep value
-inline std::string deep_name(std::size_t i, bool long_keys)
-{
-    std::string storage;
-    return (long_keys && i % 2 == 1) ? std::string(long_key_name(i, storage)) : "k" + std::to_string(i);
-}
-
-// {"a": 1, "b": [true, null, "x"], "c": {"d": 2.5}, <keys of 23, 36, and 300 characters>}
-// 23 is the longest CBOR length stored in the initial byte; 36 needs one
-// length byte in CBOR and MessagePack, 300 needs two
-template<class J>
-J make_shallow()
-{
-    using key_t = typename J::object_t::key_type;
-
-    J array = J::array();
-    array.push_back(J(true));
-    array.push_back(J(nullptr));
-    array.push_back(J("x"));
-
-    typename J::object_t inner;
-    inner.emplace(key_t("d"), J(2.5));
-
-    typename J::object_t object;
-    object.emplace(key_t("a"), J(1));
-    object.emplace(key_t("b"), std::move(array));
-    object.emplace(key_t("c"), J(std::move(inner)));
-    object.emplace(key_t(std::string(23, 'x')), J(2));
-    object.emplace(key_t(std::string(36, 'y')), J(3));
-    object.emplace(key_t(std::string(300, 'z')), J(4));
-    return J(std::move(object));
-}
-
-// {"k0": {"k1": {... {"k<depth-1>": 1} ...}}}
-template<class J>
-J make_deep(std::size_t depth, bool long_keys)
-{
-    using key_t = typename J::object_t::key_type;
-
-    J value = 1;
-    for (std::size_t i = depth; i > 0; --i)
-    {
-        typename J::object_t object;
-        object.emplace(key_t(deep_name(i - 1, long_keys)), std::move(value));
-        value = J(std::move(object));
-    }
-    return value;
-}
-
-inline std::size_t deep_depth()
-{
-    return nlohmann::detail::recursion_depth_limit() + 10;
-}
-
-// walk down the nesting levels without recursion and check the leaf
-template<class J>
-bool check_deep(const J& value, std::size_t depth, bool long_keys)
-{
-    using key_t = typename J::object_t::key_type;
-
-    const J* current = &value;
-    for (std::size_t i = 0; i < depth; ++i)
-    {
-        if (!current->is_object() || current->size() != 1)
-        {
-            return false;
-        }
-        const auto it = current->find(key_t(deep_name(i, long_keys)));
-        if (it == current->end())
-        {
-            return false;
-        }
-        current = &it.value();
-    }
-    return current->is_number_integer() && current->template get<int>() == 1;
-}
-
-template<class J>
-bool check_shallow(const J& value)
-{
-    using key_t = typename J::object_t::key_type;
-
-    if (!value.is_object() || value.size() != 6)
-    {
-        return false;
-    }
-
-    const auto a = value.find(key_t("a"));
-    const auto b = value.find(key_t("b"));
-    const auto c = value.find(key_t("c"));
-    if (a == value.end() || b == value.end() || c == value.end())
-    {
-        return false;
-    }
-
-    const auto d = c->find(key_t("d"));
-    // basic_json::operator== needs operator== on the keys, which most of the
-    // key types do not have, so the values are checked through get<>()
-    return a->template get<int>() == 1
-    && b->is_array() && b->size() == 3 && (*b)[0].template get<bool>() && (*b)[1].is_null()
-    && (*b)[2].template get<std::string>() == "x"
-    && d != c->end() && std::abs(d->template get<double>() - 2.5) < 1e-9
-    && value.find(key_t(std::string(23, 'x')))->template get<int>() == 2
-    && value.find(key_t(std::string(36, 'y')))->template get<int>() == 3
-    && value.find(key_t(std::string(300, 'z')))->template get<int>() == 4;
-}
-
-template<class J>
-bool is_missing(const J& value, const char* name)
-{
-    return value.find(typename J::object_t::key_type(name)) == value.end();
-}
-
-// member access through find(): at() does not compile for key types without
-// size() or a conversion to string_t (key_to_json), as in version 3.12.0
-template<class J>
-const J& member(const J& value, const char* name)
-{
-    const auto it = value.find(typename J::object_t::key_type(name));
-    REQUIRE(it != value.end());
-    return *it;
-}
-
-// The test cases, as function templates: each unit-custom-key-type-*.cpp file
-// runs them for one object type only. The MinGW linker fails on objects with
-// more than 65535 sections, and every basic_json specialization adds many
-// (see .github/workflows/windows.yml).
-
-// copy
-template<class J>
-void test_copy()
-{
-    SECTION("shallow")
-    {
-        const J original = custom_key_test::make_shallow<J>();
-        REQUIRE(custom_key_test::check_shallow(original));
-
-        const J copy(original); // NOLINT(performance-unnecessary-copy-initialization)
-        CHECK(custom_key_test::check_shallow(copy));
-
-        J assigned;
-        assigned = original;
-        CHECK(custom_key_test::check_shallow(assigned));
-
-        // the original is unchanged
-        CHECK(custom_key_test::check_shallow(original));
-    }
-
-    SECTION("deep")
-    {
-        const std::size_t depth = custom_key_test::deep_depth();
-
-        const J original = custom_key_test::make_deep<J>(depth, false);
-        REQUIRE(custom_key_test::check_deep(original, depth, false));
-
-        const J copy(original); // NOLINT(performance-unnecessary-copy-initialization)
-        CHECK(custom_key_test::check_deep(copy, depth, false));
-
-        J assigned;
-        assigned = original;
-        CHECK(custom_key_test::check_deep(assigned, depth, false));
-
-        CHECK(custom_key_test::check_deep(original, depth, false));
-    }
-}
-
-// parse
-template<class J>
-void test_parse()
-{
-    const J j = J::parse(R"({"a":1,"b":{"c":[1,2]}})");
-
-    CHECK(j.size() == 2);
-    CHECK(custom_key_test::member(j, "a").template get<int>() == 1);
-    CHECK(custom_key_test::member(custom_key_test::member(j, "b"), "c").size() == 2);
-    CHECK(custom_key_test::member(custom_key_test::member(j, "b"), "c")[1].template get<int>() == 2);
-
-    // a deeply nested document
-    const std::size_t depth = custom_key_test::deep_depth();
-    std::string text;
-    for (std::size_t i = 0; i < depth; ++i)
-    {
-        text += "{\"k" + std::to_string(i) + "\":";
-    }
-    text += '1';
-    text.append(depth, '}');
-    CHECK(custom_key_test::check_deep(J::parse(text), depth, false));
-}
-
-// merge_patch, update, and insert
-template<class J>
-void test_patch()
-{
-    SECTION("merge_patch")
-    {
-        J j = J::parse(R"({"a":1,"b":2,"n":{"x":1,"y":2}})");
-        j.merge_patch(J::parse(R"({"b":null,"c":3,"n":{"y":null,"z":3}})"));
-
-        CHECK(j.size() == 3);
-        CHECK(custom_key_test::member(j, "a").template get<int>() == 1);
-        CHECK(custom_key_test::is_missing(j, "b"));
-        CHECK(custom_key_test::member(j, "c").template get<int>() == 3);
-        CHECK(custom_key_test::member(j, "n").size() == 2);
-        CHECK(custom_key_test::member(custom_key_test::member(j, "n"), "x").template get<int>() == 1);
-        CHECK(custom_key_test::member(custom_key_test::member(j, "n"), "z").template get<int>() == 3);
-    }
-
-    SECTION("update")
-    {
-        J j = J::parse(R"({"a":1,"b":2,"n":{"x":1}})");
-        const J other = J::parse(R"({"b":3,"c":4,"n":{"y":2}})");
-
-        J replaced = j;
-        replaced.update(other);
-        CHECK(replaced.size() == 4);
-        CHECK(custom_key_test::member(replaced, "a").template get<int>() == 1);
-        CHECK(custom_key_test::member(replaced, "b").template get<int>() == 3);
-        CHECK(custom_key_test::member(replaced, "c").template get<int>() == 4);
-        CHECK(custom_key_test::member(replaced, "n").size() == 1);
-        CHECK(custom_key_test::member(custom_key_test::member(replaced, "n"), "y").template get<int>() == 2);
-
-        j.update(other, true);
-        CHECK(j.size() == 4);
-        CHECK(custom_key_test::member(j, "n").size() == 2);
-        CHECK(custom_key_test::member(custom_key_test::member(j, "n"), "x").template get<int>() == 1);
-        CHECK(custom_key_test::member(custom_key_test::member(j, "n"), "y").template get<int>() == 2);
-    }
-
-    SECTION("insert")
-    {
-        J j = J::parse(R"({"a":1,"b":2})");
-        const J other = J::parse(R"({"b":3,"c":4})");
-        j.insert(other.begin(), other.end());
-
-        CHECK(j.size() == 3);
-        CHECK(custom_key_test::member(j, "b").template get<int>() == 2);
-        CHECK(custom_key_test::member(j, "c").template get<int>() == 4);
-    }
-}
-
-// at() reports a missing key
-template<class J>
-void test_at()
-{
-    // not for key_to_json: at() needs the key's size() or a conversion to
-    // string_t for its error message, which also was the case in version 3.12.0
-    J j = J::parse(R"({"a":1})");
-    const J& j_const = j;
-
-    CHECK(j.at("a").template get<int>() == 1);
-    CHECK(j_const.at("a").template get<int>() == 1);
-#if JSON_DIAGNOSTIC_POSITIONS
-    CHECK_THROWS_WITH_AS(j.at("missing"), "[json.exception.out_of_range.403] (bytes 0-7) key 'missing' not found", typename J::out_of_range&);
-    CHECK_THROWS_WITH_AS(j_const.at("missing"), "[json.exception.out_of_range.403] (bytes 0-7) key 'missing' not found", typename J::out_of_range&);
-#else
-    CHECK_THROWS_WITH_AS(j.at("missing"), "[json.exception.out_of_range.403] key 'missing' not found", typename J::out_of_range&);
-    CHECK_THROWS_WITH_AS(j_const.at("missing"), "[json.exception.out_of_range.403] key 'missing' not found", typename J::out_of_range&);
-#endif
-}
-
-// BSON
-template<class J>
-void test_bson()
-{
-    SECTION("shallow")
-    {
-        const J value = custom_key_test::make_shallow<J>();
-        const nlohmann::json expected = custom_key_test::make_shallow<nlohmann::json>();
-
-        const std::vector<std::uint8_t> encoded = J::to_bson(value);
-        CHECK(encoded == nlohmann::json::to_bson(expected));
-        CHECK(nlohmann::json::from_bson(encoded) == expected);
-    }
-
-    SECTION("deep")
-    {
-        const std::size_t depth = custom_key_test::deep_depth();
-        const J value = custom_key_test::make_deep<J>(depth, false);
-        const nlohmann::json expected = custom_key_test::make_deep<nlohmann::json>(depth, false);
-
-        const std::vector<std::uint8_t> encoded = J::to_bson(value);
-        CHECK(encoded == nlohmann::json::to_bson(expected));
-        CHECK(nlohmann::json::from_bson(encoded) == expected);
-    }
-}
-
-// CBOR
-template<class J>
-void test_cbor()
-{
-    SECTION("shallow")
-    {
-        const J value = custom_key_test::make_shallow<J>();
-        const nlohmann::json expected = custom_key_test::make_shallow<nlohmann::json>();
-
-        const std::vector<std::uint8_t> encoded = J::to_cbor(value);
-        CHECK(encoded == nlohmann::json::to_cbor(expected));
-        CHECK(nlohmann::json::from_cbor(encoded) == expected);
-    }
-
-    SECTION("deeper than the recursion depth limit")
-    {
-        const std::size_t depth = custom_key_test::deep_depth();
-        const J value = custom_key_test::make_deep<J>(depth, true);
-        const nlohmann::json expected = custom_key_test::make_deep<nlohmann::json>(depth, true);
-
-        const std::vector<std::uint8_t> encoded = J::to_cbor(value);
-        CHECK(encoded == nlohmann::json::to_cbor(expected));
-        CHECK(nlohmann::json::from_cbor(encoded) == expected);
-    }
-}
-
-// MessagePack
-template<class J>
-void test_msgpack()
-{
-    SECTION("shallow")
-    {
-        const J value = custom_key_test::make_shallow<J>();
-        const nlohmann::json expected = custom_key_test::make_shallow<nlohmann::json>();
-
-        const std::vector<std::uint8_t> encoded = J::to_msgpack(value);
-        CHECK(encoded == nlohmann::json::to_msgpack(expected));
-        CHECK(nlohmann::json::from_msgpack(encoded) == expected);
-    }
-
-    SECTION("deeper than the recursion depth limit")
-    {
-        const std::size_t depth = custom_key_test::deep_depth();
-        const J value = custom_key_test::make_deep<J>(depth, true);
-        const nlohmann::json expected = custom_key_test::make_deep<nlohmann::json>(depth, true);
-
-        const std::vector<std::uint8_t> encoded = J::to_msgpack(value);
-        CHECK(encoded == nlohmann::json::to_msgpack(expected));
-        CHECK(nlohmann::json::from_msgpack(encoded) == expected);
-    }
-}
-
-} // namespace custom_key_test