Honor allow_exceptions=false for excessive array/object size (out_of_range.408)

The SAX DOM parsers' start_object()/start_array() threw out_of_range.408 directly via JSON_THROW when a binary format (CBOR/UBJSON/BJData) declared a container size exceeding max_size(), bypassing the allow_exceptions flag that every other malformed-input error path in these classes honors via parse_error(). This meant that json::from_cbor(data, true, false) etc. could still throw (or abort under JSON_NOEXCEPTION) instead of returning a discarded value, contrary to the allow_exceptions=false contract. Route all four call sites (two in json_sax_dom_parser, two in json_sax_dom_callback_parser) through parse_error() instead, matching the existing error-handling pattern used elsewhere in this file. Behavior is unchanged when allow_exceptions is true (the default); the exception message and type are identical. Signed-off-by: Niels Lohmann <mail@nlohmann.me>
Restore a duplicate key's prior value when the callback rejects its new value
2026-09-05 15:57:58 +00:00 · 2026-09-05 17:05:56 +02:00 · 2026-09-05 17:05:55 +02:00 · 2026-09-05 17:05:48 +02:00 · 2026-09-05 16:54:49 +02:00 · 2026-09-05 16:34:21 +02:00
25 changed files with 2269 additions and 3083 deletions
@@ -108,9 +108,7 @@ The tests are located in [`tests/src/unit-*.cpp`](https://github.com/nlohmann/js
 are structured along the features of the library or the nature of the tests. Usually, it should be clear from the
 context which existing file needs to be extended, and only very few cases require creating new test files.
-When fixing a bug, edit `unit-regression3.cpp` and add a test case referencing the fixed issue. Its predecessors
+When fixing a bug, edit `unit-regression2.cpp` and add a section referencing the fixed issue.
 `unit-regression1.cpp` and `unit-regression2.cpp` stay as they are: the MinGW linker fails on the object a file this
 size produces, which is why the tests are spread over several files in the first place.
 #### Exceptions
@@ -100,7 +100,7 @@ jobs:
    container: ubuntu:focal
    strategy:
      matrix:
-        target: [ci_cmake_flags, ci_test_diagnostics, ci_test_diagnostic_positions, ci_test_noexceptions, ci_test_noimplicitconversions, ci_test_legacycomparison, ci_test_noglobaludls, ci_test_no_thread_local]
+        target: [ci_cmake_flags, ci_test_diagnostics, ci_test_diagnostic_positions, ci_test_noexceptions, ci_test_noimplicitconversions, ci_test_legacycomparison, ci_test_noglobaludls]
    steps:
      - name: Install build-essential
        run: apt-get update ; apt-get install -y build-essential unzip wget git libssl-dev
@@ -158,10 +158,6 @@ jobs:
      # to fit: IMAGE_REL_AMD64_SECREL against `.debug_line'" because the
      # MinGW linker cannot relocate the debug sections this test produces.
      # The tests are only built and run here, so the debug info is not used.
      # Do not add -O1 here to shrink the objects further: it does make them
      # link, but the binaries clang 11.0.1 and clang 18.1.8 then produce crash
      # before doctest prints its first line - 39 of 102 tests on clang 18.
      # Keep the objects small by splitting the test files instead.
      - name: Run CMake
        run: cmake -S . -B build ^
             -DCMAKE_CXX_COMPILER="C:/Program Files/LLVM/bin/clang++.exe" ^
@@ -242,25 +242,6 @@ add_custom_target(ci_test_noglobaludls
    COMMENT "Compile and test with global UDLs disabled"
 )
 ###############################################################################
 # Disable thread-local storage.
 ###############################################################################
 # Without thread-local storage, copying and comparing cannot bound their
 # descent and handle every object and array without the call stack. Those paths
 # are otherwise only reached by values nested deeper than the bound, so this
 # target is what runs the whole test suite through them.
 add_custom_target(ci_test_no_thread_local
    COMMAND ${CMAKE_COMMAND}
    -DCMAKE_BUILD_TYPE=Debug -GNinja
    -DJSON_BuildTests=ON
    -DCMAKE_CXX_FLAGS=-DJSON_NO_THREAD_LOCAL
    -S${PROJECT_SOURCE_DIR} -B${PROJECT_BINARY_DIR}/build_no_thread_local
    COMMAND ${CMAKE_COMMAND} --build ${PROJECT_BINARY_DIR}/build_no_thread_local
    COMMAND cd ${PROJECT_BINARY_DIR}/build_no_thread_local && ${CMAKE_CTEST_COMMAND} --parallel ${N} --output-on-failure
    COMMENT "Compile and test without thread-local storage"
 )
 ###############################################################################
 # Coverage.
 ###############################################################################
@@ -22,7 +22,6 @@ header. See also the [macro overview page](../../features/macros.md).
 - [**JSON_HAS_STD_FORMAT**](json_has_std_format.md) - control `std::format`/`std::formatter` support
 - [**JSON_HAS_THREE_WAY_COMPARISON**](json_has_three_way_comparison.md) - control 3-way comparison support
 - [**JSON_NO_IO**](json_no_io.md) - switch off functions relying on certain C++ I/O headers
 - [**JSON_NO_THREAD_LOCAL**](json_no_thread_local.md) - switch off the use of `thread_local` storage
 - [**JSON_SKIP_UNSUPPORTED_COMPILER_CHECK**](json_skip_unsupported_compiler_check.md) - do not warn about unsupported compilers
 - [**JSON_USE_GLOBAL_UDLS**](json_use_global_udls.md) - place user-defined string literals (UDLs) into the global namespace
@@ -1,48 +0,0 @@
 # JSON_NO_THREAD_LOCAL
 ```cpp
 #define JSON_NO_THREAD_LOCAL
 ```
 When defined, the library does not use `#!cpp thread_local` storage. This is relevant for the few environments whose
 toolchain does not support it.
 Copying a value and comparing two values both descend into the first levels by letting the containers copy or compare
 themselves, and finish whatever is nested deeper than that without the call stack, so that neither can exhaust the stack
 however deeply the values are nested. Each counts the levels it has descended into in a `#!cpp thread_local` variable, as
 a counter shared between threads would be raced.
 Without those counters, no descent can be bounded safely, so objects and arrays are copied and compared without the call
 stack right away. Both keep working exactly as they do otherwise - the same values come out, the same comparisons hold,
 and deeply nested values are handled just as safely - but both are slower, because the containers no longer copy or
 compare themselves. Copying the benchmark documents takes 9% (`canada.json`) to 34% (`twitter.json`) longer, and
 comparing two equal ones 10% (`citm_catalog.json`) to 90% (`canada.json`) longer.
 ## Default definition
 By default, `#!cpp JSON_NO_THREAD_LOCAL` is not defined.
 ```cpp
 #undef JSON_NO_THREAD_LOCAL
 ```
 The library defines it by itself for Clang targeting MinGW, which does not survive the `#!cpp thread_local` storage:
 copying a value segfaults there, with both old and current Clang versions, while GCC targeting MinGW is unaffected.
 Copying and comparing fall back to working without the call stack there, as they do whenever the macro is defined.
 ## Examples
 ??? example
    The code below forces the library not to use `#!cpp thread_local` storage.
    ```cpp
    #define JSON_NO_THREAD_LOCAL 1
    #include <nlohmann/json.hpp>
    ...
    ```
 ## Version history
 - Added in version 3.12.1.
@@ -91,14 +91,6 @@ security reasons (e.g., Intel Software Guard Extensions (SGX)).
 See [full documentation of `JSON_NO_IO`](../api/macros/json_no_io.md).
 ## `JSON_NO_THREAD_LOCAL`
 When defined, the library does not use `#!cpp thread_local` storage. Copying a value and comparing two values then
 always avoid the call stack rather than descending into a bounded number of levels first, which is slower but yields the
 same values and the same comparisons.
 See [full documentation of `JSON_NO_THREAD_LOCAL`](../api/macros/json_no_thread_local.md).
 ## `JSON_SKIP_LIBRARY_VERSION_CHECK`
 When defined, the library will not create a compiler warning when a different version of the library was already
@@ -8,41 +8,72 @@ the result of an internet search. If you know further customers of the library,
 ## Space Exploration
 - [**Peregrine Lunar Lander Flight 01**](https://en.wikipedia.org/wiki/Peregrine_Mission_One) - The library was used for payload management in the **Peregrine Moon Lander**, developed by **Astrobotic Technology** and launched as part of NASA's **Commercial Lunar Payload Services (CLPS)** program. After six days in orbit, the spacecraft was intentionally redirected into Earth's atmosphere, where it burned up over the Pacific Ocean on **January 18, 2024**.
 - [**NASA Unsteady Pressure-Sensitive Paint Processing**](https://github.com/nasa/upsp-processing), NASA software for processing high-speed video recordings of wind tunnel tests on launch vehicle and aircraft models
 - [**Terma TEMU**](https://temu.terma.com/docs/public/temu-release-notes/latest/copying/json-for-modern-cpp.html), an emulator of spacecraft on-board computers used to develop and validate flight software for European space missions
 ## Automotive
 - [**Alexa Auto SDK**](https://github.com/alexa/alexa-auto-sdk), a software development kit enabling the integration of Alexa into automotive systems
 - [**Apollo**](https://github.com/ApolloAuto/apollo), a framework for building autonomous driving systems
 - [**Automotive Grade Linux (AGL)**](https://download.automotivelinux.org/AGL/release/jellyfish/latest/qemux86-64/deploy/licenses/nlohmann-json/), a collaborative open-source platform for automotive software development
 - [**Autoware**](https://github.com/autowarefoundation/autoware_universe), an open-source software stack for autonomous driving built on ROS 2
 - [**Eclipse S-CORE**](https://github.com/eclipse-score/nlohmann_json), an open-source software platform for the software-defined vehicle backed by major automotive manufacturers and suppliers
 - [**Genesis Motor** (infotainment)](http://webmanual.genesis.com/ccIC/AVNT/JW/KOR/English/reference010.html), a luxury automotive brand
 - [**Hyundai** (infotainment)](https://www.hyundai.com/wsvc/ww/download.file.do?id=/content/hyundai/ww/data/opensource/data/GN7-2022/licenseCode/info), a global automotive brand
 - [**Kia** (infotainment)](http://webmanual.kia.com/PREM_GEN6/AVNT/RJPE/KOR/Korean/reference010.html), a global automotive brand
 - [**Mercedes-Benz Operating System (MB.OS)**](https://group.mercedes-benz.com/careers/about-us/mercedes-benz-operating-system/), a core component of the vehicle software ecosystem from Mercedes-Benz
 - [**NVIDIA DRIVE OS**](https://developer.nvidia.com/docs/drive/drive-os/6.0.5/public/driveworks-nvcgf/dwx_open_source_attribution.html), the operating system and DriveWorks SDK powering NVIDIA's platform for autonomous vehicles
 - [**Rivian** (infotainment)](https://assets.ctfassets.net/2md5qhoeajym/3cwyo4eoufk4yingUwusFt/ded2c47da620fdfc99c88c7156d2c1d8/In-Vehicle_OSS_Attribution_2024__11-24_.pdf), an electric vehicle manufacturer
 - [**Suzuki** (infotainment)](https://www.globalsuzuki.com/motorcycle/ipc/oss/oss_48KA_00.pdf), a global automotive and motorcycle manufacturer
 ## Gaming and Entertainment
 - [**Anno 117: Pax Romana**](https://www.mobygames.com/person/1195889/niels-lohmann/credits/), a city-building strategy game set in the Roman Empire
 - [**Assassin's Creed: Mirage**](https://www.mobygames.com/person/1195889/niels-lohmann/credits/), a stealth-action game set in the Middle East, focusing on the journey of a young assassin with classic parkour and stealth mechanics
 - [**Battlefield 6**](https://www.mobygames.com/person/1195889/niels-lohmann/credits/), a military first-person shooter known for its large-scale multiplayer battles
 - [**Battlefield: REDSEC**](https://www.mobygames.com/person/1195889/niels-lohmann/credits/), a free-to-play battle royale experience set in the Battlefield universe
 - [**BioMenace: Remastered**](https://www.mobygames.com/person/1195889/niels-lohmann/credits/), a remaster of the classic side-scrolling platform shooter
 - [**Chasm: The Rift**](https://www.mobygames.com/person/1195889/niels-lohmann/credits/), a first-person shooter blending horror and adventure, where players navigate dark realms and battle monsters
 - [**College Football 25**](https://www.mobygames.com/person/1195889/niels-lohmann/credits/), a college football simulation game featuring gameplay that mimics real-life college teams and competitions
 - [**College Football 26**](https://www.mobygames.com/person/1195889/niels-lohmann/credits/), a college football simulation game featuring licensed teams and stadiums
 - [**College Football 27**](https://www.mobygames.com/person/1195889/niels-lohmann/credits/), the latest installment of the college football simulation series
 - [**Concepts**](https://concepts.app/en/licenses), a digital sketching app designed for creative professionals, offering flexible drawing tools for illustration, design, and brainstorming
 - [**Depthkit**](https://www.depthkit.tv/third-party-licenses), a tool for creating and capturing volumetric video, enabling immersive 3D experiences and interactive content
 - [**Dune: Awakening**](https://www.mobygames.com/person/1195889/niels-lohmann/credits/), an open-world survival MMO set on the desert planet Arrakis
 - [**EA Sports FC 25**](https://www.mobygames.com/person/1195889/niels-lohmann/credits/), an association football simulation with club, career, and online modes
 - [**EA Sports FC 26**](https://www.mobygames.com/person/1195889/niels-lohmann/credits/), the latest installment of the association football simulation series
 - [**EA Sports UFC 6**](https://www.mobygames.com/person/1195889/niels-lohmann/credits/), a mixed martial arts fighting simulation
 - [**FiveM**](https://github.com/citizenfx/fivem), a modification framework for Grand Theft Auto V that powers custom multiplayer servers
 - [**FLUX:: Immersive**](https://doc.flux.audio/syrah/Credits.html), a suite of professional audio processing and immersive mixing plugins used in music and post-production
 - [**IMG.LY**](https://img.ly/acknowledgements), a platform offering creative tools and SDKs for integrating advanced image and video editing in applications
 - [**immersivetech**](https://immersitech.io/open-source-third-party-software/), a technology company focused on immersive experiences, providing tools and solutions for virtual and augmented reality applications
 - [**Kodi**](https://github.com/xbmc/xbmc/blob/master/xbmc/utils/JSONVariantWriter.cpp), a home theater and media center application
 - [**LOOT**](https://loot.readthedocs.io/_/downloads/en/0.13.0/pdf/), a tool for optimizing the load order of game plugins, commonly used in The Elder Scrolls and Fallout series
 - [**LunaTranslator**](https://github.com/HIllya51/LunaTranslator/blob/main/src/NativeImpl/LunaSubprocess/aspatch.cpp), a real-time translation tool for visual novels
 - [**MaaAssistantArknights**](https://github.com/MaaAssistantArknights/MaaAssistantArknights/blob/dev-v2/src/MaaCore/Vision/Roguelike/BlackFlow/BlackFlowMapAnalyzer.cpp), an automation assistant for the mobile game Arknights
 - [**Madden NFL 25**](https://www.mobygames.com/person/1195889/niels-lohmann/credits/), a sports simulation game capturing the excitement of American football with realistic gameplay and team management features
 - [**Madden NFL 26**](https://www.mobygames.com/person/1195889/niels-lohmann/credits/), an American football simulation with franchise and team management modes
 - [**Madden NFL 27**](https://www.mobygames.com/person/1195889/niels-lohmann/credits/), the latest installment of the American football simulation series
 - [**Marne**](https://marne.io/licenses), an unofficial private server platform for hosting custom Battlefield 1 game experiences
 - [**Minecraft**](https://www.minecraft.net/zh-hant/attribution), a popular sandbox video game
 - [**Mumble**](https://github.com/mumble-voip/mumble), a low-latency, open-source voice chat application widely used by gaming communities
 - [**NHL 22**](https://www.mobygames.com/person/1195889/niels-lohmann/credits/), a hockey simulation game offering realistic gameplay, team management, and various modes to enhance the hockey experience
 - [**OBS Studio**](https://github.com/obsproject/obs-studio), a free and open-source suite for video recording and live streaming
 - [**OpenRCT2**](https://github.com/OpenRCT2/OpenRCT2/blob/develop/src/openrct2/core/JsonFwd.hpp), an open source re-implementation of RollerCoaster Tycoon 2
 - [**Pixelpart**](https://pixelpart.net/documentation/book/third-party.html), a 2D animation and video compositing software that allows users to create animated graphics and visual effects with a focus on simplicity and ease of use
 - [**Razer Cortex**](https://mysupport.razer.com/app/answers/detail/a_id/14146/~/open-source-software-for-razer-software), a gaming performance optimizer and system booster designed to enhance the gaming experience
 - [**Red Dead Redemption II**](https://www.mobygames.com/person/1195889/niels-lohmann/credits/), an open-world action-adventure game following an outlaw's story in the late 1800s, emphasizing deep storytelling and immersive gameplay
 - [**RetroArch**](https://github.com/libretro/RetroArch), a frontend for emulators, game engines, and media players built on the libretro API
 - [**shadPS4**](https://github.com/shadps4-emu/shadPS4/blob/main/src/core/user_manager.h), a PlayStation 4 emulator for Windows, Linux and macOS
 - [**skate.**](https://www.mobygames.com/person/1195889/niels-lohmann/credits/), a free-to-play skateboarding game set in an open world
 - [**Snapchat**](https://www.snap.com/terms/license-android), a multimedia messaging and augmented reality app for communication and entertainment
 - [**Steel Century Groove**](https://www.mobygames.com/person/1195889/niels-lohmann/credits/), an action game released in 2026
 - [**Sunshine**](https://github.com/LizardByte/Sunshine/blob/master/src/confighttp.h), a self-hosted game streaming host compatible with Moonlight clients
 - [**Tactics Ogre: Reborn**](https://www.square-enix-games.com/en_US/documents/tactics-ogre-reborn-pc-installer-software-and-associated-plug-ins-disclosure), a tactical role-playing game featuring strategic battles and deep storytelling elements
 - [**Throne and Liberty**](https://www.amazon.com/gp/help/customer/display.html?nodeId=T7fLNw5oAevCMtJFPj&pop-up=1), an MMORPG that offers an expansive fantasy world with dynamic gameplay and immersive storytelling
 - [**Unity Vivox**](https://docs.unity3d.com/Packages/com.unity.services.vivox@15.1/license/Third%20Party%20Notices.html), a communication service that enables voice and text chat functionality in multiplayer games developed with Unity
 - [**xemu**](https://github.com/xemu-project/xemu), an emulator of the original Xbox console
 - [**Zool: Redimensioned**](https://www.mobygames.com/person/1195889/niels-lohmann/credits/), a modern reimagining of the classic platformer featuring fast-paced gameplay and vibrant environments
 - [**immersivetech**](https://immersitech.io/open-source-third-party-software/), a technology company focused on immersive experiences, providing tools and solutions for virtual and augmented reality applications
 ## Consumer Electronics
@@ -50,109 +81,195 @@ the result of an internet search. If you know further customers of the library,
 - [**Canon CanoScan LIDE**](https://carolburo.com/wp-content/uploads/2024/06/LiDE400_OnlineManual_Win_FR_V02.pdf), a series of flatbed scanners offering high-resolution image scanning for home and office use
 - [**Canon PIXMA Printers**](https://www.mediaexpert.pl/products/files/73/7338196/Instrukcja-obslugi-CANON-Pixma-TS7450i.pdf), a line of all-in-one inkjet printers known for high-quality printing and wireless connectivity
 - [**Cisco Webex Desk Camera**](https://www.cisco.com/c/dam/en_us/about/doing_business/open_source/docs/CiscoWebexDeskCamera-23-1622100417.pdf), a video camera designed for professional-quality video conferencing and remote collaboration
 - [**DJI Edge SDK**](https://github.com/dji-sdk/Edge-SDK-V2-Demo), the reference applications for DJI's Edge SDK, used to build edge computing services on DJI drone docks
 - [**Elgato Stream Deck**](https://github.com/elgatosf/streamdeck-obs-plugin2), a family of programmable control surfaces for content creators and their plugin ecosystem
 - [**Instagrid**](https://instagrid.co/intellectual-property/foss), a manufacturer of portable, high-performance battery systems for professional mobile power supply
 - [**iRobot**](https://iot-content.irobot.com/iw/sfsites/c/cms/delivery/media/MCKRLTPDJSSJBNJKDA5SG5UVVIIQ), a manufacturer of autonomous home robots including the Roomba vacuum cleaner range
 - [**Logitech Logi Bolt**](https://opensource.logitech.com/wiki/Logi_BoltApp/), the management application for Logitech's secure wireless connectivity technology
 - [**Novitus**](https://novitus.pl/licencjepensource), a manufacturer of fiscal cash registers and point-of-sale devices
 - [**Philips Hue Personal Wireless Lighting**](http://2ak5ape.257.cz/), a smart lighting system for customizable and wireless home illumination
 - [**Ray-Ban Meta Smart glasses**](https://www.meta.com/de/en/legal/smart-glasses/third-party-notices-android/03/), a pair of smart glasses designed for capturing photos and videos with integrated connectivity and social features
 - [**Razer Synapse**](https://mysupport.razer.com/app/answers/detail/a_id/14146/~/open-source-software-for-razer-software), a unified configuration software enabling hardware customization for Razer devices
 - [**Sharp Professional Displays**](https://jp.sharp/restricted/business/lcd-display/cms/images/source_pnla862/PN-LA652_752_862_LicenseInformation.pdf), a range of large-format interactive displays for business and education
 - [**Siemens SINEMA Remote Connect**](https://cache.industry.siemens.com/dl/files/790/109793790/att_1054961/v2/OSS_SINEMA-RC_86.pdf), a remote connectivity solution for monitoring and managing industrial networks and devices securely
 - [**Skydio**](https://pages.skydio.com/rs/784-TUF-591/images/Open%20Source%20Software%20Notice%20v0.2.html), a manufacturer of autonomous drones for inspection, public safety, and defense applications
 - [**Sony PlayStation 4**](https://doc.dl.playstation.net/doc/ps4-oss/index.html), a gaming console developed by Sony that offers a wide range of games and multimedia entertainment features
 - [**Sony Spatial Reality Display**](https://www.sony.co.jp/en/Products/Developer-Spatial-Reality-display/download/dcc-tools/blender-plugin/SpatiaRealityDisplayPluginforPreviewBL_Manual.pdf), a glasses-free stereoscopic 3D display and its plugins for Blender, 3ds Max, and ZBrush
 - [**Sony Virtual Webcam Driver for Remote Camera**](https://helpguide.sony.net/rc/vwd/v1/zh-cn/print.pdf), a software driver that enables the use of Sony cameras as virtual webcams for video conferencing and streaming
 - [**Yamaha Clavinova**](https://usa.yamaha.com/files/download/other_assets/1/2298171/CLP-800_oss_license.pdf), a series of digital pianos combining acoustic piano feel with digital sound technology
-## Operating Systems
+## Operating Systems and Platforms
 - [**Apple iOS and macOS**](https://www.apple.com/macos), a family of operating systems developed by Apple, including iOS for mobile devices and macOS for desktop computers
 - [**Chromium**](https://chromium.googlesource.com/chromium/src/+/main/third_party/nlohmann_json/), the open-source browser project that Google Chrome, Microsoft Edge, and many other browsers are built on, where the library is used as data container for on-device model execution
 - [**Google Fuchsia**](https://fuchsia.googlesource.com/third_party/json/), an open-source operating system developed by Google, designed to be secure, updatable, and adaptable across various devices
 - [**LG webOS**](https://github.com/webosose/com.webos.service.camera), a Linux-based operating system used in LG smart TVs, signage, and embedded devices
 - [**Microsoft Azure Linux**](https://github.com/microsoft/azurelinux), a Linux distribution developed by Microsoft for Azure infrastructure and edge workloads
 - [**OpenHarmony**](https://github.com/openharmony/third_party_json), an open-source operating system for smart devices and the foundation of HarmonyOS
 - [**SerenityOS**](https://github.com/SerenityOS/serenity), an open-source operating system that aims to provide a simple and beautiful user experience with a focus on simplicity and elegance
 - [**Windows Subsystem for Linux**](https://github.com/microsoft/WSL), a compatibility layer that runs Linux environments natively on Windows
 - [**Yocto**](http://ftp.emacinc.com/openembedded-sw/kirkstone-icop-5.15-kirkstone-6.0/archive-2024-10/pn8m-090t-ppc/licenses/nlohmann-json/), a Linux-based build system for creating custom operating systems and software distributions, tailored for embedded devices and IoT applications
 ## Development Tools and IDEs
 - [**Accentize SpectralBalance**](https://www.accentize.com/products/SpectralBalanceManual.pdf), an adaptive speech analysis tool designed to enhance audio quality by optimizing frequency balance in recordings
 - [**Airbus Ghidralligator**](https://www.cyber.airbus.com/en/newsroom/stories/2025-06-ghidralligator), a Ghidra-based emulator from Airbus CyberSecurity used to fuzz and analyse embedded firmware
 - [**Apache brpc**](https://github.com/apache/brpc/blob/master/src/butil/iobuf.h), an industrial-grade remote procedure call framework for C++
 - [**Arm Compiler for Linux**](https://documentation-service.arm.com/static/66558e9d876c8d213b7843e4), a software development toolchain for compiling and optimizing applications on Arm-based Linux systems
 - [**BBEdit**](https://s3.amazonaws.com/BBSW-download/BBEdit_15.1.2_User_Manual.pdf), a professional text and code editor for macOS
 - [**CoderPad**](https://coderpad.io), a collaborative coding platform that enables real-time code interviews and assessments for developers; the library is included in every CoderPad instance and can be accessed with a simple `#include "json.hpp"`
 - [**Codon**](https://github.com/exaloop/codon/blob/develop/jupyter/jupyter.h), an ahead-of-time compiler for a Python-like language
 - [**Compiler Explorer**](https://godbolt.org), a web-based tool that allows users to write, compile, and visualize the assembly output of code in various programming languages; the library is readily available and accessible with the directive `#include <nlohmann/json.hpp>`.
- [**GitHub CodeQL**](https://github.com/github/codeql), a code analysis tool used for identifying security vulnerabilities and bugs in software through semantic queries
+- [**Flutter**](https://github.com/flutter/flutter/blob/master/engine/src/flutter/impeller/compiler/reflector.cc), a UI toolkit for building natively compiled applications for mobile, web, and desktop from a single codebase
 - [**Fraunhofer VVenC**](https://github.com/fraunhoferhhi/vvenc), a fast and efficient encoder for the Versatile Video Coding (H.266/VVC) standard
 - [**GitHub CodeQL**](https://github.com/github/codeql/blob/main/shared/cpp/Diagnostics.h), a code analysis tool used for identifying security vulnerabilities and bugs in software through semantic queries
 - [**GoPro ngfx**](https://github.com/gopro/ngfx), a low-level graphics abstraction and profiling framework developed by GoPro
 - [**gRPC**](https://github.com/grpc/grpc/blob/master/tools/artifact_gen/utils.h), a high-performance universal remote procedure call framework
 - [**Hex-Rays**](https://docs.hex-rays.com/user-guide/user-interface/licenses), a reverse engineering toolset for analyzing and decompiling binaries, primarily used for security research and vulnerability analysis
 - [**ImHex**](https://github.com/WerWolv/ImHex), a hex editor designed for reverse engineering, providing advanced features for data analysis and manipulation
 - [**Intel GITS**](https://github.com/intel/gits), a tool for capturing and replaying graphics API calls for debugging and performance analysis
 - [**Intel GPA Framework**](https://intel.github.io/gpasdk-doc/src/licenses.html), a suite of cross-platform tools for capturing, analyzing, and optimizing graphics applications across different APIs
 - [**Intopix**](https://www.intopix.com/software-licensing), a provider of advanced image processing and compression solutions used in software development and AV workflows
 - [**Java SE**](https://www.oracle.com/a/tech/docs/jdk8-lium.pdf), the core Java platform that provides the libraries and runtime needed to build and run general-purpose Java applications
 - [**MKVToolNix**](https://mkvtoolnix.download/doc/README.md), a set of tools for creating, editing, and inspecting MKV (Matroska) multimedia container files
 - [**Meta Yoga**](https://github.com/facebook/yoga), a layout engine that facilitates flexible and efficient user interface design across multiple platforms
- [**NVIDIA Nsight Compute**](https://docs.nvidia.com/nsight-compute/2022.2/pdf/CopyrightAndLicenses.pdf), a performance analysis tool for CUDA applications that provides detailed insights into GPU performance metrics
+- [**MKVToolNix**](https://mkvtoolnix.download/doc/README.md), a set of tools for creating, editing, and inspecting MKV (Matroska) multimedia container files
 - [**MRTech IFF SDK**](https://mr-technologies.com/pub/iff-sdk-manual-2-0-1/iff-sdk-manual-2-0-1.pdf), an image processing SDK for machine vision applications with GPU-accelerated pipelines
 - [**Nix**](https://github.com/NixOS/nix/blob/master/src/nix/build.cc), a purely functional package manager
 - [**Notepad++**](https://github.com/notepad-plus-plus/notepad-plus-plus), a free source code editor that supports various programming languages
 - [**NVIDIA Nsight Compute**](https://docs.nvidia.com/nsight-compute/2022.2/pdf/CopyrightAndLicenses.pdf), a performance analysis tool for CUDA applications that provides detailed insights into GPU performance metrics
 - [**openFrameworks**](https://github.com/openframeworks/openFrameworks/blob/master/libs/openFrameworks/utils/ofJson.h), a community-developed C++ toolkit for creative coding
 - [**OpenRGB**](https://gitlab.com/CalcProgrammer1/OpenRGB), an open source RGB lighting control that doesn't depend on manufacturer software
 - [**OpenTelemetry C++**](https://github.com/open-telemetry/opentelemetry-cpp), a library for collecting and exporting observability data in C++, enabling developers to implement distributed tracing and metrics in their application
 - [**Oracle GraalVM**](https://docs.oracle.com/en/graalvm/jdk/21/docs/licensing-information/), a high-performance JDK distribution with ahead-of-time compilation and polyglot runtime support
 - [**Philips amp-cucumber-cpp-runner**](https://github.com/philips-software/amp-cucumber-cpp-runner), a behaviour-driven development test runner for embedded C++ software developed at Philips
 - [**Qt Creator**](https://doc.qt.io/qtcreator/qtcreator-attribution-json-nlohmann.html), an IDE for developing applications using the Qt application framework
 - [**Qt for MCUs**](https://doc.qt.io/QtForMCUs/quickultralite-attribution-nlohmann-json.html), a graphics framework for building fluid user interfaces on microcontrollers
 - [**React Native**](https://github.com/react/react-native/blob/main/packages/react-native/ReactCxxPlatform/react/devsupport/PackagerConnection.cpp), a framework for building native mobile applications using React
 - [**Scanbot SDK**](https://docs.scanbot.io/barcode-scanner-sdk/web/third-party-libraries/), a software development kit (SDK) that provides tools for integrating advanced document scanning and barcode scanning capabilities into applications
 - [**STMicroelectronics TouchGFX**](https://www.st.com/resource/en/additional_license_terms/additional-license-terms-x-cube-touchgfx.html), a graphical user interface framework shipped with STM32 microcontrollers for building embedded HMIs
 - [**swagger-codegen**](https://github.com/swagger-api/swagger-codegen/blob/master/samples/server/petstore/pistache-server/model/Pet.h), a template-driven engine that generates API clients and server stubs from an OpenAPI specification
 - [**Swoole**](https://github.com/swoole/swoole-src/blob/master/ext-src/swoole_admin_server.cc), a coroutine-based concurrency engine for PHP
 - [**Tracy Profiler**](https://github.com/wolfpld/tracy/blob/master/profiler/src/profiler/TracyLlm.hpp), a real-time frame profiler for games and other applications
 - [**WasmEdge**](https://github.com/WasmEdge/WasmEdge/blob/master/plugins/wasi_nn/GGML/tts/tts_core.cpp), a lightweight WebAssembly runtime for edge and cloud workloads
 - [**x64dbg**](https://github.com/x64dbg/x64dbg/blob/development/src/cross/remote_table/TableRpcData.h), an open source user mode debugger for Windows, aimed at reverse engineering and malware analysis
 ## Machine Learning and AI
 - [**Alibaba MNN**](https://github.com/alibaba/MNN), a lightweight deep learning inference engine for mobile and embedded devices
 - [**AMD Gaia**](https://github.com/amd/gaia), an open-source framework for running generative AI applications locally on AMD hardware
 - [**AMD Vitis AI (VAIP)**](https://github.com/amd/vaip), the execution provider stack that runs AI models on AMD Ryzen AI and adaptive computing devices
 - [**Apple Core ML Tools**](https://github.com/apple/coremltools), a set of tools for converting and configuring machine learning models for deployment in Apple's Core ML framework
 - [**Avular Mobile Robotics**](https://www.avular.com/licenses/nlohmann-json-3.9.1.txt), a platform for developing and deploying mobile robotics solutions
 - [**FunASR**](https://github.com/modelscope/FunASR/blob/main/runtime/http/bin/asr_sessions.h), a speech recognition toolkit for training and deploying end-to-end models
 - [**Google gemma.cpp**](https://github.com/google/gemma.cpp), a lightweight C++ inference engine designed for running AI models from the Gemma family
 - [**Google Magenta The Infinite Crate**](https://github.com/magenta/the-infinite-crate), an open-source generative AI plugin for digital audio workstations from Google's Magenta research team
 - [**GPT4All**](https://github.com/nomic-ai/gpt4all/blob/main/gpt4all-chat/src/tool.h), a desktop application for running local large language models on consumer hardware
 - [**Huawei MindSpore**](https://github.com/mindspore-ai/mindspore/blob/master/Third_Party_Open_Source_Software_Notice), a deep learning framework for training and inference across device, edge, and cloud
 - [**KTransformers**](https://github.com/kvcache-ai/ktransformers/blob/main/archive/csrc/balance_serve/sched/model_config.h), a framework for heterogeneous large language model inference
 - [**llama.cpp**](https://github.com/ggerganov/llama.cpp), a C++ library designed for efficient inference of large language models (LLMs), enabling streamlined integration into applications
 - [**LocalAI**](https://github.com/mudler/LocalAI/blob/master/backend/cpp/ds4/dsml_renderer.cpp), a self-hosted inference engine that exposes local models through an OpenAI-compatible API
 - [**MLX**](https://github.com/ml-explore/mlx), an array framework for machine learning on Apple Silicon
 - [**Mozilla llamafile**](https://github.com/Mozilla-Ocho/llamafile), a tool designed for distributing and executing large language models (LLMs) efficiently using a single file format
 - [**NVIDIA ACE**](https://docs.nvidia.com/ace/latest/index.html), a suite of real-time AI solutions designed for the development of interactive avatars and digital human applications, enabling scalable and sophisticated user interactions
 - [**NVIDIA Instant NGP**](https://github.com/NVlabs/instant-ngp/blob/master/src/nerf_loader.cu), an implementation of instant neural graphics primitives for rapid scene reconstruction
 - [**NVIDIA TensorRT**](https://github.com/NVIDIA/TensorRT), an SDK for high-performance deep learning inference, including its TensorRT-LLM extension for large language models
 - [**NVIDIA TensorRT-LLM**](https://github.com/NVIDIA/TensorRT-LLM/blob/main/cpp/tensorrt_llm/common/safetensors.cpp), a toolkit for optimizing and serving large language model inference on GPUs
 - [**ONNX Runtime**](https://github.com/microsoft/onnxruntime), a cross-platform inference and training accelerator for machine learning models
 - [**OpenVINO**](https://github.com/openvinotoolkit/openvino), Intel's toolkit for optimizing and deploying deep learning inference across CPUs, GPUs, and NPUs
 - [**PaddleOCR**](https://github.com/PaddlePaddle/PaddleOCR/blob/main/deploy/cpp_infer/src/modules/text_detection/result.cc), an optical character recognition toolkit that turns documents and images into structured data
 - [**PaddlePaddle**](https://github.com/PaddlePaddle/Paddle/blob/develop/paddle/ap/src/axpr/anf_expr.cc), a deep learning framework for distributed training and inference
 - [**Peer**](https://support.peer.inc/hc/en-us/articles/17261335054235-Licenses), a platform offering personalized AI assistants for interactive learning and creative collaboration
 - [**PyTorch**](https://github.com/pytorch/pytorch), a machine learning framework for building and training neural networks, widely used in research and production
 - [**Qualcomm AI Engine Direct**](https://github.com/qualcomm/qai-appbuilder), a toolchain for building and running generative AI applications on Snapdragon devices
 - [**sherpa-onnx**](https://github.com/k2-fsa/sherpa-onnx/blob/master/sherpa-onnx/csrc/sentence-piece-tokenizer.cc), a speech toolkit for on-device recognition, synthesis and speaker diarization
 - [**stable-diffusion.cpp**](https://github.com/leejet/stable-diffusion.cpp), a C++ implementation of the Stable Diffusion image generation model
 - [**TanvasTouch**](https://tanvas.co/tanvastouch-sdk-third-party-acknowledgments), a software development kit (SDK) that enables developers to create tactile experiences on touchscreens, allowing users to feel textures and physical sensations in a digital environment
 - [**TensorFlow**](https://github.com/tensorflow/tensorflow), a machine learning framework that facilitates the development and training of models, supporting data serialization and efficient data exchange between components
 - [**whisper.cpp**](https://github.com/ggml-org/whisper.cpp), a C++ implementation of OpenAI's Whisper automatic speech recognition model
 ## Scientific Research and Analysis
 - [**BLACK**](https://www.black-sat.org/en/stable/installation/linux.html), a bounded linear temporal logic (LTL) satisfiability checker
 - [**CERN ALICE O2**](https://github.com/AliceO2Group/AliceO2), the online-offline computing framework of the ALICE heavy-ion experiment at the Large Hadron Collider
 - [**CERN Atlas Athena**](https://gitlab.cern.ch/atlas/athena/-/blob/main/Control/PerformanceMonitoring/PerfMonComps/src/PerfMonMTSvc.h), a software framework used in the ATLAS experiment at the Large Hadron Collider (LHC) for performance monitoring
 - [**CERN CMSSW**](https://github.com/cms-sw/cmssw), the offline software framework of the CMS experiment at the Large Hadron Collider
 - [**CERN Gaudi**](https://gitlab.cern.ch/gaudi/Gaudi), the event-processing framework used by the LHCb and ATLAS experiments at the Large Hadron Collider
 - [**ICU**](https://github.com/unicode-org/icu), the International Components for Unicode, a mature library for software globalization and multilingual support
 - [**KAMERA**](https://github.com/Kitware/kamera), a platform for synchronized data collection and real-time deep learning to map marine species like polar bears and seals, aiding Arctic ecosystem research
 - [**KiCad**](https://gitlab.com/kicad/code/kicad/-/tree/master/thirdparty/nlohmann_json), a free and open-source software suite for electronic design automation
 - [**LLNL ROSE**](https://github.com/llnl/rose), a compiler infrastructure from Lawrence Livermore National Laboratory for building source-to-source program analysis and transformation tools
 - [**Maple**](https://www.maplesoft.com/support/help/Maple/view.aspx?path=copyright), a symbolic and numeric computing environment for advanced mathematical modeling and analysis
 - [**MeVisLab**](https://mevislabdownloads.mevis.de/docs/current/MeVis/ThirdParty/Documentation/Publish/ThirdPartyReference/index.html), a software framework for medical image processing and visualization.
 - [**MITK**](https://github.com/MITK/MITK), the Medical Imaging Interaction Toolkit, a framework for developing interactive medical image processing software
 - [**OpenPMD API**](https://openpmd-api.readthedocs.io/en/0.8.0-alpha/backends/json.html), a versatile programming interface for accessing and managing scientific data, designed to facilitate the efficient storage, retrieval, and sharing of simulation data across various applications and platforms
 - [**ORNL DataFed**](https://github.com/ORNL/DataFed), a federated scientific data management system developed at Oak Ridge National Laboratory
 - [**ParaView**](https://github.com/Kitware/ParaView), an open-source tool for large-scale data visualization and analysis across various scientific domains
 - [**QGIS**](https://gitlab.b-data.ch/qgis/qgis/-/blob/backport-57658-to-release-3_34/external/nlohmann/json.hpp), a free and open-source geographic information system (GIS) application that allows users to create, edit, visualize, and analyze geospatial data across a variety of formats
- [**VTK**](https://github.com/Kitware/VTK), a software library for 3D computer graphics, image processing, and visualization
+- [**Sandia InterSpec**](https://github.com/sandialabs/InterSpec), spectral radiation analysis software from Sandia National Laboratories for identifying radioactive isotopes
 - [**VolView**](https://github.com/Kitware/VolView), a lightweight application for interactive visualization and analysis of 3D medical imaging data.
 - [**VTK**](https://github.com/Kitware/VTK), a software library for 3D computer graphics, image processing, and visualization
 ## Business and Productivity Software
 - [**ArcGIS PRO**](https://www.esri.com/content/dam/esrisites/en-us/media/legal/open-source-acknowledgements/arcgis-pro-2-8-attribution-report.html), a desktop geographic information system (GIS) application developed by Esri for mapping and spatial analysis
 - [**Autodesk Desktop**](https://damassets.autodesk.net/content/dam/autodesk/www/Company/legal-notices-trademarks/autodesk-desktop-platform-components/internal-autodesk-components-web-page-2023.pdf), a software platform developed by Autodesk for creating and managing desktop applications and services
 - [**Check Point**](https://www.checkpoint.com/about-us/copyright-and-trademarks/), a cybersecurity company specializing in threat prevention and network security solutions, offering a range of products designed to protect enterprises from cyber threats and ensure data integrity
 - [**EasyEffects**](https://github.com/wwmm/easyeffects/blob/master/src/presets_manager.hpp), an audio effects processor for PipeWire offering limiting, compression and equalization
 - [**espanso**](https://github.com/espanso/espanso/blob/dev/espanso-ui/src/win32/native.cpp), a cross-platform text expander
 - [**Karabiner-Elements**](https://github.com/pqrs-org/Karabiner-Elements/blob/main/src/share/app_icon.hpp), a keyboard customizer for macOS
 - [**MacType**](https://github.com/snowie2000/mactype/blob/directwrite/settings.h), a font rendering engine for Windows
 - [**magicplan**](https://help.magicplan.app/acknowledgments), a mobile application for creating floor plans and interior designs using augmented reality
 - [**Microsoft Office for Mac**](https://officecdnmac.microsoft.com/pr/legal/mac/OfficeforMacAttributions.html), a suite of productivity applications developed by Microsoft for macOS, including tools for word processing, spreadsheets, and presentations
 - [**Microsoft Teams**](https://www.microsoft.com/microsoft-teams/), a team collaboration application offering workspace chat and video conferencing, file storage, and integration of proprietary and third-party applications and services
 - [**MuseScore**](https://github.com/musescore/MuseScore), a free and open-source music notation and composition application
 - [**NanaZip**](https://github.com/M2Team/NanaZip/blob/main/NanaZip.Codecs/NanaZip.Codecs.Archive.ElectronAsar.cpp), a 7-Zip derivative built for modern Windows
 - [**Nexthink Infinity**](https://docs.nexthink.com/legal/services-terms/experience-open-source-software-licenses/infinity-2022.8-software-licenses), a digital employee experience management platform for monitoring and improving IT performance
 - [**Sophos Connect Client**](https://docs.sophos.com/nsg/licenses/SophosConnect/SophosConnectAttribution.html), a secure VPN client from Sophos that allows remote users to connect to their corporate network, ensuring secure access to resources and data
 - [**Stonebranch**](https://stonebranchdocs.atlassian.net/wiki/spaces/UA77/pages/799545647/Licenses+for+Third-Party+Libraries), a cloud-based cybersecurity solution that integrates backup, disaster recovery, and cybersecurity features to protect data and ensure business continuity for organizations
 - [**Tablecruncher**](https://tablecruncher.com/), a data analysis tool that allows users to import, analyze, and visualize spreadsheet data, offering interactive features for better insights and decision-making
- [**magicplan**](https://help.magicplan.app/acknowledgments), a mobile application for creating floor plans and interior designs using augmented reality
+- [**VNote**](https://github.com/vnotex/vnote/blob/master/src/core/services/notebookcoreservice.cpp), a Markdown-based note-taking application written in C++
 ## Databases and Big Data
 - [**ADIOS2**](https://code.ornl.gov/ecpcitest/adios2/-/tree/pr4285_FFSUpstream/thirdparty/nlohmann_json?ref_type=heads), a data management framework designed for high-performance input and output operations
 - [**Apache Doris**](https://github.com/apache/doris/blob/master/be/src/runtime/be_proc_monitor.cpp), a real-time analytical database for high-concurrency queries
 - [**Claris FileMaker Server**](https://www.claris.com/company/legal/docs/acknowledgements/filemaker-server-macwin/claris_fms2025_acknowledgements_en.pdf), the server platform hosting FileMaker custom apps and databases, developed by Apple subsidiary Claris
 - [**ClickHouse**](https://github.com/ClickHouse/ClickHouse), a column-oriented database management system for real-time analytical queries
 - [**Cribl Stream**](https://docs.cribl.io/stream/third-party-current-list/), a real-time data processing platform that enables organizations to collect, route, and transform observability data, enhancing visibility and insights into their systems
 - [**DB Browser for SQLite**](https://github.com/sqlitebrowser/sqlitebrowser), a visual open-source tool for creating, designing, and editing SQLite database files
 - [**Manticore Search**](https://github.com/manticoresoftware/manticoresearch/blob/main/src/searchdhttpcompat.cpp), a database for search, offering full-text and vector queries
 - [**Milvus**](https://github.com/milvus-io/milvus/blob/master/internal/core/src/query/PlanImpl.h), a cloud-native vector database built for embedding similarity search
 - [**MongoDB**](https://github.com/mongodb/mongo/blob/master/src/mongo/replay/config_handler.cpp), a general-purpose document database
 - [**MySQL Connector/C++**](https://docs.oracle.com/cd/E17952_01/connector-cpp-9.1-license-com-en/license-opentelemetry-cpp-com.html), a C++ library for connecting and interacting with MySQL databases
 - [**MySQL NDB Cluster**](https://downloads.mysql.com/docs/licenses/cluster-9.0-com-en.pdf), a distributed database system that provides high availability and scalability for MySQL databases
 - [**MySQL Shell**](https://downloads.mysql.com/docs/licenses/mysql-shell-8.0-gpl-en.pdf), an advanced client and code editor for interacting with MySQL servers, supporting SQL, Python, and JavaScript
- [**PrestoDB**](https://github.com/prestodb/presto), a distributed SQL query engine designed for large-scale data analytics, originally developed by Facebook
+- [**PrestoDB**](https://github.com/prestodb/presto/blob/master/presto-native-execution/presto_cpp/main/Announcer.cpp), a distributed SQL query engine designed for large-scale data analytics, originally developed by Facebook
 - [**ROOT Data Analysis Framework**](https://root.cern/doc/v614/classnlohmann_1_1basic__json.html), an open-source data analysis framework widely used in high-energy physics and other fields for data processing and visualization
 - [**Typesense**](https://github.com/typesense/typesense/blob/v31/include/join.h), an open source typo-tolerant search engine
 - [**Vearch**](https://github.com/jd-opensource/vearch), a distributed vector database developed at JD.com for similarity search and retrieval-augmented generation
 - [**WiredTiger**](https://github.com/wiredtiger/wiredtiger), a high-performance storage engine for databases, offering support for compression, concurrency, and checkpointing
 ## Simulation and Modeling
 - [**Adobe Lagrange**](https://github.com/adobe/lagrange), a geometry processing library developed by Adobe for mesh manipulation and analysis
 - [**Arcturus HoloSuite**](https://www.datocms-assets.com/104353/1698904597-holosuite-third-party-software-credits-and-attributions-2.pdf), a software toolset for capturing, editing, and streaming volumetric video, featuring advanced compression technologies for high-quality 3D content creation
 - [**azul**](https://pure.tudelft.nl/ws/files/85338589/tgis.12673.pdf), a fast and efficient 3D city model viewer designed for visualizing urban environments and spatial data
 - [**Bambu Studio**](https://github.com/bambulab/BambuStudio), a slicing and print management application for Bambu Lab 3D printers
 - [**Blender**](https://projects.blender.org/blender/blender/search?q=nlohmann), a free and open-source 3D creation suite for modeling, animation, rendering, and more
 - [**cpplot**](https://cpplot.readthedocs.io/en/latest/library_api/function_eigen_8h_1ac080eac0541014c5892a55e41bf785e6.html), a library for creating interactive graphs and charts in C++, which can be viewed in web browsers
 - [**Foundry Nuke**](https://learn.foundry.com/nuke/content/misc/studio_third_party_libraries.html), a powerful node-based digital compositing and visual effects application used in film and television post-production
 - [**FreeCAD**](https://github.com/FreeCAD/FreeCAD), a free and open-source parametric 3D CAD modeler for product design and engineering
 - [**GAMS**](https://www.gams.com/47/docs/THIRDPARTY.html), a high-performance mathematical modeling system for optimization and decision support
 - [**Keysight WirelessPro**](https://docs.keysight.com/display/engdocwirelesspro/WirelessPro+2026+Release+Notes), a simulation platform for 5G, 5G-Advanced, and 6G cellular network research
 - [**Kitware SMTK**](https://github.com/Kitware/SMTK), a software toolkit for managing simulation models and workflows in scientific and engineering applications
 - [**M-Star**](https://docs.mstarcfd.com/3_Licensing/thirdparty-licenses.html), a computational fluid dynamics software for simulating and analyzing fluid flow
 - [**MapleSim CAD Toolbox**](https://www.maplesoft.com/support/help/MapleSim/view.aspx?path=CADToolbox/copyright), a software extension for MapleSim that integrates CAD models, allowing users to import, manipulate, and analyze 3D CAD data within the MapleSim environment for enhanced modeling and simulation
 - [**Microsoft AirSim**](https://github.com/microsoft/AirSim/blob/main/AirLib/include/common/Settings.hpp), a simulator for autonomous vehicles and drones built on Unreal Engine
 - [**NVIDIA Omniverse**](https://docs.omniverse.nvidia.com/composer/latest/common/product-licenses/usd-explorer/usd-explorer-2023.2.0-licenses-manifest.html), a platform for 3D content creation and collaboration that enables real-time simulations and interactive experiences across various industries
 - [**OpenSCAD**](https://github.com/openscad/openscad/blob/master/src/core/AIClient.cc), a script-driven solid 3D CAD modeller
 - [**OrcaSlicer**](https://github.com/SoftFever/OrcaSlicer), an open-source slicer supporting a wide range of consumer 3D printers
 - [**Pixar Renderman**](https://rmanwiki-26.pixar.com/space/REN26/19662083/Legal+Notice), a photorealistic 3D rendering software developed by Pixar, widely used in the film industry for creating high-quality visual effects and animations
 - [**PrusaSlicer**](https://github.com/prusa3d/PrusaSlicer), the slicing software developed by Prusa Research for its 3D printers
 - [**ROS - Robot Operating System**](http://docs.ros.org/en/noetic/api/behaviortree_cpp/html/json_8hpp_source.html), a set of software libraries and tools that assist in developing robot applications
 - [**UBS**](https://www.ubs.com/), a multinational financial services and banking company
@@ -161,18 +278,31 @@ the result of an internet search. If you know further customers of the library,
 - [**Acronis Cyber Protect Cloud**](https://care.acronis.com/s/article/59533-Third-party-software-used-in-Acronis-Cyber-Protect-Cloud?language=en_US), an all-in-one data protection solution that combines backup, disaster recovery, and cybersecurity to safeguard business data from threats like ransomware
 - [**Baereos**](https://gitlab.tiger-computing.co.uk/packages/bareos/-/blob/tiger/bullseye/third-party/CLI11/examples/json.cpp), a backup solution that provides data protection and recovery options for various environments, including physical and virtual systems
 - [**Bitdefender Home Scanner**](https://www.bitdefender.de/site/Main/view/home-scanner-open-source.html), a tool from Bitdefender that scans devices for malware and security threats, providing a safeguard against potential online dangers
 - [**Cisco MLS++**](https://github.com/cisco/mlspp), an implementation of the Messaging Layer Security protocol for end-to-end encrypted group messaging
 - [**Citrix Provisioning**](https://docs.citrix.com/en-us/provisioning/2203-ltsr/downloads/pvs-third-party-notices-2203.pdf), a solution that streamlines the delivery of virtual desktops and applications by allowing administrators to manage and provision resources efficiently across multiple environments
 - [**Citrix Virtual Apps and Desktops**](https://docs.citrix.com/en-us/citrix-virtual-apps-desktops/2305/downloads/third-party-notices-apps-and-desktops.pdf), a solution from Citrix that delivers virtual apps and desktops
 - [**Cyberarc**](https://docs.cyberark.com/Downloads/Legal/Privileged%20Session%20Manager%20for%20SSH%20Third-Party%20Notices.pdf), a security solution that specializes in privileged access management, enabling organizations to control and monitor access to critical systems and data, thereby enhancing overall cybersecurity posture
 - [**Deutsche Telekom sysrepo-plugins**](https://github.com/telekom/sysrepo-plugins), a collection of YANG datastore plugins used to manage network devices
 - [**Egnyte Desktop**](https://helpdesk.egnyte.com/hc/en-us/articles/360007071732-Third-Party-Software-Acknowledgements), a secure cloud storage solution designed for businesses, enabling file sharing, collaboration, and data management across teams while ensuring compliance and data protection
 - [**Elster**](https://www.secunet.com/en/about-us/press/article/elstersecure-bietet-komfortablen-login-ohne-passwort-dank-secunet-protect4use), a digital platform developed by German tax authorities for secure and efficient electronic tax filing and management using secunet protect4use
 - [**Envoy**](https://github.com/envoyproxy/envoy), a cloud-native edge and service proxy that forms the data plane of many service meshes
 - [**Ethereum Solidity**](https://github.com/ethereum/solidity), a high-level, object-oriented programming language designed for implementing smart contracts on the Ethereum platform
 - [**gVisor**](https://github.com/google/gvisor), an application kernel that provides a secure sandbox for running untrusted containers
 - [**IBM Storage Virtualize**](https://public.dhe.ibm.com/systems/support/warranty/pdfs/stgoilc/SV_for_FS_7300_v8_7_0_Base_OILC.pdf), the software powering IBM FlashSystem enterprise storage arrays
 - [**Inciga**](https://fossies.org/linux/icinga2/third-party/nlohmann_json/json.hpp), a monitoring tool for IT infrastructure, designed to provide insights into system performance and availability through customizable dashboards and alerts
 - [**Intel Accelerator Management Daemon for VMware ESXi**](https://downloadmirror.intel.com/772507/THIRD-PARTY.txt), a management tool designed for monitoring and controlling Intel hardware accelerators within VMware ESXi environments, optimizing performance and resource allocation
 - [**Juniper Identity Management Service**](https://www.juniper.net/documentation/us/en/software/jims/jims-guide/jims-guide.pdf)
 - [**Meta FBOSS**](https://github.com/facebook/fboss), the software stack that controls the network switches in Meta's data centers
 - [**Microsoft Azure IoT SDK**](https://library.e.abb.com/public/2779c5f85f30484192eb3cb3f666a201/IP%20Gateway%20Open%20License%20Declaration_9AKK108467A4095_Rev_C.pdf), a collection of tools and libraries to help developers connect, build, and deploy Internet of Things (IoT) solutions on the Azure cloud platform
 - [**Microsoft Confidential Consortium Framework**](https://github.com/microsoft/CCF), a framework for building secure, highly available applications on trusted execution environments
 - [**Microsoft WinGet**](https://github.com/microsoft/winget-cli), a command-line utility included in the Windows Package Manager
 - [**Mitsubishi Electric SECS/GEM**](https://dl.mitsubishielectric.com/dl/fa/document/manual/plc/sh082483eng/sh082483engi.pdf), the semiconductor equipment communication software running on Mitsubishi Electric C Controller and C intelligent function modules
 - [**Moxa**](https://www.moxa.com/getmedia/fbe2a0c7-8dda-4b5b-a501-15e45adebb1f/moxa-foss-statement-for-da-720-series-win-10-ltsc-21h2-declaration-v1.0.pdf), a provider of industrial networking, computing, and automation infrastructure
 - [**plexusAV**](https://www.sisme.com/media/10994/manual_plexusav-p-avn-4-form8244-c.pdf), a high-performance AV-over-IP transceiver device capable of video encoding and decoding using the IPMX standard
 - [**Pointr**](https://docs-dev.pointr.tech/docs/8.x/Developer%20Portal/Open%20Source%20Licenses/), a platform for indoor positioning and navigation solutions, offering tools and SDKs for developers to create location-based applications
 - [**secunet protect4use**](https://www.secunet.com/en/about-us/press/article/elstersecure-bietet-komfortablen-login-ohne-passwort-dank-secunet-protect4use), a secure, passwordless multifactor authentication solution that transforms smartphones into digital keyrings, ensuring high security for online services and digital identities
 - [**Sencore MRD 7000**](https://www.foccusdigital.com/wp-content/uploads/2025/03/MRD-7000-Manual-8175V.pdf), a professional multi-channel receiver and decoder supporting UHD and HD stream decoding
 - [**Siemens SINEC**](https://cache.industry.siemens.com/dl/files/917/109974917/att_1298783/v2/OSS_SINEC-NMS_99.pdf), a family of network management and infrastructure services for industrial networks
 - [**Toshiba Industrial Servers**](https://www.global.toshiba/content/dam/toshiba/jp/products-solutions/industrial/computer/product/server/fs20000r/pdf/FS20000R_OSS_License_6E8C5817_rev0.pdf), the FS20000R series of industrial servers for factory automation and control systems
 - [**Wazuh**](https://github.com/wazuh/wazuh/blob/main/src/data_provider/src/sysInfo.cpp), a security platform for threat detection, integrity monitoring and incident response
 - [**ZeroTier**](https://github.com/zerotier/ZeroTierOne/blob/dev/osdep/OSUtils.hpp), a software-defined networking service that creates virtual Ethernet networks
@@ -291,7 +291,6 @@ nav:
          - 'JSON_HAS_THREE_WAY_COMPARISON': api/macros/json_has_three_way_comparison.md
          - 'JSON_NOEXCEPTION': api/macros/json_noexception.md
          - 'JSON_NO_IO': api/macros/json_no_io.md
          - 'JSON_NO_THREAD_LOCAL': api/macros/json_no_thread_local.md
          - 'JSON_SKIP_LIBRARY_VERSION_CHECK': api/macros/json_skip_library_version_check.md
          - 'JSON_SKIP_UNSUPPORTED_COMPILER_CHECK': api/macros/json_skip_unsupported_compiler_check.md
          - 'JSON_USE_GLOBAL_UDLS': api/macros/json_use_global_udls.md
@@ -8,10 +8,11 @@
 #pragma once
 #include <algorithm> // find_if
 #include <cstddef>
 #include <string> // string
 #include <type_traits> // enable_if_t
-#include <utility> // move
+#include <utility> // move, pair
 #include <vector> // vector
 #include <nlohmann/detail/exceptions.hpp>
@@ -249,7 +250,7 @@ class json_sax_dom_parser
        if (JSON_HEDLEY_UNLIKELY(len != detail::unknown_size() && len > ref_stack.back()->max_size()))
        {
-            JSON_THROW(out_of_range::create(408, concat("excessive object size: ", std::to_string(len)), ref_stack.back()));
+            return parse_error(0, "", out_of_range::create(408, concat("excessive object size: ", std::to_string(len)), ref_stack.back()));
        }
        return true;
@@ -298,7 +299,7 @@ class json_sax_dom_parser
        if (JSON_HEDLEY_UNLIKELY(len != detail::unknown_size() && len > ref_stack.back()->max_size()))
        {
-            JSON_THROW(out_of_range::create(408, concat("excessive array size: ", std::to_string(len)), ref_stack.back()));
+            return parse_error(0, "", out_of_range::create(408, concat("excessive array size: ", std::to_string(len)), ref_stack.back()));
        }
        return true;
@@ -568,7 +569,7 @@ class json_sax_dom_callback_parser
            // check object limit
            if (JSON_HEDLEY_UNLIKELY(len != detail::unknown_size() && len > ref_stack.back()->max_size()))
            {
-                JSON_THROW(out_of_range::create(408, concat("excessive object size: ", std::to_string(len)), ref_stack.back()));
+                return parse_error(0, "", out_of_range::create(408, concat("excessive object size: ", std::to_string(len)), ref_stack.back()));
            }
        }
        return true;
@@ -585,7 +586,17 @@ class json_sax_dom_callback_parser
        // add discarded value at the given key and store the reference for later
        if (keep && ref_stack.back())
        {
-            object_element = &(ref_stack.back()->m_data.m_value.object->operator[](val) = discarded);
+            auto& obj = *ref_stack.back()->m_data.m_value.object;
            const auto it = obj.find(val);
            if (it != obj.end())
            {
                // this is a duplicate key (legal in JSON); remember its
                // current value so it can be restored later if the new
                // value is rejected by the callback, instead of being
                // erased together with the discarded placeholder
                duplicate_key_stash.emplace_back(&(it->second), it->second);
            }
            object_element = &(obj[val] = discarded);
        }
        return true;
@@ -597,13 +608,18 @@ class json_sax_dom_callback_parser
        {
            if (!callback(static_cast<int>(ref_stack.size()) - 1, parse_event_t::object_end, *ref_stack.back()))
            {
-                // discard object
+                // discard object, unless this slot holds a duplicate key's
-                *ref_stack.back() = discarded;
+                // previous value pending restoration, in which case that
                // value is restored instead of being discarded
                if (!resolve_duplicate_key_stash(ref_stack.back(), true))
                {
                    *ref_stack.back() = discarded;
 #if JSON_DIAGNOSTIC_POSITIONS
-                // Set start/end positions for discarded object.
+                    // Set start/end positions for discarded object.
-                handle_diagnostic_positions_for_json_value(*ref_stack.back());
+                    handle_diagnostic_positions_for_json_value(*ref_stack.back());
 #endif
                }
            }
            else
            {
@@ -617,6 +633,10 @@ class json_sax_dom_callback_parser
 #endif
                ref_stack.back()->set_parents();
                // this object is finally, definitively kept; drop any
                // pending duplicate-key stash entry for its slot since it
                // can no longer be restored
                resolve_duplicate_key_stash(ref_stack.back(), false);
            }
        }
@@ -659,7 +679,7 @@ class json_sax_dom_callback_parser
            // check array limit
            if (JSON_HEDLEY_UNLIKELY(len != detail::unknown_size() && len > ref_stack.back()->max_size()))
            {
-                JSON_THROW(out_of_range::create(408, concat("excessive array size: ", std::to_string(len)), ref_stack.back()));
+                return parse_error(0, "", out_of_range::create(408, concat("excessive array size: ", std::to_string(len)), ref_stack.back()));
            }
        }
@@ -686,16 +706,25 @@ class json_sax_dom_callback_parser
 #endif
                ref_stack.back()->set_parents();
                // this array is finally, definitively kept; drop any
                // pending duplicate-key stash entry for its slot since it
                // can no longer be restored
                resolve_duplicate_key_stash(ref_stack.back(), false);
            }
            else
            {
-                // discard array
+                // discard array, unless this slot holds a duplicate key's
-                *ref_stack.back() = discarded;
+                // previous value pending restoration, in which case that
                // value is restored instead of being discarded
                if (!resolve_duplicate_key_stash(ref_stack.back(), true))
                {
                    *ref_stack.back() = discarded;
 #if JSON_DIAGNOSTIC_POSITIONS
-                // Set start/end positions for discarded array.
+                    // Set start/end positions for discarded array.
-                handle_diagnostic_positions_for_json_value(*ref_stack.back());
+                    handle_diagnostic_positions_for_json_value(*ref_stack.back());
 #endif
                }
            }
        }
@@ -809,14 +838,48 @@ class json_sax_dom_callback_parser
    }
 #endif
-    /// remove the discarded value the callback rejected from its parent
+    /// if there is a pending duplicate-key stash entry for this exact slot,
-    static void remove_discarded_value(BasicJsonType& parent)
+    /// remove it from the stash; if restore_value is true, the stashed
    /// previous value is moved back into the slot first (use this when the
    /// new value at that slot was rejected); otherwise the stash entry is
    /// simply dropped (use this when the new value was accepted, so it
    /// correctly supersedes the old one and no restore should ever happen
    /// for this slot again)
    /// @return whether a matching stash entry was found (and processed)
    bool resolve_duplicate_key_stash(BasicJsonType* slot, bool restore_value)
    {
        const auto it = std::find_if(duplicate_key_stash.begin(), duplicate_key_stash.end(),
                                     [slot](const std::pair<BasicJsonType*, BasicJsonType>& entry)
        {
            return entry.first == slot;
        });
        if (it == duplicate_key_stash.end())
        {
            return false;
        }
        if (restore_value)
        {
            *slot = std::move(it->second);
        }
        duplicate_key_stash.erase(it);
        return true;
    }
    /// remove the discarded value the callback rejected from its parent,
    /// unless it is a duplicate key's slot with a stashed previous value,
    /// in which case that previous value is restored instead
    void remove_discarded_value(BasicJsonType& parent)
    {
        for (auto it = parent.begin(); it != parent.end(); ++it)
        {
            if (it->is_discarded())
            {
-                parent.erase(it);
+                if (!resolve_duplicate_key_stash(&(*it), true))
                {
                    parent.erase(it);
                }
                break;
            }
        }
@@ -914,6 +977,16 @@ class json_sax_dom_callback_parser
        JSON_ASSERT(object_element);
        *object_element = std::move(value);
        if (!skip_callback)
        {
            // this scalar value finally, definitively replaces whatever was
            // at this slot; drop any pending duplicate-key stash entry for
            // it since it can no longer be restored (a container value at
            // this slot is resolved later, in end_object()/end_array(),
            // since skip_callback is true for the placeholder handling that
            // happens here for those)
            resolve_duplicate_key_stash(object_element, false);
        }
        return {true, object_element};
    }
@@ -927,6 +1000,12 @@ class json_sax_dom_callback_parser
    std::vector<bool> key_keep_stack {}; // NOLINT(readability-redundant-member-init)
    /// helper to hold the reference for the next object element
    BasicJsonType* object_element = nullptr;
    /// stash of (slot pointer, previous value) for object members that
    /// already existed when key() was called again for the same key
    /// (duplicate keys); used to restore the previous value if the new
    /// value is later rejected by the callback, instead of erasing the
    /// member entirely
    std::vector<std::pair<BasicJsonType*, BasicJsonType>> duplicate_key_stash {};
    /// whether a syntax error occurred
    bool errored = false;
    /// callback function
@@ -186,15 +186,6 @@
    #define JSON_NO_UNIQUE_ADDRESS
 #endif
 // Clang targeting MinGW does not survive the thread_local storage the copy
 // constructor uses to bound its descent: every test that copies a value
 // segfaults with clang 11.0.1 and clang 18.1.8, while the same tests pass with
 // GCC targeting MinGW and with every other toolchain the library is tested on.
 // Copying works the same way without the counter, only more slowly.
 #if !defined(JSON_NO_THREAD_LOCAL) && defined(__clang__) && defined(__MINGW32__)
    #define JSON_NO_THREAD_LOCAL 1
 #endif
 // disable documentation warnings on clang
 #if defined(__clang__)
    #pragma clang diagnostic push
@@ -9,9 +9,12 @@
 #pragma once
 #include <array> // array
 #include <cmath> // isnan, ldexp, trunc
 #include <cstddef> // size_t
 #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
@@ -114,5 +117,67 @@ inline bool operator<(const value_t lhs, const value_t rhs) noexcept
 }
 #endif
 /*!
@brief compare an integer with a floating point number without precision loss
 Widening the integer to the floating point type loses precision beyond the
 float's mantissa, which makes equality intransitive: both 2^63-2 and 2^63-1
 round to 2^63, so each compares equal to that float while differing from each
 other. Ordering built on that is not a strict weak ordering, so sorting such
 values, or using them as keys in an ordered container, is undefined behavior.
 Returns a value to be compared against zero with the original operator, which
 reproduces the exact ordering. A NaN operand is returned as is, so comparing it
 against zero keeps NaN's semantics: false for the relational operators and
 unordered for `<=>`.
 */
 template<typename IntegerType, typename FloatType>
 FloatType compare_integer_with_float(const IntegerType i, const FloatType f) noexcept
 {
    const auto ordered = [](int c) noexcept
    {
        return static_cast<FloatType>(c);
    };
    if (std::isnan(f))
    {
        return f;
    }
    // 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);
    if (f >= bound)
    {
        return ordered(-1);
    }
    if (std::is_signed<IntegerType>::value ? (f < -bound) : (f < static_cast<FloatType>(0)))
    {
        return ordered(1);
    }
    // f is now within the integer's range, so truncating it is exact
    const FloatType truncated = std::trunc(f);
    const auto as_integer = static_cast<IntegerType>(truncated);
    if (i != as_integer)
    {
        return ordered(i < as_integer ? -1 : 1);
    }
    // the integer parts agree, so any fractional part decides
    const FloatType fraction = f - truncated;
    if (fraction > static_cast<FloatType>(0))
    {
        return ordered(-1);
    }
    if (fraction < static_cast<FloatType>(0))
    {
        return ordered(1);
    }
    return ordered(0);
 }
 }  // namespace detail
 NLOHMANN_JSON_NAMESPACE_END
@@ -28,14 +28,14 @@
    #pragma GCC diagnostic ignored "-Wignored-attributes"
 #endif
-#include <algorithm> // all_of, find, for_each, none_of
+#include <algorithm> // all_of, find, for_each
 #include <cstddef> // nullptr_t, ptrdiff_t, size_t
 #include <functional> // hash, less
 #include <initializer_list> // initializer_list
 #ifndef JSON_NO_IO
    #include <iosfwd> // istream, ostream
 #endif  // JSON_NO_IO
-#include <iterator> // make_move_iterator, random_access_iterator_tag
+#include <iterator> // random_access_iterator_tag
 #include <memory> // unique_ptr
 #include <string> // string, stoi, to_string
 #include <utility> // declval, forward, move, pair, swap
@@ -821,623 +821,6 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
        return j;
    }
 #ifndef JSON_NO_THREAD_LOCAL
    /// the number of levels an operation descends into before it finishes the
    /// value below it without the call stack
    static constexpr std::uint8_t nesting_depth_limit()
    {
        return 128;
    }
    /*!
    @brief how many levels the operation going on in this thread has descended into
    Copying a value and comparing two values share this count. The library never
    nests one inside the other - copying a value does not compare one, and
    comparing two values does not copy them - and where user code nests them
    anyway, sharing the count only ends a descent sooner than it had to, which
    costs a little speed and is never wrong.
    A byte is enough: the count never exceeds the limit by more than the single
    level that notices the limit has been reached.
    */
    static std::uint8_t& nesting_depth() noexcept
    {
        static thread_local std::uint8_t depth = 0; // NOLINT(misc-use-internal-linkage)
        return depth;
    }
 #endif
    /*!
    @brief whether a descent must stop here and finish without the call stack
    @a may_descend says whether the operator descends at all; it is a constant
    at every call site, and is passed rather than tested by the caller so that
    the test does not become a constant condition there, which MSVC reports as
    C4127.
    The comparison operators use this rather than @ref nesting_depth_guard::okay,
    because they are written as a macro and a macro cannot use the preprocessor
    the way the guard's constructor does; @ref copy_structured, which can, asks
    the guard instead and never calls this.
    */
    static bool nesting_depth_exhausted(bool may_descend = true) noexcept
    {
 #ifdef JSON_NO_THREAD_LOCAL
        // without a count of its own per thread, a descent cannot be bounded
        // without racing another one, so none is made
        static_cast<void>(may_descend);
        return true;
 #else
        return !may_descend || nesting_depth() >= nesting_depth_limit();
 #endif
    }
    /*!
    @brief counts one level of a bounded descent for as long as it runs, and
           reports whether the descent was still within the limit when it began
    Looks the count up and tests it against the limit itself, rather than
    leaving that to the caller: either way it is reached exactly once, so
    there is nothing to be gained by making the caller do it.
    Does nothing and is never @ref okay without thread-local storage, where no
    descent can be bounded at all: a caller that only descends while this says
    it may always ends up finishing without the call stack, exactly as if every
    value were nested past the limit.
    */
    class nesting_depth_guard
    {
      public:
        nesting_depth_guard() noexcept
 #ifdef JSON_NO_THREAD_LOCAL
            : m_okay(false)
 #else
            : m_okay(nesting_depth() < nesting_depth_limit())
 #endif
        {
 #ifndef JSON_NO_THREAD_LOCAL
            ++nesting_depth();
 #endif
        }
        ~nesting_depth_guard()
        {
 #ifndef JSON_NO_THREAD_LOCAL
            --nesting_depth();
 #endif
        }
        nesting_depth_guard(const nesting_depth_guard&) = delete;
        nesting_depth_guard& operator=(const nesting_depth_guard&) = delete;
        nesting_depth_guard(nesting_depth_guard&&) = delete;
        nesting_depth_guard& operator=(nesting_depth_guard&&) = delete;
        bool okay() const noexcept
        {
            return m_okay;
        }
      private:
        bool m_okay;
    };
    /// an entry of the iterative deep copy's worklist: a structured value and
    /// the value that is to become its copy
    using copy_worklist_t = std::vector<std::pair<const basic_json*, basic_json*>>;
    /// scratch space to build the key skeleton of an object copy in one go
    using copy_scratch_t = std::vector<std::pair<typename object_t::key_type, basic_json>>;
    /// @brief copy everything of @a src into @a dst but its type and value
    static void copy_metadata(const basic_json& src, basic_json& dst)
    {
        // a custom base class is only required to be copy-constructible and
        // move-assignable, so the copy has to go through a temporary
        static_cast<json_base_class_t&>(dst) = json_base_class_t(static_cast<const json_base_class_t&>(src));
 #if JSON_DIAGNOSTIC_POSITIONS
        dst.start_position = src.start_position;
        dst.end_position = src.end_position;
 #else
        static_cast<void>(src);
        static_cast<void>(dst);
 #endif
    }
    /*!
    @brief copy the value of @a src into @a dst, which must not be structured
    Objects and arrays are left alone: creating those is the one thing the copy
    constructor and @ref copy_shallow do differently from one another, and it is
    the reason copying a value can descend at all.
    */
    /// @note inlined on purpose: both callers have already told an object or an
    ///       array apart from the rest, and letting the compiler fold that test
    ///       into this switch is worth a few percent when copying a value made
    ///       mostly of numbers
    JSON_HEDLEY_ALWAYS_INLINE
    static void copy_leaf_value(const basic_json& src, basic_json& dst)
    {
        switch (src.m_data.m_type)
        {
            case value_t::string:
            {
                dst.m_data.m_value = *src.m_data.m_value.string;
                break;
            }
            case value_t::binary:
            {
                dst.m_data.m_value = *src.m_data.m_value.binary;
                break;
            }
            case value_t::boolean:
            {
                dst.m_data.m_value = src.m_data.m_value.boolean;
                break;
            }
            case value_t::number_integer:
            {
                dst.m_data.m_value = src.m_data.m_value.number_integer;
                break;
            }
            case value_t::number_unsigned:
            {
                dst.m_data.m_value = src.m_data.m_value.number_unsigned;
                break;
            }
            case value_t::number_float:
            {
                dst.m_data.m_value = src.m_data.m_value.number_float;
                break;
            }
            case value_t::object:
            case value_t::array:
            case value_t::null:
            case value_t::discarded:
            default:
                break;
        }
    }
    /*!
    @brief copy everything of @a src into the null value @a dst but the children
    Objects and arrays are not copied here; they are appended to @a worklist to
    be created later by @ref copy_iteratively. Until that happens, @a dst remains
    a null value, so that a partially built copy can be destroyed at any point
    without ever violating the class invariants.
    */
    static void copy_shallow(const basic_json& src, basic_json& dst, copy_worklist_t& worklist)
    {
        copy_metadata(src, dst);
        if (src.m_data.m_type == value_t::object || src.m_data.m_type == value_t::array)
        {
            // defer: dst stays a null value until its container exists
            worklist.emplace_back(&src, &dst);
            return;
        }
        copy_leaf_value(src, dst);
        // only now that the value exists may the type be set: had the creation
        // of the value thrown, dst would have been left as a valid null value
        dst.m_data.m_type = src.m_data.m_type;
    }
    /// @brief create the copy of the array @a src in @a dst
    /// @note structured elements are appended to @a worklist instead
    static void copy_array_level(const basic_json& src, basic_json& dst, copy_worklist_t& worklist)
    {
        const array_t& src_array = *src.m_data.m_value.array;
        // create all elements up front: growing the array afterwards could
        // invalidate the pointers that are handed to the worklist
        dst.m_data.m_value.array = create<array_t>(src_array.size(), basic_json());
        auto dst_it = dst.m_data.m_value.array->begin();
        for (auto src_it = src_array.cbegin(); src_it != src_array.cend(); ++src_it, ++dst_it)
        {
            copy_shallow(*src_it, *dst_it, worklist);
        }
    }
    /// @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,
                                  copy_worklist_t& worklist, copy_scratch_t& scratch)
    {
        const object_t& src_object = *src.m_data.m_value.object;
        // build the complete key skeleton and hand it to the object's range
        // constructor: adding the keys one by one would be quadratic for object
        // types that are backed by a vector, such as nlohmann::ordered_map
        scratch.clear();
        scratch.reserve(src_object.size());
        for (const auto& element : src_object)
        {
            scratch.emplace_back(element.first, basic_json());
        }
        dst.m_data.m_value.object = create<object_t>(std::make_move_iterator(scratch.begin()),
                                    std::make_move_iterator(scratch.end()));
        scratch.clear();
        // pair every value of the copy with its counterpart in the original;
        // both are enumerated in the same order for every object type with a
        // deterministic order, so the lookup is only needed for exotic ones
        auto src_it = src_object.cbegin();
        for (auto& element : *dst.m_data.m_value.object)
        {
            if (JSON_HEDLEY_LIKELY(src_it != src_object.cend() && src_it->first == element.first))
            {
                copy_shallow(src_it->second, element.second, worklist);
                ++src_it;
            }
            else
            {
                const auto found = src_object.find(element.first);
                JSON_ASSERT(found != src_object.cend());
                copy_shallow(found->second, element.second, worklist);
            }
        }
    }
    /*!
    @brief deep-copy the object or array @a src into this value without recursing
    The values whose copy has not been created yet are kept on an explicit
    worklist rather than on the call stack. This is only reached for values
    nested deeper than @ref nesting_depth_limit levels, which is why it copies
    every container by hand instead of letting the container do it: the fast
    ways of doing so would descend into the elements and defeat the purpose.
    */
    void copy_iteratively(const basic_json& src)
    {
        copy_worklist_t worklist;
        copy_scratch_t scratch;
        const basic_json* src_value = &src;
        basic_json* dst_value = this;
        for (;;)
        {
            if (src_value->m_data.m_type == value_t::array)
            {
                copy_array_level(*src_value, *dst_value, worklist);
            }
            else
            {
                copy_object_level(*src_value, *dst_value, worklist, scratch);
            }
            // the container is complete and will not be modified again
            dst_value->set_parents();
            if (worklist.empty())
            {
                break;
            }
            const auto& next = worklist.back();
            src_value = next.first;
            dst_value = next.second;
            worklist.pop_back();
            // the value stops being a null value exactly here
            dst_value->m_data.m_type = src_value->m_data.m_type;
        }
    }
    /*!
    @brief copy one level of the object or array @a src into this value
    The container copies its own elements, which is the fastest way to fill it.
    Every element that is structured itself comes back to @ref copy_structured.
    */
    void copy_level(const basic_json& src)
    {
        if (m_data.m_type == value_t::object)
        {
            m_data.m_value = *src.m_data.m_value.object;
        }
        else
        {
            m_data.m_value = *src.m_data.m_value.array;
        }
        set_parents();
    }
    /*!
    @brief deep-copy the object or array @a src into this value
    Copying a container copies its elements, so a value nested deeply enough
    used to exhaust the call stack. The descent is bounded here: the first
    @ref nesting_depth_limit levels are copied by the containers themselves, just
    as they always were, and anything below that is copied without the call
    stack by @ref copy_iteratively. Copying a value can therefore no longer
    exhaust the stack, however deeply it is nested, just like destroying one
    cannot since #1436.
    Nothing has to be scanned or built by hand to reach that: a value that is
    not nested deeper than the limit - all but a vanishing minority - is copied
    exactly as it was before, and this whole detour costs it one counter.
    @sa https://github.com/nlohmann/json/issues/5387
    */
    void copy_structured(const basic_json& src)
    {
        const nesting_depth_guard guard;
        if (JSON_HEDLEY_LIKELY(guard.okay()))
        {
            copy_level(src);
            return;
        }
        // Finish this value without descending any further. It is completed
        // before this returns, so a copy made by a custom base class - or by
        // anything else that runs while a copy is going on - is unaffected by
        // the copy it is nested in.
        copy_iteratively(src);
    }
    /// the result of comparing two values, including values that cannot be
    /// ordered at all, such as a discarded value or a NaN
    enum class compare_result { less, equal, greater, unordered };
 #if JSON_HAS_THREE_WAY_COMPARISON
    /// @brief the ordering that @a result stands for
    static std::partial_ordering to_partial_ordering(compare_result result) noexcept // *NOPAD*
    {
        switch (result)
        {
            case compare_result::less:
                return std::partial_ordering::less;
            case compare_result::greater:
                return std::partial_ordering::greater;
            case compare_result::equal:
                return std::partial_ordering::equivalent;
            case compare_result::unordered:
            default:
                return std::partial_ordering::unordered;
        }
    }
 #endif
    /*!
    @brief compare two values that are not both an array or both an object
    Such a pair is compared by the operators themselves, which cannot descend
    into it and therefore cannot recurse.
    That holds for a pair whose types differ as much as for a pair of leaves: an
    array and an object are told apart by their types alone, because an operator
    only ever descends into two values of the same type. So `==` reports them as
    unequal without looking inside either, and an ordering falls back to the
    order of the types - an object sorts before an array - exactly as it does
    for a value that is not nested deeply enough to get here.
    */
    template<bool Ordered>
    static compare_result compare_leaves(const_reference lhs, const_reference rhs) noexcept
    {
        if (lhs == rhs)
        {
            return compare_result::equal;
        }
        return order_leaves(lhs, rhs, std::integral_constant<bool, Ordered> {});
    }
    /*!
    @brief compare two object keys
    An object compares its entries as pairs of a key and a value, so its keys
    are compared exactly as std::pair compares them: with < where the objects
    are being ordered, and with == where they are only checked for equality.
    Note that this is not the object's own comparator, which for a vector-backed
    object type such as nlohmann::ordered_map tells equality rather than order.
    */
    static compare_result compare_keys(const typename object_t::key_type& lhs,
                                       const typename object_t::key_type& rhs,
                                       std::true_type /*ordered*/)
    {
        if (lhs < rhs)
        {
            return compare_result::less;
        }
        if (rhs < lhs)
        {
            return compare_result::greater;
        }
        return compare_result::equal;
    }
    /// @brief check two object keys for equality
    static compare_result compare_keys(const typename object_t::key_type& lhs,
                                       const typename object_t::key_type& rhs,
                                       std::false_type /*ordered*/)
    {
        return lhs == rhs ? compare_result::equal : compare_result::unordered;
    }
    /// @brief tell apart two values that are not equal
    /// @note only instantiated where the values are being ordered, as a key or
    ///       string type is not required to be ordered to be compared for equality
    static compare_result order_leaves(const_reference lhs, const_reference rhs, std::true_type /*ordered*/) noexcept
    {
        if (lhs < rhs)
        {
            return compare_result::less;
        }
        if (rhs < lhs)
        {
            return compare_result::greater;
        }
        return compare_result::unordered;
    }
    /// @brief report two values as not equal without ordering them
    static compare_result order_leaves(const_reference /*lhs*/, const_reference /*rhs*/, std::false_type /*ordered*/) noexcept
    {
        return compare_result::unordered;
    }
    /*!
    @brief compare @a lhs and @a rhs without descending into them
    Reached once a comparison has descended @ref nesting_depth_limit levels, so
    that comparing values cannot exhaust the call stack however deeply they are
    nested. The two values are walked in lockstep on an explicit stack and
    compared lexicographically, element by element in the order the containers
    enumerate them - which is how the container types this library ships compare
    themselves: a std::map enumerates its entries in key order, and
    nlohmann::ordered_map in insertion order. An object type that enumerates its
    entries in an unspecified order, such as std::unordered_map, compares them
    pairwise instead; the difference could only ever show below the bound.
    Note that the stack this walks with is allocated, while the comparison
    operators are noexcept and the container comparison this replaces allocated
    nothing. Failing that allocation therefore ends the process rather than
    throwing. It only arises for values nested past the bound, and only when
    memory has run out - where the same comparison used to exhaust the call
    stack instead - but it is a way to fail that the operators did not have.
    */
    template<bool Ordered>
    static compare_result compare_iteratively(const_reference lhs, const_reference rhs,
            const bool unordered_compares_equal) noexcept
    {
        /// a pair of containers being compared in lockstep
        struct frame
        {
            const basic_json* lhs_value{nullptr};
            const basic_json* rhs_value{nullptr};
            typename array_t::const_iterator lhs_array_it{};
            typename array_t::const_iterator rhs_array_it{};
            typename object_t::const_iterator lhs_object_it{};
            typename object_t::const_iterator rhs_object_it{};
        };
        std::vector<frame> stack;
        const basic_json* left = &lhs;
        const basic_json* right = &rhs;
        for (;;)
        {
            const auto type = left->m_data.m_type;
            if (type == right->m_data.m_type && (type == value_t::array || type == value_t::object))
            {
                // descend: the elements decide, and are compared further down
                stack.emplace_back();
                frame& pushed = stack.back();
                pushed.lhs_value = left;
                pushed.rhs_value = right;
                if (type == value_t::array)
                {
                    pushed.lhs_array_it = left->m_data.m_value.array->cbegin();
                    pushed.rhs_array_it = right->m_data.m_value.array->cbegin();
                }
                else
                {
                    pushed.lhs_object_it = left->m_data.m_value.object->cbegin();
                    pushed.rhs_object_it = right->m_data.m_value.object->cbegin();
                }
            }
            else
            {
                const compare_result result = compare_leaves<Ordered>(*left, *right);
                // Values that cannot be ordered - a NaN, say - end an ordered
                // comparison for std::lexicographical_compare_three_way, but
                // std::lexicographical_compare treats them as equivalent and
                // carries on with the next element. Both are reproduced here,
                // so that a value nested too deeply to descend into compares
                // exactly as one that is not.
                if (result != compare_result::equal &&
                        !(unordered_compares_equal && result == compare_result::unordered))
                {
                    return result;
                }
            }
            // walk back up past the containers that are exhausted, then take the
            // next pair of elements from the innermost one that is not
            for (;;)
            {
                if (stack.empty())
                {
                    return compare_result::equal;
                }
                frame& current = stack.back();
                const bool is_object = current.lhs_value->m_data.m_type == value_t::object;
                const bool lhs_done = is_object
                                      ? current.lhs_object_it == current.lhs_value->m_data.m_value.object->cend()
                                      : current.lhs_array_it == current.lhs_value->m_data.m_value.array->cend();
                const bool rhs_done = is_object
                                      ? current.rhs_object_it == current.rhs_value->m_data.m_value.object->cend()
                                      : current.rhs_array_it == current.rhs_value->m_data.m_value.array->cend();
                if (lhs_done || rhs_done)
                {
                    // whichever ran out first holds the smaller container; if
                    // both did, they are equal and the container above decides
                    if (lhs_done != rhs_done)
                    {
                        return lhs_done ? compare_result::less : compare_result::greater;
                    }
                    stack.pop_back();
                    continue;
                }
                if (is_object)
                {
                    // an entry is a key and a value, and the key decides first
                    const compare_result key_result =
                        compare_keys(current.lhs_object_it->first, current.rhs_object_it->first,
                                     std::integral_constant<bool, Ordered> {});
                    if (key_result != compare_result::equal)
                    {
                        return key_result;
                    }
                    left = &(current.lhs_object_it->second);
                    right = &(current.rhs_object_it->second);
                    ++current.lhs_object_it;
                    ++current.rhs_object_it;
                }
                else
                {
                    left = &(*current.lhs_array_it);
                    right = &(*current.rhs_array_it);
                    ++current.lhs_array_it;
                    ++current.rhs_array_it;
                }
                break;
            }
        }
    }
  public:
    //////////////////////////
    // JSON parser callback //
@@ -1817,15 +1200,60 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
        // check of passed value is valid
        other.assert_invariant();
-        if (m_data.m_type == value_t::object || m_data.m_type == value_t::array)
+        switch (m_data.m_type)
        {
-            // copying the container directly would call this constructor again
+            case value_t::object:
-            // for every element, once per nesting level
+            {
-            copy_structured(other);
+                m_data.m_value = *other.m_data.m_value.object;
-        }
+                break;
-        else
+            }
-        {
+
-            copy_leaf_value(other, *this);
+            case value_t::array:
            {
                m_data.m_value = *other.m_data.m_value.array;
                break;
            }
            case value_t::string:
            {
                m_data.m_value = *other.m_data.m_value.string;
                break;
            }
            case value_t::boolean:
            {
                m_data.m_value = other.m_data.m_value.boolean;
                break;
            }
            case value_t::number_integer:
            {
                m_data.m_value = other.m_data.m_value.number_integer;
                break;
            }
            case value_t::number_unsigned:
            {
                m_data.m_value = other.m_data.m_value.number_unsigned;
                break;
            }
            case value_t::number_float:
            {
                m_data.m_value = other.m_data.m_value.number_float;
                break;
            }
            case value_t::binary:
            {
                m_data.m_value = *other.m_data.m_value.binary;
                break;
            }
            case value_t::null:
            case value_t::discarded:
            default:
                break;
        }
        set_parents();
@@ -4145,6 +3573,7 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
        {
            using std::swap;
            swap(*(m_data.m_value.array), other);
            set_parents();
        }
        else
        {
@@ -4161,6 +3590,7 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
        {
            using std::swap;
            swap(*(m_data.m_value.object), other);
            set_parents();
        }
        else
        {
@@ -4233,7 +3663,7 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
    // because any negative signed value is smaller than any unsigned value.
    // Otherwise, the non-negative signed value is cast to unsigned before the
    // comparison to avoid wraparound.
-#define JSON_IMPLEMENT_OPERATOR(op, null_result, unordered_result, default_result, deep_result, may_descend) \
+#define JSON_IMPLEMENT_OPERATOR(op, null_result, unordered_result, default_result)                       \
    const auto lhs_type = lhs.type();                                                                    \
    const auto rhs_type = rhs.type();                                                                    \
    \
@@ -4242,25 +3672,11 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
        switch (lhs_type)                                                                                \
        {                                                                                                \
            case value_t::array:                                                                         \
            {                                                                                            \
                if (JSON_HEDLEY_UNLIKELY(nesting_depth_exhausted(may_descend)))                        \
                {                                                                                        \
                    return (deep_result);                                                                \
                }                                                                                        \
                const nesting_depth_guard guard;                                                         \
                return (*lhs.m_data.m_value.array) op (*rhs.m_data.m_value.array);                                     \
-            }                                                                                            \
+                \
            \
            case value_t::object:                                                                        \
            {                                                                                            \
                if (JSON_HEDLEY_UNLIKELY(nesting_depth_exhausted(may_descend)))                        \
                {                                                                                        \
                    return (deep_result);                                                                \
                }                                                                                        \
                const nesting_depth_guard guard;                                                         \
                return (*lhs.m_data.m_value.object) op (*rhs.m_data.m_value.object);                                   \
-            }                                                                                            \
+                \
            \
            case value_t::null:                                                                          \
                return (null_result);                                                                    \
                \
@@ -4289,19 +3705,19 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
    }                                                                                                    \
    else if (lhs_type == value_t::number_integer && rhs_type == value_t::number_float)                   \
    {                                                                                                    \
-        return static_cast<number_float_t>(lhs.m_data.m_value.number_integer) op rhs.m_data.m_value.number_float;      \
+        return (detail::compare_integer_with_float(lhs.m_data.m_value.number_integer, rhs.m_data.m_value.number_float)) op (static_cast<number_float_t>(0)); \
    }                                                                                                    \
    else if (lhs_type == value_t::number_float && rhs_type == value_t::number_integer)                   \
    {                                                                                                    \
-        return lhs.m_data.m_value.number_float op static_cast<number_float_t>(rhs.m_data.m_value.number_integer);      \
+        return (static_cast<number_float_t>(0)) op (detail::compare_integer_with_float(rhs.m_data.m_value.number_integer, lhs.m_data.m_value.number_float)); \
    }                                                                                                    \
    else if (lhs_type == value_t::number_unsigned && rhs_type == value_t::number_float)                  \
    {                                                                                                    \
-        return static_cast<number_float_t>(lhs.m_data.m_value.number_unsigned) op rhs.m_data.m_value.number_float;     \
+        return (detail::compare_integer_with_float(lhs.m_data.m_value.number_unsigned, rhs.m_data.m_value.number_float)) op (static_cast<number_float_t>(0)); \
    }                                                                                                    \
    else if (lhs_type == value_t::number_float && rhs_type == value_t::number_unsigned)                  \
    {                                                                                                    \
-        return lhs.m_data.m_value.number_float op static_cast<number_float_t>(rhs.m_data.m_value.number_unsigned);     \
+        return (static_cast<number_float_t>(0)) op (detail::compare_integer_with_float(rhs.m_data.m_value.number_unsigned, lhs.m_data.m_value.number_float)); \
    }                                                                                                    \
    else if (lhs_type == value_t::number_unsigned && rhs_type == value_t::number_integer)                \
    {                                                                                                    \
@@ -4360,8 +3776,7 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
 #pragma GCC diagnostic ignored "-Wfloat-equal"
 #endif
        const_reference lhs = *this;
-        JSON_IMPLEMENT_OPERATOR( ==, true, false, false,
+        JSON_IMPLEMENT_OPERATOR( ==, true, false, false)
                                 compare_iteratively<false>(lhs, rhs, false) == compare_result::equal, true)
 #ifdef __GNUC__
 #pragma GCC diagnostic pop
 #endif
@@ -4386,8 +3801,7 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
        JSON_IMPLEMENT_OPERATOR(<=>, // *NOPAD*
                                std::partial_ordering::equivalent,
                                std::partial_ordering::unordered,
-                                lhs_type <=> rhs_type, // *NOPAD*
+                                lhs_type <=> rhs_type) // *NOPAD*
                                to_partial_ordering(compare_iteratively<true>(lhs, rhs, false)), true)
    }
    /// @brief comparison: 3-way
@@ -4454,8 +3868,7 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
 #pragma GCC diagnostic push
 #pragma GCC diagnostic ignored "-Wfloat-equal"
 #endif
-        JSON_IMPLEMENT_OPERATOR( ==, true, false, false,
+        JSON_IMPLEMENT_OPERATOR( ==, true, false, false)
                                 compare_iteratively<false>(lhs, rhs, false) == compare_result::equal, true)
 #ifdef __GNUC__
 #pragma GCC diagnostic pop
 #endif
@@ -4511,8 +3924,7 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
        // default_result is used if we cannot compare values. In that case,
        // we compare types. Note we have to call the operator explicitly,
        // because MSVC has problems otherwise.
-        JSON_IMPLEMENT_OPERATOR( <, false, false, operator<(lhs_type, rhs_type),
+        JSON_IMPLEMENT_OPERATOR( <, false, false, operator<(lhs_type, rhs_type))
                                 compare_iteratively<true>(lhs, rhs, true) == compare_result::less, false)
    }
    /// @brief comparison: less than
@@ -5718,19 +5130,17 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
                // We now reached the end of at least one array
                // in a second pass, traverse the remaining elements
-                // remove my remaining elements
+                // remove my remaining elements, highest index first; appending
-                const auto end_index = static_cast<difference_type>(result.size());
+                // in that order avoids the quadratic reinsertion done before
-                while (i < source.size())
+                for (std::size_t j = source.size(); j > i; --j)
                {
-                    // add operations in reverse order to avoid invalid
+                    result.push_back(object(
                    // indices
                    result.insert(result.begin() + end_index, object(
                    {
                        {"op", "remove"},
-                        {"path", detail::concat<string_t>(path, '/', detail::to_string<string_t>(i))}
+                        {"path", detail::concat<string_t>(path, '/', detail::to_string<string_t>(j - 1))}
                    }));
                    ++i;
                }
                i = source.size();
                // add other remaining elements
                while (i < target.size())
@@ -5749,34 +5159,130 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
            case value_t::object:
            {
-                // first pass: traverse this object's elements
+                // first pass: find keys that were deleted (i.e., in source but
                // not in target), and record the keys common to both, in
                // source's iteration order -- this is a by-product of the
                // target.find() call already needed to detect removed keys,
                // so it adds no extra lookups.
                std::vector<typename object_t::key_type> common_keys_source_order;
                for (auto it = source.cbegin(); it != source.cend(); ++it)
                {
-                    // escape the key name to be used in a JSON patch
+                    if (target.find(it.key()) == target.end())
                    const auto path_key = detail::concat<string_t>(path, '/', detail::escape(it.key()));
                    if (target.find(it.key()) != target.end())
                    {
-                        // recursive call to compare object values at key it
+                        // found a key that is not in target -> remove it
-                        auto temp_diff = diff(it.value(), target[it.key()], path_key);
+                        const auto path_key = detail::concat<string_t>(path, '/', detail::escape(it.key()));
                        result.insert(result.end(), temp_diff.begin(), temp_diff.end());
                    }
                    else
                    {
                        // found a key that is not in o -> remove it
                        result.push_back(object(
                        {
                            {"op", "remove"}, {"path", path_key}
                        }));
                    }
                    else
                    {
                        common_keys_source_order.push_back(it.key());
                    }
                }
-                // second pass: traverse other object's elements
+                // second pass: find keys that were added (i.e., in target but
                // not in source), and record the keys common to both, in
                // target's iteration order -- again a by-product of the
                // source.find() call already needed to detect added keys. At
                // the same time, determine whether every added key comes
                // after every common key in target's order (a precondition
                // for the fast path below, which only ever appends new keys
                // at the very end): for an object_t whose iteration order is
                // a pure function of the key set (e.g. the default std::map,
                // which always iterates in sorted key order), the order
                // check further below is always true and this whole
                // mechanism is effectively a no-op; it only matters for a
                // reorderable object_t such as the one backing `ordered_json`.
                // patch ops for keys that were added (i.e., in target but not
                // in source); built here so the fast path below can reuse
                // them without a second source.find() per target key. Only
                // used by the fast path -- the slow (reordering) path
                // rebuilds "add" ops for every key itself.
                std::vector<typename object_t::key_type> common_keys_target_order;
                basic_json added_ops(value_t::array);
                bool new_keys_form_suffix = true;
                bool seen_new_key = false;
                for (auto it = target.cbegin(); it != target.cend(); ++it)
                {
                    if (source.find(it.key()) == source.end())
                    {
-                        // found a key that is not in this -> add it
+                        seen_new_key = true;
                        const auto path_key = detail::concat<string_t>(path, '/', detail::escape(it.key()));
                        added_ops.push_back(
                        {
                            {"op", "add"}, {"path", path_key},
                            {"value", it.value()}
                        });
                    }
                    else
                    {
                        common_keys_target_order.push_back(it.key());
                        if (seen_new_key)
                        {
                            new_keys_form_suffix = false;
                        }
                    }
                }
                if (common_keys_source_order == common_keys_target_order && new_keys_form_suffix)
                {
                    // fast path: order of common keys already matches (or the
                    // object_t's iteration order does not depend on
                    // insertion history), so a plain per-key recursive diff
                    // is correct and minimal, as before. common_keys_source_order
                    // is, by construction, the subsequence of source's keys
                    // that are common to both objects, in source's iteration
                    // order -- so it can be walked in lockstep with `source`
                    // using a cheap key comparison instead of another lookup.
                    auto common_it = common_keys_source_order.cbegin();
                    for (auto it = source.cbegin(); it != source.cend() && common_it != common_keys_source_order.cend(); ++it)
                    {
                        if (it.key() == *common_it)
                        {
                            const auto path_key = detail::concat<string_t>(path, '/', detail::escape(it.key()));
                            auto temp_diff = diff(it.value(), target[it.key()], path_key);
                            result.insert(result.end(), temp_diff.begin(), temp_diff.end());
                            ++common_it;
                        }
                    }
                    // append the "add" ops for brand-new keys collected above
                    // during the pass over target -- no second source.find()
                    // per target key needed
                    result.insert(result.end(), added_ops.begin(), added_ops.end());
                }
                else
                {
                    // slow path: the common keys are in a different relative
                    // order in source and target (only possible for a
                    // reorderable object_t like ordered_map). Building a
                    // minimal reordering patch is a nontrivial (LCS-like)
                    // problem; instead, remove every common key and re-add it
                    // (with its final target value) in target's order, which
                    // is enough to guarantee source.patch(diff(source,
                    // target)) == target. basic_json::patch()'s "add"
                    // operation on an object uses operator[], which appends
                    // at the end for a vector-backed insertion-ordered map
                    // when the key does not already exist -- so removing a
                    // key and then adding it moves it to the end, fixing its
                    // position.
                    for (const auto& key : common_keys_source_order)
                    {
                        const auto path_key = detail::concat<string_t>(path, '/', detail::escape(key));
                        result.push_back(object(
                        {
                            {"op", "remove"}, {"path", path_key}
                        }));
                    }
                    // add every key that is either common (just removed
                    // above) or brand new, in target's iteration order, so
                    // that the final order after applying the patch matches
                    // target exactly
                    for (auto it = target.cbegin(); it != target.cend(); ++it)
                    {
                        const auto path_key = detail::concat<string_t>(path, '/', detail::escape(it.key()));
                        result.push_back(
                        {
@@ -72,12 +72,7 @@ target_compile_options(test_main PUBLIC
    #                              is annotated JSON_HEDLEY_NO_RETURN (it always throws), which
    #                              makes MSVC flag the code following its call in binary_reader.hpp
    #                              as unreachable for that instantiation, in both Debug and Release
-    #       Disable warning C4503: decorated name length exceeded, name was truncated; the deep
+    $<$<CXX_COMPILER_ID:MSVC>:/W4;/wd4566;/wd4996;/wd4702>
    #                              copy support added for #5387 pushes the mangled name of
    #                              std::allocator_traits<...>::construct for the custom-base-class
    #                              test's map type past VS2015's limit. The name is only used for
    #                              debug info, so truncation does not affect the build.
    $<$<CXX_COMPILER_ID:MSVC>:/W4;/wd4566;/wd4996;/wd4702;/wd4503>
    # https://github.com/nlohmann/json/issues/1114
    $<$<CXX_COMPILER_ID:MSVC>:/bigobj> $<$<BOOL:${MINGW}>:-Wa,-mbig-obj>
@@ -216,57 +216,6 @@ TEST_CASE("controlled bad_alloc")
            CHECK_THROWS_AS(my_json(s), std::bad_alloc&);
            next_construct_fails = false;
        }
        SECTION("basic_json(const basic_json&) of a deeply nested value (#5387)")
        {
            // Copying a value nested deeper than the descent bound builds the
            // copy from the top down: every value whose own copy has not been
            // made yet stays a null value until it is. Failing an allocation
            // part-way through is what proves such a half-built copy can still
            // be destroyed.
            //
            // Which path the failure lands in depends on the build: the first
            // allocation of a copy belongs to the outermost level, so here it
            // is the descending one. Built with JSON_NO_THREAD_LOCAL - as the
            // ci_test_no_thread_local target builds the whole suite - no
            // descent is made at all and the very same failure lands in the
            // iterative path instead, part-way through its worklist.
            const auto check_deep_copy = [](bool objects)
            {
                CAPTURE(objects);
                next_construct_fails = false;
                // deeper than the 128 levels the copy constructor descends into
                const std::size_t depth = 300;
                my_json j = 1;
                for (std::size_t i = 0; i < depth; ++i)
                {
                    if (objects)
                    {
                        my_json wrapper = my_json::object();
                        wrapper["a"] = std::move(j);
                        j = std::move(wrapper);
                    }
                    else
                    {
                        j = my_json::array({std::move(j)});
                    }
                }
                // NOLINTNEXTLINE(performance-unnecessary-copy-initialization): the copy is what is tested
                CHECK_NOTHROW(my_json(j));
                next_construct_fails = true;
                // NOLINTNEXTLINE(performance-unnecessary-copy-initialization): the copy is what is tested
                CHECK_THROWS_AS(my_json(j), std::bad_alloc&);
                next_construct_fails = false;
            };
            check_deep_copy(false);
            check_deep_copy(true);
        }
    }
 }
@@ -326,6 +326,57 @@ TEST_CASE("lexicographical comparison operators")
 #endif
        }
        SECTION("integer/float mixed comparison is exact")
        {
            // Widening the integer to a double loses precision past the
            // mantissa, so 2^63-2 and 2^63-1 both used to compare equal to the
            // double 2^63 while differing from each other. That makes equality
            // intransitive and the ordering not a strict weak ordering.
            const json below_two_63 = static_cast<std::int64_t>(9223372036854775806LL);
            const json max_int64 = (std::numeric_limits<std::int64_t>::max)();
            const json two_63 = 9223372036854775808.0;
            CHECK_FALSE(below_two_63 == two_63);
            CHECK_FALSE(max_int64 == two_63);
            CHECK(below_two_63 != max_int64);
            CHECK(below_two_63 < max_int64);
            CHECK(below_two_63 < two_63);
            CHECK(max_int64 < two_63);
            CHECK(two_63 > max_int64);
            CHECK_FALSE(two_63 < max_int64);
            // the same past the unsigned range
            const json max_uint64 = (std::numeric_limits<std::uint64_t>::max)();
            const json two_64 = 18446744073709551616.0;
            CHECK_FALSE(max_uint64 == two_64);
            CHECK(max_uint64 < two_64);
            CHECK(two_64 > max_uint64);
            // values a double represents exactly still compare equal
            CHECK(json(1) == json(1.0));
            CHECK(json(1u) == json(1.0));
            CHECK(json(-3) == json(-3.0));
            CHECK(json(1) < json(1.5));
            CHECK(json(1.5) < json(2));
            CHECK(json(2) > json(1.5));
            // a NaN operand stays unordered against either integer kind
            CHECK_FALSE(json(1) == json(nan));
            CHECK_FALSE(json(1) < json(nan));
            CHECK_FALSE(json(nan) < json(1));
            CHECK_FALSE(json(1u) == json(nan));
 #if JSON_HAS_THREE_WAY_COMPARISON
            // JSON_HAS_CPP_20 (do not remove; see note at top of file)
            CHECK((max_int64 <=> two_63) == std::partial_ordering::less); // *NOPAD*
            CHECK((two_63 <=> max_int64) == std::partial_ordering::greater); // *NOPAD*
            CHECK((below_two_63 <=> max_int64) == std::partial_ordering::less); // *NOPAD*
            CHECK((max_uint64 <=> two_64) == std::partial_ordering::less); // *NOPAD*
            CHECK((json(1) <=> json(1.0)) == std::partial_ordering::equivalent); // *NOPAD*
            CHECK((json(1) <=> json(nan)) == std::partial_ordering::unordered); // *NOPAD*
 #endif
        }
        SECTION("compares unordered")
        {
            std::vector<std::vector<bool>> expected =
@@ -68,72 +68,6 @@ TEST_CASE("Better diagnostics with positions")
        CHECK(j.end_pos() == root.size());
    }
    SECTION("copying keeps the positions of nested values (#5387)")
    {
        // Values nested deeper than the copy constructor's descent bound are
        // copied without the call stack, on a path that has to carry the
        // positions over itself; shallower ones copy their containers, which
        // bring the positions along. Both sides of the bound are checked here.
        const auto check_copy = [](std::size_t depth, bool objects)
        {
            CAPTURE(depth)
            CAPTURE(objects)
            const std::string opening = objects ? R"({"a":)" : "[";
            const std::string closing = objects ? "}" : "]";
            std::string text;
            for (std::size_t i = 0; i < depth; ++i)
            {
                text += opening;
            }
            text += "12";
            for (std::size_t i = 0; i < depth; ++i)
            {
                text += closing;
            }
            const json original = json::parse(text);
            const json copy(original); // NOLINT(performance-unnecessary-copy-initialization)
            const json* o = &original;
            const json* c = &copy;
            for (std::size_t level = 0; level <= depth; ++level)
            {
                CAPTURE(level)
                REQUIRE(c->start_pos() == o->start_pos());
                REQUIRE(c->end_pos() == o->end_pos());
                if (level < depth)
                {
                    o = objects ? &o->at("a") : &o->at(0);
                    c = objects ? &c->at("a") : &c->at(0);
                }
            }
        };
        const auto check_arrays = [&check_copy](std::size_t depth)
        {
            check_copy(depth, false);
        };
        const auto check_objects = [&check_copy](std::size_t depth)
        {
            check_copy(depth, true);
        };
        check_arrays(1);
        check_arrays(127);
        check_arrays(128);
        check_arrays(129);
        check_arrays(300);
        check_objects(1);
        check_objects(127);
        check_objects(128);
        check_objects(129);
        check_objects(300);
    }
    SECTION("JSON patch add to primitive parent (#4292)")
    {
        // the JSON Patch "add" target /foo/bar/baz has a string parent
@@ -274,60 +274,34 @@ TEST_CASE("Regression tests for extended diagnostics")
        CHECK(j1["string"] == "t");
    }
-    SECTION("Regression test for issue #5387 - copying keeps the parents of nested values")
+    SECTION("Regression test - swap(array_t&)/swap(object_t&) must update JSON_DIAGNOSTICS parent pointers")
    {
-        // A value nested deeper than the copy constructor's descent bound is
+        // swap(array_t&)
        // copied without the call stack. Every container that path creates has
        // to have the parents of its children set, or the JSON Pointer in the
        // diagnostic is cut short.
        const std::size_t depth = 300;
        SECTION("objects")
        {
-            json j = "not a number";
+            json j = json::array();
-            std::string pointer;
+            json::array_t arr = {json::array({1})};
-            for (std::size_t i = 0; i < depth; ++i)
+            j.swap(arr);
            {
                j = json{{"a", j}};
                pointer += "/a";
            }
-            json const copy(j); // NOLINT(performance-unnecessary-copy-initialization)
+            // parent pointers of the moved-in elements must point into j, not
            // into the now-defunct free-standing array_t
            CHECK_THROWS_WITH_AS(j[0][0].get<std::string>(), "[json.exception.type_error.302] (/0/0) type must be string, but is number", json::type_error);
-            const json* inner = &copy;
+            // must not trigger assert_invariant() in a debug/assert-enabled build
-            for (std::size_t i = 0; i < depth; ++i)
+            json const k = j;
-            {
+            CHECK(k == j);
                inner = &inner->at("a");
            }
            std::string const expected = "[json.exception.type_error.302] (" + pointer + ") type must be number, but is string";
            int i = 0;
            CHECK_THROWS_WITH_AS(i = inner->get<int>(), expected.c_str(), json::type_error);
            CHECK(i == 0);
        }
-        SECTION("arrays")
+        // swap(object_t&)
        {
-            json j = "not a number";
+            json o = json::object();
-            std::string pointer;
+            json::object_t obj = {{"a", json::array({1})}};
-            for (std::size_t i = 0; i < depth; ++i)
+            o.swap(obj);
            {
                j = json::array({j});
                pointer += "/0";
            }
-            json const copy(j); // NOLINT(performance-unnecessary-copy-initialization)
+            CHECK_THROWS_WITH_AS(o["a"][0].get<std::string>(), "[json.exception.type_error.302] (/a/0) type must be string, but is number", json::type_error);
-            const json* inner = &copy;
+            // must not trigger assert_invariant() in a debug/assert-enabled build
-            for (std::size_t i = 0; i < depth; ++i)
+            json const p = o;
-            {
+            CHECK(p == o);
                inner = &inner->at(0);
            }
            std::string const expected = "[json.exception.type_error.302] (" + pointer + ") type must be number, but is string";
            int i = 0;
            CHECK_THROWS_WITH_AS(i = inner->get<int>(), expected.c_str(), json::type_error);
            CHECK(i == 0);
        }
    }
 }
@@ -1388,3 +1388,84 @@ TEST_CASE("JSON patch - add to a primitive parent (regression #4292)")
        CHECK_THROWS_AS(doc.patch(patch), json::out_of_range&);
    }
 }
 TEST_CASE("JSON patch - diff emits array removals in descending index order")
 {
    SECTION("array shrunk to empty")
    {
        json const source = {0, 1, 2, 3, 4};
        json const target = json::array();
        json const patch = json::diff(source, target);
        json const expected = R"(
            [
                {"op": "remove", "path": "/4"},
                {"op": "remove", "path": "/3"},
                {"op": "remove", "path": "/2"},
                {"op": "remove", "path": "/1"},
                {"op": "remove", "path": "/0"}
            ]
        )"_json;
        CHECK(patch == expected);
        CHECK(source.patch(patch) == target);
    }
    SECTION("array partially shrunk, after a replacement at a common index")
    {
        json const source = {0, 1, 2, 3, 4};
        json const target = {0, 9};
        json const patch = json::diff(source, target);
        // the replacement comes first, then the removals, highest index first
        json const expected = R"(
            [
                {"op": "replace", "path": "/1", "value": 9},
                {"op": "remove", "path": "/4"},
                {"op": "remove", "path": "/3"},
                {"op": "remove", "path": "/2"}
            ]
        )"_json;
        CHECK(patch == expected);
        CHECK(source.patch(patch) == target);
    }
    SECTION("nested array shrunk")
    {
        json const source = {{"a", {0, 1, 2}}};
        json const target = {{"a", json::array()}};
        json const patch = json::diff(source, target);
        json const expected = R"(
            [
                {"op": "remove", "path": "/a/2"},
                {"op": "remove", "path": "/a/1"},
                {"op": "remove", "path": "/a/0"}
            ]
        )"_json;
        CHECK(patch == expected);
        CHECK(source.patch(patch) == target);
    }
    SECTION("many removals still round-trip")
    {
        json source = json::array();
        for (int i = 0; i < 1000; ++i)
        {
            source.push_back(i);
        }
        json const target = json::array();
        json const patch = json::diff(source, target);
        CHECK(patch.size() == 1000);
        CHECK(patch.front().at("path") == "/999");
        CHECK(patch.back().at("path") == "/0");
        CHECK(source.patch(patch) == target);
    }
 }
@@ -12,7 +12,6 @@
 using nlohmann::json;
 #include <algorithm>
 #include <string>
 TEST_CASE("tests on very large JSONs")
 {
@@ -28,201 +27,3 @@ TEST_CASE("tests on very large JSONs")
    }
 }
 namespace
 {
 // Descend a chain of single-element containers and return the value at its end,
 // reporting the number of levels traversed in @a depth.
 //
 // The values in the test case below are nested far deeper than the call stack
 // can follow, so they must not be inspected with operator== or dump(): both are
 // still recursive and would overflow the stack themselves.
 const json* innermost_value(const json& j, std::size_t& depth)
 {
    const json* current = &j;
    depth = 0;
    while ((current->is_array() || current->is_object()) && !current->empty())
    {
        current = current->is_array()
                  ? &current->front()
                  : &current->begin().value();
        ++depth;
    }
    return current;
 }
 } // namespace
 TEST_CASE("tests on deeply nested JSONs")
 {
    // deep enough to exhaust the call stack, but small enough to stay cheap:
    // parsing is iterative, so building the values below costs little
    const std::size_t depth = 100000;
    SECTION("issue #5387 - stack overflow in the copy constructor")
    {
        SECTION("array")
        {
            const json j = json::parse(std::string(depth, '[') + '0' + std::string(depth, ']'));
            const json copy(j); // NOLINT(performance-unnecessary-copy-initialization): the copy is what is tested
            std::size_t copy_depth = 0;
            CHECK(*innermost_value(copy, copy_depth) == 0);
            CHECK(copy_depth == depth);
        }
        SECTION("object")
        {
            std::string s;
            s.reserve((6 * depth) + 1);
            for (std::size_t i = 0; i < depth; ++i)
            {
                s += "{\"a\":";
            }
            s += '1';
            s.append(depth, '}');
            const json j = json::parse(s);
            const json copy(j); // NOLINT(performance-unnecessary-copy-initialization): the copy is what is tested
            std::size_t copy_depth = 0;
            CHECK(*innermost_value(copy, copy_depth) == 1);
            CHECK(copy_depth == depth);
        }
        SECTION("copy assignment")
        {
            // operator=(basic_json) takes its argument by value, so the deep
            // copy happens in the copy constructor
            const json j = json::parse(std::string(depth, '[') + '0' + std::string(depth, ']'));
            json target;
            target = j;
            std::size_t target_depth = 0;
            CHECK(*innermost_value(target, target_depth) == 0);
            CHECK(target_depth == depth);
        }
        SECTION("depths around the bound of the recursive descent")
        {
            // The copy constructor descends into a bounded number of levels and
            // completes whatever is below that without the call stack. Cover
            // every depth around that bound, so that the two ways of copying
            // are known to meet cleanly - wherever the bound is set.
            for (std::size_t d = 1; d <= 300; ++d)
            {
                CAPTURE(d);
                const json array = json::parse(std::string(d, '[') + '0' + std::string(d, ']'));
                const json array_copy(array); // NOLINT(performance-unnecessary-copy-initialization): the copy is what is tested
                std::size_t array_depth = 0;
                CHECK(*innermost_value(array_copy, array_depth) == 0);
                CHECK(array_depth == d);
                std::string object_text;
                for (std::size_t i = 0; i < d; ++i)
                {
                    object_text += "{\"a\":";
                }
                object_text += '1';
                object_text.append(d, '}');
                const json object = json::parse(object_text);
                const json object_copy(object); // NOLINT(performance-unnecessary-copy-initialization): the copy is what is tested
                std::size_t object_depth = 0;
                CHECK(*innermost_value(object_copy, object_depth) == 1);
                CHECK(object_depth == d);
            }
        }
        SECTION("a value that is deep in one place only")
        {
            json j = json::object();
            j["shallow"] = 1;
            j["deep"] = json::parse(std::string(depth, '[') + '0' + std::string(depth, ']'));
            j["also_shallow"] = json::array({1, 2, 3});
            const json copy(j);
            CHECK(copy["shallow"] == 1);
            CHECK(copy["also_shallow"] == json::array({1, 2, 3}));
            std::size_t deep_depth = 0;
            CHECK(*innermost_value(copy["deep"], deep_depth) == 0);
            CHECK(deep_depth == depth);
        }
        SECTION("comparing")
        {
            // Comparing used to descend once per level, and an ordered
            // comparison used to compare every pair of elements twice, once in
            // each direction, which took exponentially long in the nesting
            // depth. Both are gone: these finish in milliseconds, where the
            // second used to take longer than anyone would wait even for a
            // value nested only a few dozen levels deep.
            const std::string text = std::string(depth, '[') + '0' + std::string(depth, ']');
            const json j = json::parse(text);
            const json same = json::parse(text);
            const json larger = json::parse(std::string(depth, '[') + '1' + std::string(depth, ']'));
            CHECK(j == same);
            CHECK_FALSE(j == larger);
            CHECK(j != larger);
            CHECK(j < larger);
            CHECK_FALSE(larger < j);
            CHECK(larger > j);
            CHECK(j <= same);
            CHECK(j >= same);
            // a value that ends earlier is the smaller one
            const json shorter = json::parse(std::string(depth - 1, '[') + '0' + std::string(depth - 1, ']'));
            CHECK_FALSE(j == shorter);
        }
        SECTION("comparing objects")
        {
            std::string text;
            text.reserve((6 * depth) + 1);
            for (std::size_t i = 0; i < depth; ++i)
            {
                text += "{\"a\":";
            }
            text += '1';
            text.append(depth, '}');
            const json j = json::parse(text);
            const json same = json::parse(text);
            CHECK(j == same);
            CHECK_FALSE(j != same);
            CHECK(j <= same);
            CHECK(j >= same);
        }
        SECTION("the copy is independent of the original")
        {
            const json j = json::parse(std::string(depth, '[') + '0' + std::string(depth, ']'));
            json copy(j);
            // reach the innermost value without recursing and replace it
            json* current = &copy;
            while (current->is_array() && !current->empty())
            {
                current = &current->front();
            }
            *current = 42;
            std::size_t unused = 0;
            CHECK(*innermost_value(copy, unused) == 42);
            CHECK(*innermost_value(j, unused) == 0);
        }
    }
 }
@@ -82,36 +82,83 @@ TEST_CASE("regression test for issue #3732 - iteration_proxy_value<iter_impl<ord
    static_cast<void>(fn);
 }
-TEST_CASE("copying an ordered_json with nested values")
+TEST_CASE("regression test - diff() must account for ordered_json member order")
 {
-    // ordered_map is backed by a vector, so copying an object that has
+    SECTION("pure reorder, no value changes")
    // structured values takes a different route than copying a std::map-backed
    // one; see https://github.com/nlohmann/json/issues/5387
    ordered_json oj;
    oj["z"] = 1;
    oj["a"]["y"] = 2;
    oj["a"]["b"]["x"] = 3;
    oj["m"] = {1, 2, {{"w", 4}}};
    const ordered_json copy(oj);
    SECTION("the copy is equal to the original")
    {
-        CHECK(copy == oj);
+        ordered_json a = {{"a", 1}, {"b", 2}};
-        CHECK(copy.dump() == oj.dump());
+        ordered_json b = {{"b", 2}, {"a", 1}};
        CHECK(a != b); // order-sensitive equality
        CHECK(a.patch(ordered_json::diff(a, b)) == b);
    }
-    SECTION("the key order is preserved at every level")
+    SECTION("new key must land at the front")
    {
-        CHECK(copy.dump() == R"({"z":1,"a":{"y":2,"b":{"x":3}},"m":[1,2,{"w":4}]})");
+        ordered_json c = {{"b", 2}};
        ordered_json e = {{"a", 1}, {"b", 2}};
        CHECK(c.patch(ordered_json::diff(c, e)) == e);
    }
-    SECTION("the copy is independent of the original")
+    SECTION("reorder plus a value change on one of the reordered keys")
    {
-        ordered_json mutated(oj);
+        ordered_json a = {{"a", 1}, {"b", 2}};
-        mutated["a"]["b"]["x"] = 99;
+        ordered_json b = {{"b", 20}, {"a", 1}};
        CHECK(a != b);
        CHECK(a.patch(ordered_json::diff(a, b)) == b);
    }
-        CHECK(oj["a"]["b"]["x"] == 3);
+    SECTION("reorder plus a deleted key")
-        CHECK(mutated["a"]["b"]["x"] == 99);
+    {
        ordered_json a = {{"a", 1}, {"b", 2}, {"c", 3}};
        ordered_json b = {{"b", 2}, {"a", 1}};
        CHECK(a != b);
        CHECK(a.patch(ordered_json::diff(a, b)) == b);
    }
    SECTION("reorder plus a nested value that itself needs a recursive diff")
    {
        ordered_json a = {{"a", {{"x", 1}, {"y", 2}}}, {"b", 2}};
        ordered_json b = {{"b", 2}, {"a", {{"x", 1}, {"y", 99}}}};
        CHECK(a != b);
        CHECK(a.patch(ordered_json::diff(a, b)) == b);
    }
    SECTION("three or more keys shuffled into a different order")
    {
        ordered_json a = {{"a", 1}, {"b", 2}, {"c", 3}, {"d", 4}};
        ordered_json b = {{"d", 4}, {"b", 2}, {"a", 1}, {"c", 3}};
        CHECK(a != b);
        CHECK(a.patch(ordered_json::diff(a, b)) == b);
    }
    SECTION("matching order still produces a minimal patch (fast path unaffected)")
    {
        ordered_json a = {{"a", 1}, {"b", 2}, {"c", 3}};
        ordered_json b = {{"a", 1}, {"b", 20}, {"c", 3}};
        auto p = ordered_json::diff(a, b);
        // only the changed value should be touched, not a wholesale remove+add
        CHECK(p.size() == 1);
        CHECK(p[0]["op"] == "replace");
        CHECK(p[0]["path"] == "/b");
        CHECK(a.patch(p) == b);
    }
    SECTION("plain json (std::map-backed) is unaffected by same-key-different-insertion-order")
    {
        json a;
        a["b"] = 2;
        a["a"] = 1;
        json b;
        b["a"] = 1;
        b["b"] = 2;
        // std::map iteration is always sorted by key, so a == b regardless of
        // insertion order, and diff() must still produce the same minimal
        // (empty) result as before this fix
        CHECK(a == b);
        auto p = json::diff(a, b);
        CHECK(p.empty());
        CHECK(a.patch(p) == b);
    }
 }
Author	SHA1	Message	Date
Niels Lohmann	2cee81ae6b	Honor allow_exceptions=false for excessive array/object size (out_of_range.408) The SAX DOM parsers' start_object()/start_array() threw out_of_range.408 directly via JSON_THROW when a binary format (CBOR/UBJSON/BJData) declared a container size exceeding max_size(), bypassing the allow_exceptions flag that every other malformed-input error path in these classes honors via parse_error(). This meant that json::from_cbor(data, true, false) etc. could still throw (or abort under JSON_NOEXCEPTION) instead of returning a discarded value, contrary to the allow_exceptions=false contract. Route all four call sites (two in json_sax_dom_parser, two in json_sax_dom_callback_parser) through parse_error() instead, matching the existing error-handling pattern used elsewhere in this file. Behavior is unchanged when allow_exceptions is true (the default); the exception message and type are identical. Signed-off-by: Niels Lohmann <mail@nlohmann.me>	2026-09-05 17:05:56 +02:00
Niels Lohmann	0ec4bdb8fa	Restore a duplicate key's prior value when the callback rejects its new value json_sax_dom_callback_parser::key() unconditionally overwrote the object slot for a key with a `discarded` placeholder as soon as the key was accepted by the parser callback. For a duplicate key (legal JSON), this destroyed the pre-existing value from an earlier occurrence of the same key before the new value was even parsed. If the new value was then rejected by the callback, remove_discarded_value() erased the member entirely instead of leaving the original value in place, contradicting the documented behavior that a discarded value behaves as if it was never read. Add a small stash of (slot pointer, previous value) pairs so that when key() overwrites an existing member with the discarded placeholder, the previous value can be restored later if the corresponding value (scalar, object, or array) is rejected, instead of being erased. The stash entry is dropped without restoring once the new value is definitively accepted (in handle_value() for scalars, end_object()/end_array() for containers), so a duplicate key whose new value is accepted still keeps the last value as before. Non-duplicate keys are unaffected: rejecting their value still removes the member entirely, since there is nothing to restore. Signed-off-by: Niels Lohmann <mail@nlohmann.me>	2026-09-05 17:05:55 +02:00
Niels Lohmann	03784997bf	Avoid redundant lookups in diff()'s object-order tracking The previous fix for ordered_json member order re-derived common-key order and suffix information with extra target.find()/source.find() calls layered on top of the pre-existing removed/added-key passes, instead of reusing those same passes. This roughly tripled the number of map lookups per diff() call for every object, including plain `json`, where the reordering path is never taken. Piggyback the order tracking (and the "add" op construction for new keys) onto the two passes the algorithm already needs to detect removed/added keys, and walk the fast path's recursion in lockstep with the precomputed common-key list instead of re-querying `target`. This restores diff() to its pre-existing lookup count; benchmarked at n=1000 keys, ordered_json::diff() was roughly 2x slower than baseline before this change and is back within noise of baseline after it. Signed-off-by: Niels Lohmann <mail@nlohmann.me>	2026-09-05 17:05:48 +02:00
Niels Lohmann	221dcf814c	Make diff() account for member order in ordered_json objects diff() compared source/target objects purely by key set, ignoring relative member order. For ordered_json (insertion-ordered, vector- backed object_t), two objects that differ only in member order are unequal via operator==, but diff() never emitted any patch operation to fix the order, so source.patch(diff(source, target)) == target could fail to hold. Fix by detecting when common keys appear in a different relative order in source vs. target (or when a new key would need to land somewhere other than the end), and in that case removing and re-adding the affected keys in target's order, which relies on patch()'s "add" op appending new keys at the end of an ordered_map. For plain json (std::map-backed, always key-sorted iteration) this is a no-op and the original minimal per-key diff path is unchanged. Signed-off-by: Niels Lohmann <mail@nlohmann.me>	2026-09-05 16:54:49 +02:00
Niels Lohmann	3678634bf2	Fix swap(array_t&)/swap(object_t&) to update parent pointers under JSON_DIAGNOSTICS Both overloads swapped the underlying container storage but never called set_parents(), leaving elements moved into *this with stale m_parent pointers (typically nullptr from the free-standing array_t/object_t). This produced wrong JSON Pointer paths in diagnostic messages and could trip assert_invariant() on subsequent copies. Mirrors the fix already applied in swap(reference other). Signed-off-by: Niels Lohmann <mail@nlohmann.me>	2026-09-05 16:34:21 +02:00
Niels Lohmann	dd26d3ff07	docs: add 41 customers and rebuild the overview image (#5463 ) * docs: add 89 customers and sort all sections Extend the customers page from 136 to 225 entries. New entries were found by searching vendor open-source notices and by inspecting dependency manifests in public repositories. Every added entry was verified to link either to a page that credits the library, or to an open source repository where its use is directly visible (a vendored copy, a build manifest, or an include). Candidates whose only evidence was a transitive dependency (via ICU or KDDockWidgets), packaging metadata, or an unused vendored file were dropped rather than listed. Also sort every section alphabetically ignoring case, and keep the Peregrine lunar lander first under "Space Exploration". Signed-off-by: Niels Lohmann <mail@nlohmann.me> * docs: add 41 customers and rebuild the overview image The list was assembled by searching for names one at a time, which is why it had plateaued. These additions come from enumerating instead: a public code search returning every repository that references the library, and the reverse build-dependencies of the Debian and Ubuntu source indices. Every addition cites a first-party call site rather than a repository root, and every evidence URL was checked to resolve. Several prominent candidates were rejected on exactly that test: - Node.js reaches the library only through deps/icu-small, the inherited attribution ICU carries into everything that ships it. - Visual Studio Code's only hits are copies of the library's own headers used as sample C++ in the Copilot extension's test fixtures. - OSS-Fuzz fuzzes the library rather than calling it; projects/json/ is the library's own OSS-Fuzz integration. - libuv matched only its AUTHORS file, which lists a contributor by name. - simdjson and LLVM matched only benchmarks and a mangled-symbol test. Two entries were already present under a different name and are merged rather than duplicated: PrestoDB, and DB Browser for SQLite under its repository name. GitHub CodeQL's citation moves from the repository root to shared/cpp/Diagnostics.h, which includes the header directly. The image is rebuilt with 236 logos over 17 rows. It is smaller than the one it replaces, 1.02 MB against 1.35 MB, despite carrying 100 more marks. Signed-off-by: Niels Lohmann <mail@nlohmann.me> --------- Signed-off-by: Niels Lohmann <mail@nlohmann.me>	2026-09-05 11:27:57 +02:00
Avionic Harshit	3c875683a5	Make diff() linear when an array shrinks (#5461 ) Signed-off-by: avionicharshit-byte <harshitavionic@gmail.com>	2026-09-05 09:52:53 +02:00
Qatadaha Bin Matloob	137a40b9aa	Compare integers with floats exactly instead of widening the integer (#5459 ) The mixed number arms of JSON_IMPLEMENT_OPERATOR cast the integer to number_float_t before comparing. Past the float's mantissa that cast is lossy: 2^63-2 and 2^63-1 both round to 2^63, so each compares equal to that float while differing from each other. Equality is therefore intransitive and the ordering is not a strict weak ordering, which makes std::sort over such values, or using them as keys in std::set or std::map, undefined behavior. Compare the two exactly instead. The integer's range is a power of two the float represents exactly, so a float outside it is ordered by magnitude alone; inside it, truncating the float is exact, and the integer parts and then any fractional part decide. The helper hands back a pair whose comparison with the original operator reproduces that ordering, which keeps every operator's return type as it was, including partial_ordering for the spaceship. A NaN operand is returned in both members, so NaN stays false for the relational operators and unordered for <=>. Values a float represents exactly still compare equal, so json(1) == json(1.0) is unchanged. Signed-off-by: qatcod <79017227+qatcod@users.noreply.github.com>	2026-09-05 09:43:07 +02:00