Merge branch 'develop' into cleanup

# Conflicts:
#	.gitignore

Author: nlohmann

.gitignore

@@ -44,3 +44,6 @@
 venv
 
 nlohmann_json.spdx
+
+# Bazel-related
+MODULE.bazel.lock

BUILD.bazel

@@ -1,3 +1,20 @@
+load("@rules_cc//cc:cc_library.bzl", "cc_library")
+load("@rules_license//rules:license.bzl", "license")
+
+package(
+    default_applicable_licenses = [":license"],
+)
+
+exports_files([
+    "LICENSE.MIT",
+])
+
+license(
+    name = "license",
+    license_kinds = ["@rules_license//licenses/spdx:MIT"],
+    license_text = "LICENSE.MIT",
+)
+
 cc_library(
     name = "json",
     hdrs = [
@@ -52,3 +69,12 @@ cc_library(
     visibility = ["//visibility:public"],
     alwayslink = True,
 )
+
+cc_library(
+    name = "singleheader-json",
+    hdrs = [
+        "single_include/nlohmann/json.hpp",
+    ],
+    includes = ["single_include"],
+    visibility = ["//visibility:public"],
+)

MODULE.bazel

@@ -0,0 +1,7 @@
+module(
+    name = "nlohmann_json",
+    compatibility_level = 1,
+)
+
+bazel_dep(name = "rules_cc", version = "0.0.17")
+bazel_dep(name = "rules_license", version = "1.0.0")

WORKSPACE.bazel

@@ -4,13 +4,16 @@
 // (1)
 static std::vector<std::uint8_t> to_bjdata(const basic_json& j,
                                            const bool use_size = false,
-                                           const bool use_type = false);
+                                           const bool use_type = false,
+                                           const bjdata_version_t version = bjdata_version_t::draft2);
 
 // (2)
 static void to_bjdata(const basic_json& j, detail::output_adapter<std::uint8_t> o,
-                      const bool use_size = false, const bool use_type = false);
+                      const bool use_size = false, const bool use_type = false,
+                      const bjdata_version_t version = bjdata_version_t::draft2);
 static void to_bjdata(const basic_json& j, detail::output_adapter<char> o,
-                      const bool use_size = false, const bool use_type = false);
+                      const bool use_size = false, const bool use_type = false,
+                      const bjdata_version_t version = bjdata_version_t::draft2);
 ```
 
 Serializes a given JSON value `j` to a byte vector using the BJData (Binary JData) serialization format. BJData aims to
@@ -34,6 +37,9 @@ The exact mapping and its limitations is described on a [dedicated page](../../f
 
 `use_type` (in)
 :   whether to add type annotations to container types (must be combined with `#!cpp use_size = true`); optional,
