Merge branch 'perf/lexer-dispatch' into perf/dom-move-keys

Signed-off-by: Niels Lohmann <mail@nlohmann.me>
Merge branch 'perf/lexer-simd-strings' into perf/lexer-dispatch
2026-10-16 19:18:12 +00:00 · 2026-10-16 08:21:29 +02:00 · 2026-10-16 08:21:10 +02:00 · 2026-10-16 08:10:42 +02:00 · 2026-10-15 22:47:13 +02:00 · 2026-10-15 22:47:09 +02:00
187 changed files with 4216 additions and 11223 deletions
@@ -56,23 +56,6 @@ labels:
 - label: "aspect: binary formats"
  title: "(?i)(bson|cbor|msgpack|messagepack|ubjson|bjdata|bon8|binary format)"
 - label: "aspect: json_view"
  files:
    - "include/nlohmann/json_view\\.hpp"
    - "include/nlohmann/detail/view/.*"
    - "single_include/nlohmann/json_view\\.hpp"
    - "tests/src/unit-json_view.*"
    - "tests/src/fuzzer-parse_json_view\\.cpp"
    - "tools/amalgamate/config_json_view\\.json"
    - "docs/mkdocs/docs/features/json_view\\.md"
    - "docs/mkdocs/docs/api/basic_json_(document|view)/.*"
    - "docs/mkdocs/docs/api/(ordered_)?json_(document|view)\\.md"
    - "docs/mkdocs/docs/examples/(basic_json_(document|view)__|(ordered_)?json_(document|view)).*"
    - "tests/benchmarks/src/benchmarks_view\\.cpp"
 - label: "aspect: json_view"
  title: "(?i)(json_view|json_document|zero-copy)"
 - label: "python"
  files:
    - "\\.py$"
@@ -116,15 +116,12 @@ jobs:
          python3 $TOOL_DIR/amalgamate.py -c $TOOL_DIR/config_json.json -s .
          python3 $TOOL_DIR/amalgamate.py -c $TOOL_DIR/config_json_fwd.json -s .
          # the configuration of json_view.hpp comes with the pull request until
          # it is on develop; the tool itself is still develop's
          python3 $TOOL_DIR/amalgamate.py -c $MAIN_DIR/tools/amalgamate/config_json_view.json -s .
          # the header list of the Bazel "json" target must match the files in include/
          cmake -P cmake/scripts/gen_bazel_build_file.cmake
          ${{ github.workspace }}/venv/bin/astyle --project=tools/astyle/.astylerc --suffix=none --quiet \
-            $INCLUDE_DIR/json.hpp $INCLUDE_DIR/json_fwd.hpp $INCLUDE_DIR/json_view.hpp
+            $INCLUDE_DIR/json.hpp $INCLUDE_DIR/json_fwd.hpp
          # fail loudly if a directory is renamed or removed: find would only warn
          # about the missing path and silently drop its files from the check
@@ -166,21 +166,19 @@ jobs:
      # 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.
-      # The tests link with LLD: GNU ld fails on objects with more than 32767
+      # Objects with more than 65535 sections fail to link with "relocation
-      # sections with "relocation truncated to fit: IMAGE_REL_AMD64_REL32
+      # truncated to fit: IMAGE_REL_AMD64_REL32 against `.rdata'": the MinGW
-      # against `.rdata'", as it stores the section an associative COMDAT
+      # linker stores the section an associative COMDAT section belongs to in
-      # section belongs to in 16 bits (x_associated in binutils'
+      # 16 bits (x_associated in binutils' include/coff/internal.h), so it
-      # include/coff/internal.h) and so discards the jump tables of inline
+      # discards the jump tables of inline functions together with the wrong
-      # functions together with the wrong function. Each basic_json
+      # function. Each basic_json specialization a test file instantiates adds
-      # specialization and input type a test file instantiates adds many
+      # many sections, so test a second one in a file of its own.
      # sections, so unit-msgpack.cpp and unit-regression2.cpp kept crossing
      # that limit as the library grew.
      - name: Run CMake
        run: cmake -S . -B build ^
             -DCMAKE_CXX_COMPILER="C:/Program Files/LLVM/bin/clang++.exe" ^
             -DCMAKE_CXX_FLAGS="--target=x86_64-w64-mingw32 -stdlib=libstdc++ -pthread" ^
             -DCMAKE_CXX_FLAGS_DEBUG="-g0" ^
-             -DCMAKE_EXE_LINKER_FLAGS="-fuse-ld=lld -lwinpthread" ^
+             -DCMAKE_EXE_LINKER_FLAGS="-lwinpthread" ^
             -G"MinGW Makefiles" ^
             -DCMAKE_BUILD_TYPE=Debug ^
             -DJSON_BuildTests=On