+
+`version` (in)
+:   which version of BJData to use (see [draft 3](../../features/binary_formats/bjdata.md#draft-3-binary-format)); optional,
 `#!cpp false` by default.
 
 ## Return value
@@ -68,3 +74,4 @@ Linear in the size of the JSON value `j`.
 ## Version history
 
 - Added in version 3.11.0.
+- BJData version parameter (for draft3 binary encoding) added in version 3.12.0.

docs/mkdocs/docs/api/basic_json/to_bjdata.md

@@ -2,10 +2,10 @@
 
 The [BJData format](https://neurojson.org) was derived from and improved upon
 [Universal Binary JSON(UBJSON)](https://ubjson.org) specification (Draft 12). Specifically, it introduces an optimized
-array container for efficient storage of N-dimensional packed arrays (**ND-arrays**); it also adds 4 new type markers -
-`[u] - uint16`, `[m] - uint32`, `[M] - uint64` and `[h] - float16` - to unambiguously map common binary numeric types;
-furthermore, it uses little-endian (LE) to store all numerics instead of big-endian (BE) as in UBJSON to avoid
-unnecessary conversions on commonly available platforms.
+array container for efficient storage of N-dimensional packed arrays (**ND-arrays**); it also adds 5 new type markers -
+`[u] - uint16`, `[m] - uint32`, `[M] - uint64`, `[h] - float16` and `[B] - byte` - to unambiguously map common binary
+numeric types; furthermore, it uses little-endian (LE) to store all numerics instead of big-endian (BE) as in UBJSON to
+avoid  unnecessary conversions on commonly available platforms.
 
 Compared to other binary JSON-like formats such as MessagePack and CBOR, both BJData and UBJSON demonstrate a rare
 combination of being both binary and **quasi-human-readable**. This is because all semantic elements in BJData and
@@ -49,6 +49,7 @@ The library uses the following mapping from JSON values types to BJData types ac
 | string          | *with shortest length indicator*          | string         | `S`    |
 | array           | *see notes on optimized format/ND-array*  | array          | `[`    |
 | object          | *see notes on optimized format*           | map            | `{`    |
+| binary          | *see notes on binary values*              | array          | `[$B`  |
 
 !!! success "Complete mapping"
 
@@ -128,15 +129,24 @@ The library uses the following mapping from JSON values types to BJData types ac
 
     Due to diminished space saving, hampered readability, and increased security risks, in BJData, the allowed data
     types following the `$` marker in an optimized array and object container are restricted to
-    **non-zero-fixed-length** data types. Therefore, the valid optimized type markers can only be one of `UiuImlMLhdDC`.
-    This also means other variable (`[{SH`) or zero-length types (`TFN`) can not be used in an optimized array or object
-    in BJData.
+    **non-zero-fixed-length** data types. Therefore, the valid optimized type markers can only be one of
+    `UiuImlMLhdDCB`. This also means other variable (`[{SH`) or zero-length types (`TFN`) can not be used in an
+    optimized array or object in BJData.
 
 !!! info "Binary values"
 
-    If the JSON data contains the binary type, the value stored is a list of integers, as suggested by the BJData
-    documentation. In particular, this means that the serialization and the deserialization of JSON containing binary
-    values into BJData and back will result in a different JSON object.
+    BJData provides a dedicated `B` marker (defined in the [BJData specification (Draft 3)][BJDataBinArr]) that is used
+    in optimized arrays to designate binary data. This means that, unlike UBJSON, binary data can be both serialized and
+    deserialized.
+
+    To preserve compatibility with BJData Draft 2, the Draft 3 optimized binary array must be explicitly enabled using
+    the `version` parameter of [`to_bjdata`](../../api/basic_json/to_bjdata.md).
+
+    In Draft2 mode (default), if the JSON data contains the binary type, the value stored as a list of integers, as
+    suggested by the BJData documentation. In particular, this means that the serialization and the deserialization of
+    JSON containing binary values into BJData and back will result in a different JSON object.
+
+    [BJDataBinArr]: https://github.com/NeuroJSON/bjdata/blob/master/Binary_JData_Specification.md#optimized-binary-array)
 
 ??? example
 
@@ -171,11 +181,13 @@ The library maps BJData types to JSON value types as follows:
 | int32       | number_integer                          | `l`    |
 | uint64      | number_unsigned                         | `M`    |
 | int64       | number_integer                          | `L`    |
+| byte        | number_unsigned                         | `B`    |
 | string      | string                                  | `S`    |
 | char        | string                                  | `C`    |
 | array       | array (optimized values are supported)  | `[`    |
 | ND-array    | object (in JData annotated array format)|`[$.#[.`|
 | object      | object (optimized values are supported) | `{`    |
+| binary      | binary (strongly-typed byte array)      | `[$B`  |
 
 !!! success "Complete mapping"
 

docs/mkdocs/docs/features/binary_formats/bjdata.md

@@ -0,0 +1 @@
+bazel_dep(name = "nlohmann_json", version = "3.11.3.bcr.1")

docs/mkdocs/docs/integration/bazel/MODULE.bazel

@@ -156,16 +156,14 @@ using the subproject directly.
 
 !!! abstract "Summary"
 
-    use `http_archive`, `git_repository`, or `local_repository`
+    use `bazel_dep`, `git_override`, or `local_path_override`
 
-    - :octicons-tag-24: Any version, as version is specified in `WORKSPACE` file
+    - :octicons-tag-24: Any version, that is available via [Bazel Central Registry](https://registry.bazel.build/modules/nlohmann_json)
     - :octicons-file-24: File issues at the [library issue tracker](https://github.com/nlohmann/json/issues)
     - :octicons-question-24: [Bazel website](https://bazel.build)
 
-This repository provides a [Bazel](https://bazel.build/) `WORKSPACE.bazel` and a corresponding `BUILD.bazel` file. Therefore, this
-repository can be referenced by workspace rules such as `http_archive`, `git_repository`, or `local_repository` from
-other Bazel workspaces. To use the library you only need to depend on the target `@nlohmann_json//:json` (e.g., via
-`deps` attribute).
+This repository provides a [Bazel](https://bazel.build/) `MODULE.bazel` and a corresponding `BUILD.bazel` file. Therefore, this
+repository can be referenced within a `MODULE.bazel` by rules such as `archive_override`, `git_override`, or `local_path_override`. To use the library you need to depend on the target `@nlohmann_json//:json` (i.e., via `deps` attribute).
 
 ??? example
 
@@ -176,7 +174,7 @@ other Bazel workspaces. To use the library you only need to depend on the target
         ```
 
         ```ini title="WORKSPACE"
-        --8<-- "integration/bazel/WORKSPACE"
+        --8<-- "integration/bazel/MODULE.bazel"
         ```
 
         ```cpp title="example.cpp"

docs/mkdocs/docs/integration/bazel/WORKSPACE

@@ -2313,6 +2313,16 @@ class binary_reader
             case 'Z':  // null
                 return sax->null();
 
+            case 'B':  // byte
+            {
+                if (input_format != input_format_t::bjdata)
+                {
+                    break;
+                }
+                std::uint8_t number{};
+                return get_number(input_format, number) && sax->number_unsigned(number);
+            }
+
             case 'U':
             {
                 std::uint8_t number{};
@@ -2513,7 +2523,7 @@ class binary_reader
                 return false;
             }
 
-            if (size_and_type.second == 'C')
+            if (size_and_type.second == 'C' || size_and_type.second == 'B')
             {
                 size_and_type.second = 'U';
             }
@@ -2535,6 +2545,13 @@ class binary_reader
             return (sax->end_array() && sax->end_object());
         }
 
+        // If BJData type marker is 'B' decode as binary
+        if (input_format == input_format_t::bjdata && size_and_type.first != npos && size_and_type.second == 'B')
+        {
+            binary_t result;
+            return get_binary(input_format, size_and_type.first, result) && sax->binary(result);
+        }
+
         if (size_and_type.first != npos)
         {
             if (JSON_HEDLEY_UNLIKELY(!sax->start_array(size_and_type.first)))
@@ -3008,6 +3025,7 @@ class binary_reader
 
 #define JSON_BINARY_READER_MAKE_BJD_TYPES_MAP_ \
     make_array<bjd_type>(                      \
+    bjd_type{'B', "byte"},                     \
     bjd_type{'C', "char"},                     \
     bjd_type{'D', "double"},                   \
     bjd_type{'I', "int16"},                    \