@@ -20,7 +20,6 @@ cc_library(
    hdrs = [
        "include/nlohmann/adl_serializer.hpp",
        "include/nlohmann/byte_container_with_subtype.hpp",
        "include/nlohmann/detail/abi_config.hpp",
        "include/nlohmann/detail/abi_macros.hpp",
        "include/nlohmann/detail/bit_ops.hpp",
        "include/nlohmann/detail/conversions/from_json.hpp",
@@ -37,6 +36,7 @@ cc_library(
        "include/nlohmann/detail/input/parser.hpp",
        "include/nlohmann/detail/input/position_t.hpp",
        "include/nlohmann/detail/input/pow5_table.hpp",
        "include/nlohmann/detail/input/simd_scan.hpp",
        "include/nlohmann/detail/input/string_scan.hpp",
        "include/nlohmann/detail/iterators/internal_iterator.hpp",
        "include/nlohmann/detail/iterators/iter_impl.hpp",
@@ -67,21 +67,9 @@ cc_library(
        "include/nlohmann/detail/string_escape.hpp",
        "include/nlohmann/detail/string_utils.hpp",
        "include/nlohmann/detail/value_t.hpp",
        "include/nlohmann/detail/view/builder.hpp",
        "include/nlohmann/detail/view/document_data.hpp",
        "include/nlohmann/detail/view/errors.hpp",
        "include/nlohmann/detail/view/input.hpp",
        "include/nlohmann/detail/view/macro_scope.hpp",
        "include/nlohmann/detail/view/macro_unscope.hpp",
        "include/nlohmann/detail/view/materialize.hpp",
        "include/nlohmann/detail/view/node.hpp",
        "include/nlohmann/detail/view/number.hpp",
        "include/nlohmann/detail/view/scan.hpp",
        "include/nlohmann/detail/view/string_ref.hpp",
        "include/nlohmann/json.hpp",
        "include/nlohmann/json_fwd.hpp",
        "include/nlohmann/json_literals.hpp",
        "include/nlohmann/json_view.hpp",
        "include/nlohmann/ordered_map.hpp",
        "include/nlohmann/thirdparty/hedley/hedley.hpp",
        "include/nlohmann/thirdparty/hedley/hedley_undef.hpp",
@@ -96,7 +84,6 @@ cc_library(
        "single_include/nlohmann/json.hpp",
        "single_include/nlohmann/json_fwd.hpp",
        "single_include/nlohmann/json_literals.hpp",
        "single_include/nlohmann/json_view.hpp",
    ],
    includes = ["single_include"],
    visibility = ["//visibility:public"],
@@ -26,7 +26,6 @@ AMALGAMATED_FILE=single_include/nlohmann/json.hpp
 AMALGAMATED_FWD_FILE=single_include/nlohmann/json_fwd.hpp
 # json_literals.hpp only includes <nlohmann/json.hpp>, so it is copied verbatim
 AMALGAMATED_LITERALS_FILE=single_include/nlohmann/json_literals.hpp
 AMALGAMATED_VIEW_FILE=single_include/nlohmann/json_view.hpp
 # the header with the argument-counting macros generated by tools/macro_builder
 MACRO_SCOPE_HPP=include/nlohmann/detail/macro_scope.hpp
@@ -38,7 +37,7 @@ MACRO_SCOPE_HPP=include/nlohmann/detail/macro_scope.hpp
 # main target
 all:
-	@echo "amalgamate - amalgamate files single_include/nlohmann/json{,_fwd,_literals,_view}.hpp from the include/nlohmann sources"
+	@echo "amalgamate - amalgamate files single_include/nlohmann/json{,_fwd,_literals}.hpp from the include/nlohmann sources"
 	@echo "BUILD.bazel - regenerate the Bazel BUILD file from the include/nlohmann sources"
 	@echo "ChangeLog.md - generate ChangeLog file"
 	@echo "check-amalgamation - check whether sources have been amalgamated and BUILD.bazel is up to date"
@@ -97,10 +96,10 @@ install_astyle:
 # call the Artistic Style pretty printer on all source files
 pretty: install_astyle
-	$(ASTYLE) --project=tools/astyle/.astylerc $(SRCS) $(TESTS_SRCS) $(AMALGAMATED_FILE) $(AMALGAMATED_FWD_FILE) $(AMALGAMATED_LITERALS_FILE) $(AMALGAMATED_VIEW_FILE) docs/mkdocs/docs/examples/*.cpp docs/mkdocs/docs/examples/*.hpp
+	$(ASTYLE) --project=tools/astyle/.astylerc $(SRCS) $(TESTS_SRCS) $(AMALGAMATED_FILE) $(AMALGAMATED_FWD_FILE) $(AMALGAMATED_LITERALS_FILE) docs/mkdocs/docs/examples/*.cpp docs/mkdocs/docs/examples/*.hpp
 # create single header files and pretty print
-amalgamate: $(AMALGAMATED_FILE) $(AMALGAMATED_FWD_FILE) $(AMALGAMATED_LITERALS_FILE) $(AMALGAMATED_VIEW_FILE)
+amalgamate: $(AMALGAMATED_FILE) $(AMALGAMATED_FWD_FILE) $(AMALGAMATED_LITERALS_FILE)
 	$(MAKE) pretty
 # call the amalgamation tool for json.hpp
@@ -115,10 +114,6 @@ $(AMALGAMATED_FWD_FILE): $(SRCS)
 $(AMALGAMATED_LITERALS_FILE): include/nlohmann/json_literals.hpp
 	cp include/nlohmann/json_literals.hpp $(AMALGAMATED_LITERALS_FILE)
 # call the amalgamation tool for json_view.hpp (keeps including json.hpp)
 $(AMALGAMATED_VIEW_FILE): $(SRCS)
 	tools/amalgamate/amalgamate.py -c tools/amalgamate/config_json_view.json -s . --verbose=yes
 NATVIS_VENV=tools/generate_natvis/venv
 # regenerate nlohmann_json.natvis from the ABI tags and version in include/nlohmann/detail/abi_macros.hpp
@@ -152,18 +147,18 @@ check_build_options:
 check-amalgamation:
 	@status=0; \
 	banner() { printf '===================================================================\n  %s\n===================================================================\n' "$$1"; }; \
-	for FILE in $(AMALGAMATED_FILE) $(AMALGAMATED_FWD_FILE) $(AMALGAMATED_LITERALS_FILE) $(AMALGAMATED_VIEW_FILE) BUILD.bazel nlohmann_json.natvis; do \
+	for FILE in $(AMALGAMATED_FILE) $(AMALGAMATED_FWD_FILE) $(AMALGAMATED_LITERALS_FILE) BUILD.bazel nlohmann_json.natvis; do \
 	    mv "$$FILE" "$$FILE~" || exit 1; \
 	done; \
 	$(MAKE) amalgamate || status=1; \
 	$(MAKE) BUILD.bazel || status=1; \
 	$(MAKE) natvis || status=1; \
-	for FILE in $(AMALGAMATED_FILE) $(AMALGAMATED_FWD_FILE) $(AMALGAMATED_LITERALS_FILE) $(AMALGAMATED_VIEW_FILE); do \
+	for FILE in $(AMALGAMATED_FILE) $(AMALGAMATED_FWD_FILE) $(AMALGAMATED_LITERALS_FILE); do \
 	    diff "$$FILE" "$$FILE~" || { banner "$$FILE is out of date! Amalgamation required! Please read the contribution guidelines in file .github/CONTRIBUTING.md."; status=1; }; \
 	done; \
 	diff BUILD.bazel BUILD.bazel~ || { banner "BUILD.bazel is out of date! Please run 'make BUILD.bazel'."; status=1; }; \
 	diff nlohmann_json.natvis nlohmann_json.natvis~ || { banner "nlohmann_json.natvis is out of date! Please run 'make natvis'."; status=1; }; \
-	for FILE in $(AMALGAMATED_FILE) $(AMALGAMATED_FWD_FILE) $(AMALGAMATED_LITERALS_FILE) $(AMALGAMATED_VIEW_FILE) BUILD.bazel nlohmann_json.natvis; do \
+	for FILE in $(AMALGAMATED_FILE) $(AMALGAMATED_FWD_FILE) $(AMALGAMATED_LITERALS_FILE) BUILD.bazel nlohmann_json.natvis; do \
 	    mv "$$FILE~" "$$FILE"; \
 	done; \
 	$(MAKE) macro_builder_check || status=1; \
@@ -204,7 +199,7 @@ json.tar.xz:
 # We use `-X` to make the resulting ZIP file reproducible, see
 # <https://content.pivotal.io/blog/barriers-to-deterministic-reproducible-zip-files>.
 include.zip: BUILD.bazel
-	zip -9 --recurse-paths -X include.zip $(SRCS) $(AMALGAMATED_FILE) $(AMALGAMATED_FWD_FILE) $(AMALGAMATED_LITERALS_FILE) $(AMALGAMATED_VIEW_FILE) BUILD.bazel MODULE.bazel meson.build meson_options.txt LICENSE.MIT
+	zip -9 --recurse-paths -X include.zip $(SRCS) $(AMALGAMATED_FILE) $(AMALGAMATED_FWD_FILE) $(AMALGAMATED_LITERALS_FILE) BUILD.bazel MODULE.bazel meson.build meson_options.txt LICENSE.MIT
 # Create the files for a release and add signatures and hashes.
 release: include.zip json.tar.xz
@@ -214,13 +209,11 @@ release: include.zip json.tar.xz
 	gpg --armor --detach-sig $(AMALGAMATED_FILE)
 	gpg --armor --detach-sig $(AMALGAMATED_FWD_FILE)
 	gpg --armor --detach-sig $(AMALGAMATED_LITERALS_FILE)
 	gpg --armor --detach-sig $(AMALGAMATED_VIEW_FILE)
 	gpg --armor --detach-sig json.tar.xz
 	cp $(AMALGAMATED_FILE) release_files
 	cp $(AMALGAMATED_FWD_FILE) release_files
 	cp $(AMALGAMATED_LITERALS_FILE) release_files
-	cp $(AMALGAMATED_VIEW_FILE) release_files
+	mv $(AMALGAMATED_FILE).asc $(AMALGAMATED_FWD_FILE).asc $(AMALGAMATED_LITERALS_FILE).asc json.tar.xz json.tar.xz.asc include.zip include.zip.asc release_files
 	mv $(AMALGAMATED_FILE).asc $(AMALGAMATED_FWD_FILE).asc $(AMALGAMATED_LITERALS_FILE).asc $(AMALGAMATED_VIEW_FILE).asc json.tar.xz json.tar.xz.asc include.zip include.zip.asc release_files
 	cd release_files ; shasum -a 256 $$(find . -type f -not -name '*.asc' | sed 's|^\./||' | sort) > hashes.txt
@@ -1202,14 +1202,6 @@ binary.set_subtype(0x10);
 auto msgpack = json::to_msgpack(j); // 0xD5 (fixext2), 0x10, 0xCA, 0xFE
 ```
 ### Zero-copy views
 Header `<nlohmann/json_view.hpp>` adds `json_document`/`json_view`, a read-only, non-owning way to look at a parsed
 JSON text: parsing builds a flat index (16 bytes per value) instead of a tree, strings and numbers stay in the source
 text, and `materialize()` builds a `json` value for a subtree only when you actually need one. See
 [Zero-copy JSON views](https://json.nlohmann.me/features/json_view/) for the details, including which inputs are
 borrowed and which are copied.
 ## Customers
 The library is used in multiple projects, applications, operating systems, etc. The list below is not exhaustive, but the result of an internet search. If you know further customers of the library, please let me know, see [contact](#contact).
@@ -1409,7 +1401,6 @@ THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR I
 - The class contains a copy of [Hedley](https://nemequ.github.io/hedley/) from Evan Nemerson which is licensed as [CC0-1.0](https://creativecommons.org/publicdomain/zero/1.0/).
 - The class contains parts of [Google Abseil](https://github.com/abseil/abseil-cpp) which is licensed under the [Apache 2.0 License](https://opensource.org/licenses/Apache-2.0).
 - The class contains an adapted version of the Eisel-Lemire algorithm, its table of powers of five, and its digit comparison for long numbers from [fast_float](https://github.com/fastfloat/fast_float) by Daniel Lemire and contributors, which is available under the [MIT License](https://opensource.org/licenses/MIT) (used here), the Apache 2.0 License, and the Boost Software License. Copyright &copy; 2021 The fast_float authors
 - The view's parser (`<nlohmann/json_view.hpp>`) contains techniques and code adapted from [yyjson](https://github.com/ibireme/yyjson) by YaoYuan, which is licensed under the [MIT License](https://opensource.org/licenses/MIT) (see above): table-driven decoding of `\u` escapes and fixed-offset unrolled checks.
 <img align="right" src="https://git.fsfe.org/reuse/reuse-ci/raw/branch/master/reuse-horizontal.png" alt="REUSE Software">
@@ -407,11 +407,10 @@ list(FILTER INDENT_FILES EXCLUDE REGEX "/tests/thirdparty/|/tests/abi/include/nl
 set(include_dir ${PROJECT_SOURCE_DIR}/single_include/nlohmann)
 set(tool_dir ${PROJECT_SOURCE_DIR}/tools/amalgamate)
 add_custom_target(ci_test_amalgamation
-    COMMAND rm -fr ${include_dir}/json.hpp~ ${include_dir}/json_fwd.hpp~ ${include_dir}/json_literals.hpp~ ${include_dir}/json_view.hpp~
+    COMMAND rm -fr ${include_dir}/json.hpp~ ${include_dir}/json_fwd.hpp~ ${include_dir}/json_literals.hpp~
    COMMAND cp ${include_dir}/json.hpp ${include_dir}/json.hpp~
    COMMAND cp ${include_dir}/json_fwd.hpp ${include_dir}/json_fwd.hpp~
    COMMAND cp ${include_dir}/json_literals.hpp ${include_dir}/json_literals.hpp~
    COMMAND cp ${include_dir}/json_view.hpp ${include_dir}/json_view.hpp~
    COMMAND cp ${PROJECT_SOURCE_DIR}/BUILD.bazel ${PROJECT_SOURCE_DIR}/BUILD.bazel~
    COMMAND ${Python3_EXECUTABLE} -mvenv venv_astyle
@@ -421,20 +420,18 @@ add_custom_target(ci_test_amalgamation
    COMMAND ${Python3_EXECUTABLE} ${tool_dir}/amalgamate.py -c ${tool_dir}/config_json.json -s .
    COMMAND ${Python3_EXECUTABLE} ${tool_dir}/amalgamate.py -c ${tool_dir}/config_json_fwd.json -s .
    COMMAND cp ${PROJECT_SOURCE_DIR}/include/nlohmann/json_literals.hpp ${include_dir}/json_literals.hpp
-    COMMAND ${Python3_EXECUTABLE} ${tool_dir}/amalgamate.py -c ${tool_dir}/config_json_view.json -s .
+    COMMAND venv_astyle/bin/astyle --project=tools/astyle/.astylerc --suffix=none ${include_dir}/json.hpp ${include_dir}/json_fwd.hpp ${include_dir}/json_literals.hpp
    COMMAND venv_astyle/bin/astyle --project=tools/astyle/.astylerc --suffix=none ${include_dir}/json.hpp ${include_dir}/json_fwd.hpp ${include_dir}/json_literals.hpp ${include_dir}/json_view.hpp
    COMMAND ${CMAKE_COMMAND} -P ${PROJECT_SOURCE_DIR}/cmake/scripts/gen_bazel_build_file.cmake
    COMMAND diff ${include_dir}/json.hpp~ ${include_dir}/json.hpp
    COMMAND diff ${include_dir}/json_fwd.hpp~ ${include_dir}/json_fwd.hpp
    COMMAND diff ${include_dir}/json_literals.hpp~ ${include_dir}/json_literals.hpp
    COMMAND diff ${include_dir}/json_view.hpp~ ${include_dir}/json_view.hpp
    COMMAND diff ${PROJECT_SOURCE_DIR}/BUILD.bazel~ ${PROJECT_SOURCE_DIR}/BUILD.bazel
    COMMAND venv_astyle/bin/astyle --project=tools/astyle/.astylerc --suffix=orig ${INDENT_FILES}
    COMMAND for FILE in `find . -name '*.orig'`\; do false \; done
-    COMMAND rm -f ${include_dir}/json.hpp~ ${include_dir}/json_fwd.hpp~ ${include_dir}/json_literals.hpp~ ${include_dir}/json_view.hpp~ ${PROJECT_SOURCE_DIR}/BUILD.bazel~
+    COMMAND rm -f ${include_dir}/json.hpp~ ${include_dir}/json_fwd.hpp~ ${include_dir}/json_literals.hpp~ ${PROJECT_SOURCE_DIR}/BUILD.bazel~
    WORKING_DIRECTORY ${PROJECT_SOURCE_DIR}
    COMMENT "Check amalgamation, formatting, and BUILD.bazel"
@@ -4,11 +4,5 @@
 # call converts -1 to size_t, which -fsanitize=integer reports as implicit-integer-sign-change. This is
 # https://gcc.gnu.org/bugzilla/show_bug.cgi?id=119429, not a bug in this library. Only that check and only <format> are
 # excluded, so implicit sign changes in the library and the tests are still reported.
 #
 # libstdc++'s <string_view> compares two views of different lengths through `_S_compare(size_type __n1, size_type
 # __n2)`, which stores `__n1 - __n2` in a signed difference_type and clamps it to int. Any comparison with a shorter
 # view wraps that subtraction on purpose, and -fsanitize=integer reports it as implicit-integer-sign-change. json_view
 # compares keys as string views, so the same check is excluded for <string_view> as well.
 [implicit-integer-sign-change]
 src:*/include/c++/*/format
 src:*/include/c++/*/string_view
@@ -50,7 +50,6 @@ cc_library(
        "single_include/nlohmann/json.hpp",
        "single_include/nlohmann/json_fwd.hpp",
        "single_include/nlohmann/json_literals.hpp",
        "single_include/nlohmann/json_view.hpp",
    ],
    includes = ["single_include"],
    visibility = ["//visibility:public"],
@@ -132,6 +132,10 @@ outside of a string, invalid) byte; see the [FAQ entry](../../home/faq.md#nul-by
 - [operator>>](../operator_gtgt.md) - deserialize from stream
 - [`JSON_STRICT_NUL_HANDLING`](../macros/json_strict_nul_handling.md) - opt in to rejecting a NUL byte in the input
  instead of treating it as end of input
 - [`JSON_DISABLE_STREAM_BULK_SCAN`](../macros/json_disable_stream_bulk_scan.md) - read a `std::istream` one character
  at a time
 - [`JSON_DISABLE_UNLOCKED_FILE_IO`](../macros/json_disable_unlocked_file_io.md) - read a `FILE*` with the locking stdio
  functions
 ## Version history
@@ -143,6 +147,10 @@ outside of a string, invalid) byte; see the [FAQ entry](../../home/faq.md#nul-by
 - Extended overload (2) to accept heterogeneous iterator+sentinel pairs (C++20 ranges support) in version 3.13.0.
 - `JSON_STRICT_NUL_HANDLING` added in version 3.13.0 to optionally reject a NUL byte in the input instead of treating
  it as end of input; planned to become the default in version 4.0.0.
 - Parsing from an `std::istream` scans the characters in its stream buffer in bulk in version 3.13.0
  ([`JSON_DISABLE_STREAM_BULK_SCAN`](../macros/json_disable_stream_bulk_scan.md)).
 - Parsing from a `FILE*` locks the file once instead of once per character in version 3.13.0
  ([`JSON_DISABLE_UNLOCKED_FILE_IO`](../macros/json_disable_unlocked_file_io.md)).
 !!! warning "Deprecation"
@@ -64,7 +64,6 @@ itself is empty which is `#!cpp false` in the case of a string.
 - [size](size.md) returns the number of elements
 - [clear](clear.md) clears the content and resets the value to the default value
 - [basic_json_view::empty](../basic_json_view/empty.md) - the same check on a zero-copy view
 ## Version history
@@ -40,7 +40,6 @@ Constant.
 - [is_structured](is_structured.md) checks whether the JSON value is structured (array or object)
 - [type](type.md) returns the type of the JSON value
 - [array_t](array_t.md) the type used to store JSON arrays
 - [basic_json_view::is_array](../basic_json_view/is_array.md) - the same check on a zero-copy view
 ## Version history
@@ -39,7 +39,6 @@ Constant.
 - [is_primitive](is_primitive.md) checks whether the JSON value is primitive
 - [binary_t](binary_t.md) the type used to store binary values
 - [get_binary](get_binary.md) returns a reference to the stored binary value
 - [basic_json_view::is_binary](../basic_json_view/is_binary.md) - the same check on a zero-copy view
 ## Version history
@@ -38,7 +38,6 @@ Constant.
 - [boolean_t](boolean_t.md) the type used to store JSON booleans
 - [is_primitive](is_primitive.md) checks whether the JSON value is primitive
 - [basic_json_view::is_boolean](../basic_json_view/is_boolean.md) - the same check on a zero-copy view
 ## Version history
@@ -85,11 +85,6 @@ with `allow_exceptions` set to `#!cpp false`: a parse error then yields a discar
    --8<-- "examples/is_discarded__parse.output"
    ```
 ## See also
 - [basic_json_view::is_discarded](../basic_json_view/is_discarded.md) - the corresponding check on a zero-copy view,
  which is `#!cpp true` if the view refers to no value
 ## Version history
 - Added in version 1.0.0.
@@ -40,7 +40,6 @@ Constant.
 - [is_object](is_object.md) checks whether the JSON value is an object
 - [type](type.md) returns the type of the JSON value
 - [value_t](value_t.md) the enumeration of JSON types
 - [basic_json_view::is_null](../basic_json_view/is_null.md) - the same check on a zero-copy view
 ## Version history
@@ -49,7 +49,6 @@ constexpr bool is_number() const noexcept
 - [is_number_integer()](is_number_integer.md) check if the value is an integer or unsigned integer number
 - [is_number_unsigned()](is_number_unsigned.md) check if the value is an unsigned integer number
 - [is_number_float()](is_number_float.md) check if the value is a floating-point number
 - [basic_json_view::is_number](../basic_json_view/is_number.md) - the same check on a zero-copy view
 ## Version history
@@ -40,7 +40,6 @@ Constant.
 - [is_number()](is_number.md) check if the value is a number
 - [is_number_integer()](is_number_integer.md) check if the value is an integer or unsigned integer number
 - [is_number_unsigned()](is_number_unsigned.md) check if the value is an unsigned integer number
 - [basic_json_view::is_number_float](../basic_json_view/is_number_float.md) - the same check on a zero-copy view
 ## Version history
@@ -40,7 +40,6 @@ Constant.
 - [is_number()](is_number.md) check if the value is a number
 - [is_number_unsigned()](is_number_unsigned.md) check if the value is an unsigned integer number
 - [is_number_float()](is_number_float.md) check if the value is a floating-point number
 - [basic_json_view::is_number_integer](../basic_json_view/is_number_integer.md) - the same check on a zero-copy view
 ## Version history
@@ -43,7 +43,6 @@ Constant.
 - [is_number()](is_number.md) check if the value is a number
 - [is_number_integer()](is_number_integer.md) check if the value is an integer or unsigned integer number
 - [is_number_float()](is_number_float.md) check if the value is a floating-point number
 - [basic_json_view::is_number_unsigned](../basic_json_view/is_number_unsigned.md) - the same check on a zero-copy view
 ## Version history
@@ -40,7 +40,6 @@ Constant.
 - [is_structured](is_structured.md) checks whether the JSON value is structured (array or object)
 - [type](type.md) returns the type of the JSON value
 - [object_t](object_t.md) the type used to store JSON objects
 - [basic_json_view::is_object](../basic_json_view/is_object.md) - the same check on a zero-copy view
 ## Version history
@@ -62,7 +62,6 @@ This library extends primitive types to binary types, because binary types are r
 - [is_boolean()](is_boolean.md) returns whether the JSON value is a boolean
 - [is_number()](is_number.md) returns whether the JSON value is a number
 - [is_binary()](is_binary.md) returns whether the JSON value is a binary array
 - [basic_json_view::is_primitive](../basic_json_view/is_primitive.md) - the same check on a zero-copy view
 ## Version history
@@ -39,7 +39,6 @@ Constant.
 - [is_primitive](is_primitive.md) checks whether the JSON value is primitive
 - [type](type.md) returns the type of the JSON value
 - [string_t](string_t.md) the type used to store JSON strings
 - [basic_json_view::is_string](../basic_json_view/is_string.md) - the same check on a zero-copy view
 ## Version history
@@ -57,7 +57,6 @@ Note that though strings are containers in C++, they are treated as primitive va
 - [is_primitive()](is_primitive.md) returns whether JSON value is primitive
 - [is_array()](is_array.md) returns whether the value is an array
 - [is_object()](is_object.md) returns whether the value is an object
 - [basic_json_view::is_structured](../basic_json_view/is_structured.md) - the same check on a zero-copy view
 ## Version history
@@ -112,6 +112,16 @@ By default, a `'\0'` (NUL) byte anywhere in the input is treated as end of input
 outside of a string, invalid) byte; see the [FAQ entry](../../home/faq.md#nul-bytes-in-the-input) for details and the
 [`JSON_STRICT_NUL_HANDLING`](../macros/json_strict_nul_handling.md) macro to opt into rejecting it instead.
 !!! tip "Performance"
    Contiguous inputs (strings, string views, vectors, arrays, pointer ranges) are the fastest to parse. A
    `#!cpp std::istream` comes close: the parser scans the characters its stream buffer holds in bulk, without reading
    ahead, so the stream is left exactly where it would be after reading one character at a time. A `#!cpp FILE*` is
    read one character at a time, but the file is locked only once, so other threads that use the same `FILE` object
    wait until parsing is done. See [input sources and performance](../../features/parsing/index.md#input-sources-and-performance),
    [`JSON_DISABLE_STREAM_BULK_SCAN`](../macros/json_disable_stream_bulk_scan.md), and
    [`JSON_DISABLE_UNLOCKED_FILE_IO`](../macros/json_disable_unlocked_file_io.md).
 ## Examples
 ??? example "Example: (1) parse from a character array"
@@ -247,6 +257,10 @@ outside of a string, invalid) byte; see the [FAQ entry](../../home/faq.md#nul-by
 - [operator>>](../operator_gtgt.md) - deserialize from stream
 - [`JSON_STRICT_NUL_HANDLING`](../macros/json_strict_nul_handling.md) - opt in to rejecting a NUL byte in the input
  instead of treating it as end of input
 - [`JSON_DISABLE_STREAM_BULK_SCAN`](../macros/json_disable_stream_bulk_scan.md) - read a `std::istream` one character
  at a time
 - [`JSON_DISABLE_UNLOCKED_FILE_IO`](../macros/json_disable_unlocked_file_io.md) - read a `FILE*` with the locking stdio
  functions
 ## Version history
@@ -261,6 +275,11 @@ outside of a string, invalid) byte; see the [FAQ entry](../../home/faq.md#nul-by
  it as end of input; planned to become the default in version 4.0.0.
 - Extended empty-input detection to also cover an `std::istream` without a stream buffer, and fixed a crash
  (`std::terminate`) when parsing from an `std::istream` with `eofbit` in its exception mask, in version 3.13.0.
 - Parsing from an `std::istream` scans the characters in its stream buffer in bulk in version 3.13.0
  ([`JSON_DISABLE_STREAM_BULK_SCAN`](../macros/json_disable_stream_bulk_scan.md) restores reading one character at a
  time).
 - Parsing from a `FILE*` locks the file once instead of once per character in version 3.13.0
  ([`JSON_DISABLE_UNLOCKED_FILE_IO`](../macros/json_disable_unlocked_file_io.md) restores `std::fgetc`).
 !!! warning "Deprecation"
@@ -116,6 +116,10 @@ consumer `sax` has a super-linear complexity.
 A UTF-8 byte order mark is silently ignored.
 When reading from a `#!c FILE*`, the file is locked while it is parsed. The lock is recursive, so the SAX handler may
 use the same file with stdio functions, but it must not wait for another thread that uses the same `FILE` object; see
 [`JSON_DISABLE_UNLOCKED_FILE_IO`](../macros/json_disable_unlocked_file_io.md).
 ## Examples
 ??? example
@@ -137,6 +141,10 @@ A UTF-8 byte order mark is silently ignored.
 - [parse](parse.md) - deserialize from a compatible input
 - [accept](accept.md) - check if the input is valid JSON
 - [`JSON_DISABLE_STREAM_BULK_SCAN`](../macros/json_disable_stream_bulk_scan.md) - read a `std::istream` one character
  at a time
 - [`JSON_DISABLE_UNLOCKED_FILE_IO`](../macros/json_disable_unlocked_file_io.md) - read a `FILE*` with the locking stdio
  functions
 ## Version history
@@ -148,6 +156,10 @@ A UTF-8 byte order mark is silently ignored.
 - Extended overload (2) to accept heterogeneous iterator+sentinel pairs (C++20 ranges support) in version 3.13.0.
 - `JSON_PRECISE_STREAM_POSITION` added in version 3.13.0 to optionally leave a `#!cpp std::istream` positioned right
  after the parsed value when `strict` is `#!cpp false`.
 - Parsing from an `std::istream` scans the characters in its stream buffer in bulk in version 3.13.0
  ([`JSON_DISABLE_STREAM_BULK_SCAN`](../macros/json_disable_stream_bulk_scan.md)).
 - Parsing from a `FILE*` locks the file once instead of once per character in version 3.13.0
  ([`JSON_DISABLE_UNLOCKED_FILE_IO`](../macros/json_disable_unlocked_file_io.md)).
 !!! warning "Deprecation"
@@ -55,7 +55,6 @@ JSON value which is `1` in the case of a string.
 - [empty](empty.md) checks whether the JSON value has no elements
 - [max_size](max_size.md) returns the maximum possible number of elements
 - [basic_json_view::size](../basic_json_view/size.md) - the same function on a zero-copy view
 ## Version history
@@ -52,7 +52,6 @@ Constant.
 - [operator value_t](operator_value_t.md) implicit conversion operator equivalent to this named member function
 - [type_name](type_name.md) returns the type as a string, for use in error messages
 - [value_t](value_t.md) the enumeration of JSON types
 - [basic_json_view::type](../basic_json_view/type.md) - the same function on a zero-copy view
 ## Version history
@@ -1,77 +0,0 @@
 # <small>nlohmann::basic_json_document::</small>accept
 ```cpp
 template<typename InputType>
 static bool accept(InputType&& input,
                   const bool ignore_comments = false,
                   const bool ignore_trailing_commas = false);
 ```
 Checks whether the input is valid JSON, accepting and rejecting exactly what
 [`BasicJsonType::accept()`](../basic_json/accept.md) does, with the same options. Unlike [`parse()`](parse.md), this
 function never throws an exception for invalid input, and the returned `#!cpp bool` is the only result -- no document
 is returned.
 The result is the same as that of `BasicJsonType::accept()` by design; the difference is how the check is made. This
 function runs the document's index builder (and discards the index), while `BasicJsonType::accept()` runs the SAX
 parser with a handler that ignores every event. Use this one if you go on to parse the same input with
 [`parse()`](parse.md) anyway, so that both use the same code; either is fine for a plain yes/no answer.
 ## Template parameters
 `InputType`
 :   A compatible input; see [`parse`](parse.md#template-parameters).
 ## Parameters
 `input` (in)
 :   Input to check.
 `ignore_comments` (in)
 :   whether comments should be ignored and treated like whitespace (`#!cpp true`) or yield a parse error
    (`#!cpp false`); (optional, `#!cpp false` by default)
 `ignore_trailing_commas` (in)
 :   whether trailing commas in arrays or objects should be ignored and treated like whitespace (`#!cpp true`) or
    yield a parse error (`#!cpp false`); (optional, `#!cpp false` by default)
 ## Return value
 Whether the input is valid JSON.
 ## Exception safety
 Strong guarantee: this function itself never throws for an invalid input; it can only throw what allocating the
 input's own copy (for inputs that are always read into a buffer) throws.
 ## Complexity
 Linear in the length of the input.
 ## Notes
 An integer argument that is not a `#!cpp bool` where the flags are expected, such as `#!cpp accept(ptr, len)`, does not
 compile; see [`parse`](parse.md#notes).
 ## Examples
 ??? example
    ```cpp
    --8<-- "examples/basic_json_document__accept.cpp"
    ```
    Output:
    ```json
    --8<-- "examples/basic_json_document__accept.output"
    ```
 ## See also
 - [parse](parse.md) - deserialize from a compatible input
 - [`BasicJsonType::accept`](../basic_json/accept.md) - the corresponding function of `basic_json`
 ## Version history
 - Added in version 3.13.0.
@@ -1,58 +0,0 @@
 # <small>nlohmann::basic_json_document::</small>basic_json_document
 ```cpp
 // (1)
 basic_json_document() = default;
 // (2)
 basic_json_document(basic_json_document&& other) noexcept = default;
 // (3)
 basic_json_document(const basic_json_document&) = delete;
 ```
 1. Creates an empty (discarded) document: [`root()`](root.md) returns a discarded view, and
   [`is_discarded()`](is_discarded.md) is `#!cpp true`.
 2. Move constructor. Takes over `other`'s index and, if owned, its text; `other` is left as an empty document. Views
   taken from `other` before the move remain valid, because the index is heap-allocated independently of the
   `basic_json_document` object.
 3. `basic_json_document` is move-only. Copying is disabled because of its cost: a copy would duplicate the whole
   index, the decoded-string buffer, and the owned text, while a move is enough in every use we know of.
 ## Parameters
 `other` (in)
 :   another document to move the index and text from
 ## Exception safety
 No-throw guarantee: the default and move constructors never throw exceptions.
 ## Complexity
 Constant.
 ## Examples
 ??? example
    The example below shows the default constructor and demonstrates that `basic_json_document` is move-only.
    ```cpp
    --8<-- "examples/basic_json_document__basic_json_document.cpp"
    ```
    Output:
    ```json
    --8<-- "examples/basic_json_document__basic_json_document.output"
    ```
 ## See also
 - [parse](parse.md) - deserialize from a compatible input
 - [is_discarded](is_discarded.md) - return whether the last parse failed
 ## Version history
 - Added in version 3.13.0.
@@ -1,57 +0,0 @@
 # <small>nlohmann::</small>basic_json_document
 <small>Defined in header `<nlohmann/json_view.hpp>`</small>
 ```cpp
 template<typename BasicJsonType>
 class basic_json_document;
 ```
 A parsed JSON text, held as a flat index of its values
 ([16 bytes per value](../../home/architecture.md#node-index-of-json-views)) instead of a tree of `BasicJsonType` values.
 Strings and numbers stay in the source text; only strings that contain escapes are decoded, into one buffer owned by
 the document. [`basic_json_view`](../basic_json_view/index.md) is a read-only handle to one value of a
 `basic_json_document`; [`materialize()`](../basic_json_view/materialize.md) turns a subtree into the
 `BasicJsonType` value that [`BasicJsonType::parse()`](../basic_json/parse.md) would have produced for it.
 A document may **borrow** the text it was parsed from (the caller's buffer must then outlive the document) or **own**
 it (a copy, or an rvalue `#!cpp std::string` that was moved in); see [`owns_source`](owns_source.md). `basic_json_document`
 is move-only: a copy would duplicate the whole index, the decoded-string buffer, and the owned text, and a move is
 enough in every use we know of. The index, the decoded strings, and the owned text live in one heap block that the
 document holds through a `#!cpp std::unique_ptr`; this is also why views survive a move of the document.
 ## Template parameters
 `BasicJsonType`
 :   a specialization of [`basic_json`](../basic_json/index.md), for instance [`json`](../json.md) or
    [`ordered_json`](../ordered_json.md). Only 64-bit `number_integer_t`/`number_unsigned_t` types are supported; this
    is checked with a `static_assert`.
 ## Specializations
 - [**json_document**](../json_document.md) - documents of the default specialization [`json`](../json.md)
 - [**ordered_json_document**](../ordered_json_document.md) - documents of [`ordered_json`](../ordered_json.md)
 ## Member types
 - **view_type** - the type of view returned by [`root()`](root.md) (`#!cpp basic_json_view<BasicJsonType>`)
 - **value_t** - the JSON type enumeration, see [`basic_json::value_t`](../basic_json/value_t.md)
 ## Member functions
 - [(constructor)](basic_json_document.md)
 - [**parse**](parse.md) (_static_) - deserialize from a compatible input, borrowing or owning it as appropriate
 - [**parse_copy**](parse_copy.md) (_static_) - deserialize a copy of a compatible input
 - [**accept**](accept.md) (_static_) - check whether the input is valid JSON
 - [**read**](read.md) - (re-)parse into this document, reusing its memory
 - [**root**](root.md) - the view of the root value
 - [**is_discarded**](is_discarded.md) - return whether the last parse failed
 - [**source**](source.md) - the parsed text
 - [**owns_source**](owns_source.md) - return whether the document holds its own copy of the text
 - [**node_count**](node_count.md) - the number of index entries (values plus object keys)
 - [**memory_usage**](memory_usage.md) - the number of bytes held by the document
 - [**shrink_to_fit**](shrink_to_fit.md) - release unused index capacity
 ## Version history
 - Added in version 3.13.0.
@@ -1,49 +0,0 @@
 # <small>nlohmann::basic_json_document::</small>is_discarded
 ```cpp
 bool is_discarded() const noexcept;
 ```
 Returns whether the document holds no value, either because it was default-constructed or because the last call to
 [`parse()`](parse.md), [`parse_copy()`](parse_copy.md), or [`read()`](read.md) failed with `allow_exceptions` set to
 `#!cpp false`.
 ## Return value
 `#!cpp true` if the document is discarded, `#!cpp false` otherwise.
 ## Exception safety
 No-throw guarantee: this function never throws exceptions.
 ## Complexity
 Constant.
 ## Notes
 When the document is discarded, [`root()`](root.md) returns a discarded view (its
 [`is_discarded()`](../basic_json_view/is_discarded.md) is also `#!cpp true`).
 ## Examples
 ??? example
    ```cpp
    --8<-- "examples/basic_json_document__is_discarded.cpp"
    ```
    Output:
    ```json
    --8<-- "examples/basic_json_document__is_discarded.output"
    ```
 ## See also
 - [parse](parse.md) - deserialize from a compatible input
 - [is_discarded (basic_json_view)](../basic_json_view/is_discarded.md) - return whether a view is invalid
 ## Version history
 - Added in version 3.13.0.
@@ -1,50 +0,0 @@
 # <small>nlohmann::basic_json_document::</small>memory_usage
 ```cpp
 std::size_t memory_usage() const noexcept;
 ```
 Returns the number of bytes held by the document: the node index, the decoded-string buffer (for strings that
 contain escapes), and, for an owned document, its copy of the source text.
 ## Return value
 The number of bytes the document holds, `0` for a [discarded](is_discarded.md) document.
 ## Exception safety
 No-throw guarantee: this function never throws exceptions.
 ## Complexity
 Constant.
 ## Notes
 The exact value depends on the platform, the allocator, and the library's own layout, and may change between
 versions; do not rely on it being a specific number, and do not compare it across different builds or platforms.
 Compare it for the same document over time, or between documents built with the same binary, instead -- for instance
 to observe the effect of [`shrink_to_fit()`](shrink_to_fit.md).
 ## Examples
 ??? example
    ```cpp
    --8<-- "examples/basic_json_document__memory_usage.cpp"
    ```
    Output:
    ```json
    --8<-- "examples/basic_json_document__memory_usage.output"
    ```
 ## See also
 - [node_count](node_count.md) - the number of index entries
 - [shrink_to_fit](shrink_to_fit.md) - release unused index capacity
 ## Version history
 - Added in version 3.13.0.
@@ -1,49 +0,0 @@
 # <small>nlohmann::basic_json_document::</small>node_count
 ```cpp
 std::size_t node_count() const noexcept;
 ```
 Returns the number of entries in the document's flat index.
 ## Return value
 The number of index entries: one per value (of any type, at any nesting depth) plus one per object key. `0` for a
 [discarded](is_discarded.md) document.
 ## Exception safety
 No-throw guarantee: this function never throws exceptions.
 ## Complexity
 Constant.
 ## Notes
 Each index entry is [16 bytes](../../home/architecture.md#node-index-of-json-views), so `#!cpp node_count() * 16` is
 the size of the index itself (part, but not all, of [`memory_usage()`](memory_usage.md), which also counts decoded
 strings and, for an owned document, the text).
 ## Examples
 ??? example
    ```cpp
    --8<-- "examples/basic_json_document__node_count.cpp"
    ```
    Output:
    ```json
    --8<-- "examples/basic_json_document__node_count.output"
    ```
 ## See also
 - [memory_usage](memory_usage.md) - the number of bytes held by the document
 - [shrink_to_fit](shrink_to_fit.md) - release unused index capacity
 ## Version history
 - Added in version 3.13.0.
@@ -1,49 +0,0 @@
 # <small>nlohmann::basic_json_document::</small>owns_source
 ```cpp
 bool owns_source() const noexcept;
 ```
 Returns whether the document holds its own copy of the parsed text or is borrowing the caller's buffer.
 ## Return value
 `#!cpp true` if the document owns the text returned by [`source()`](source.md), `#!cpp false` if it borrows it (or if
 the document is [discarded](is_discarded.md)).
 ## Exception safety
 No-throw guarantee: this function never throws exceptions.
 ## Complexity
 Constant.
 ## Notes
 See the ownership table on [`parse`](parse.md#notes) for which inputs are borrowed and which are owned. A borrowed
 document (`#!cpp owns_source() == false`) is only valid while the buffer it was parsed from is still alive.
 ## Examples
 ??? example
    ```cpp
    --8<-- "examples/basic_json_document__owns_source.cpp"
    ```
    Output:
    ```json
    --8<-- "examples/basic_json_document__owns_source.output"
    ```
 ## See also
 - [parse](parse.md) - deserialize from a compatible input
 - [parse_copy](parse_copy.md) - deserialize a copy of a compatible input, always owned
 - [source](source.md) - the parsed text
 ## Version history
 - Added in version 3.13.0.
@@ -1,156 +0,0 @@
 # <small>nlohmann::basic_json_document::</small>parse
 ```cpp
 // (1)
 template<typename InputType>
 static basic_json_document parse(InputType&& input,
                                 const bool allow_exceptions = true,
                                 const bool ignore_comments = false,
                                 const bool ignore_trailing_commas = false);
 // (2)
 template<typename IteratorType>
 static basic_json_document parse(IteratorType first, IteratorType last,
                                 const bool allow_exceptions = true,
                                 const bool ignore_comments = false,
                                 const bool ignore_trailing_commas = false);
 ```
 1. Deserialize from a compatible input, borrowing or owning it depending on its value category and type (see Notes).
 2. Deserialize from a pair of input iterators.
 Both overloads accept the same JSON text as [`BasicJsonType::parse()`](../basic_json/parse.md), with the same
 `ignore_comments`/`ignore_trailing_commas` options, but build a [`basic_json_document`](index.md) (a flat index into
 the input) instead of a tree of `BasicJsonType` values. They take the same inputs as `BasicJsonType::parse()`. Byte
 inputs that stay alive can be borrowed; all others (streams, `#!cpp FILE*`, wide characters, non-contiguous
 iterators) are read into a copy that the document owns -- see the Notes. Use [`parse_copy()`](parse_copy.md) to get an
 owned copy of a borrowable input as well.
 ## Template parameters
 `InputType`
 :   A compatible input, for instance:
    - a `#!cpp std::string`, `#!cpp std::string_view`, or a C-style array of single-byte characters
    - a pointer to a null-terminated string of single-byte characters (`#!cpp char`, `#!cpp signed char`,
      `#!cpp unsigned char`, `#!cpp std::uint8_t`)
    - a container for which `#!cpp obj.data()` and `#!cpp obj.size()` give contiguous single-byte access, e.g.
      `#!cpp std::vector<char>` or `#!cpp std::vector<std::uint8_t>`
    - an `#!cpp std::istream` object
    - a `#!cpp FILE*` pointer
    - wide characters (`#!cpp wchar_t`, `#!cpp char16_t`, `#!cpp char32_t`), which are converted to UTF-8: a wide
      string object (`#!cpp std::wstring`, `#!cpp std::u16string`, `#!cpp std::u32string`), an array (e.g. a wide
      string literal), or a pointer to a null-terminated wide string
 `IteratorType`
 :   an input iterator type, for instance a pair of pointers such as `ptr` and `ptr + len`, or a pair of
    `#!cpp std::string::iterator`; the iterators of single-byte characters are borrowed or read like the byte inputs
    above, those of wide characters are converted to UTF-8
 ## Parameters
 `input` (in)
 :   Input to parse from.
 `allow_exceptions` (in)
 :   whether to throw exceptions in case of a parse error (optional, `#!cpp true` by default)
 `ignore_comments` (in)
 :   whether comments should be ignored and treated like whitespace (`#!cpp true`) or yield a parse error
    (`#!cpp false`); (optional, `#!cpp false` by default)
 `ignore_trailing_commas` (in)
 :   whether trailing commas in arrays or objects should be ignored and treated like whitespace (`#!cpp true`) or
    yield a parse error (`#!cpp false`); (optional, `#!cpp false` by default)
 `first` (in)
 :   iterator to the start of a character range
 `last` (in)
 :   iterator to the end of a character range
 ## Return value
 The parsed document. If `allow_exceptions` is `#!cpp false` and the input is not valid JSON, the returned document is
 discarded; see [`is_discarded`](is_discarded.md).
 ## Exceptions
 Throws the same exception [`BasicJsonType::parse()`](../basic_json/parse.md) throws for the same input and options --
 the same exception id, message, and position -- because on a failing input the library's own parser is run on the
 same bytes to produce the diagnostic. This replay runs only for a failing input, and costs about a lexing pass up to
 the error (its SAX handler builds no values); with `allow_exceptions` set to `#!cpp false`, it is skipped and a
 discarded document is returned instead. Additionally throws
 [`out_of_range.416`](../../home/exceptions.md#jsonexceptionout_of_range416) if the input is 4294967280 bytes (4 GiB
 minus 16 bytes) or larger, a size [`BasicJsonType::parse()`](../basic_json/parse.md) does not reject.
 ## Complexity
 Linear in the length of the input.
 ## Notes
 **Ownership.** Whether the document borrows `input` or owns a copy of it depends on its value category and type:
 | `input`                                                                             | ownership                                                    |
 |--------------------------------------------------------------------------------------|--------------------------------------------------------------|
 | lvalue byte container (`std::string`, `std::vector<char>`, ...), `std::string_view`, C string, character array | **borrowed** -- `input` must outlive the document |
 | non-const rvalue `#!cpp std::string`                                                  | **owned**, moved in without a copy                            |
 | other rvalue byte container (including a `#!cpp const` rvalue `#!cpp std::string`)  | **owned**, copied                                             |
 | stream, `#!cpp FILE*`, wide characters, or anything else read through the general input adapter | **owned**, read into a buffer (a stream is read to its end) |
 For overload (2), a pair of pointers to single-byte integers (e.g. `#!cpp const char*`, `#!cpp std::uint8_t*`) is
 borrowed. From C++20 on, so is any other contiguous iterator over single bytes, such as
 `#!cpp std::vector<char>::iterator` or `#!cpp std::string::const_iterator`. Before C++20 these iterators cannot be
 told apart from other class-type iterators, so their range is read into an owned buffer, as is any non-contiguous
 range (e.g. of a `#!cpp std::list<char>`).
 See [`owns_source`](owns_source.md) to check which happened after a call, and the
 [feature page](../../features/json_view.md) for the reasoning.
 **Numbers.** As for [`BasicJsonType::parse()`](../basic_json/parse.md), an integer literal too large for the 64-bit
 integer type becomes a floating-point value.
 **No lengths.** An integer argument that is not a `#!cpp bool` where the flags are expected -- for example
 `#!cpp parse(ptr, len)` -- does not compile (the overload is deleted). Such a call would convert `len` to
 `allow_exceptions` and read `ptr` as a null-terminated string, past the end of a buffer that has none. To parse a
 buffer of a given length, pass a pair of pointers: `#!cpp parse(ptr, ptr + len)`. The same holds for
 [`parse_copy`](parse_copy.md), [`accept`](accept.md), and [`read`](read.md).
 ## Examples
 ??? example "Example: (1) borrowed vs. owned input, and errors identical to `BasicJsonType::parse()`"
    ```cpp
    --8<-- "examples/basic_json_document__parse.cpp"
    ```
    Output:
    ```json
    --8<-- "examples/basic_json_document__parse.output"
    ```
 ??? example "Example: (2) parse an iterator range (no NUL terminator required)"
    ```cpp
    --8<-- "examples/basic_json_document__parse_iterator_pair.cpp"
    ```
    Output:
    ```json
    --8<-- "examples/basic_json_document__parse_iterator_pair.output"
    ```
 ## See also
 - [parse_copy](parse_copy.md) - deserialize a copy of a compatible input
 - [accept](accept.md) - check whether the input is valid JSON
 - [read](read.md) - (re-)parse into this document, reusing its memory
 - [owns_source](owns_source.md) - return whether the document holds its own copy of the text
 - [`BasicJsonType::parse`](../basic_json/parse.md) - the corresponding function of `basic_json`
 ## Version history
 - Added in version 3.13.0.
@@ -1,80 +0,0 @@
 # <small>nlohmann::basic_json_document::</small>parse_copy
 ```cpp
 template<typename InputType>
 static basic_json_document parse_copy(InputType&& input,
                                      const bool allow_exceptions = true,
                                      const bool ignore_comments = false,
                                      const bool ignore_trailing_commas = false);
 ```
 Deserialize from a compatible input, always taking the document's own copy of it, regardless of the value category or
 type of `input`. Unlike [`parse()`](parse.md), the returned document never depends on `input` staying alive.
 ## Template parameters
 `InputType`
 :   A compatible input; see [`parse`](parse.md#template-parameters).
 ## Parameters
 `input` (in)
 :   Input to parse from.
 `allow_exceptions` (in)
 :   whether to throw exceptions in case of a parse error (optional, `#!cpp true` by default)
 `ignore_comments` (in)
 :   whether comments should be ignored and treated like whitespace (`#!cpp true`) or yield a parse error
    (`#!cpp false`); (optional, `#!cpp false` by default)
 `ignore_trailing_commas` (in)
 :   whether trailing commas in arrays or objects should be ignored and treated like whitespace (`#!cpp true`) or
    yield a parse error (`#!cpp false`); (optional, `#!cpp false` by default)
 ## Return value
 The parsed document, with [`owns_source()`](owns_source.md) `#!cpp true`. If `allow_exceptions` is `#!cpp false` and
 the input is not valid JSON, the returned document is discarded; see [`is_discarded`](is_discarded.md).
 ## Exceptions
 Same as [`parse`](parse.md#exceptions).
 ## Complexity
 Linear in the length of the input.
 ## Notes
 `parse_copy()` accepts and rejects exactly what [`parse()`](parse.md) does, and classifies numbers the same way; it
 only differs in that the input is always copied rather than sometimes borrowed. Prefer [`parse()`](parse.md) when the
 input's lifetime already covers the document's, since it avoids the copy for borrowed inputs.
 An integer argument that is not a `#!cpp bool` where the flags are expected, such as `#!cpp parse_copy(ptr, len)`, does not
 compile; see [`parse`](parse.md#notes).
 ## Examples
 ??? example
    The example below returns a document from a function whose local buffer would otherwise not outlive it.
    ```cpp
    --8<-- "examples/basic_json_document__parse_copy.cpp"
    ```
    Output:
    ```json
    --8<-- "examples/basic_json_document__parse_copy.output"
    ```
 ## See also
 - [parse](parse.md) - deserialize from a compatible input, borrowing it where possible
 - [owns_source](owns_source.md) - return whether the document holds its own copy of the text
 ## Version history
 - Added in version 3.13.0.
@@ -1,81 +0,0 @@
 # <small>nlohmann::basic_json_document::</small>read
 ```cpp
 template<typename InputType>
 void read(InputType&& input,
         const bool allow_exceptions = true,
         const bool ignore_comments = false,
         const bool ignore_trailing_commas = false);
 ```
 (Re-)parses `input` into `#!cpp *this`, discarding the document's previous value and reusing its memory (the node
 index, the decoded-string buffer, and, if applicable, the owned copy of the text) rather than allocating a fresh
 document. [`parse()`](parse.md) is implemented in terms of this function, applied to a default-constructed document.
 ## Template parameters
 `InputType`
 :   A compatible input; see [`parse`](parse.md#template-parameters).
 ## Parameters
 `input` (in)
 :   Input to parse from.
 `allow_exceptions` (in)
 :   whether to throw exceptions in case of a parse error (optional, `#!cpp true` by default)
 `ignore_comments` (in)
 :   whether comments should be ignored and treated like whitespace (`#!cpp true`) or yield a parse error
    (`#!cpp false`); (optional, `#!cpp false` by default)
 `ignore_trailing_commas` (in)
 :   whether trailing commas in arrays or objects should be ignored and treated like whitespace (`#!cpp true`) or
    yield a parse error (`#!cpp false`); (optional, `#!cpp false` by default)
 ## Exceptions
 Same as [`parse`](parse.md#exceptions).
 ## Complexity
 Linear in the length of the input.
 ## Notes
 Every view taken from `#!cpp *this` before the call -- including the previous [`root()`](root.md) -- is invalidated,
 whether or not the new parse succeeds; take fresh views from [`root()`](root.md) afterward.
 `input` is borrowed or owned by the same rules as [`parse()`](parse.md#notes); a document can borrow on one call and
 own on the next, since ownership is decided freshly each time. An input that is copied (see the table in
 [`parse()`](parse.md#notes)) is written into the document's previous owned copy, reusing its memory; a moved-in
 `#!cpp std::string` replaces it.
 An integer argument that is not a `#!cpp bool` where the flags are expected, such as `#!cpp read(ptr, len)`, does not
 compile; see [`parse`](parse.md#notes).
 ## Examples
 ??? example
    The example below parses a sequence of messages into the same document, reusing its memory instead of allocating
    a new document for each one.
    ```cpp
    --8<-- "examples/basic_json_document__read.cpp"
    ```
    Output:
    ```json
    --8<-- "examples/basic_json_document__read.output"
    ```
 ## See also
 - [parse](parse.md) - deserialize from a compatible input
 - [root](root.md) - the view of the root value
 ## Version history
 - Added in version 3.13.0.
@@ -1,66 +0,0 @@
 # <small>nlohmann::basic_json_document::</small>root
 ```cpp
 // (1)
 view_type root() const& noexcept;
 // (2)
 view_type root() const&& = delete;
 ```
 1. Returns a view of the root value of the document.
 2. Deleted: the view of a temporary document would dangle.
 ## Return value
 A [`view_type`](index.md#member-types) (i.e. `#!cpp basic_json_view<BasicJsonType>`) for the root value, or a
 discarded view if the document is [discarded](is_discarded.md).
 ## Exception safety
 No-throw guarantee: this function never throws exceptions.
 ## Complexity
 Constant.
 ## Notes
 **Lifetime.** A view refers into the document, so the document must outlive it. `root()` can therefore only be called
 on a document that has a name (an lvalue); calling it on a temporary does not compile:
 ```cpp
 auto v = json_document::parse(text).root();  // error: the document is destroyed at the end of the statement
 auto doc = json_document::parse(text);       // OK: keep the document alive
 auto v = doc.root();
 ```
 `root()` is a cheap handle into the document's index, not a copy of anything; call it as often as needed. The
 returned view is valid under the same conditions as any other view of the document -- see
 [Object inspection](../basic_json_view/index.md) -- in particular, it is invalidated by the next
 [`read()`](read.md) or [`shrink_to_fit()`](shrink_to_fit.md) on this document. A view can dangle, like a
 `#!cpp std::string_view`; see [Ownership and lifetime](../../features/json_view.md#ownership-and-lifetime).
 ## Examples
 ??? example
    ```cpp
    --8<-- "examples/basic_json_document__root.cpp"
    ```
    Output:
    ```json
    --8<-- "examples/basic_json_document__root.output"
    ```
 ## See also
 - [is_discarded](is_discarded.md) - return whether the last parse failed
 - [materialize](../basic_json_view/materialize.md) - build the `BasicJsonType` value of a subtree
 ## Version history
 - Added in version 3.13.0.
@@ -1,58 +0,0 @@
 # <small>nlohmann::basic_json_document::</small>shrink_to_fit
 ```cpp
 void shrink_to_fit();
 ```
 Releases capacity that is no longer needed, both of the node index and of the buffer for decoded strings (strings that
 contained escape sequences), e.g. after [`read()`](read.md) replaced a large document with a much smaller one. Like
 `#!cpp std::vector::shrink_to_fit()`, this is a non-binding request: the library may keep more capacity than strictly
 necessary.
 ## Exception safety
 Strong guarantee: if an exception is thrown, there are no changes to the document.
 ## Exceptions
 May throw `#!cpp std::bad_alloc` if the reallocation fails; on exception, the document is unchanged.
 ## Complexity
 Linear in [`node_count()`](node_count.md) plus the length of the decoded strings.
 ## Notes
 !!! warning "Invalidates views"
    Unlike moving the document, `shrink_to_fit()` **invalidates every view taken from this document before the
    call**, including a previously obtained [`root()`](root.md): the node index is moved into a new, smaller
    allocation, and the old one is freed. Take a fresh view from [`root()`](root.md) after calling this function.
 This is unlike `#!cpp std::vector::shrink_to_fit()`, which promises nothing about validity but in practice often
 leaves iterators alone when it did not need to reallocate; here, an implementation that avoids a reallocation when
 possible would be an internal optimization only, not a guarantee to rely on.
 ## Examples
 ??? example
    ```cpp
    --8<-- "examples/basic_json_document__shrink_to_fit.cpp"
    ```
    Output:
    ```json
    --8<-- "examples/basic_json_document__shrink_to_fit.output"
    ```
 ## See also
 - [node_count](node_count.md) - the number of index entries
 - [memory_usage](memory_usage.md) - the number of bytes held by the document
 - [root](root.md) - the view of the root value
 ## Version history
 - Added in version 3.13.0.
@@ -1,48 +0,0 @@
 # <small>nlohmann::basic_json_document::</small>source
 ```cpp
 view_type::string_view_t source() const noexcept;
 ```
 Returns the parsed text, whether it is borrowed from the caller or owned by the document.
 ## Return value
 A `#!cpp string_view_t` (`#!cpp std::string_view` on C++17 and newer) over the parsed text, or an empty one if the
 document is [discarded](is_discarded.md).
 ## Exception safety
 No-throw guarantee: this function never throws exceptions.
 ## Complexity
 Constant.
 ## Notes
 For a borrowed document, `source()` points directly into the caller's buffer, so it is only valid while that buffer
 is; see [`owns_source`](owns_source.md).
 ## Examples
 ??? example
    ```cpp
    --8<-- "examples/basic_json_document__source.cpp"
    ```
    Output:
    ```json
    --8<-- "examples/basic_json_document__source.output"
    ```
 ## See also
 - [owns_source](owns_source.md) - return whether the document holds its own copy of the text
 - [source_offset](../basic_json_view/source_offset.md) - byte offset of a value in the source text
 ## Version history
 - Added in version 3.13.0.
@@ -1,50 +0,0 @@
 # <small>nlohmann::basic_json_view::</small>basic_json_view
 ```cpp
 basic_json_view() noexcept = default;
 ```
 Creates an invalid (discarded) view: [`type()`](type.md) is `#!cpp value_t::discarded` and
 [`is_discarded()`](is_discarded.md) is `#!cpp true`.
 This is the only constructor a caller can use directly. Every other view is obtained from a
 [`basic_json_document`](../basic_json_document/index.md), via [`root()`](../basic_json_document/root.md) or (once
 element access is added) from navigating into a container.
 ## Exception safety
 No-throw guarantee: this constructor never throws exceptions.
 ## Complexity
 Constant.
 ## Notes
 `basic_json_view` is trivially copyable (it holds two pointers), so a default-constructed view can be used as a
 placeholder for "no value yet" and later be assigned a real view.
 ## Examples
 ??? example
    The example below shows the default constructor and that a `basic_json_view` is a small, copyable handle.
    ```cpp
    --8<-- "examples/basic_json_view__basic_json_view.cpp"
    ```
    Output:
    ```json
    --8<-- "examples/basic_json_view__basic_json_view.output"
    ```
 ## See also
 - [is_discarded](is_discarded.md) - return whether the view is invalid
 - [root](../basic_json_document/root.md) - the view of a document's root value
 ## Version history
 - Added in version 3.13.0.
@@ -1,61 +0,0 @@
 # <small>nlohmann::basic_json_view::</small>empty
 ```cpp
 bool empty() const noexcept;
 ```
 Checks whether [`size()`](size.md) is `0`, as [`BasicJsonType::empty()`](../basic_json/empty.md) would for the same
 value.
 ## Return value
 The return value depends on the type and is defined as follows:
 | Value type          | return value    |
 |----------------------|-----------------|
 | null                  | `#!cpp true`     |
 | discarded             | `#!cpp true`     |
 | boolean               | `#!cpp false`    |
 | string                | `#!cpp false`    |
 | number                | `#!cpp false`    |
 | object                | `#!cpp object_t::empty()` |
 | array                 | `#!cpp array_t::empty()`  |
 ## Exception safety
 No-throw guarantee: this function never throws exceptions.
 ## Complexity
 Constant.
 ## Notes
 As for [`BasicJsonType::empty()`](../basic_json/empty.md), this does not return whether a string value is empty -- it
 is `#!cpp false` for any string, regardless of its length.
 ## Examples
 ??? example
    The example below uses [`size()`](size.md) and `empty()` to decide whether a parsed message is worth acting on,
    without materializing it into a `BasicJsonType` value.
    ```cpp
    --8<-- "examples/basic_json_view__size_empty.cpp"
    ```
    Output:
    ```json
    --8<-- "examples/basic_json_view__size_empty.output"
    ```
 ## See also
 - [size](size.md) - return the number of elements
 - [`BasicJsonType::empty`](../basic_json/empty.md) - the corresponding function of `basic_json`
 ## Version history
 - Added in version 3.13.0.
@@ -1,81 +0,0 @@
 # <small>nlohmann::</small>basic_json_view
 <small>Defined in header `<nlohmann/json_view.hpp>`</small>
 ```cpp
 template<typename BasicJsonType>
 class basic_json_view;
 ```
 A read-only handle to one value of a [`basic_json_document`](../basic_json_document/index.md): two pointers (a pointer
 to the document and a pointer into its index), trivially copyable. A view is valid as long as
 - the document is alive,
 - the document has not been re-parsed with [`read()`](../basic_json_document/read.md) (or
  [`parse()`](../basic_json_document/parse.md) into it) or shrunk with
  [`shrink_to_fit()`](../basic_json_document/shrink_to_fit.md) since the view was taken, and
 - if the document borrows its source text, that text is still alive.
 Moving the document itself does not invalidate its views: the index is heap-allocated independently of the
 `basic_json_document` object.
 `basic_json_view` provides the read-only part of the `BasicJsonType` interface: the type-inspection functions, and
 [`materialize()`](materialize.md) to build the `BasicJsonType` value of a subtree on demand. It does not (yet) provide
 element access, iteration, `get<T>()`, JSON Pointer support, `dump()`, or comparison.
 ## Template parameters
 `BasicJsonType`
 :   a specialization of [`basic_json`](../basic_json/index.md), matching the
    [`basic_json_document`](../basic_json_document/index.md) the view was taken from.
 ## Specializations
 - [**json_view**](../json_view.md) - views of a [`json_document`](../json_document.md)
 - [**ordered_json_view**](../ordered_json_view.md) - views of an [`ordered_json_document`](../ordered_json_document.md)
 ## Member types
 - **value_t** - the JSON type enumeration, see [`basic_json::value_t`](../basic_json/value_t.md)
 - **string_t**, **number_integer_t**, **number_unsigned_t**, **number_float_t**, **json_pointer** - the corresponding
  member types of `BasicJsonType`
 - **size_type** - `#!cpp std::size_t`
 - **string_view_t** - `#!cpp std::string_view` on C++17 and newer, a minimal internal substitute otherwise
 ## Member functions
 - [(constructor)](basic_json_view.md)
 ### Object inspection
 - [**type**](type.md) - return the type of the value
 - [**is_null**](is_null.md) - return whether the value is null
 - [**is_boolean**](is_boolean.md) - return whether the value is a boolean
 - [**is_number**](is_number.md) - return whether the value is a number
 - [**is_number_integer**](is_number_integer.md) - return whether the value is an integer number
 - [**is_number_unsigned**](is_number_unsigned.md) - return whether the value is an unsigned integer number
 - [**is_number_float**](is_number_float.md) - return whether the value is a floating-point number
 - [**is_string**](is_string.md) - return whether the value is a string
 - [**is_array**](is_array.md) - return whether the value is an array
 - [**is_object**](is_object.md) - return whether the value is an object
 - [**is_binary**](is_binary.md) - return whether the value is a binary array (always `#!cpp false`)
 - [**is_primitive**](is_primitive.md) - return whether the type is primitive
 - [**is_structured**](is_structured.md) - return whether the type is structured
 - [**is_discarded**](is_discarded.md) - return whether the view is invalid
 ### Capacity
 - [**size**](size.md) - return the number of elements
 - [**empty**](empty.md) - return whether the value has no elements
 ### Conversion
 - [**materialize**](materialize.md) - build the `BasicJsonType` value of this subtree
 ### Source access
 - [**source_offset**](source_offset.md) - byte offset of this value in the document's source text
 ## Version history
 - Added in version 3.13.0.
@@ -1,47 +0,0 @@
 # <small>nlohmann::basic_json_view::</small>is_array
 ```cpp
 bool is_array() const noexcept;
 ```
 This function returns `#!cpp true` if and only if the value is an array.
 ## Return value
 `#!cpp true` if the type is an array, `#!cpp false` otherwise.
 ## Exception safety
 No-throw guarantee: this function never throws exceptions.
 ## Complexity
 Constant.
 ## Examples
 ??? example
    The example below classifies several parsed documents by the type of their root value, without materializing any
    of them into a `BasicJsonType` value.
    ```cpp
    --8<-- "examples/basic_json_view__type_predicates.cpp"
    ```
    Output:
    ```json
    --8<-- "examples/basic_json_view__type_predicates.output"
    ```
 ## See also
 - [is_structured](is_structured.md) - return whether the type is structured
 - [size](size.md) - the number of elements
 - [empty](empty.md) - whether there are no elements
 - [`BasicJsonType::is_array`](../basic_json/is_array.md) - the corresponding function of `basic_json`
 ## Version history
 - Added in version 3.13.0.
@@ -1,47 +0,0 @@
 # <small>nlohmann::basic_json_view::</small>is_binary
 ```cpp
 bool is_binary() const noexcept;
 ```
 This function always returns `#!cpp false`: a document is only ever parsed from JSON text, never from CBOR or the other
 binary formats, and a JSON text has no binary values, so a view can never refer to one. The function exists for
 interface parity with [`BasicJsonType::is_binary`](../basic_json/is_binary.md).
 ## Return value
 `#!cpp false`, always.
 ## Exception safety
 No-throw guarantee: this function never throws exceptions.
 ## Complexity
 Constant.
 ## Examples
 ??? example
    The example below classifies several parsed documents by the type of their root value, without materializing any
    of them into a `BasicJsonType` value.
    ```cpp
    --8<-- "examples/basic_json_view__type_predicates.cpp"
    ```
    Output:
    ```json
    --8<-- "examples/basic_json_view__type_predicates.output"
    ```
 ## See also
 - [type](type.md) - return the type of the value
 - [`BasicJsonType::is_binary`](../basic_json/is_binary.md) - the corresponding function of `basic_json`
 ## Version history
 - Added in version 3.13.0.
@@ -1,45 +0,0 @@
 # <small>nlohmann::basic_json_view::</small>is_boolean
 ```cpp
 bool is_boolean() const noexcept;
 ```
 This function returns `#!cpp true` if and only if the value is a boolean.
 ## Return value
 `#!cpp true` if the type is a boolean, `#!cpp false` otherwise.
 ## Exception safety
 No-throw guarantee: this function never throws exceptions.
 ## Complexity
 Constant.
 ## Examples
 ??? example
    The example below classifies several parsed documents by the type of their root value, without materializing any
    of them into a `BasicJsonType` value.
    ```cpp
    --8<-- "examples/basic_json_view__type_predicates.cpp"
    ```
    Output:
    ```json
    --8<-- "examples/basic_json_view__type_predicates.output"
    ```
 ## See also
 - [type](type.md) - return the type of the value
 - [`BasicJsonType::is_boolean`](../basic_json/is_boolean.md) - the corresponding function of `basic_json`
 ## Version history
 - Added in version 3.13.0.
@@ -1,55 +0,0 @@
 # <small>nlohmann::basic_json_view::</small>is_discarded
 ```cpp
 bool is_discarded() const noexcept;
 ```
 Returns whether this view is invalid, i.e. does not refer to a value. This is the case for a default-constructed
 view (see [(constructor)](basic_json_view.md)), and for [`root()`](../basic_json_document/root.md) of a document
 that is itself [discarded](../basic_json_document/is_discarded.md) -- in particular, the root of a failed
 [`parse()`](../basic_json_document/parse.md) with `allow_exceptions` set to `#!cpp false`.
 ## Return value
 `#!cpp true` if the view or its document is discarded, `#!cpp false` otherwise.
 ## Exception safety
 No-throw guarantee: this function never throws exceptions.
 ## Complexity
 Constant.
 ## Notes
 A `basic_json_view` is not convertible to `#!cpp bool`: such a conversion would mean "refers to a value", whereas
 `basic_json` converts to the `#!cpp bool` it holds, so the same code would silently behave differently. Test
 `#!cpp !v.is_discarded()` explicitly.
 ## Examples
 ??? example
    The example below classifies several parsed documents by the type of their root value, without materializing any
    of them into a `BasicJsonType` value.
    ```cpp
    --8<-- "examples/basic_json_view__type_predicates.cpp"
    ```
    Output:
    ```json
    --8<-- "examples/basic_json_view__type_predicates.output"
    ```
 ## See also
 - [(constructor)](basic_json_view.md) - the default constructor creates a discarded view
 - [is_discarded (basic_json_document)](../basic_json_document/is_discarded.md) - return whether the last parse failed
 - [`BasicJsonType::is_discarded`](../basic_json/is_discarded.md) - the corresponding function of `basic_json`
 ## Version history
 - Added in version 3.13.0.
@@ -1,45 +0,0 @@
 # <small>nlohmann::basic_json_view::</small>is_null
 ```cpp
 bool is_null() const noexcept;
 ```
 This function returns `#!cpp true` if and only if the value is `#!json null`.
 ## Return value
 `#!cpp true` if the type is `#!json null`, `#!cpp false` otherwise.
 ## Exception safety
 No-throw guarantee: this function never throws exceptions.
 ## Complexity
 Constant.
 ## Examples
 ??? example
    The example below classifies several parsed documents by the type of their root value, without materializing any
    of them into a `BasicJsonType` value.
    ```cpp
    --8<-- "examples/basic_json_view__type_predicates.cpp"
    ```
    Output:
    ```json
    --8<-- "examples/basic_json_view__type_predicates.output"
    ```
 ## See also
 - [type](type.md) - return the type of the value
 - [`BasicJsonType::is_null`](../basic_json/is_null.md) - the corresponding function of `basic_json`
 ## Version history
 - Added in version 3.13.0.
@@ -1,47 +0,0 @@
 # <small>nlohmann::basic_json_view::</small>is_number
 ```cpp
 bool is_number() const noexcept;
 ```
 This function returns `#!cpp true` if and only if the value is a number, i.e. an integer, unsigned integer, or floating-point value. It is defined as `#!cpp is_number_integer() || is_number_float()`.
 ## Return value
 `#!cpp true` if the type is a number, `#!cpp false` otherwise.
 ## Exception safety
 No-throw guarantee: this function never throws exceptions.
 ## Complexity
 Constant.
 ## Examples
 ??? example
    The example below classifies several parsed documents by the type of their root value, without materializing any
    of them into a `BasicJsonType` value.
    ```cpp
    --8<-- "examples/basic_json_view__type_predicates.cpp"
    ```
    Output:
    ```json
    --8<-- "examples/basic_json_view__type_predicates.output"
    ```
 ## See also
 - [is_number_integer](is_number_integer.md) - return whether the value is an integer or unsigned integer number
 - [is_number_unsigned](is_number_unsigned.md) - return whether the value is an unsigned integer number
 - [is_number_float](is_number_float.md) - return whether the value is a floating-point number
 - [`BasicJsonType::is_number`](../basic_json/is_number.md) - the corresponding function of `basic_json`
 ## Version history
 - Added in version 3.13.0.
@@ -1,51 +0,0 @@
 # <small>nlohmann::basic_json_view::</small>is_number_float
 ```cpp
 bool is_number_float() const noexcept;
 ```
 This function returns `#!cpp true` if and only if the value is a floating-point number.
 ## Return value
 `#!cpp true` if the type is `#!cpp value_t::number_float`, `#!cpp false` otherwise.
 ## Exception safety
 No-throw guarantee: this function never throws exceptions.
 ## Complexity
 Constant.
 ## Notes
 As for [`BasicJsonType::parse`](../basic_json/parse.md), an integer literal that does not fit into the 64-bit
 integer type is classified as a floating-point number, so `is_number_float()` can be `#!cpp true` even for an
 integer-looking token in the source text.
 ## Examples
 ??? example
    The example below classifies several parsed documents by the type of their root value, without materializing any
    of them into a `BasicJsonType` value.
    ```cpp
    --8<-- "examples/basic_json_view__type_predicates.cpp"
    ```
    Output:
    ```json
    --8<-- "examples/basic_json_view__type_predicates.output"
    ```
 ## See also
 - [is_number](is_number.md) - return whether the value is a number
 - [`BasicJsonType::is_number_float`](../basic_json/is_number_float.md) - the corresponding function of `basic_json`
 ## Version history
 - Added in version 3.13.0.
@@ -1,51 +0,0 @@
 # <small>nlohmann::basic_json_view::</small>is_number_integer
 ```cpp
 bool is_number_integer() const noexcept;
 ```
 This function returns `#!cpp true` if and only if the value is an integer or unsigned integer number.
 ## Return value
 `#!cpp true` if the type is `#!cpp value_t::number_integer` or `#!cpp value_t::number_unsigned`, `#!cpp false` otherwise.
 ## Exception safety
 No-throw guarantee: this function never throws exceptions.
 ## Complexity
 Constant.
 ## Notes
 As for [`BasicJsonType::is_number_integer`](../basic_json/is_number_integer.md), this includes unsigned integer
 values; use [`is_number_unsigned`](is_number_unsigned.md) to test for those specifically.
 ## Examples
 ??? example
    The example below classifies several parsed documents by the type of their root value, without materializing any
    of them into a `BasicJsonType` value.
    ```cpp
    --8<-- "examples/basic_json_view__type_predicates.cpp"
    ```
    Output:
    ```json
    --8<-- "examples/basic_json_view__type_predicates.output"
    ```
 ## See also
 - [is_number](is_number.md) - return whether the value is a number
 - [is_number_unsigned](is_number_unsigned.md) - return whether the value is an unsigned integer number
 - [`BasicJsonType::is_number_integer`](../basic_json/is_number_integer.md) - the corresponding function of `basic_json`
 ## Version history
 - Added in version 3.13.0.
@@ -1,45 +0,0 @@
 # <small>nlohmann::basic_json_view::</small>is_number_unsigned
 ```cpp
 bool is_number_unsigned() const noexcept;
 ```
 This function returns `#!cpp true` if and only if the value is an unsigned integer number.
 ## Return value
 `#!cpp true` if the type is `#!cpp value_t::number_unsigned`, `#!cpp false` otherwise.
 ## Exception safety
 No-throw guarantee: this function never throws exceptions.
 ## Complexity
 Constant.
 ## Examples
 ??? example
    The example below classifies several parsed documents by the type of their root value, without materializing any
    of them into a `BasicJsonType` value.
    ```cpp
    --8<-- "examples/basic_json_view__type_predicates.cpp"
    ```
    Output:
    ```json
    --8<-- "examples/basic_json_view__type_predicates.output"
    ```
 ## See also
 - [is_number_integer](is_number_integer.md) - return whether the value is an integer or unsigned integer number
 - [`BasicJsonType::is_number_unsigned`](../basic_json/is_number_unsigned.md) - the corresponding function of `basic_json`
 ## Version history
 - Added in version 3.13.0.
@@ -1,47 +0,0 @@
 # <small>nlohmann::basic_json_view::</small>is_object
 ```cpp
 bool is_object() const noexcept;
 ```
 This function returns `#!cpp true` if and only if the value is an object.
 ## Return value
 `#!cpp true` if the type is an object, `#!cpp false` otherwise.
 ## Exception safety
 No-throw guarantee: this function never throws exceptions.
 ## Complexity
 Constant.
 ## Examples
 ??? example
    The example below classifies several parsed documents by the type of their root value, without materializing any
    of them into a `BasicJsonType` value.
    ```cpp
    --8<-- "examples/basic_json_view__type_predicates.cpp"
    ```
    Output:
    ```json
    --8<-- "examples/basic_json_view__type_predicates.output"
    ```
 ## See also
 - [is_structured](is_structured.md) - return whether the type is structured
 - [size](size.md) - the number of elements
 - [empty](empty.md) - whether there are no elements
 - [`BasicJsonType::is_object`](../basic_json/is_object.md) - the corresponding function of `basic_json`
 ## Version history
 - Added in version 3.13.0.
@@ -1,46 +0,0 @@
 # <small>nlohmann::basic_json_view::</small>is_primitive
 ```cpp
 bool is_primitive() const noexcept;
 ```
 This function returns `#!cpp true` if and only if the value is primitive, i.e. `#!json null`, a boolean, a number, or a string. It is defined as `#!cpp is_null() || is_string() || is_boolean() || is_number()`.
 ## Return value
 `#!cpp true` if the type is primitive, `#!cpp false` otherwise.
 ## Exception safety
 No-throw guarantee: this function never throws exceptions.
 ## Complexity
 Constant.
 ## Examples
 ??? example
    The example below classifies several parsed documents by the type of their root value, without materializing any
    of them into a `BasicJsonType` value.
    ```cpp
    --8<-- "examples/basic_json_view__type_predicates.cpp"
    ```
    Output:
    ```json
    --8<-- "examples/basic_json_view__type_predicates.output"
    ```
 ## See also
 - [is_structured](is_structured.md) - return whether the type is structured (the complement of this function, for a
  non-discarded view)
 - [`BasicJsonType::is_primitive`](../basic_json/is_primitive.md) - the corresponding function of `basic_json`
 ## Version history
 - Added in version 3.13.0.
@@ -1,46 +0,0 @@
 # <small>nlohmann::basic_json_view::</small>is_string
 ```cpp
 bool is_string() const noexcept;
 ```
 This function returns `#!cpp true` if and only if the value is a string.
 ## Return value
 `#!cpp true` if the type is a string, `#!cpp false` otherwise.
 ## Exception safety
 No-throw guarantee: this function never throws exceptions.
 ## Complexity
 Constant.
 ## Examples
 ??? example
    The example below classifies several parsed documents by the type of their root value, without materializing any
    of them into a `BasicJsonType` value.
    ```cpp
    --8<-- "examples/basic_json_view__type_predicates.cpp"
    ```
    Output:
    ```json
    --8<-- "examples/basic_json_view__type_predicates.output"
    ```
 ## See also
 - [source_offset](source_offset.md) - byte offset of this value in the source text, which differs for strings: an
  escaped string has none
 - [`BasicJsonType::is_string`](../basic_json/is_string.md) - the corresponding function of `basic_json`
 ## Version history
 - Added in version 3.13.0.
@@ -1,46 +0,0 @@
 # <small>nlohmann::basic_json_view::</small>is_structured
 ```cpp
 bool is_structured() const noexcept;
 ```
 This function returns `#!cpp true` if and only if the value is structured, i.e. an array or an object. It is defined as `#!cpp is_array() || is_object()`.
 ## Return value
 `#!cpp true` if the type is structured, `#!cpp false` otherwise.
 ## Exception safety
 No-throw guarantee: this function never throws exceptions.
 ## Complexity
 Constant.
 ## Examples
 ??? example
    The example below classifies several parsed documents by the type of their root value, without materializing any
    of them into a `BasicJsonType` value.
    ```cpp
    --8<-- "examples/basic_json_view__type_predicates.cpp"
    ```
    Output:
    ```json
    --8<-- "examples/basic_json_view__type_predicates.output"
    ```
 ## See also
 - [is_primitive](is_primitive.md) - return whether the type is primitive
 - [size](size.md), [empty](empty.md) - the number of elements, and whether there are none
 - [`BasicJsonType::is_structured`](../basic_json/is_structured.md) - the corresponding function of `basic_json`
 ## Version history
 - Added in version 3.13.0.
@@ -1,70 +0,0 @@
 # <small>nlohmann::basic_json_view::</small>materialize
 ```cpp
 BasicJsonType materialize() const;
 ```
 Builds the `BasicJsonType` value of this subtree: the value [`BasicJsonType::parse()`](../basic_json/parse.md) would
 have produced for the same source text, allocated for the first time by this call.
 ## Return value
 The `BasicJsonType` value of this subtree, or a discarded `BasicJsonType` value (`#!cpp BasicJsonType(value_t::discarded)`)
 if the view is [discarded](is_discarded.md).
 ## Exception safety
 Strong guarantee: there are no changes to the view or the document it refers to (nothing about either is mutated by
 this function).
 ## Exceptions
 May throw `#!cpp std::bad_alloc` (via `BasicJsonType`'s allocator) if constructing the result fails.
 ## Complexity
 Linear in the size of the subtree.
 ## Notes
 `materialize()` replays the subtree through the same SAX builder [`BasicJsonType::parse()`](../basic_json/parse.md)
 uses, so the result matches it exactly -- including, for an object, that a repeated key keeps only its
 last value. The replay is iterative, so it is not limited by the call stack the way a naive recursive conversion
 would be; the JSON nesting depth is limited only by available memory, as for `BasicJsonType::parse()` itself.
 Unlike parsing with [`JSON_DIAGNOSTIC_POSITIONS`](../macros/json_diagnostic_positions.md) enabled, the values
 produced by `materialize()` do not carry source positions. The index has the start offset of every value, but not the
 end of arrays, objects, and escaped strings, which the positions also need.
 Calling `materialize()` on the same view repeatedly builds a new, independent `BasicJsonType` value each time; it
 never caches the result.
 ## Examples
 ??? example
    The example below skips messages that are not useful -- a discarded value, or an empty array -- using only
    [`is_array()`](is_array.md) and [`empty()`](empty.md), and calls `materialize()` only for the messages that are
    actually used, so no `BasicJsonType` value (and none of its per-element allocations) is ever built for the
    skipped ones.
    ```cpp
    --8<-- "examples/basic_json_view__materialize.cpp"
    ```
    Output:
    ```json
    --8<-- "examples/basic_json_view__materialize.output"
    ```
 ## See also
 - [root](../basic_json_document/root.md) - the view of a document's root value
 - [`BasicJsonType::parse`](../basic_json/parse.md) - build a `BasicJsonType` value directly from a JSON text
 - [`JSON_DIAGNOSTIC_POSITIONS`](../macros/json_diagnostic_positions.md) - source positions on parsed values (not
  produced by `materialize()`)
 ## Version history
 - Added in version 3.13.0.
@@ -1,60 +0,0 @@
 # <small>nlohmann::basic_json_view::</small>size
 ```cpp
 size_type size() const noexcept;
 ```
 Returns the number of elements, as [`BasicJsonType::size()`](../basic_json/size.md) would for the same value.
 ## Return value
 The return value depends on the type and is defined as follows:
 | Value type | return value              |
 |------------|---------------------------|
 | null       | `0`                       |
 | discarded  | `0`                       |
 | boolean    | `1`                       |
 | string     | `1`                       |
 | number     | `1`                       |
 | object     | number of key/value pairs |
 | array      | number of elements        |
 ## Exception safety
 No-throw guarantee: this function never throws exceptions.
 ## Complexity
 Constant: for an object or array, the element count is stored in the index, not counted on demand.
 ## Notes
 As for [`BasicJsonType::size()`](../basic_json/size.md), this does not return the length of a string value -- it is
 `1` for a string, regardless of its length.
 ## Examples
 ??? example
    The example below uses `size()` and [`empty()`](empty.md) to decide whether a parsed message is worth acting on,
    without materializing it into a `BasicJsonType` value.
    ```cpp
    --8<-- "examples/basic_json_view__size_empty.cpp"
    ```
    Output:
    ```json
    --8<-- "examples/basic_json_view__size_empty.output"
    ```
 ## See also
 - [empty](empty.md) - return whether the value has no elements
 - [`BasicJsonType::size`](../basic_json/size.md) - the corresponding function of `basic_json`
 ## Version history
 - Added in version 3.13.0.
@@ -1,55 +0,0 @@
 # <small>nlohmann::basic_json_view::</small>source_offset
 ```cpp
 std::size_t source_offset() const noexcept;
 ```
 Returns the byte offset of this value in the document's [`source()`](../basic_json_document/source.md) text, without
 materializing anything.
 ## Return value
 - For a string with no escapes, a number, `#!json true`/`#!json false`/`#!json null`, an array, or an object: the
  byte offset of the first byte of the value's token (for a string: the first byte after the opening quote) in
  [`source()`](../basic_json_document/source.md).
 - `#!cpp static_cast<std::size_t>(-1)` for a [discarded](is_discarded.md) view, and for a string that contains
  escapes -- such a string was decoded once into the document's own buffer, so there is no single byte range in
  `source()` left to point at.
 ## Exception safety
 No-throw guarantee: this function never throws exceptions.
 ## Complexity
 Constant.
 ## Notes
 This is a raw offset, not a length: the API does not (yet) expose how many bytes the token occupies in the source
 text, so `source_offset()` alone is enough to report *where* a value came from (for an error message, for syntax
 highlighting, ...) but not to slice its exact text back out of [`source()`](../basic_json_document/source.md) for a
 string, whose token length is not the same as its decoded [`size()`](size.md).
 ## Examples
 ??? example
    ```cpp
    --8<-- "examples/basic_json_view__source_offset.cpp"
    ```
    Output:
    ```json
    --8<-- "examples/basic_json_view__source_offset.output"
    ```
 ## See also
 - [source](../basic_json_document/source.md) - the parsed text
 - [is_string](is_string.md) - return whether the value is a string
 ## Version history
 - Added in version 3.13.0.
@@ -1,53 +0,0 @@
 # <small>nlohmann::basic_json_view::</small>type
 ```cpp
 value_t type() const noexcept;
 ```
 Returns the type of the value this view refers to, as a value from the [`value_t`](../basic_json/value_t.md)
 enumeration -- the same enumeration [`BasicJsonType::type()`](../basic_json/type.md) uses.
 ## Return value
 The type of the value; `#!cpp value_t::discarded` for a [discarded](is_discarded.md) view.
 ## Exception safety
 No-throw guarantee: this function never throws exceptions.
 ## Complexity
 Constant.
 ## Notes
 Unlike [`BasicJsonType::type()`](../basic_json/type.md), this function can never return `#!cpp value_t::binary`: a
 JSON text has no binary values, so `type()` only distinguishes the eight ordinary JSON value types (plus
 `#!cpp discarded`).
 ## Examples
 ??? example
    The example below classifies several parsed documents by the type of their root value, without materializing any
    of them into a `BasicJsonType` value.
    ```cpp
    --8<-- "examples/basic_json_view__type_predicates.cpp"
    ```
    Output:
    ```json
    --8<-- "examples/basic_json_view__type_predicates.output"
    ```
 ## See also
 - [is_null](is_null.md), [is_boolean](is_boolean.md), [is_number](is_number.md), [is_string](is_string.md),
  [is_array](is_array.md), [is_object](is_object.md) - type-specific predicates built on `type()`
 - [`BasicJsonType::type`](../basic_json/type.md) - the corresponding function of `basic_json`
 ## Version history
 - Added in version 3.13.0.
@@ -1,35 +0,0 @@
 # <small>nlohmann::</small>json_document
 <small>Defined in header `<nlohmann/json_view.hpp>`</small>
 ```cpp
 using json_document = basic_json_document<json>;
 ```
 This type is a [`basic_json_document`](basic_json_document/index.md) of the default [`json`](json.md)
 specialization.
 ## Examples
 ??? example
    The example below demonstrates how to use the type `nlohmann::json_document`.
    ```cpp
    --8<-- "examples/json_document.cpp"
    ```
    Output:
    ```json
    --8<-- "examples/json_document.output"
    ```
 ## See also
 - [json_view](json_view.md) - a view of a value of a `json_document`
 - [ordered_json_document](ordered_json_document.md) - the corresponding document for `ordered_json`
 ## Version history
 Since version 3.13.0.
@@ -1,34 +0,0 @@
 # <small>nlohmann::</small>json_view
 <small>Defined in header `<nlohmann/json_view.hpp>`</small>
 ```cpp
 using json_view = basic_json_view<json>;
 ```
 This type is a [`basic_json_view`](basic_json_view/index.md) of a value of a [`json_document`](json_document.md).
 ## Examples
 ??? example
    The example below demonstrates how to use the type `nlohmann::json_view`.
    ```cpp
    --8<-- "examples/json_view.cpp"
    ```
    Output:
    ```json
    --8<-- "examples/json_view.output"
    ```
 ## See also
 - [json_document](json_document.md) - the document type this view refers into
 - [ordered_json_view](ordered_json_view.md) - the corresponding view for `ordered_json_document`
 ## Version history
 Since version 3.13.0.
@@ -16,6 +16,10 @@ header. See also the [macro overview page](../../features/macros.md).
 ## Parsing
 - [**JSON_DISABLE_STREAM_BULK_SCAN**](json_disable_stream_bulk_scan.md) - read a `std::istream` one character at a time
  instead of scanning its stream buffer in bulk
 - [**JSON_DISABLE_UNLOCKED_FILE_IO**](json_disable_unlocked_file_io.md) - read a `FILE*` with `std::fgetc` instead of
  locking it once and using the unlocked stdio functions
 - [**JSON_PRECISE_STREAM_POSITION**](json_precise_stream_position.md) - opt in to leaving an input stream positioned
  right after a parsed number
 - [**JSON_STRICT_BINARY_UTF8**](json_strict_binary_utf8.md) - opt in to checking strings for valid UTF-8 in the CBOR,
@@ -34,6 +38,7 @@ header. See also the [macro overview page](../../features/macros.md).
 - [**JSON_HAS_THREE_WAY_COMPARISON**](json_has_three_way_comparison.md) - control 3-way comparison support
 - [**JSON_NO_AUTOMATIC_UDLS**](json_no_automatic_udls.md) - do not include the user-defined string literals (UDLs) automatically
 - [**JSON_NO_IO**](json_no_io.md) - switch off functions relying on certain C++ I/O headers
 - [**JSON_NO_SIMD**](json_no_simd.md) - use only portable code instead of vector instructions (SSE2, SSSE3, NEON)
 - [**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
@@ -0,0 +1,145 @@
 # JSON_DISABLE_STREAM_BULK_SCAN
 ```cpp
 #define JSON_DISABLE_STREAM_BULK_SCAN /* value */
 ```
 When defined to `1`, parsing from a `#!cpp std::istream` reads the input one character at a time through the stream
 buffer, as in version 3.12.0 and earlier, instead of scanning the characters that the stream buffer already holds in
 bulk.
 The macro is an escape hatch for stream buffers that do not follow the usual contract of `std::basic_streambuf` (see
 the requirements on the stream buffer in the notes below). It does not change any result: values, exceptions, and the
 position of the stream after parsing are the same either way. Only the speed differs.
 ## Default definition
 The default value is `0`: streams are scanned in bulk.
 ```cpp
 #define JSON_DISABLE_STREAM_BULK_SCAN 0
 ```
 ## Notes
 !!! note "How streams are scanned"
    A `std::streambuf` keeps the part of the input it has read but not yet handed out in its *get area*, the range
    from `gptr()` to `egptr()`. A `std::filebuf`, for instance, reads the file in blocks of a few kilobytes into its get
    area, and a `std::stringbuf` exposes its whole string as one get area.
    When parsing from a `std::istream`, the parser scans this get area directly, with the same fast paths that it uses
    for a `std::string`: runs of ordinary string characters, numbers, and indentation are recognized several bytes at a
    time instead of being requested from the stream buffer one character at a time. When the parser reaches the end of
    the get area, it asks the stream buffer for the next character as before, which makes the stream buffer refill its
    get area.
    The parser only reads characters that it would also have read one at a time, and it advances the stream buffer
    exactly over the characters it consumes. Nothing is read ahead, buffered elsewhere, or put back. Therefore, the
    stream is left exactly where it was left before:
    - [`operator>>`](../operator_gtgt.md) and [`sax_parse`](../basic_json/sax_parse.md) with `strict = false` can still
      read several values from one stream, and the stream can still be used with other `std::istream` functions after a
      value has been read.
    - With [`JSON_PRECISE_STREAM_POSITION`](json_precise_stream_position.md), the stream is still positioned right after
      a parsed number.
    - Exception messages, including the line, the column, and the last read token, are unchanged.
 !!! note "Performance"
    Parsing from a `std::ifstream` or `std::istringstream` is typically 1.5 to 2 times as fast as before, and reading
    many small values from one stream with `operator>>` 1.4 to 4 times as fast. Parsing from a stream is then within
    about 10 to 20 % of first reading the whole file into a `std::string` and parsing that.
    A stream buffer without a get area (one that only overrides `underflow()` and `uflow()` and hands out every
    character from there) offers nothing to scan in bulk, so it is read one character at a time as before.
 !!! note "Requirements on the stream buffer"
    The bulk scan relies on the following behavior, which every stream buffer of the standard library and every stream
    buffer that keeps its input in its get area has:
    - When `sgetc()` returns a character while `gptr() < egptr()`, that character is `*gptr()`; when `sbumpc()` returns
      one, it was at `gptr()` before the call.
    - Characters in the get area are not changed while they are in the get area.
    - `underflow()` or `uflow()` either sets up a get area that holds the returned character at `gptr()` (or at
      `gptr() - 1` after `uflow()`), or leaves the get area empty.
    A stream buffer that returns characters from `uflow()` while leaving unrelated characters in its get area, or that
    changes the characters in its get area in place, does not meet these requirements. Define the macro to `1` for
    such stream buffers.
 !!! warning "Define consistently"
    The macro selects between two definitions of the library's internal stream input adapter. It must therefore be
    defined identically for **every** translation unit that includes the library; mixing translation units that define
    it with ones that do not is an ODR violation. Prefer setting it as a compile definition on the target rather than
    with `#!cpp #define` in individual source files.
 !!! note "Other inputs"
    Strings, string views, vectors, arrays, and pointer or iterator ranges over contiguous memory are scanned in bulk
    anyway. Reading from a `#!cpp FILE*` is not affected by this macro; see
    [`JSON_DISABLE_UNLOCKED_FILE_IO`](json_disable_unlocked_file_io.md) for that input.
 ## Examples
 ??? example "Example: reading values from a stream (default)"
    The stream is scanned in bulk, and the values are read one after the other:
    ```cpp
    #include <iostream>
    #include <sstream>
    #include <nlohmann/json.hpp>
    using json = nlohmann::json;
    int main()
    {
        std::istringstream input(R"({"id": 1} {"id": 2} 42 rest)");
        json j1, j2, j3;
        input >> j1 >> j2 >> j3;  // {"id":1}, {"id":2}, 42
        std::string word;
        input >> word;            // "rest"
    }
    ```
 ??? example "Example: reading one character at a time (macro defined to 1)"
    With the macro, the same program reads the stream one character at a time, with the same results:
    ```cpp
    #define JSON_DISABLE_STREAM_BULK_SCAN 1
    #include <iostream>
    #include <sstream>
    #include <nlohmann/json.hpp>
    using json = nlohmann::json;
    int main()
    {
        std::istringstream input(R"({"id": 1} {"id": 2} 42 rest)");
        json j1, j2, j3;
        input >> j1 >> j2 >> j3;  // {"id":1}, {"id":2}, 42
        std::string word;
        input >> word;            // "rest"
    }
    ```
 ## See also
 - [**parse**](../basic_json/parse.md) - deserialize from a compatible input
 - [**operator>>**](../operator_gtgt.md) - deserialize from stream
 - [**sax_parse**](../basic_json/sax_parse.md) - generate SAX events
 - [**JSON_PRECISE_STREAM_POSITION**](json_precise_stream_position.md) - leave an input stream positioned right after a
  parsed number
 - [**JSON_DISABLE_UNLOCKED_FILE_IO**](json_disable_unlocked_file_io.md) - read a `FILE*` with the locking stdio
  functions
 - [Parsing: input sources and performance](../../features/parsing/index.md#input-sources-and-performance)
 ## Version history
 - Added in version 3.13.0.
@@ -0,0 +1,113 @@
 # JSON_DISABLE_UNLOCKED_FILE_IO
 ```cpp
 #define JSON_DISABLE_UNLOCKED_FILE_IO /* value */
 ```
 When defined to `1`, parsing from a `#!cpp FILE*` reads every character with `std::fgetc`, as in version 3.12.0 and
 earlier, instead of locking the file once and reading it with the unlocked stdio functions.
 It does not change any result: values, exceptions, and the position of the file after parsing are the same either way.
 Only the speed and the locking of the file differ (see the notes on locking below).
 ## Default definition
 The default value is `0`: the file is locked once and read with the unlocked stdio functions where they are available.
 ```cpp
 #define JSON_DISABLE_UNLOCKED_FILE_IO 0
 ```
 ## Notes
 !!! note "Background"
    The C standard library makes every `std::fgetc` call thread-safe by locking and unlocking the `FILE` object. When
    parsing from a `FILE*`, the parser reads one character at a time, so this happens for every character of the input.
    Instead, the parser locks the file once when parsing starts and unlocks it when parsing ends - also when an
    exception is thrown - and reads the characters in between without locking:
    | C library                                                  | functions                                          |
    |------------------------------------------------------------|----------------------------------------------------|
    | glibc (Linux), Apple (macOS, iOS), Android, FreeBSD, NetBSD, OpenBSD, DragonFly BSD | `flockfile`, `getc_unlocked`, `funlockfile` (POSIX) |
    | Microsoft (MSVC, clang-cl)                                 | `_lock_file`, `_fgetc_nolock`, `_unlock_file`       |
    | others (e.g., musl, MinGW, newlib)                         | `std::fgetc`, as before                             |
    This makes parsing from a `FILE*` 3 to 4 times as fast with the Apple C library and 1.1 to 1.3 times as fast with
    glibc, whose locking is cheaper. The binary formats ([`from_cbor`](../basic_json/from_cbor.md),
    [`from_msgpack`](../basic_json/from_msgpack.md), ...) read from a `FILE*` the same way.
 !!! note "Locking"
    While a value is parsed from a `FILE*`, the parsing thread holds the file's lock. The lock is recursive, so the
    parsing thread itself - for instance, a [SAX](../json_sax/index.md) handler or a
    [parser callback](../basic_json/parser_callback_t.md) - can keep using the file with stdio functions such as
    `std::ftell`. Other threads that use the same `FILE` object wait until the parser is done. Before, they could
    interleave their reads with the parser's, which made the parsed input unpredictable anyway.
    A program in which a SAX handler or parser callback waits for **another** thread that uses the **same** `FILE`
    object would deadlock. Define the macro to `1` for such programs.
 !!! warning "Define consistently"
    The macro selects between two definitions of the library's internal `FILE*` input adapter. It must therefore be
    defined identically for **every** translation unit that includes the library; mixing translation units that define
    it with ones that do not is an ODR violation (and can leave a file locked). Prefer setting it as a compile
    definition on the target rather than with `#!cpp #define` in individual source files.
 !!! note "Other inputs"
    Reading from a `#!cpp std::istream` is not affected by this macro; see
    [`JSON_DISABLE_STREAM_BULK_SCAN`](json_disable_stream_bulk_scan.md) for that input.
 ## Examples
 ??? example "Example: parsing from a `FILE*` (default)"
    The file is locked once while it is parsed:
    ```cpp
    #include <cstdio>
    #include <nlohmann/json.hpp>
    using json = nlohmann::json;
    int main()
    {
        std::FILE* f = std::fopen("example.json", "rb");
        json j = json::parse(f);  // f is locked until parse() returns
        std::fclose(f);
    }
    ```
 ??? example "Example: locking for every character (macro defined to 1)"
    With the macro, every character is read with `std::fgetc`, with the same result:
    ```cpp
    #define JSON_DISABLE_UNLOCKED_FILE_IO 1
    #include <cstdio>
    #include <nlohmann/json.hpp>
    using json = nlohmann::json;
    int main()
    {
        std::FILE* f = std::fopen("example.json", "rb");
        json j = json::parse(f);  // std::fgetc for every character
        std::fclose(f);
    }
    ```
 ## See also
 - [**parse**](../basic_json/parse.md) - deserialize from a compatible input
 - [**sax_parse**](../basic_json/sax_parse.md) - generate SAX events
 - [**JSON_DISABLE_STREAM_BULK_SCAN**](json_disable_stream_bulk_scan.md) - read a `std::istream` one character at a
  time
 - [Parsing: input sources and performance](../../features/parsing/index.md#input-sources-and-performance)
 ## Version history
 - Added in version 3.13.0.
@@ -0,0 +1,83 @@
 # JSON_NO_SIMD
 ```cpp
 #define JSON_NO_SIMD
 ```
 When defined, the library uses only portable C++ code where it would otherwise use vector instructions: when scanning
 strings during parsing, and when writing floating-point numbers during serialization.
 The macro is an escape hatch, for example for toolchains that cannot compile the vector code, for sanitizers or
 analyzers that do not understand it, or to compare the speed of both variants. It does not change any result: values,
 exceptions, and error positions are the same either way. Only the speed differs.
 ## Default definition
 By default, `#!cpp JSON_NO_SIMD` is not defined, and vector instructions are used where the target has them.
 ```cpp
 #undef JSON_NO_SIMD
 ```
 ## Notes
 !!! note "Which instructions are used"
    - **x86-64:** SSE2, which every x86-64 CPU has, finds the end of runs of plain string characters 16 bytes at a time
      and writes the digits of floating-point numbers. The UTF-8 check of non-ASCII text needs SSSE3, which is not part
      of x86-64: it is compiled for SSSE3 with a function attribute and used when the CPU has SSSE3 (every x86-64 CPU
      since about 2011), else the portable check. Code compiled for SSSE3 anyway (e.g., with `-mssse3` or `-march=native`)
      skips this check of the CPU. 32-bit x86 uses SSE2 for strings when the compiler targets it.
    - **AArch64:** NEON, which every 64-bit Arm CPU has, checks UTF-8 text and long runs of plain string characters 16
      bytes at a time, and writes the digits of floating-point numbers. With MSVC, only the floating-point digits use
      NEON.
    - **Other targets:** portable code only.
    Strings are only scanned this way for contiguous input and for the characters a `#!cpp std::istream` holds in its
    stream buffer (see [`JSON_DISABLE_STREAM_BULK_SCAN`](json_disable_stream_bulk_scan.md)); other inputs are read one
    character at a time.
 !!! note "Interaction with `JSON_USE_SIMDUTF`"
    With [`JSON_USE_SIMDUTF`](json_use_simdutf.md), runs of string characters are first validated by simdutf; the code
    described here is used for what simdutf does not accept, so that errors are reported at the same position.
    `JSON_NO_SIMD` does not affect simdutf.
 !!! warning "Define consistently"
    The macro selects between two definitions of the library's internal scanning and formatting functions. It must
    therefore be defined identically for **every** translation unit that includes the library; mixing translation units
    that define it with ones that do not is an ODR violation. Prefer setting it as a compile definition on the target
    rather than with `#!cpp #define` in individual source files.
 ## Examples
 ??? example "Example: switching off vector instructions"
    The program parses and serializes the same values with and without the macro:
    ```cpp
    #define JSON_NO_SIMD
    #include <iostream>
    #include <nlohmann/json.hpp>
    using json = nlohmann::json;
    int main()
    {
        const json j = json::parse(R"({"name": "日本語 text", "pi": 3.141592653589793})");
        std::cout << j.dump() << '\n';  // {"name":"日本語 text","pi":3.141592653589793}
    }
    ```
 ## See also
 - [**parse**](../basic_json/parse.md) - deserialize from a compatible input
 - [**dump**](../basic_json/dump.md) - serialization
 - [**JSON_USE_SIMDUTF**](json_use_simdutf.md) - use the simdutf library to accelerate UTF-8 validation
 - [**JSON_DISABLE_STREAM_BULK_SCAN**](json_disable_stream_bulk_scan.md) - read a `std::istream` one character at a time
 - [Parsing: input sources and performance](../../features/parsing/index.md#input-sources-and-performance)
 ## Version history
 - Added in version 3.13.0.
@@ -72,6 +72,12 @@ The default value is `0` (disabled — existing behavior is preserved).
    distinct symbol names. Translation units compiled with and without it can therefore be linked into the same program
    without One Definition Rule (ODR) violations, but they cannot exchange instances of library types.
 !!! note "Bulk scanning"
    The parser scans the characters in the stream buffer in bulk (see
    [`JSON_DISABLE_STREAM_BULK_SCAN`](json_disable_stream_bulk_scan.md)), but it never reads ahead. The stream is left
    at the same position with and without bulk scanning, in both modes of this macro.
 !!! tip "Workaround without the macro"
    Separate the values in the stream with whitespace. The character consumed after a number is then the separator,
@@ -6,14 +6,16 @@
 When defined, the parser validates the UTF-8 content of JSON strings that come from a **contiguous byte input**
 (`std::string`, `std::vector<char>`/`<std::uint8_t>`, string literals, `const char*` ranges, …) using the
-[simdutf](https://github.com/simdutf/simdutf) library instead of the built-in scalar validator. On text with many
+[simdutf](https://github.com/simdutf/simdutf) library instead of the built-in validator (which uses SSSE3 or NEON where
-non-ASCII characters (e.g. CJK or emoji) this can validate several times faster.
+available, see [`JSON_NO_SIMD`](json_no_simd.md)). On text with many non-ASCII characters (e.g. CJK or emoji) this can
 validate faster, depending on the CPU.
 This is an **opt-in external dependency**. The library itself remains header-only and its behavior is unchanged: the
 same input is accepted or rejected either way, and every parse error is reported at the same position with the same
 message (simdutf is only used to fast-path *valid* runs; anything it flags falls back to the scalar path so the exact
-diagnostic is preserved). Streaming inputs (files, `std::istream`, wide strings, user-defined adapters) always use the
+diagnostic is preserved). A `std::istream` uses simdutf for the characters its stream buffer holds (see
-scalar path.
+[`JSON_DISABLE_STREAM_BULK_SCAN`](json_disable_stream_bulk_scan.md)); other streaming inputs (`FILE*`, wide strings,
 user-defined adapters) always use the scalar path.
 When `JSON_USE_SIMDUTF` is defined you must make the `simdutf.h` header available on the include path and link the
 simdutf library. When it is not defined, no simdutf header is included and there is no dependency.
@@ -121,6 +121,7 @@ being read.
 - [`JSON_STRICT_NUL_HANDLING`](macros/json_strict_nul_handling.md) - opt in to rejecting a NUL byte in the input
  instead of treating it as end of input
 - [`JSON_PRECISE_STREAM_POSITION`](macros/json_precise_stream_position.md) - opt in to leaving the stream positioned right after a number
 - [`JSON_DISABLE_STREAM_BULK_SCAN`](macros/json_disable_stream_bulk_scan.md) - read the stream one character at a time
 ## Version history
@@ -133,3 +134,6 @@ being read.
  crash (`std::terminate`) when `i` has `eofbit` in its exception mask, in version 3.13.0.
 - Changed to the strong exception safety guarantee in version 3.13.0: `j` is no longer left with a partially parsed
  value if parsing throws.
 - Scans the characters in the stream buffer of `i` in bulk in version 3.13.0; the position of `i` after the call is
  unchanged ([`JSON_DISABLE_STREAM_BULK_SCAN`](macros/json_disable_stream_bulk_scan.md) restores reading one character
  at a time).
@@ -1,38 +0,0 @@
 # <small>nlohmann::</small>ordered_json_document
 <small>Defined in header `<nlohmann/json_view.hpp>`</small>
 ```cpp
 using ordered_json_document = basic_json_document<ordered_json>;
 ```
 This type is a [`basic_json_document`](basic_json_document/index.md) of the [`ordered_json`](ordered_json.md)
 specialization: [`materialize()`](basic_json_view/materialize.md) on one of its views preserves the insertion order
 of object keys, instead of sorting them like [`json_document`](json_document.md) does.
 ## Examples
 ??? example
    The example below demonstrates how `ordered_json_document` preserves the insertion order of object keys when
    materializing.
    ```cpp
    --8<-- "examples/ordered_json_document.cpp"
    ```
    Output:
    ```json
    --8<-- "examples/ordered_json_document.output"
    ```
 ## See also
 - [ordered_json_view](ordered_json_view.md) - a view of a value of an `ordered_json_document`
 - [json_document](json_document.md) - the corresponding document for the default `json` specialization
 - [Object Order](../features/object_order.md)
 ## Version history
 Since version 3.13.0.
@@ -1,35 +0,0 @@
 # <small>nlohmann::</small>ordered_json_view
 <small>Defined in header `<nlohmann/json_view.hpp>`</small>
 ```cpp
 using ordered_json_view = basic_json_view<ordered_json>;
 ```
 This type is a [`basic_json_view`](basic_json_view/index.md) of a value of an
 [`ordered_json_document`](ordered_json_document.md).
 ## Examples
 ??? example
    The example below demonstrates how to use the type `nlohmann::ordered_json_view`.
    ```cpp
    --8<-- "examples/ordered_json_view.cpp"
    ```
    Output:
    ```json
    --8<-- "examples/ordered_json_view.output"
    ```
 ## See also
 - [ordered_json_document](ordered_json_document.md) - the document type this view refers into
 - [json_view](json_view.md) - the corresponding view for `json_document`
 ## Version history
 Since version 3.13.0.
@@ -1,19 +0,0 @@
 #include <iostream>
 #include <nlohmann/json.hpp>
 #include <nlohmann/json_view.hpp>
 using json_document = nlohmann::json_document;
 int main()
 {
    std::cout << std::boolalpha;
    // accept() behaves exactly like basic_json::accept(): the same inputs are
    // accepted or rejected, with the same ignore_comments/ignore_trailing_commas
    // options
    std::cout << json_document::accept(R"({"a": 1})") << '\n';
    std::cout << json_document::accept(R"({"a": 1,})") << '\n'; // trailing comma: rejected by default
    std::cout << json_document::accept(R"({"a": 1,})", false, true) << '\n'; // ignore_trailing_commas
    std::cout << (json_document::accept(R"({"a": 1})") == nlohmann::json::accept(R"({"a": 1})")) << '\n';
 }
@@ -1,4 +0,0 @@
 true
 false
 true
 true
@@ -1,23 +0,0 @@
 #include <iostream>
 #include <utility>
 #include <nlohmann/json_view.hpp>
 using json_document = nlohmann::json_document;
 int main()
 {
    std::cout << std::boolalpha;
    // the default constructor creates an empty (discarded) document
    json_document empty;
    std::cout << empty.is_discarded() << '\n';
    // json_document is move-only: parse() itself returns by value (moved out),
    // and a document can be moved again, e.g. into a container
    json_document doc = json_document::parse(R"({"a": 1})");
    json_document moved = std::move(doc);
    std::cout << moved.root().is_object() << '\n';
    // copying is disabled at compile time:
    // json_document another = moved; // does not compile
 }
@@ -1,2 +0,0 @@
 true
 true
@@ -1,19 +0,0 @@
 #include <iostream>
 #include <nlohmann/json_view.hpp>
 using json_document = nlohmann::json_document;
 int main()
 {
    std::cout << std::boolalpha;
    // with allow_exceptions == false, a parse error produces a discarded
    // document instead of throwing -- exactly like basic_json::parse()
    json_document doc = json_document::parse(R"({"a": )", /* allow_exceptions */ false);
    std::cout << doc.is_discarded() << '\n';
    std::cout << doc.root().is_discarded() << '\n';
    // a successful parse is never discarded
    json_document ok = json_document::parse(R"({"a": 1})", false);
    std::cout << ok.is_discarded() << '\n';
 }
@@ -1,3 +0,0 @@
 true
 true
 false
@@ -1,28 +0,0 @@
 #include <iostream>
 #include <string>
 #include <nlohmann/json_view.hpp>
 using json_document = nlohmann::json_document;
 int main()
 {
    std::cout << std::boolalpha;
    // long enough that copying it needs a real (heap) allocation, so the
    // comparison below does not depend on the standard library's small
    // string optimization threshold
    const std::string text = std::string(200, ' ') + "[1, 2, 3, 4, 5]";
    // memory_usage() is not portable across platforms/allocators/compilers, so
    // compare it relatively instead of printing the raw byte count
    json_document borrowed = json_document::parse(text);
    json_document owned = json_document::parse_copy(text);
    // the owned document additionally stores its own copy of the source text
    std::cout << (owned.memory_usage() > borrowed.memory_usage()) << '\n';
    // a document with more values needs a larger index
    json_document small = json_document::parse(std::string("[1]"));
    json_document large = json_document::parse(std::string("[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]"));
    std::cout << (large.memory_usage() > small.memory_usage()) << '\n';
 }
@@ -1,2 +0,0 @@
 true
 true
@@ -1,15 +0,0 @@
 #include <iostream>
 #include <nlohmann/json_view.hpp>
 using json_document = nlohmann::json_document;
 int main()
 {
    // node_count() is the size of the flat index: one 16-byte node per value,
    // plus one per object key (values and keys are all the index stores)
    json_document scalar = json_document::parse("42");
    std::cout << scalar.node_count() << '\n';
    json_document doc = json_document::parse(R"({"a": 1, "b": [1, 2]})");
    std::cout << doc.node_count() << '\n';
 }
@@ -1,2 +0,0 @@
 1
 7
@@ -1,24 +0,0 @@
 #include <iostream>
 #include <string>
 #include <nlohmann/json_view.hpp>
 using json_document = nlohmann::json_document;
 int main()
 {
    std::cout << std::boolalpha;
    std::string text = R"({"a": 1})";
    // borrowed: the document only points into `text`; `text` must outlive it
    json_document borrowed = json_document::parse(text);
    std::cout << borrowed.owns_source() << '\n';
    // owned: parse_copy() always takes its own copy
    json_document copied = json_document::parse_copy(text);
    std::cout << copied.owns_source() << '\n';
    // owned: an rvalue std::string is moved in, not copied, but still owned
    json_document moved_in = json_document::parse(std::string(text));
    std::cout << moved_in.owns_source() << '\n';
 }
@@ -1,3 +0,0 @@
 false
 true
 true
@@ -1,33 +0,0 @@
 #include <iostream>
 #include <string>
 #include <nlohmann/json.hpp>
 #include <nlohmann/json_view.hpp>
 using json_document = nlohmann::json_document;
 int main()
 {
    std::cout << std::boolalpha;
    // an lvalue std::string is BORROWED: the document only stores a pointer
    // into `text`, so `text` must outlive `borrowed`
    std::string text = R"({"count": 3})";
    json_document borrowed = json_document::parse(text);
    std::cout << borrowed.owns_source() << '\n'; // false
    // an rvalue std::string is MOVED into the document -- no copy of the text
    json_document owned = json_document::parse(std::string(R"({"count": 3})"));
    std::cout << owned.owns_source() << '\n'; // true
    // errors are identical to basic_json::parse: same exception id, message,
    // and position, because the library parser runs on the same bytes on a
    // failing input
    try
    {
        static_cast<void>(json_document::parse(R"({"count": )"));
    }
    catch (const nlohmann::json::parse_error& e)
    {
        std::cout << e.id << '\n';
    }
 }
@@ -1,3 +0,0 @@
 false
 true
 101
@@ -1,22 +0,0 @@
 #include <iostream>
 #include <nlohmann/json_view.hpp>
 using json_document = nlohmann::json_document;
 json_document parse_from_temporary_buffer()
 {
    char buffer[] = R"({"a": 1})";
    // parse() would borrow `buffer`, which is about to go out of scope;
    // parse_copy() takes its own copy instead, so the returned document does
    // not depend on `buffer` afterward
    return json_document::parse_copy(buffer);
 }
 int main()
 {
    std::cout << std::boolalpha;
    json_document doc = parse_from_temporary_buffer();
    std::cout << doc.owns_source() << '\n';
    std::cout << doc.root().is_object() << '\n';
 }
@@ -1,2 +0,0 @@
 true
 true
@@ -1,22 +0,0 @@
 #include <iostream>
 #include <vector>
 #include <nlohmann/json_view.hpp>
 using json_document = nlohmann::json_document;
 int main()
 {
    std::cout << std::boolalpha;
    // a JSON value embedded in a larger, non-null-terminated buffer (e.g. a
    // slice received over the network)
    std::vector<char> buffer = {'[', '1', ',', '2', ']', 'j', 'u', 'n', 'k'};
    // a pointer pair is BORROWED, exactly like a byte container lvalue: the
    // document points into the buffer. (From C++20 on, std::vector<char>
    // iterators are borrowed as well; before, they are copied.)
    const char* first = buffer.data();
    json_document doc = json_document::parse(first, first + 5);
    std::cout << doc.root().is_array() << ' ' << doc.root().size() << '\n';
    std::cout << doc.owns_source() << '\n'; // false: borrowed
 }
@@ -1,2 +0,0 @@
 true 2
 false
@@ -1,31 +0,0 @@
 #include <iostream>
 #include <string>
 #include <vector>
 #include <nlohmann/json_view.hpp>
 using json_document = nlohmann::json_document;
 int main()
 {
    std::cout << std::boolalpha;
    std::vector<std::string> messages =
    {
        R"({"id": 1})", R"({"id": 2, "tag": "x"})", R"({"id": 3})"
    };
    // parse into the same document over and over: its node index and decode
    // buffer are reused instead of being freed and reallocated for each message
    json_document doc;
    std::size_t total = 0;
    for (const auto& msg : messages)
    {
        doc.read(msg);
        total += doc.root().size();
    }
    std::cout << total << '\n';
    // read() can also change what kind of input is owned/borrowed between calls
    doc.read(std::string(R"({"owned": true})"));
    std::cout << doc.owns_source() << '\n';
 }
@@ -1,2 +0,0 @@
 4
 true
@@ -1,19 +0,0 @@
 #include <iostream>
 #include <nlohmann/json_view.hpp>
 using json_document = nlohmann::json_document;
 int main()
 {
    std::cout << std::boolalpha;
    json_document doc = json_document::parse(R"({"greeting": "hi"})");
    std::cout << doc.root().is_object() << '\n';
    // root() is a cheap handle, not a copy: repeated calls observe the same value
    std::cout << (doc.root().type() == doc.root().type()) << '\n';
    // the root of a failed parse (allow_exceptions == false) is discarded
    json_document failed = json_document::parse("{", false);
    std::cout << failed.root().is_discarded() << '\n';
 }
@@ -1,3 +0,0 @@
 true
 true
 true
@@ -1,44 +0,0 @@
 #include <iostream>
 #include <sstream>
 #include <string>
 #include <nlohmann/json_view.hpp>
 using json_document = nlohmann::json_document;
 int main()
 {
    std::cout << std::boolalpha;
    // build a large array (many nodes), then read a small one into the same
    // document: the index grown for the large input is still allocated
    std::ostringstream big;
    big << '[';
    for (int i = 0; i < 500; ++i)
    {
        if (i != 0)
        {
            big << ',';
        }
        big << i;
    }
    big << ']';
    json_document doc;
    doc.read(big.str());
    const std::size_t big_nodes = doc.node_count();
    doc.read(std::string("[1]"));
    std::cout << (doc.node_count() < big_nodes) << '\n'; // far fewer live nodes now
    const std::size_t before = doc.memory_usage();
    // shrink_to_fit() moves the index into a block sized for what is actually
    // used. This INVALIDATES every view taken from this document before the
    // call (they point into the old, now-freed block) -- take fresh ones from
    // root() afterward.
    doc.shrink_to_fit();
    const std::size_t after = doc.memory_usage();
    std::cout << (after <= before) << '\n';
    // a freshly taken view is valid and correct
    std::cout << doc.root().is_array() << ' ' << doc.root().size() << '\n';
 }
@@ -1,3 +0,0 @@
 true
 true
 true 1
@@ -1,20 +0,0 @@
 #include <iostream>
 #include <string>
 #include <nlohmann/json_view.hpp>
 using json_document = nlohmann::json_document;
 int main()
 {
    std::cout << std::boolalpha;
    std::string text = R"({"a": 1})";
    json_document doc = json_document::parse(text);
    // source() is the parsed text, whether borrowed or owned
    std::cout << (doc.source().size() == text.size()) << '\n';
    std::cout << std::string(doc.source().data(), doc.source().size()) << '\n';
    // for a borrowed document, source() points right into the caller's buffer
    std::cout << (doc.source().data() == text.data()) << '\n';
 }
@@ -1,3 +0,0 @@
 true
 {"a": 1}
 true
@@ -1,17 +0,0 @@
 #include <iostream>
 #include <nlohmann/json_view.hpp>
 int main()
 {
    std::cout << std::boolalpha;
    // the default constructor is the only public one: it creates an invalid
    // (discarded) view, useful as a "no value yet" placeholder
    nlohmann::json_view v;
    std::cout << v.is_discarded() << '\n';
    // views are trivially copyable handles (two pointers); the document owns
    // the actual data
    nlohmann::json_view copy = v;
    std::cout << copy.is_discarded() << '\n';
 }
@@ -1,2 +0,0 @@
 true
 true
Author	SHA1	Message	Date
Niels Lohmann	8bf710053e	Merge branch 'perf/lexer-dispatch' into perf/dom-move-keys Signed-off-by: Niels Lohmann <mail@nlohmann.me>	2026-10-16 08:21:29 +02:00
Niels Lohmann	92dc52162e	Merge branch 'perf/lexer-simd-strings' into perf/lexer-dispatch Signed-off-by: Niels Lohmann <mail@nlohmann.me>	2026-10-16 08:21:10 +02:00
Niels Lohmann	67cc56e9e8	Keep the string scan from slowing down short strings and dump() on Arm Three benchmarks were 7-9% slower than develop on Apple M1 (Apple Clang, -O3 -flto): Accept/jeopardy, Dump/citm_catalog, and Dump/jeopardy. - dump(): the serializer passes a string without its closing quote, so plain_run_end() ran out of input and called the out-of-line NEON loop for every string, with fewer than 16 bytes left. The loop is now only called for 16 bytes or more. - accept(): no string of jeopardy.json reaches the vector UTF-8 check, yet compiling it into the lexer's scan function made it 5% slower: the function runs once per token and now saved more registers and kept a stack slot. lexer_string_bulk_run() checks the first four words inline and continues out of line, and the serializer keeps string_bulk_run() inline, which is faster there. - The byte that ends a run is read from the scanned buffer instead of through get(), which Apple Clang merged with the other get() calls that load the read position again right after it was stored (3%). Signed-off-by: Niels Lohmann <mail@nlohmann.me>	2026-10-16 08:10:42 +02:00
Niels Lohmann	07be943802	Merge branch 'perf/lexer-dispatch' into perf/dom-move-keys Signed-off-by: Niels Lohmann <mail@nlohmann.me>	2026-10-15 22:47:13 +02:00
Niels Lohmann	9d15d23131	Merge branch 'perf/lexer-simd-strings' into perf/lexer-dispatch Signed-off-by: Niels Lohmann <mail@nlohmann.me>	2026-10-15 22:47:09 +02:00
Niels Lohmann	5eff50a5f9	Merge branch 'perf/lexer-lazy-float-text' into perf/lexer-simd-strings Signed-off-by: Niels Lohmann <mail@nlohmann.me>	2026-10-15 22:47:04 +02:00
Niels Lohmann	649961c8fe	Merge branch 'perf/lexer-number-scan' into perf/lexer-lazy-float-text Signed-off-by: Niels Lohmann <mail@nlohmann.me>	2026-10-15 22:46:59 +02:00
Niels Lohmann	fe8900bd92	Merge branch 'claude/parser-stream-performance-8cebe9' into perf/lexer-number-scan Signed-off-by: Niels Lohmann <mail@nlohmann.me>	2026-10-15 22:46:54 +02:00
Niels Lohmann	39565f62d7	Merge branch 'develop' into claude/parser-stream-performance-8cebe9 Signed-off-by: Niels Lohmann <mail@nlohmann.me>	2026-10-15 22:46:29 +02:00
Niels Lohmann	38130afca9	Merge branch 'perf/lexer-dispatch' into perf/dom-move-keys Signed-off-by: Niels Lohmann <mail@nlohmann.me>	2026-10-15 20:23:35 +02:00
Niels Lohmann	1b84568e5e	Merge branch 'perf/lexer-simd-strings' into perf/lexer-dispatch Signed-off-by: Niels Lohmann <mail@nlohmann.me>	2026-10-15 20:23:30 +02:00
Niels Lohmann	2e81630c47	Merge branch 'perf/lexer-lazy-float-text' into perf/lexer-simd-strings Signed-off-by: Niels Lohmann <mail@nlohmann.me>	2026-10-15 20:23:24 +02:00
Niels Lohmann	48d5e59adf	Merge branch 'perf/lexer-number-scan' into perf/lexer-lazy-float-text Signed-off-by: Niels Lohmann <mail@nlohmann.me>	2026-10-15 20:23:21 +02:00
Niels Lohmann	547e745289	Merge branch 'claude/parser-stream-performance-8cebe9' into perf/lexer-number-scan Signed-off-by: Niels Lohmann <mail@nlohmann.me>	2026-10-15 20:23:17 +02:00
Niels Lohmann	1457bfb948	Merge branch 'develop' into claude/parser-stream-performance-8cebe9 Signed-off-by: Niels Lohmann <mail@nlohmann.me>	2026-10-15 20:22:53 +02:00
Niels Lohmann	fa5ecbae53	Move object keys into the value when parsing json_sax_dom_parser::key() copied the key from the lexer's buffer into the object. The lexer starts every token with an empty buffer (reset()), so the key can be moved instead, which saves an allocation and a copy for every key that does not fit into the string's inline buffer. json_sax_dom_parser already moved string values the same way. ordered_map has no rvalue operator[], so ordered_json still copies keys. Signed-off-by: Niels Lohmann <mail@nlohmann.me>	2026-10-15 18:37:06 +02:00
Niels Lohmann	57424ab0b5	Match literals without a stack array and keep parser states in bytes scan_after_whitespace() built the expected text of true, false, and null in local std::array objects. With -fstack-protector-strong (the default of Ubuntu's GCC, among others), a local array gives the function a stack canary check, which then ran on every token. scan_literal() now takes the text after the first character as a string literal, with its length as a template parameter; for contiguous input it compares the rest at once and falls back to the byte loop on a mismatch, so errors are reported at the same character. It is out of line, which keeps the token dispatch small. The parser kept the nesting of arrays and objects in a std::vector<bool>, whose push_back() GCC calls out of line; it is a std::vector<std::uint8_t> now. Signed-off-by: Niels Lohmann <mail@nlohmann.me>	2026-10-15 18:37:05 +02:00
Niels Lohmann	c6742f9761	Scan strings with SSE2, SSSE3, or NEON The string fast path found the end of a run of plain characters 8 bytes at a time (SWAR) and validated non-ASCII text one sequence at a time, calling validate_one_utf8() out of line for each. The vector code of json_view's scanner, in the new shared header detail/input/simd_scan.hpp, now does both 16 bytes at a time: SSE2 finds the end of a run on x86-64, and the UTF-8 check of Keiser and Lemire runs with NEON on AArch64 and with SSSE3 on x86-64. SSSE3 is not part of x86-64, so the check is compiled for it with a function attribute and used when the CPU has it (cached in a constant-initialized atomic), else the scalar check; code compiled with -mssse3 skips the CPU check. The first word of a run is still checked with SWAR (the first four with NEON, where a vector mask costs more), as most keys and short values end there, and the scalar helpers are always inlined. On anything else, the scalar code is unchanged. The new macro JSON_NO_SIMD selects the portable code everywhere, including the SSE2/NEON digit formatting of the floating-point writer. The lexer tests now also run with JSON_NO_SIMD and, on x86-64, with -mssse3, and a new test places every byte that ends a run at each offset across several 16-byte blocks, after ASCII and after CJK text. Signed-off-by: Niels Lohmann <mail@nlohmann.me>	2026-10-15 18:37:04 +02:00
Niels Lohmann	5423dd8de3	Copy the text of float tokens only when a SAX handler asks for it After the digits are converted while scanning, copying the token text into token_buffer (an out-of-line std::string::append) was about 10% of parsing canada.json. The only reader is the string argument of json_sax::number_float(), and the library's own handlers (json_sax_dom_parser, json_sax_dom_callback_parser, json_sax_acceptor) ignore it. For contiguous input, the fast path now keeps a pointer to the token in the input, and get_string() copies it on first use. The parser passes an empty string to the handlers marked by the new internal trait sax_ignores_number_text instead of calling get_string(), so json::parse() and json::accept() never copy float text. User handlers, and JSON_DIAGNOSTIC_POSITIONS (which reads get_string().size()), still see the exact text. Keys and strings, which never have pending text, use the unchecked get_string_token(). Input read through a window into a stream (std::istream, FILE*) copies the text right away, because the next read may refill the window. Signed-off-by: Niels Lohmann <mail@nlohmann.me>	2026-10-15 18:37:02 +02:00
Niels Lohmann	32ca00cdfa	Accumulate number digits while scanning them The contiguous number fast path validated a token byte by byte, copied it into token_buffer, and then converted it in out-of-line functions that scanned the digits a second time: parse_float_native() called parse_float_significand(), which returned its result through memory and called std::any_of (out of line with GCC) twice per number, and parse_integer_signed() divided by ten on every digit for its overflow check. scan_number_bulk_contiguous() now accumulates the significand while it validates the digits, eight at a time where at least eight bytes remain (is_eight_digits() and parse_eight_digits(), after fast_float). Floats with at most 19 digits go straight to decimal_to_float(); integers with at most 18 digits are stored without an overflow check (a narrower number type still rejects values that do not round-trip). Longer tokens take the existing path. has_nonzero_digit() is a plain loop and parse_float_significand() is always inlined, which helps that path. Signed-off-by: Niels Lohmann <mail@nlohmann.me>	2026-10-15 18:37:01 +02:00
Niels Lohmann	598fbd0417	Avoid implicit unsigned char to char conversion in stream tests Building a std::string from the iterators of a CBOR byte vector narrows each byte, which -fsanitize=implicit-conversion reports for bytes above 0x7F. Construct the string from the raw bytes instead. Signed-off-by: Niels Lohmann <mail@nlohmann.me>	2026-10-14 21:30:07 +02:00
Niels Lohmann	898084b386	Merge branch 'develop' into claude/parser-stream-performance-8cebe9 Resolve the macro_unscope.hpp conflict by keeping both sets of #undefs and regenerate the amalgamation. The \u fast path from #5738 (get_codepoint_bulk) assumed that bulk scanning implies lazy position tracking and advanced the adapter with a bare bulk_skip(4). Stream adapters now scan in bulk but track position and token eagerly, so a lone-surrogate error was reported 4 columns too early. Advance through bulk_consume() instead. Signed-off-by: Niels Lohmann <mail@nlohmann.me>	2026-10-14 21:30:06 +02:00
Niels Lohmann	f13fbd2577	Add benchmarks for parsing from a FILE* and for many values from a stream ParseFILE/* parses the nativejson-benchmark files from a FILE, and ParseStreamValues/ reads 10,000 small values from one std::istringstream with operator>> (NDJSON objects and plain numbers), which measures the per-value cost of stream input. Signed-off-by: Niels Lohmann <mail@nlohmann.me>	2026-10-14 17:34:01 +02:00
Niels Lohmann	c391abccb1	Lock a FILE once per parse instead of once per character Parsing from a FILE* reads one character at a time with std::fgetc, which locks and unlocks the FILE object for every character. file_input_adapter now locks the file once when it is created and unlocks it when it is destroyed - also when parsing throws - and reads with the unlocked stdio functions in between: flockfile/getc_unlocked/funlockfile with glibc, Apple, Android, and the BSDs, and _lock_file/_fgetc_nolock/_unlock_file with the Microsoft C runtime. Other C libraries keep std::fgetc. The lock is recursive, so fread() in the binary readers and stdio calls of a SAX handler or parser callback on the same thread keep working. On an Apple M1 Max, parsing from a FILE* is 2.9 to 4.0 times as fast (twitter.json 14.3 -> 4.1 ms, citm_catalog.json 35.4 -> 8.8 ms); with glibc, whose locking is cheaper, 1.1 to 1.3 times. The values and the position of the file after parsing are unchanged. Other threads that use the same FILE object now wait until parsing is done instead of interleaving their reads with the parser's. JSON_DISABLE_UNLOCKED_FILE_IO restores std::fgetc, for programs in which a SAX handler waits for another thread that uses the same FILE. The new tests check from a second thread that the lock is released after success and after a parse error, and run again with the macro. Signed-off-by: Niels Lohmann <mail@nlohmann.me>	2026-10-14 17:34:00 +02:00
Niels Lohmann	d5631dccbd	Scan the get area of an input stream in bulk Parsing from a std::istream read one character at a time through the streambuf, so none of the parser's fast paths applied: it was 1.8 to 2.5 times slower than reading the file into a string and parsing that. input_stream_adapter now exposes the streambuf's get area (gptr() to egptr()) to the lexer as a window. The protected get-area members are reached through member pointers formed in a class derived from std::streambuf, which is ordinary, standard-conforming member access. The lexer scans the window with the same bulk paths as a string, and asks the streambuf for the next character as before when the window is used up. Nothing is read ahead, copied, or put back, so the stream is left exactly where it was left before, with and without JSON_PRECISE_STREAM_POSITION, and a streambuf without a get area is still read one character at a time. The adapter also keeps the current token for error messages as a pointer into the get area, and copies it out only before the get area is refilled, instead of the lexer copying every character. On an Apple M1 Max (Apple Clang, -O3), parsing from an std::ifstream is 1.6 to 2.1 times as fast (twitter.json 4.08 -> 2.30 ms, citm_catalog.json 8.75 -> 4.08 ms), and reading 100,000 small values with operator>> 1.4 (objects) to 4.0 (integers) times as fast. With GCC 13 and libstdc++ on x86-64 Linux, std::ifstream is 1.5 to 2.2 times as fast. Parsing from a stream is now within 11 to 18 % of reading the file into a string first. JSON_DISABLE_STREAM_BULK_SCAN restores reading one character at a time, for streambufs that do not follow the usual get-area contract. The new tests compare every observable result (values, exception messages, stream state, remaining characters) for get areas of 1 to 4096 bytes against a streambuf without a get area, and run again with the macro and with JSON_PRECISE_STREAM_POSITION. Signed-off-by: Niels Lohmann <mail@nlohmann.me>	2026-10-14 17:26:38 +02:00
Niels Lohmann	80d00eda50	Let the lexer's bulk fast paths run on a window of the input The SWAR string scan, the bulk number scan, and the indentation skip were only enabled for adapters that support seeking (contiguous random-access input), because they rely on the lazy token and position tracking that reconstructs both from the consumed input on demand. This decouples the bulk paths from seeking, so that an adapter can expose a contiguous block that is only a window into its input (bulk_window): - bulk_consume() does the bookkeeping that get() would have done for the skipped characters when token and position are tracked eagerly. - A number that reaches the end of a window is finished character by character, because it may continue after the window. - After a bulk-scanned number, a window adapter reads the terminating character and ungets it, as scan_number() does, so that the input handed back to the user is consumed exactly as before. - An adapter can keep the current token itself (supports_token_tracking, begin_token(), mark_token_start(), copy_token()) so the lexer need not copy every character for its error messages. No adapter declares any of this yet, so the behavior is unchanged. Signed-off-by: Niels Lohmann <mail@nlohmann.me>	2026-10-14 17:13:58 +02:00