Set version to 6.18.2

The Arduino Library Specification forbids symlinks, that's probably the reason why version 6.18.1 is missing from the Library Manager.

.clang-format

@@ -0,0 +1,10 @@
+# http://clang.llvm.org/docs/ClangFormatStyleOptions.html
+
+BasedOnStyle: Google
+Standard: Cpp03
+AllowShortFunctionsOnASingleLine: Empty
+IncludeBlocks: Preserve
+IndentPPDirectives: AfterHash
+
+# Always break after if to get accurate coverage
+AllowShortIfStatementsOnASingleLine: false

.devcontainer/Dockerfile

@@ -0,0 +1,43 @@
+FROM ubuntu:20.04
+
+RUN apt-get update && \
+  apt-get install -y software-properties-common curl && \
+  apt-get upgrade -y
+RUN apt-key adv --keyserver keyserver.ubuntu.com --recv-keys 15CF4D18AF4F7421
+RUN add-apt-repository -yn 'deb http://archive.ubuntu.com/ubuntu/ trusty main' && \
+  add-apt-repository -yn 'deb http://archive.ubuntu.com/ubuntu/ trusty universe' && \
+  add-apt-repository -yn 'deb http://archive.ubuntu.com/ubuntu/ xenial main' && \
+  add-apt-repository -yn 'deb http://archive.ubuntu.com/ubuntu/ xenial universe' && \
+  add-apt-repository -yn 'deb http://archive.ubuntu.com/ubuntu/ bionic main' && \
+  add-apt-repository -yn 'deb http://archive.ubuntu.com/ubuntu/ bionic universe' && \
+  add-apt-repository -yn 'deb http://apt.llvm.org/bionic/ llvm-toolchain-bionic-6.0 main' && \
+  add-apt-repository -yn 'deb http://apt.llvm.org/bionic/ llvm-toolchain-bionic-7 main' && \
+  add-apt-repository -yn 'deb http://apt.llvm.org/bionic/ llvm-toolchain-bionic-8 main' && \
+  add-apt-repository -yn 'deb http://apt.llvm.org/bionic/ llvm-toolchain-bionic-9 main'
+
+RUN apt-get update && apt-get -y install \
+  cmake \
+  ninja-build \
+  git \
+  clang-format \
+  g++-4.4 \
+  g++-4.6 \
+  g++-4.7 \
+  g++-4.8 \
+  g++-4.9 \
+  g++-5 \
+  g++-7 \
+  g++-8 \
+  g++-9 \
+  g++-10 \
+  clang-3.5 \
+  clang-3.6 \
+  clang-3.7 \
+  clang-3.8 \
+  clang-3.9 \
+  clang-6.0 \
+  clang-7 \
+  clang-8 \
+  clang-9 \
+  clang-10 \
+  clang-11

.devcontainer/devcontainer.json

@@ -0,0 +1,23 @@
+// For format details, see https://aka.ms/devcontainer.json. For config options, see the README at:
+// https://github.com/microsoft/vscode-dev-containers/tree/v0.183.0/containers/ubuntu
+{
+  "name": "Ubuntu",
+  "build": {
+    "dockerfile": "Dockerfile"
+  },
+
+  // Set *default* container specific settings.json values on container create.
+  "settings": {},
+
+  // Add the IDs of extensions you want installed when the container is created.
+  "extensions": [
+	"ms-vscode.cmake-tools",
+	"ms-vscode.cpptools"
+],
+
+  // Use 'forwardPorts' to make a list of ports inside the container available locally.
+  // "forwardPorts": [],
+
+  // Use 'postCreateCommand' to run commands after the container is created.
+  // "postCreateCommand": "uname -a",
+}

.gitattributes

@@ -0,0 +1 @@
+*.sh text eol=lf

.github/FUNDING.yml

@@ -0,0 +1,4 @@
+github: bblanchon
+custom:
+  - https://arduinojson.org/book/
+  - https://donate.benoitblanchon.fr/

.github/ISSUE_TEMPLATE.md

@@ -0,0 +1,14 @@
+<!--
+Before opening an issue, please read the FAQ:
+https://arduinojson.org/faq/
+
+Please provide all the relevant information:
+* good title
+* short description of the problem
+* target platform
+* compiler model and version
+* MVCE (https://stackoverflow.com/help/mcve)
+* compiler output
+
+Good questions get fast answers!
+-->

.github/workflows/ci.yml

@@ -0,0 +1,484 @@
+name: Continuous Integration
+
+on: [push, pull_request]
+
+jobs:
+  lint:
+    name: Lint
+    runs-on: ubuntu-20.04
+    steps:
+      - name: Install
+        run: sudo apt-get install -y clang-format
+      - name: Checkout
+        uses: actions/checkout@v2
+      - name: Symlinks
+        run: find * -type l -printf "::error::%p is a symlink. This is forbidden by the Arduino Library Specification." -exec false {} +
+      - name: Clang-format
+        run: |
+          find src/ extras/ -name '*.[ch]pp' | xargs clang-format -i --verbose --style=file
+          git diff --exit-code
+
+  gcc:
+    name: GCC
+    needs: lint
+    runs-on: ubuntu-20.04
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - gcc: "4.4"
+          - gcc: "4.6"
+          - gcc: "4.7"
+          - gcc: "4.8"
+          - gcc: "4.9"
+          - gcc: "5"
+          - gcc: "6"
+          - gcc: "7"
+            cxxflags: -fsanitize=leak -fno-sanitize-recover=all
+          - gcc: "8"
+            cxxflags: -fsanitize=undefined -fno-sanitize-recover=all
+          - gcc: "9"
+            cxxflags: -fsanitize=address -fno-sanitize-recover=all
+          - gcc: "10"
+    steps:
+      - name: Install
+        run: |
+          sudo add-apt-repository -yn 'deb http://archive.ubuntu.com/ubuntu/ trusty main'
+          sudo add-apt-repository -yn 'deb http://archive.ubuntu.com/ubuntu/ trusty universe'
+          sudo add-apt-repository -yn 'deb http://archive.ubuntu.com/ubuntu/ xenial main'
+          sudo add-apt-repository -yn 'deb http://archive.ubuntu.com/ubuntu/ xenial universe' 
+          sudo add-apt-repository -yn 'deb http://archive.ubuntu.com/ubuntu/ bionic main'
+          sudo add-apt-repository -yn 'deb http://archive.ubuntu.com/ubuntu/ bionic universe' 
+          sudo apt-get update
+          sudo apt-get install -y gcc-${{ matrix.gcc }} g++-${{ matrix.gcc }}
+      - name: Checkout
+        uses: actions/checkout@v2
+      - name: Configure
+        run: cmake -DCMAKE_BUILD_TYPE=Debug .
+        env:
+          CC: gcc-${{ matrix.gcc }}
+          CXX: g++-${{ matrix.gcc }}
+          CXXFLAGS: ${{ matrix.cxxflags }}
+      - name: Build
+        run: cmake --build .
+      - name: Test
+        run: ctest --output-on-failure -C Debug .
+        env:
+          UBSAN_OPTIONS: print_stacktrace=1
+
+  clang:
+    name: Clang
+    needs: lint
+    runs-on: ubuntu-20.04
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - clang: "3.5"
+            cxxflags: "-stdlib=libc++"
+          - clang: "3.6"
+            cxxflags: "-stdlib=libc++"
+          - clang: "3.7"
+            cxxflags: "-stdlib=libc++"
+          - clang: "3.8"
+            cxxflags: "-stdlib=libc++"
+          - clang: "3.9"
+            cxxflags: "-stdlib=libc++"
+          - clang: "4.0"
+            cxxflags: "-stdlib=libc++"
+          - clang: "5.0"
+          - clang: "6.0"
+          - clang: "7"
+          - clang: "8"
+            cxxflags: -fsanitize=leak -fno-sanitize-recover=all
+          - clang: "9"
+            cxxflags: -fsanitize=undefined -fno-sanitize-recover=all
+          - clang: "10"
+            cxxflags: -fsanitize=address -fno-sanitize-recover=all
+    steps:
+      - name: Install
+        run: |
+          sudo add-apt-repository -yn 'deb http://archive.ubuntu.com/ubuntu/ trusty main'
+          sudo add-apt-repository -yn 'deb http://archive.ubuntu.com/ubuntu/ trusty universe'
+          sudo add-apt-repository -yn 'deb http://archive.ubuntu.com/ubuntu/ xenial main'
+          sudo add-apt-repository -yn 'deb http://archive.ubuntu.com/ubuntu/ xenial universe' 
+          sudo add-apt-repository -yn 'deb http://archive.ubuntu.com/ubuntu/ bionic main'
+          sudo add-apt-repository -yn 'deb http://archive.ubuntu.com/ubuntu/ bionic universe' 
+          sudo apt-get update
+          sudo apt-get install -y clang-${{ matrix.clang }}
+      - name: Checkout
+        uses: actions/checkout@v2
+      - name: Configure
+        run: cmake -DCMAKE_BUILD_TYPE=Debug .
+        env:
+          CC: clang-${{ matrix.clang }}
+          CXX: clang++-${{ matrix.clang }}
+          CXXFLAGS: >-
+            ${{ matrix.cxxflags }}
+            ${{ contains(matrix.cxxflags, 'libc++') && '-I/usr/lib/llvm-10/include/c++/v1/' || '' }}
+      - name: Build
+        run: cmake --build .
+      - name: Test
+        run: ctest --output-on-failure -C Debug .
+        env:
+          UBSAN_OPTIONS: print_stacktrace=1
+
+  xcode:
+    name: XCode
+    needs: clang
+    runs-on: macos-10.15
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - xcode: "10.3"
+          - xcode: "11.7"
+          - xcode: "12.4"
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v2
+      - name: Select XCode version
+        run: sudo xcode-select --switch /Applications/Xcode_${{ matrix.xcode }}.app
+      - name: Configure
+        run: cmake -DCMAKE_BUILD_TYPE=Debug .
+      - name: Build
+        run: cmake --build .
+      - name: Test
+        run: ctest --output-on-failure -C Debug .
+
+  # DISABLED: Running on AppVeyor instead because it supports older versions of the compiler
+  # msvc:
+  #   name: Visual Studio
+  #   strategy:
+  #     fail-fast: false
+  #     matrix:
+  #       include:
+  #         - os: windows-2016
+  #         - os: windows-2019
+  #   runs-on: ${{ matrix.os }}
+  #   steps:
+  #     - name: Checkout
+  #       uses: actions/checkout@v2
+  #     - name: Configure
+  #       run: cmake -DCMAKE_BUILD_TYPE=Debug .
+  #     - name: Build
+  #       run: cmake --build .
+  #     - name: Test
+  #       run: ctest --output-on-failure -C Debug .
+
+  arduino:
+    name: Arduino
+    needs: gcc
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - arduino: "1.6.7"
+            os: ubuntu-18.04 # java.lang.Error: Cannot load com.sun.java.swing.plaf.gtk.GTKLookAndFeel
+            board: arduino:avr:uno
+          - arduino: "1.8.2"
+            board: arduino:samd:mkr1000
+    runs-on: ${{ matrix.os || 'ubuntu-latest' }}
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v2
+      - name: Build
+        run: extras/ci/arduino.sh ${{ matrix.board }}
+        env:
+          BOARD: ${{ matrix.board }}
+          VERSION: ${{ matrix.arduino }}
+
+  platformio:
+    name: PlatformIO
+    needs: gcc
+    runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - platform: atmelavr
+            board: leonardo
+            libraries:
+              - SD
+              - Ethernet
+          - platform: espressif8266
+            board: huzzah
+          - platform: espressif32
+            board: esp32dev
+            libraries:
+              - Ethernet
+          - platform: atmelsam
+            board: mkr1000USB
+            libraries:
+              - SD
+              - Ethernet
+          - platform: teensy
+            board: teensy31
+          - platform: ststm32
+            board: adafruit_feather_f405
+            libraries:
+              - SD
+              - Ethernet
+          - platform: nordicnrf52
+            board: adafruit_feather_nrf52840
+            libraries:
+              - SD
+              - Ethernet
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v2
+      - name: Set up cache for pip
+        uses: actions/cache@v2
+        with:
+          path: ~/.cache/pip
+          key: ${{ runner.os }}-pip
+      - name: Set up Python 3.x
+        uses: actions/setup-python@v2
+        with:
+          python-version: "3.x"
+      - name: Install PlatformIO
+        run: pip install platformio
+      - name: Install adafruit-nrfutil
+        if: ${{ matrix.platform == 'nordicnrf52' }}
+        run: pip install adafruit-nrfutil
+      - name: Set up cache for platformio
+        uses: actions/cache@v2
+        with:
+          path: ~/.platformio
+          key: ${{ runner.os }}-platformio-${{ matrix.platform }}
+      - name: Install platform "${{ matrix.platform }}"
+        run: platformio platform install ${{ matrix.platform }}
+      - name: Install libraries
+        if: ${{ matrix.libraries }}
+        run: platformio lib install arduino-libraries/${{ join(matrix.libraries, ' arduino-libraries/') }}
+      - name: Build JsonConfigFile
+        run: platformio ci "examples/JsonConfigFile/JsonConfigFile.ino" -l '.' -b ${{ matrix.board }}
+      - name: Build JsonFilterExample
+        run: platformio ci "examples/JsonFilterExample/JsonFilterExample.ino" -l '.' -b ${{ matrix.board }}
+      - name: Build JsonGeneratorExample
+        run: platformio ci "examples/JsonGeneratorExample/JsonGeneratorExample.ino" -l '.' -b ${{ matrix.board }}
+      - name: Build JsonHttpClient
+        run: platformio ci "examples/JsonHttpClient/JsonHttpClient.ino" -l '.' -b ${{ matrix.board }}
+      - name: Build JsonParserExample
+        run: platformio ci "examples/JsonParserExample/JsonParserExample.ino" -l '.' -b ${{ matrix.board }}
+      - name: Build JsonServer
+        if: ${{ matrix.platform != 'espressif32' }}
+        run: platformio ci "examples/JsonServer/JsonServer.ino" -l '.' -b ${{ matrix.board }}
+      - name: Build JsonUdpBeacon
+        run: platformio ci "examples/JsonUdpBeacon/JsonUdpBeacon.ino" -l '.' -b ${{ matrix.board }}
+      - name: Build MsgPackParser
+        run: platformio ci "examples/MsgPackParser/MsgPackParser.ino" -l '.' -b ${{ matrix.board }}
+      - name: Build ProgmemExample
+        run: platformio ci "examples/ProgmemExample/ProgmemExample.ino" -l '.' -b ${{ matrix.board }}
+      - name: Build StringExample
+        run: platformio ci "examples/StringExample/StringExample.ino" -l '.' -b ${{ matrix.board }}
+      - name: PlatformIO prune
+        if: ${{ always() }}
+        run: platformio system prune -f
+
+  particle:
+    name: Particle
+    needs: gcc
+    runs-on: ubuntu-latest
+    if: github.event_name == 'push'
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - board: argon
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v2
+      - name: Install Particle CLI
+        run: sudo npm install -g particle-cli
+      - name: Login to Particle
+        run: particle login -t "${{ secrets.PARTICLE_TOKEN }}"
+      - name: Compile
+        run: extras/ci/particle.sh ${{ matrix.board }}
+
+  arm:
+    name: GCC for ARM processor
+    needs: gcc
+    runs-on: ubuntu-20.04
+    steps:
+      - name: Install
+        run: |
+          sudo apt-get update
+          sudo apt-get install -y g++-arm-linux-gnueabihf
+      - name: Checkout
+        uses: actions/checkout@v2
+      - name: Configure
+        run: cmake .
+        env:
+          CC: arm-linux-gnueabihf-gcc
+          CXX: arm-linux-gnueabihf-g++
+      - name: Build
+        run: cmake --build .
+
+  coverage:
+    needs: gcc
+    name: Coverage
+    runs-on: ubuntu-20.04
+    steps:
+      - name: Install
+        run: sudo apt-get install -y lcov ninja-build
+      - name: Checkout
+        uses: actions/checkout@v2
+      - name: Configure
+        run: cmake -G Ninja -DCOVERAGE=true .
+      - name: Build
+        run: ninja
+      - name: Test
+        run: ctest -LE 'WillFail|Fuzzing' -T test
+      - name: lcov --capture
+        run: lcov --capture --no-external --directory . --output-file coverage.info
+      - name: lcov --remove
+        run: lcov --remove coverage.info "$(pwd)/extras/*" --output-file coverage_filtered.info
+      - name: genhtml
+        run: mkdir coverage && genhtml coverage_filtered.info -o coverage -t ArduinoJson
+      - name: Upload HTML report
+        uses: actions/upload-artifact@v2
+        with:
+          name: Coverage report
+          path: coverage
+      - name: Upload to Coveralls
+        uses: coverallsapp/github-action@master
+        with:
+          github-token: ${{ secrets.GITHUB_TOKEN }}
+          path-to-lcov: coverage_filtered.info
+
+  valgrind:
+    needs: gcc
+    name: Valgrind
+    runs-on: ubuntu-20.04
+    steps:
+      - name: Install
+        run: sudo apt-get install -y valgrind ninja-build
+      - name: Checkout
+        uses: actions/checkout@v2
+      - name: Configure
+        run: cmake -G Ninja -D MEMORYCHECK_COMMAND_OPTIONS="--error-exitcode=1 --leak-check=full"  .
+      - name: Build
+        run: ninja
+      - name: Memcheck
+        run: ctest -LE WillFail -T memcheck
+        id: memcheck
+      - name: MemoryChecker.*.log
+        run: cat Testing/Temporary/MemoryChecker.*.log
+        if: failure()
+
+  clang-tidy:
+    needs: clang
+    name: Clang-Tidy
+    runs-on: ubuntu-20.04
+    steps:
+      - name: Install
+        run: sudo apt-get install -y clang-tidy cmake ninja-build
+      - name: Checkout
+        uses: actions/checkout@v2
+      - name: Configure
+        run: cmake -G Ninja -DCMAKE_CXX_CLANG_TIDY="clang-tidy-10;--warnings-as-errors=*" -DCMAKE_BUILD_TYPE=Debug .
+        env:
+          CC: clang-10
+          CXX: clang++-10
+      - name: Check
+        run: cmake --build . -- -k 0
+
+  amalgamate-h:
+    needs: gcc
+    name: Amalgamate ArduinoJson.h
+    runs-on: ubuntu-20.04
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v2
+      - name: Amalgamate
+        id: amalgamate
+        run: |
+          if [[ $GITHUB_REF == refs/tags/* ]]; then
+            VERSION=${GITHUB_REF#refs/tags/}
+          else
+            VERSION=${GITHUB_SHA::7}
+          fi
+          INPUT=src/ArduinoJson.h
+          OUTPUT=ArduinoJson-$VERSION.h
+          extras/scripts/build-single-header.sh "$INPUT" "$OUTPUT"
+          echo ::set-output name=filename::${OUTPUT}
+      - name: Smoke test
+        run: |
+          g++ -x c++ - <<END
+          #include "${{ steps.amalgamate.outputs.filename }}"
+          int main() {
+            StaticJsonDocument<300> doc;
+            deserializeJson(doc, "{}");
+          }
+          END
+      - name: Upload artifact
+        uses: actions/upload-artifact@v2
+        with:
+          name: Single headers
+          path: ${{ steps.amalgamate.outputs.filename }}
+
+  amalgamate-hpp:
+    needs: gcc
+    name: Amalgamate ArduinoJson.hpp
+    runs-on: ubuntu-20.04
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v2
+      - name: Amalgamate
+        id: amalgamate
+        run: |
+          if [[ $GITHUB_REF == refs/tags/* ]]; then
+            VERSION=${GITHUB_REF#refs/tags/}
+          else
+            VERSION=${GITHUB_SHA::7}
+          fi
+          INPUT=src/ArduinoJson.hpp
+          OUTPUT=ArduinoJson-$VERSION.hpp
+          extras/scripts/build-single-header.sh "$INPUT" "$OUTPUT"
+          echo ::set-output name=filename::${OUTPUT}
+      - name: Smoke test
+        run: |
+          g++ -x c++ - <<END
+          #include "${{ steps.amalgamate.outputs.filename }}"
+          int main() {
+            ArduinoJson::StaticJsonDocument<300> doc;
+            deserializeJson(doc, "{}");
+          }
+          END
+      - name: Upload artifact
+        uses: actions/upload-artifact@v2
+        with:
+          name: Single headers
+          path: ${{ steps.amalgamate.outputs.filename }}
+
+  esp-idf:
+    needs: gcc
+    name: ESP-IDF
+    runs-on: ubuntu-latest
+    steps:
+      - name: Setup cache
+        uses: actions/cache@v2
+        with:
+          path: ~/.espressif
+          key: ${{ runner.os }}-esp-idf
+      - name: Checkout ArduinoJson
+        uses: actions/checkout@v2
+      - name: Checkout ESP-IDF
+        uses: actions/checkout@v2
+        with:
+          repository: espressif/esp-idf
+          path: esp-idf
+          submodules: true
+      - name: Install ESP-IDF
+        run: ./esp-idf/install.sh
+      - name: Add component
+        # NOTE: we cannot commit the symlink because the Arduino Library Specification forbids it.
+        run: |
+          mkdir -p extras/ci/espidf/components
+          ln -s $PWD extras/ci/espidf/components/ArduinoJson
+      - name: Build example
+        run: |
+          source esp-idf/export.sh
+          cd extras/ci/espidf
+          idf.py build

.github/workflows/lock.yml

@@ -0,0 +1,14 @@
+name: 'Lock Threads'
+
+on:
+  schedule:
+    - cron: '0 0 * * *'
+
+jobs:
+  lock:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: dessant/lock-threads@v2
+        with:
+          github-token: ${{ github.token }}
+          issue-lock-inactive-days: 30

.github/workflows/release.yml

@@ -0,0 +1,51 @@
+name: Release
+
+on:
+  push:
+    tags:
+      - v*.*.*
+
+jobs:
+  release:
+    name: Create release
+    runs-on: ubuntu-20.04
+    steps:
+      - name: Set variables
+        id: init
+        run: |
+          echo ::set-output name=tag::${GITHUB_REF#refs/tags/}
+          echo ::set-output name=version::${GITHUB_REF#refs/tags/v}
+      - name: Checkout
+        uses: actions/checkout@v2
+      - name: Write release body
+        id: body
+        run: |
+          FILENAME=RELEASE.md
+          extras/scripts/get-release-body.sh ${{ steps.init.outputs.tag }} CHANGELOG.md | tee $FILENAME
+          echo ::set-output name=filename::$FILENAME
+      - name: Amalgamate ArduinoJson.h
+        id: amalgamate_h
+        run: |
+          FILENAME=ArduinoJson-${{ steps.init.outputs.tag }}.h
+          extras/scripts/build-single-header.sh src/ArduinoJson.h "$FILENAME"
+          echo ::set-output name=filename::$FILENAME
+      - name: Amalgamate ArduinoJson.hpp
+        id: amalgamate_hpp
+        run: |
+          FILENAME=ArduinoJson-${{ steps.init.outputs.tag }}.hpp
+          extras/scripts/build-single-header.sh src/ArduinoJson.hpp "$FILENAME"
+          echo ::set-output name=filename::$FILENAME
+      - name: Create Arduino package
+        id: arduino
+        run: |
+          FILENAME=ArduinoJson-${{ steps.init.outputs.tag }}.zip
+          extras/scripts/build-arduino-package.sh . "$FILENAME"
+          echo ::set-output name=filename::$FILENAME
+      - name: Create release
+        uses: ncipollo/release-action@v1
+        with:
+          bodyFile: ${{ steps.body.outputs.filename }}
+          draft: true
+          name: ArduinoJson ${{ steps.init.outputs.version }}
+          artifacts: ${{ steps.amalgamate_h.outputs.filename }},${{ steps.amalgamate_hpp.outputs.filename }},${{ steps.arduino.outputs.filename }}
+          token: ${{ secrets.GITHUB_TOKEN }}

.gitignore

@@ -3,3 +3,14 @@
 /build
 /bin
 /lib
+/sftp-config.json
+.tags
+.tags_sorted_by_file
+/extras/fuzzing/*_fuzzer
+/extras/fuzzing/*_fuzzer.options
+/extras/fuzzing/*_fuzzer_seed_corpus.zip
+.vs/
+
+# Used by CI for Particle
+/src/*.ino
+/project.properties

.mbedignore

@@ -0,0 +1,3 @@
+.github/
+examples/
+extras/

.prettierignore

@@ -0,0 +1 @@
+*.md

.travis.yml

@@ -1,6 +0,0 @@
-language: c++
-compiler:
-  - gcc
-  - clang
-before_script: cmake .
-script: make && make test

.vscode/settings.json

@@ -0,0 +1,8 @@
+{
+  "C_Cpp.default.configurationProvider": "ms-vscode.cmake-tools",
+  "cmake.generator": "Ninja",
+  "git.inputValidationLength": 80,
+  "git.inputValidationSubjectLength": 72,
+  "files.insertFinalNewline": true,
+  "files.trimFinalNewlines": true
+}

ArduinoJson.h

@@ -0,0 +1,5 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright Benoit Blanchon 2014-2021
+// MIT License
+
+#include "src/ArduinoJson.h"

CMakeLists.txt

@@ -1,15 +1,26 @@
-cmake_minimum_required(VERSION 2.8.4)
-project(ArduinoJson)
+# ArduinoJson - https://arduinojson.org
+# Copyright Benoit Blanchon 2014-2021
+# MIT License
 
-enable_testing()
+cmake_minimum_required(VERSION 3.3)
 
-set(CMAKE_ARCHIVE_OUTPUT_DIRECTORY ${CMAKE_SOURCE_DIR}/lib)
-set(CMAKE_LIBRARY_OUTPUT_DIRECTORY ${CMAKE_SOURCE_DIR}/lib)
-set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${CMAKE_SOURCE_DIR}/bin)
+if(ESP_PLATFORM)
+   # Build ArduinoJson as an ESP-IDF component
+   idf_component_register(INCLUDE_DIRS src)
+   target_compile_definitions(${COMPONENT_LIB} INTERFACE ARDUINOJSON_EMBEDDED_MODE=1)
+   return()
+endif()
 
-if(MSVC)
-	add_definitions(-D_CRT_SECURE_NO_WARNINGS -W4)
+project(ArduinoJson VERSION 6.18.2)
+
+if(CMAKE_PROJECT_NAME STREQUAL PROJECT_NAME)
+    include(CTest)
 endif()
 
 add_subdirectory(src)
-add_subdirectory(test)
+
+if(CMAKE_PROJECT_NAME STREQUAL PROJECT_NAME AND BUILD_TESTING)
+	include(extras/CompileOptions.cmake)
+	add_subdirectory(extras/tests)
+	add_subdirectory(extras/fuzzing)
+endif()

CONTRIBUTING.md

@@ -0,0 +1,10 @@
+# Contribution to ArduinoJson
+
+First, thank you for taking the time to contribute to this project.
+
+You can submit changes via GitHub Pull Requests.
+
+Please:
+
+1. Update the test suite for any change of behavior
+2. Use clang-format in "file" mode to format the code

LICENSE.md

@@ -1,10 +1,10 @@
 The MIT License (MIT)
 ---------------------
 
-Copyright © 2014 Benoit BLANCHON
+Copyright © 2014-2021 Benoit BLANCHON
 
 Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the “Software”), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
 
 The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
 
-THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

README.md

@@ -1,79 +1,144 @@
-Arduino JSON library
-====================
-
-[![Build Status](https://travis-ci.org/bblanchon/ArduinoJson.svg?branch=master)](https://travis-ci.org/bblanchon/ArduinoJson)
-
-*An elegant and efficient JSON library for embedded systems.*
-
-It's design to have the most intuitive API, the smallest footprint and works without any allocation on the heap (no malloc).
-
-It has been written with Arduino in mind, but it isn't linked to Arduino libraries so you can use this library in any other C++ project.
-
-Features
---------
-
-* JSON decoding
-* JSON encoding (with optional indentation)
-* Elegant API, very easy to use 
-* Fixed memory allocation (no malloc)
-* Small footprint
-* MIT License
-
-Quick start
------------
-
-#### Decoding / Parsing
-   
-    char json[] = "{\"sensor\":\"gps\",\"time\":1351824120,\"data\":[48.756080,2.302038]}";
-
-    StaticJsonBuffer<200> jsonBuffer;
-
-    JsonObject& root = jsonBuffer.parseObject(json);
-
-    const char* sensor = root["sensor"];
-    long time          = root["time"];
-    double latitude    = root["data"][0];
-    double longitude   = root["data"][1];
-
-[See complete guide](/doc/Decoding JSON.md)
-
-#### Encoding / Generating
-   
-    StaticJsonBuffer<200> jsonBuffer;
-
-    JsonObject& root = jsonBuffer.createObject();
-    root["sensor"] = "gps";
-    root["time"] = 1351824120;
-
-    JsonArray& data = root.createNestedArray("data");
-    data.add(48.756080, 6);  // 6 is the number of decimals to print
-    data.add(2.302038, 6);   // if not specified, 2 digits are printed
-
-    root.printTo(Serial);
-    // This prints:
-    // {"sensor":"gps","time":1351824120,"data":[48.756080,2.302038]}
-
-[See complete guide](/doc/Encoding JSON.md)
-
-Testimonials
-------------
-
-From Arduino's Forum user `jflaplante`:
-> I tried aJson json-arduino before trying your library. I always ran into memory problem after a while. 
-> I have no such problem so far with your library. It is working perfectly with my web services.
-
-From Arduino's Forum user `gbathree`:
-> Thanks so much - this is an awesome library!  If you want to see what we're doing with it - the project is located at www.photosynq.org.
-
-From StackOverflow user `thegreendroid`:
-> It has a really elegant, simple API and it works like a charm on embedded and Windows/Linux platforms. We recently started using this on an embedded project and I can vouch for its quality.
-
-From GitHub user `zacsketches`:
-
-> Thanks for a great library!!!
-> I've been watching you consistently develop this library over the past six months, and I used it today for a publish and subscribe architecture designed to help hobbyists move into more advanced robotics. Your library allowed me to implement remote subscription in order to facilitate multi-processor robots.
-> ArduinoJson saved me a week's worth of time!!
+![ArduinoJson](banner.svg)
 
 ---
 
-Found this library useful? [Help me back with a donation!](https://www.paypal.com/cgi-bin/webscr?cmd=_donations&business=donate%40benoitblanchon%2efr&lc=GB&item_name=Benoit%20Blanchon&item_number=Arduino%20JSON&currency_code=EUR&bn=PP%2dDonationsBF%3abtn_donate_LG%2egif%3aNonHosted) :smile:
+[![arduino-library-badge](https://www.ardu-badge.com/badge/ArduinoJson.svg?version=6.18.2)](https://www.ardu-badge.com/ArduinoJson/6.18.2)
+[![Continuous Integration](https://github.com/bblanchon/ArduinoJson/workflows/Continuous%20Integration/badge.svg?branch=6.x)](https://github.com/bblanchon/ArduinoJson/actions?query=workflow%3A%22Continuous+Integration%22+branch%3A6.x)
+[![Continuous Integration](https://ci.appveyor.com/api/projects/status/m7s53wav1l0abssg/branch/6.x?svg=true)](https://ci.appveyor.com/project/bblanchon/arduinojson/branch/6.x)
+[![Fuzzing Status](https://oss-fuzz-build-logs.storage.googleapis.com/badges/arduinojson.svg)](https://bugs.chromium.org/p/oss-fuzz/issues/list?sort=-opened&can=1&q=proj:arduinojson)
+[![Coverage Status](https://coveralls.io/repos/github/bblanchon/ArduinoJson/badge.svg?branch=6.x)](https://coveralls.io/github/bblanchon/ArduinoJson?branch=6.x)
+[![GitHub stars](https://img.shields.io/github/stars/bblanchon/ArduinoJson?style=flat)](https://github.com/bblanchon/ArduinoJson/stargazers)
+
+ArduinoJson is a C++ JSON library for Arduino and IoT (Internet Of Things).
+
+## Features
+
+* [JSON deserialization](https://arduinojson.org/v6/api/json/deserializejson/?utm_source=github&utm_medium=readme)
+    * [Optionally decodes UTF-16 escape sequences to UTF-8](https://arduinojson.org/v6/api/config/decode_unicode/?utm_source=github&utm_medium=readme)
+    * [Optionally stores links to the input buffer (zero-copy)](https://arduinojson.org/v6/api/json/deserializejson/?utm_source=github&utm_medium=readme)
+    * [Optionally supports comments in the input](https://arduinojson.org/v6/api/config/enable_comments/?utm_source=github&utm_medium=readme)
+    * [Optionally filters the input to keep only desired values](https://arduinojson.org/v6/api/json/deserializejson/?utm_source=github&utm_medium=readme#filtering)
+    * Supports single quotes as a string delimiter
+    * Compatible with [NDJSON](http://ndjson.org/) and [JSON Lines](https://jsonlines.org/)
+* [JSON serialization](https://arduinojson.org/v6/api/json/serializejson/?utm_source=github&utm_medium=readme)
+    * [Can write to a buffer or a stream](https://arduinojson.org/v6/api/json/serializejson/?utm_source=github&utm_medium=readme)
+    * [Optionally indents the document (prettified JSON)](https://arduinojson.org/v6/api/json/serializejsonpretty/?utm_source=github&utm_medium=readme)
+* [MessagePack serialization](https://arduinojson.org/v6/api/msgpack/serializemsgpack/?utm_source=github&utm_medium=readme)
+* [MessagePack deserialization](https://arduinojson.org/v6/api/msgpack/deserializemsgpack/?utm_source=github&utm_medium=readme)
+* Efficient
+    * [Twice smaller than the "official" Arduino_JSON library](https://arduinojson.org/2019/11/19/arduinojson-vs-arduino_json/?utm_source=github&utm_medium=readme)
+    * [Almost 10% faster than the "official" Arduino_JSON library](https://arduinojson.org/2019/11/19/arduinojson-vs-arduino_json/?utm_source=github&utm_medium=readme)
+    * [Consumes roughly 10% less RAM than the "official" Arduino_JSON library](https://arduinojson.org/2019/11/19/arduinojson-vs-arduino_json/?utm_source=github&utm_medium=readme)
+    * [Fixed memory allocation, no heap fragmentation](https://arduinojson.org/v6/api/jsondocument/?utm_source=github&utm_medium=readme)
+    * [Optionally works without heap memory (zero malloc)](https://arduinojson.org/v6/api/staticjsondocument/?utm_source=github&utm_medium=readme)
+    * Deduplicates strings
+* Versatile
+    * Supports [custom allocators (to use external RAM chip, for example)](https://arduinojson.org/v6/how-to/use-external-ram-on-esp32/?utm_source=github&utm_medium=readme)
+    * Supports [`String`](https://arduinojson.org/v6/api/config/enable_arduino_string/?utm_source=github&utm_medium=readme), [`std::string`](https://arduinojson.org/v6/api/config/enable_std_string/?utm_source=github&utm_medium=readme) and [`std::string_view`](https://arduinojson.org/v6/api/config/enable_string_view/?utm_source=github&utm_medium=readme)
+    * Supports [`Stream`](https://arduinojson.org/v6/api/config/enable_arduino_stream/?utm_source=github&utm_medium=readme) and [`std::istream`/`std::ostream`](https://arduinojson.org/v6/api/config/enable_std_stream/?utm_source=github&utm_medium=readme)
+    * Supports [Flash strings](https://arduinojson.org/v6/api/config/enable_progmem/?utm_source=github&utm_medium=readme)
+    * Supports [custom readers](https://arduinojson.org/v6/api/json/deserializejson/?utm_source=github&utm_medium=readme#custom-reader) and [custom writers](https://arduinojson.org/v6/api/json/serializejson/?utm_source=github&utm_medium=readme#custom-writer)
+    * Supports [custom converters](https://arduinojson.org/news/2021/05/04/version-6-18-0/?utm_source=github&utm_medium=readme)
+* Portable
+    * Usable on any C++ project (not limited to Arduino)
+    * Compatible with C++98, C++11, C++14 and C++17
+    * Zero warnings with `-Wall -Wextra -pedantic` and `/W4`
+    * [Header-only library](https://en.wikipedia.org/wiki/Header-only)
+    * Works with virtually any board
+        * Arduino boards: [Uno](https://amzn.to/38aL2ik), [Due](https://amzn.to/36YkWi2), [Micro](https://amzn.to/35WkdwG), [Nano](https://amzn.to/2QTvwRX), [Mega](https://amzn.to/36XWhuf), [Yun](https://amzn.to/30odURc), [Leonardo](https://amzn.to/36XWjlR)...
+        * Espressif chips: [ESP8266](https://amzn.to/36YluV8), [ESP32](https://amzn.to/2G4pRCB)
+        * Lolin (WeMos) boards: [D1 mini](https://amzn.to/2QUpz7q), [D1 Mini Pro](https://amzn.to/36UsGSs)...
+        * Teensy boards: [4.0](https://amzn.to/30ljXGq), [3.2](https://amzn.to/2FT0EuC), [2.0](https://amzn.to/2QXUMXj) 
+        * Particle boards: [Argon](https://amzn.to/2FQHa9X), [Boron](https://amzn.to/36WgLUd), [Electron](https://amzn.to/30vEc4k), [Photon](https://amzn.to/387F9Cd)...
+        * Texas Instruments boards: [MSP430](https://amzn.to/30nJWgg)...
+    * Tested on all major development environments
+        * [Arduino IDE](https://www.arduino.cc/en/Main/Software)
+        * [Atmel Studio](http://www.atmel.com/microsite/atmel-studio/)
+        * [Atollic TrueSTUDIO](https://atollic.com/truestudio/)
+        * [Energia](http://energia.nu/)
+        * [IAR Embedded Workbench](https://www.iar.com/iar-embedded-workbench/)
+        * [Keil uVision](http://www.keil.com/)
+        * [MPLAB X IDE](http://www.microchip.com/mplab/mplab-x-ide)
+        * [Particle](https://www.particle.io/)
+        * [PlatformIO](http://platformio.org/)
+        * [Sloeber plugin for Eclipse](https://eclipse.baeyens.it/)
+        * [Visual Micro](http://www.visualmicro.com/)
+        * [Visual Studio](https://www.visualstudio.com/)
+    * [Even works with online compilers like wandbox.org](https://wandbox.org/permlink/RlZSKy17DjJ6HcdN)
+    * [CMake friendly](https://arduinojson.org/v6/how-to/use-arduinojson-with-cmake/?utm_source=github&utm_medium=readme)
+* Well designed
+    * [Elegant API](http://arduinojson.org/v6/example/?utm_source=github&utm_medium=readme)
+    * [Thread-safe](https://en.wikipedia.org/wiki/Thread_safety)
+    * Self-contained (no external dependency)
+    * `const` friendly
+    * [`for` friendly](https://arduinojson.org/v6/api/jsonobject/begin_end/?utm_source=github&utm_medium=readme)
+    * [TMP friendly](https://en.wikipedia.org/wiki/Template_metaprogramming)
+    * Handles [integer overflows](https://arduinojson.org/v6/api/jsonvariant/as/?utm_source=github&utm_medium=readme#integer-overflows)
+* Well tested
+    * [Unit test coverage close to 100%](https://coveralls.io/github/bblanchon/ArduinoJson?branch=6.x)
+    * Continuously tested on
+        * [Visual Studio 2010, 2012, 2013, 2015, 2017, 2019](https://ci.appveyor.com/project/bblanchon/arduinojson/branch/6.x)
+        * [GCC 4.4, 4.6, 4.7, 4.8, 4.9, 5, 6, 7, 8, 9, 10](https://github.com/bblanchon/ArduinoJson/actions?query=workflow%3A%22Continuous+Integration%22)
+        * [Clang 3.5, 3.6, 3.7, 3.8, 3.9, 4.0, 5.0, 6.0, 7, 8, 9, 10](https://github.com/bblanchon/ArduinoJson/actions?query=workflow%3A%22Continuous+Integration%22)
+    * [Continuously fuzzed with Google OSS Fuzz](https://bugs.chromium.org/p/oss-fuzz/issues/list?sort=-opened&can=1&q=proj:arduinojson)
+    * Passes all default checks of [clang-tidy](https://releases.llvm.org/10.0.0/tools/clang/tools/extra/docs/clang-tidy/)
+* Well documented
+    * [Tutorials](https://arduinojson.org/v6/doc/deserialization/?utm_source=github&utm_medium=readme)
+    * [Examples](https://arduinojson.org/v6/example/?utm_source=github&utm_medium=readme)
+    * [How-tos](https://arduinojson.org/v6/example/?utm_source=github&utm_medium=readme)
+    * [FAQ](https://arduinojson.org/v6/faq/?utm_source=github&utm_medium=readme)
+    * [Troubleshooter](https://arduinojson.org/v6/troubleshooter/?utm_source=github&utm_medium=readme)
+    * [Book](https://arduinojson.org/book/?utm_source=github&utm_medium=readme)
+    * [Changelog](CHANGELOG.md)
+* Vibrant user community
+    * Most popular of all Arduino libraries on [GitHub](https://github.com/search?o=desc&q=arduino+library&s=stars&type=Repositories)
+    * [Used in hundreds of projects](https://www.hackster.io/search?i=projects&q=arduinojson)
+    * [Responsive support](https://github.com/bblanchon/ArduinoJson/issues?q=is%3Aissue+is%3Aclosed)
+
+## Quickstart
+
+### Deserialization
+
+Here is a program that parses a JSON document with ArduinoJson.
+
+```c++
+char json[] = "{\"sensor\":\"gps\",\"time\":1351824120,\"data\":[48.756080,2.302038]}";
+
+DynamicJsonDocument doc(1024);
+deserializeJson(doc, json);
+
+const char* sensor = doc["sensor"];
+long time          = doc["time"];
+double latitude    = doc["data"][0];
+double longitude   = doc["data"][1];
+```
+
+See the [tutorial on arduinojson.org](https://arduinojson.org/doc/decoding/?utm_source=github&utm_medium=readme)
+
+### Serialization
+
+Here is a program that generates a JSON document with ArduinoJson:
+
+```c++
+DynamicJsonDocument doc(1024);
+
+doc["sensor"] = "gps";
+doc["time"]   = 1351824120;
+doc["data"][0] = 48.756080;
+doc["data"][1] = 2.302038;
+
+serializeJson(doc, Serial);
+// This prints:
+// {"sensor":"gps","time":1351824120,"data":[48.756080,2.302038]}
+```
+
+See the [tutorial on arduinojson.org](https://arduinojson.org/doc/encoding/?utm_source=github&utm_medium=readme)
+
+## Support the project ❤️
+
+Do you like this library?  
+Please [star this project on GitHub](https://github.com/bblanchon/ArduinoJson/stargazers)!
+
+What? You don't like it but you *love* it?  
+You can support the project by [purchasing my book](https://arduinojson.org/book/?utm_source=github&utm_medium=readme).
+Alternatively, you can make a recurring donation via [GitHub Sponsors](https://github.com/sponsors/bblanchon).  

SUPPORT.md

@@ -0,0 +1,27 @@
+# ArduinoJson Support
+
+First off, thank you very much for using ArduinoJson.
+
+We'll be very happy to help you, but first please read the following.
+
+## Before asking for help
+
+1. Read the [FAQ](https://arduinojson.org/faq/?utm_source=github&utm_medium=support)
+2. Search in the [API Reference](https://arduinojson.org/api/?utm_source=github&utm_medium=support)
+
+If you did not find the answer, please create a [new issue on GitHub](https://github.com/bblanchon/ArduinoJson/issues/new).
+
+It is OK to add a comment to a currently opened issue, but please avoid adding comments to a closed issue.
+
+## Before hitting the Submit button
+
+Please provide all the relevant information:
+
+* Good title
+* Short description of the problem
+* Target platform
+* Compiler model and version
+* [MVCE](https://stackoverflow.com/help/mcve)
+* Compiler output
+
+Good questions get fast answers!

appveyor.yml

@@ -0,0 +1,22 @@
+version: 6.18.2.{build}
+environment:
+  matrix:
+  - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2019
+    CMAKE_GENERATOR: Visual Studio 16 2019
+  - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2017
+    CMAKE_GENERATOR: Visual Studio 15 2017
+  - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2015
+    CMAKE_GENERATOR: Visual Studio 14 2015
+  - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2013
+    CMAKE_GENERATOR: Visual Studio 12 2013
+  - CMAKE_GENERATOR: Visual Studio 11 2012
+  - CMAKE_GENERATOR: Visual Studio 10 2010
+  - CMAKE_GENERATOR: MinGW Makefiles
+configuration: Debug
+before_build:
+- set PATH=C:\MinGW\bin;%PATH:C:\Program Files\Git\usr\bin;=% # Workaround for CMake not wanting sh.exe on PATH for MinGW
+- cmake -DCMAKE_BUILD_TYPE=%CONFIGURATION% -G "%CMAKE_GENERATOR%" .
+build_script:
+- cmake --build . --config %CONFIGURATION%
+test_script:
+- ctest -C %CONFIGURATION% --output-on-failure .

component.mk

@@ -0,0 +1 @@
+COMPONENT_ADD_INCLUDEDIRS := src

doc/Avoiding pitfalls.md

@@ -1,102 +0,0 @@
-Avoiding common pitfalls in Arduino JSON
-========================================
-
-As `StaticJsonBuffer` is the corner stone of this library, you'll see that every pitfall listed here are related to a wrong understanding of the memory model.
-
-Make sure you read [Arduino JSON memory model](Memory model.md) before going further.
-
-## 1. Make `StaticJsonBuffer` big enough
-
-By design, the library has no way to tell you why `parseArray()` or `parseObject()` failed.
-
-There are basically two reasons why they may fail:
-
-1. the JSON string is invalid,
-2. the JSON string contains more values that the buffer can store.
-
-So, if you are sure the JSON string is correct and you still can't parse it, you should try to increase the size of the `StaticJsonBuffer`.
-
-## 2. Make sure everything fits in memory
-
-You may go into unpredictable trouble if you allocate more memory than your processor really has.
-It's a very common issue in embedded development.
-
-To diagnose this, look at every big objects in you code and sum their size to check that they fit in RAM.
-
-For example, don't do this:
-
-    char json[1024];                // 1 KB
-    StaticJsonBuffer<512> buffer;   // 514 B
-
-because it may be too big for a processor with only 2 KB: you need free memory to store other variables and the call stack.
-
-That is why an 8-bit processor is not able to parse long and complex JSON strings.
-
-## 3. Keep the `StaticJsonBuffer` in memory long enough
-
-Remember that `StaticJsonBuffer`'s function return references.
-References don't contain data, they are just pointer to the actual.
-So they can only work if the actual data is in memory.
-
-For example, don't do this:
-
-    JsonArray& getArray(char* json)
-    {
-        StaticJsonBuffer<200> buffer;
-        return buffer.parseArray(json); 
-    }
-
-because the local variable `buffer` will be *removed* from memory when the function `parseArray()` returns, and the `JsonArray&` will point to an invalid location.
-
-## 4. Don't reuse the same `StaticJsonBuffer`
-
-During is lifetime a `StaticJsonBuffer` growth until it's discarded. If you try to reuse the same instance several time, it will rapidly get full.
-
-For this reason, you should not use a global variable for your `StaticJsonBuffer`. I don't think there is any scenario in which a global `StaticJsonBuffer` would be a valid option.
-
-The best practice is to declare it in a local scope, so that it's discarded as soon as possible. My advice it to declare it in a function which unique role is to handle the JSON serialization.
-
-## 5. Keep the JSON string in memory long enough
-
-The library never make memory duplication.
-This has an important implication on string values, it means that the library will return pointer to chunks of the string.
-
-For instance, let's imagine that you parse `["hello","world"]`, like this:
-
-    char[] json = "[\"hello\",\"world\"]";
-    StaticJsonBuffer<32> buffer;
-    JsonArray& array = buffer.parseArray(json);
-
-    const char* first = array[0];
-    const char* second = array[1];
-
-In that case, both `first` and `second` are pointers to the content of the original string `json`.
-So this will only work if `json` is still in memory.
-
-## 6. JSON string is altered
-
-If you read carefully the previous section, you may have come to the conclusion that the JSON parser modifies the JSON string.
-
-Indeed, the parser modifies the string for two reasons:
-
-1. it inserts `\0` to terminate substrings,
-2. it translate escaped characters like `\n` or `\t`.
-
-Most of the time this wont be an issue, but there are some corner cases that can be problematic.
-
-Let take the example bellow:
-
-    char[] json = "[\"hello\",\"world\"]";
-    StaticJsonBuffer<32> buffer;
-    JsonArray& array = buffer.parseArray(json);
-
-If you replace it by:
-
-    char* json = "[\"hello\",\"world\"]";
-    StaticJsonBuffer<32> buffer;
-    JsonArray& array = buffer.parseArray(json);
-
-Depending on your platform, you may have an exception because the parser tries to write at a location that is read-only.
-In the first case `char json[]` declares an array of `char` initialized to the specified string.
-In the second case `char* json` declares a pointer to a read-only string, in fact it should be a `const char*` instead of a `char*`.
-

doc/Contributing.md

@@ -1,15 +0,0 @@
-Contributing to Arduino JSON
-============================
-
-If you want to contribute to the project, please:
-
-1. Use GitHub pull request feature
-2. Follow the coding conventions
-3. Write tests
-
-About the coding conventions: I try to follow the [Google C++ Style Guide](http://google-styleguide.googlecode.com/svn/trunk/cppguide.html) with few variations to match the Arduino conventions.
-
-I use [ClangFormat](http://clang.llvm.org/docs/ClangFormat.html) to format the code for me.
-I use [CppLint](http://google-styleguide.googlecode.com/svn/trunk/cpplint/cpplint.py) to detect non-compliant stuff.
-
-You should have a look at the `scripts/` folder as it contains a few helpers scripts.

doc/Decoding JSON.md

@@ -1,148 +0,0 @@
-Decoding JSON with Arduino JSON
-===============================
-
-Before writing any code, don't forget to include the header:
-
-    #include <ArduinoJson.h>
-
-For instructions on how to install the library, please read [Using the library with Arduino](Using the library with Arduino.md) or [Using the library without Arduino](Using the library without Arduino.md).
-
-## Example
-
-Here an example that parse the string `{"sensor":"gps","time":1351824120,"data":[48.756080,2.302038]}`:
-
-    char json[] = "{\"sensor\":\"gps\",\"time\":1351824120,\"data\":[48.756080,2.302038]}";
-    
-    //
-    // Step 1: Reserve memory space
-    //
-    StaticJsonBuffer<200> jsonBuffer;
-    
-    //
-    // Step 2: Deserialize the JSON string
-    //
-    JsonObject& root = jsonBuffer.parseObject(json);
-
-    if (!root.success())
-    {
-      Serial.println("parseObject() failed");
-      return;
-    }
-
-    //
-    // Step 3: Retrieve the values
-    //
-    const char* sensor    = root["sensor"];
-    long        time      = root["time"];
-    double      latitude  = root["data"][0];
-    double      longitude = root["data"][1];
-
-## Step 1: Reserve memory space
-
-Arduino JSON uses a preallocated memory pool to store the object tree, this is done by the `StaticJsonBuffer`.
-
-Before continuing please read the page [Arduino JSON memory model](Memory model.md) that explains everything you need to know about `StaticJsonBuffer`.
-
-## Step 2: Parse the JSON string
-
-You invoke the JSON parser through the instance of `StaticJsonBuffer`.
-It exposes two functions for parsing JSON:
-
-1. `parseArray()` that returns a reference to a `JsonArray`
-2. `parseObject()` that returns a reference to a `JsonObject`
-
-Let's see an example.
-Say we want to parse `{"sensor":"gps","time":1351824120,"data":[48.756080,2.302038]}`, it's an object so we call `parseObject()` as follows:
-
-    char json[] = "{\"sensor\":\"gps\",\"time\":1351824120,\"data\":[48.756080,2.302038]}";
-
-    JsonObject& root = jsonBuffer.parseObject(json);
-
-As you can see `parseObject()` takes a `char*` as a parameter.
-Be careful, it's not a `const char*`, the memory must be writable.
-Indeed, the parser will modify the string in two cases:
-
-1. to insert string endings (character `\0`),
-2. to translate escaped characters (like `\n` or `\t`).
-
-Another thing that you must keep in mind is that the string (`char json[]` in the example above) must stay in memory during the whole parsing process.
-That is because the in memory object tree will store pointer to chunks of the string, so as to avoid any memory duplication. 
-
-Now, to check if the parsing was successful, you can call `JsonObject::success()`:
-
-    if (!root.success())
-    {
-        // Parsing fail
-    }
-
-The result can be `false` for tree reasons:
-
-1. the JSON string is invalid,
-2. the JSON string doesn't represent an object,
-3. the `StaticJsonBuffer` is too small.
-
-We just saw how to parse an object, there is nothing more to say for arrays, the procedure is exactly the same.
-
-## Step 3: Retrieve the values
-
-Now that the object or array is in memory, you can extract the data very easily.
-
-In this section, we'll see how to do it with a `JsonObject`.
-Once again, there is nothing more to say about arrays, `JsonArray` works exactly the same as `JsonObject`.
-
-#### Subscript operator
-
-The simplest way is to use the subscript operator of `JsonObject`:
-    
-    const char* sensor = root["sensor"];
-    long time = root["time"];
-
-You can chain the subscript operator if you have nested arrays or objects:
-
-    double latitude  = root["data"][0];
-    double longitude = root["data"][1];
-
-But alternatively, you can get a reference to the nested array:
-
-    JsonArray& nestedArray = root["data"];
-
-#### Casting values
-
-In the previous examples, the values were implicitly casted to the target type.
-You can also do this explicitly
-
-    const char* sensor = root["sensor"].asString();
-    long time = root["time"].as<long>();
-    JsonArray& nestedArray = root["data"].asArray();
-
-If the actual value doesn't match the target type, a default value will be return:
-
-1. `false` for boolean values
-2. `0` for integer values
-3. `NULL` for string values
-4. `JsonArray::invalid()` for nested arrays
-5. `JsonObject::invalid()` for nested object
-
-#### Check values
-
-If you want to know if some value is present, call `containsKey()`:
-
-    if (root.contains("extra"))
-    {
-        // root["extra"] is valid
-    }
-
-If you want to check the type value has a certain type, call `is<T>()`:
-
-    if (root["extra"].is<JsonArray&>())
-    {
-        // root["extra"] is an array
-    }
-
-You can also iterate through the key-value pairs of the object:
-
-    for (JsonObject::itertor it=root.begin(); it!=root.end(); ++it)
-    {
-      Serial.println(it->key);
-      Serial.println(i->value.asString());
-    }

doc/Encoding JSON.md

@@ -1,140 +0,0 @@
-Encoding JSON with Arduino JSON
-===============================
-
-Before writing any code, don't forget to include the header:
-
-    #include <ArduinoJson.h>
-
-For instructions on how to install the library, please read [Using the library with Arduino](Using the library with Arduino.md) or [Using the library without Arduino](Using the library without Arduino.md).
-
-## Example
-
-Here is an example to generate `{"sensor":"gps","time":1351824120,"data":[48.756080,2.302038]}`
-
-    //
-    // Step 1: Reserve memory space
-    //
-    StaticJsonBuffer<200> jsonBuffer;
-
-    //
-    // Step 2: Build object tree in memory
-    //
-    JsonObject& root = jsonBuffer.createObject();
-    root["sensor"] = "gps";
-    root["time"] = 1351824120;
-
-    JsonArray& data = root.createNestedArray("data");
-    data.add(48.756080, 6);  // 6 is the number of decimals to print
-    data.add(2.302038, 6);   // if not specified, 2 digits are printed
-
-    //
-    // Step 3: Generate the JSON string
-    //
-    root.printTo(Serial);
-
-## Step 1: Reserve memory space
-
-Arduino JSON uses a preallocated memory pool to store the object tree, this is done by the `StaticJsonBuffer`.
-
-Before continuing please read the page [Arduino JSON memory model](Memory model.md) that explains everything you need to know about `StaticJsonBuffer`.
-
-## Step 2: Build object tree in memory
-
-Now that you have enough memory hold by the `StaticJsonBuffer`, you can use it to build your in-memory representation of the JSON string.
-
-#### Arrays
-
-You create an array like this:
-
-    JsonArray& array = jsonBuffer.createArray();
-
-Don't forget the `&` after `JsonArray`, it needs to be a reference to the array.
-
-Then you can add strings, integer, booleans, etc:
-
-    array.add("bazinga!");
-    array.add(42);
-    array.add(true);
-
-There are two syntaxes for floating point values:
-
-	array.add(3.1415, 4);  // 4 digits: "3.1415"
-    array.add(3.1415);	   // 2 digits: "3.14"
-
-> ##### About floating point precision
-> The overload of `add()` with 2 parameters allows you to specify the number of decimals to save in the JSON string.
-> When you use the overload with one parameter, you use the default number of decimals which is 2.
-> Note that this behavior is the exact same as Arduino's `Print::print(double,int);` which is implemented by `Serial`, so you may already be familiar with this behavior.
-
-You can add a nested array or object if you have a reference to it.
-Or simpler, you can create nested array or nested objects from the array:
-
-    JsonArray&  nestedArray  = array.createNestedArray();
-    JsonObject& nestedObject = array.createNestedObject();
-
-#### Objects
-
-You create an object like this:
-
-    JsonObject& object = jsonBuffer.createObject();
-
-Again, don't forget the `&` after `JsonObject`, it needs to be a reference to the object.
-
-Then you can add strings, integer, booleans, etc:
-
-    object["key1"] = "bazinga!";
-    object["key2"] = 42;
-    object["key3"] = true;
-
-As for the arrays, there are two syntaxes for the floating point values:
-
-	object["key4"].set(3.1415, 4);  // 4 digits "3.1415"
-    object["key5"] = 3.1415;	    // default: 2 digits "3.14"
-
-You can add a nested array or object if you have a reference to it.
-Or simpler, you can create nested array or nested objects from the object:
-
-    JsonArray&  nestedArray  = object.createNestedArray("key6");
-    JsonObject& nestedObject = object.createNestedObject("key7");
-
-> ##### Other JsonObject functions
-> * `object.add(key, value)` is a synonym for `object[key] = value`
-> * `object.containsKey(key)` returns `true` is the `key` is present in `object`
-> * `object.remove(key)` removes the `value` associated with `key`
-
-## Step 3: Generate the JSON string
-
-There are two ways tho get the resulting JSON string.
-
-Depending on your project, you may need to dump the string in a classic `char[]` or send it to a `Print` implementation like `Serial` or `EthernetClient `.
-
-Both ways are the easy way :-)
-
-#### Use a classic `char[]`
-
-Whether you have a `JsonArray&` or a `JsonObject&`, simply call `printTo()` with the destination buffer, like so:
-
-	char buffer[256];
-    array.printTo(buffer, sizeof(buffer));
-
-> ##### Want an indented output?
-> By default the generated JSON is as small as possible. It contains no extra space, nor line break.
-> But if you want an indented, more readable output, you can.
-> Simply call `prettyPrintTo` instead of `printTo()`:
-> 
->     array.prettyPrintTo(buffer, sizeof(buffer));
-
-#### Send to a `Print` implementation
-
-It's very likely that the generated JSON will end up in a stream like `Serial` or `EthernetClient `, so you can save some time and memory by doing this:
-
-    array.printTo(Serial);
-
-And, of course if you need an indented JSON string:
-
-    array.prettyPrintTo(Serial);
-
-> ##### About the Print interface
-> The library is designed to send the JSON string to an implementation of the `Print` interface that is part of Arduino.
-> In the example above we used `Serial`, but they are many other implementations that would work as well, including: `HardwareSerial`,  `SoftwareSerial`, `LiquidCrystal`, `EthernetClient`, `WiFiClient`, `Wire`...
-> When you use this library out of the Arduino environment, it will use it's own implementation of `Print` and everything will be the same.

doc/Memory model.md

@@ -1,58 +0,0 @@
-Arduino JSON memory model
-=========================
-
-## Fixed memory allocation
-
-### Introducing `StaticJsonBuffer`
-
-Arduino JSON uses a preallocated memory pool to store the object tree, this is done by the `StaticJsonBuffer` class.
-
-Before using any function of the library you need to create a `StaticJsonBuffer`. Then you can use this instance to create arrays and objects, or parse a JSON string.
-
-`StaticJsonBuffer` has a template parameter that determines its capacity. For example, the following line create a `StaticJsonBuffer` with a capacity of 200 bytes:
-
-    StaticJsonBuffer<200> jsonBuffer;
-
-The bigger the buffer is, the more complex the object tree can be, but also the more memory you need.
-
-### How to determine the buffer size?
-
-So the big question you should have in mind right now is *How can I determine the size?*.
-
-There are basically two approaches here:
-
-1. either you can predict the content of the object tree,
-2. or, you know how much memory is available.
-
-In the first case, you know some constraints on the object tree. For instance, let's say that your know in advance (and by that I mean "at compilation time") that you want to generate an object with 3 values, one of them being an array with 2 values, like the following:
-
-    {"sensor":"gps","time":1351824120,"data":[48.756080,2.302038]}
-
-To determine the memory usage of this object tree, you use the two macros `JSON_ARRAY_SIZE(n)` and `JSON_OBJECT_SIZE(n)`, both take the number of elements as an argument.
-For the example above, it would be:
-
-    const int BUFFER_SIZE = JSON_OBJECT_SIZE(3) + JSON_ARRAY_SIZE(2);
-    StaticJsonBuffer<BUFFER_SIZE> jsonBuffer;
-
-In the second case, let's say you dynamically generate a JSON object tree of a random complexity so you can't put a limit based on that. But on the other hand, you don't want your program to crash because the object tree doesn't fit in memory.
-The solution here is to determine how much memory is available, or in other words how much memory you can afford for the JSON object tree.
-
-### Why choosing fixed allocation?
-
-This fixed allocation approach may seem a bit strange, especially if your a desktop application developer used to dynamic allocation, but it make a lot of sense in an embedded context:
-
-1. the code is smaller
-2. it uses less memory
-3. it doesn't create memory fragmentation
-4. it predictable
-
-Don't forget that the memory is "freed" as soon as the `StaticJsonBuffer` is out of scope, like any other variable. It only hold the memory for a short amount of time.
-
-## Memory usage
-
-#### Object size for 8-bit AVR
-
-| Type                    | Size       |
-|-------------------------|------------|
-| JsonArray of N element  | 4 + 8 * N  |
-| JsonObject of N element | 4 + 10 * N |

doc/Migrating code to new API.md

@@ -1,80 +0,0 @@
-Migrating code written for Arduino JSON v3 to v4
-================================================
-
-Arduino JSON v4 was a major rewrite of the library, and the API changed significantly.
-
-## Includes
-
-Arduino JSON v3 had two include files:
-
-    #include <JsonParser.h>
-    #include <JsonGenerator.h>
-
-Arduino JSON v4 only has one:
-
-	#include <ArduinoJson.h>
-
-## Namespaces
-
-Arduino JSON v3 had two namespaces:
-
-	using namespace ArduinoJson::Parser;
-	using namespace ArduinoJson::Generator;
-
-Arduino JSON v4 doesn't require the `using namespace` statement.
-It has a namespace but the `using namespace` is done in the header file.
-
-## StaticJsonBuffer
-
-Arduino JSON v3 had different memory allocation models for the parser:
-
-	JsonParser<16> parser; // 16 being the capacity in "tokens"
-
-and for the generator:
-
-	JsonArray<4> array; // 4 being the number of element
-	JsonObject<4> object;
-
-Arduino JSON v4 only has one memory allocation model:
-
-	StaticJsonBuffer<128> buffer; // 128 being the capacity in bytes
-
-## Return values for the parser
-
-Arduino JSON v3 returned value types:
-
-	JsonArray array = parser.parseArray(json);
-	JsonObject object = parser.parseObject(json);
-
-Arduino JSON v4 returns references types:
-
-	JsonArray& array = buffer.parseArray(json);
-	JsonObject& object = buffer.parseObject(json);
-
-Everything else is compatible
-
-## Creating arrays and objects
-
-Arduino JSON v3 allowed to create `JsonArray` and `JsonObject` directly:
-
-	JsonArray<4> array;
-	JsonObject<4> object;
-
-Arduino JSON v4 requires that you use a `StaticJsonBuffer` for that:
-
-	JsonArray& array = buffer.createArray();
-	JsonObject& object = buffer.createObject();
-
-Note: you don't have to specify the capacity anymore.
-
-## Printable interface
-
-Arduino JSON v3 used to implement the Printable interface, which allowed statements like:
-
-    Serial.print(array);
-
-But Arduino JSON v4 doesn't, instead you need to write this:
-
-	array.printTo(Serial);
-
-Note: there was a good reason for removing that feature, and it's reducing the size of `JsonArray` and `JsonObject`.

doc/Using the library with Arduino.md

@@ -1,30 +0,0 @@
-Using the library with Arduino
-==============================
-
-This library is primarily design to be used with the Arduino IDE and therefore has a simplified setup procedure for that environment.
-If you don't use the Arduino IDE, please read [Using the library without Arduino](Using the library without Arduino.md).
-
-## Install the library
-
-[Download the zip package](https://github.com/bblanchon/ArduinoJson/releases) and extract it to:
-
-    <your Arduino Sketch folder>/libraries/ArduinoJson
-
-Then restart the Arduino IDE.
-
-## Run the examples sketches
-
-Click `File` / `Example` / `ArduinoJson`.
-
-![Screen capture of Arduino IDE](http://i.imgur.com/g5UwkVh.png)
-
-## Use the library in your sketches
-
-Just add the following line at the top of your program:
-
-    #include <ArduinoJson.h>
-
-Then follow the instructions:
-
-1. [Parsing JSON](Parsin JSON.md)
-2. [Generating JSON](Generating JSON.md)

doc/Using the library without Arduino.md

@@ -1,37 +0,0 @@
-Using the library without Arduino
-=================================
-
-This library is primarily design to be used with the Arduino IDE and therefore has a simplified setup procedure for that environment.
-If you use the Arduino IDE, please read [Using the library with Arduino](Using the library with Arduino.md).
-
-However, it can be used without Arduino IDE with very little effort.
-
-## Compiling the library
-
-Step 1: Download source code:
-
-    git clone https://github.com/bblanchon/ArduinoJson.git
-
-Step 2: Generate the `Makefile` for your environment
-
-    cd ArduinoJson
-    cmake .
-
-Step 3: Build
-
-	make
-
-## File paths
-
-Assuming you installed the library into `<arduino-json>`, you need to add:
-
-1. `<arduino-json>/include` to your include path
-2. `<arduino-json>/lib` to your library path
-
-
-----------
-
-You are now ready to follow the instructions:
-
-1. [Parsing JSON](Parsin JSON.md)
-2. [Generating JSON](Generating JSON.md)

examples/IndentedPrintExample/IndentedPrintExample.ino

@@ -1,30 +0,0 @@
-/*
- * Arduino JSON library - IndentedPrint example
- * Benoit Blanchon 2014 - MIT License
- */
-
-#include <ArduinoJson.h>
-
-using namespace ArduinoJson::Internals;
-
-void setup() {
-  Serial.begin(9600);
-
-  IndentedPrint serial(Serial);
-  serial.setTabSize(4);
-
-  serial.println("This is at indentation 0");
-  serial.indent();
-  serial.println("This is at indentation 1");
-  serial.println("This is also at indentation 1");
-  serial.indent();
-  serial.println("This is at indentation 2");
-
-  serial.unindent();
-  serial.unindent();
-  serial.println("This is back at indentation 0");
-}
-
-void loop() {
-  // not used in this example
-}

examples/JsonConfigFile/JsonConfigFile.ino

@@ -0,0 +1,160 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright Benoit Blanchon 2014-2021
+// MIT License
+//
+// This example shows how to store your project configuration in a file.
+// It uses the SD library but can be easily modified for any other file-system.
+//
+// The file contains a JSON document with the following content:
+// {
+//   "hostname": "examples.com",
+//   "port": 2731
+// }
+//
+// To run this program, you need an SD card connected to the SPI bus as follows:
+// * MOSI <-> pin 11
+// * MISO <-> pin 12
+// * CLK  <-> pin 13
+// * CS   <-> pin 4
+//
+// https://arduinojson.org/v6/example/config/
+
+#include <ArduinoJson.h>
+#include <SD.h>
+#include <SPI.h>
+
+// Our configuration structure.
+//
+// Never use a JsonDocument to store the configuration!
+// A JsonDocument is *not* a permanent storage; it's only a temporary storage
+// used during the serialization phase. See:
+// https://arduinojson.org/v6/faq/why-must-i-create-a-separate-config-object/
+struct Config {
+  char hostname[64];
+  int port;
+};
+
+const char *filename = "/config.txt";  // <- SD library uses 8.3 filenames
+Config config;                         // <- global configuration object
+
+// Loads the configuration from a file
+void loadConfiguration(const char *filename, Config &config) {
+  // Open file for reading
+  File file = SD.open(filename);
+
+  // Allocate a temporary JsonDocument
+  // Don't forget to change the capacity to match your requirements.
+  // Use https://arduinojson.org/v6/assistant to compute the capacity.
+  StaticJsonDocument<512> doc;
+
+  // Deserialize the JSON document
+  DeserializationError error = deserializeJson(doc, file);
+  if (error)
+    Serial.println(F("Failed to read file, using default configuration"));
+
+  // Copy values from the JsonDocument to the Config
+  config.port = doc["port"] | 2731;
+  strlcpy(config.hostname,                  // <- destination
+          doc["hostname"] | "example.com",  // <- source
+          sizeof(config.hostname));         // <- destination's capacity
+
+  // Close the file (Curiously, File's destructor doesn't close the file)
+  file.close();
+}
+
+// Saves the configuration to a file
+void saveConfiguration(const char *filename, const Config &config) {
+  // Delete existing file, otherwise the configuration is appended to the file
+  SD.remove(filename);
+
+  // Open file for writing
+  File file = SD.open(filename, FILE_WRITE);
+  if (!file) {
+    Serial.println(F("Failed to create file"));
+    return;
+  }
+
+  // Allocate a temporary JsonDocument
+  // Don't forget to change the capacity to match your requirements.
+  // Use https://arduinojson.org/assistant to compute the capacity.
+  StaticJsonDocument<256> doc;
+
+  // Set the values in the document
+  doc["hostname"] = config.hostname;
+  doc["port"] = config.port;
+
+  // Serialize JSON to file
+  if (serializeJson(doc, file) == 0) {
+    Serial.println(F("Failed to write to file"));
+  }
+
+  // Close the file
+  file.close();
+}
+
+// Prints the content of a file to the Serial
+void printFile(const char *filename) {
+  // Open file for reading
+  File file = SD.open(filename);
+  if (!file) {
+    Serial.println(F("Failed to read file"));
+    return;
+  }
+
+  // Extract each characters by one by one
+  while (file.available()) {
+    Serial.print((char)file.read());
+  }
+  Serial.println();
+
+  // Close the file
+  file.close();
+}
+
+void setup() {
+  // Initialize serial port
+  Serial.begin(9600);
+  while (!Serial) continue;
+
+  // Initialize SD library
+  const int chipSelect = 4;
+  while (!SD.begin(chipSelect)) {
+    Serial.println(F("Failed to initialize SD library"));
+    delay(1000);
+  }
+
+  // Should load default config if run for the first time
+  Serial.println(F("Loading configuration..."));
+  loadConfiguration(filename, config);
+
+  // Create configuration file
+  Serial.println(F("Saving configuration..."));
+  saveConfiguration(filename, config);
+
+  // Dump config file
+  Serial.println(F("Print config file..."));
+  printFile(filename);
+}
+
+void loop() {
+  // not used in this example
+}
+
+// Performance issue?
+// ------------------
+//
+// File is an unbuffered stream, which is not optimal for ArduinoJson.
+// See: https://arduinojson.org/v6/how-to/improve-speed/
+
+// See also
+// --------
+//
+// https://arduinojson.org/ contains the documentation for all the functions
+// used above. It also includes an FAQ that will help you solve any
+// serialization or deserialization problem.
+//
+// The book "Mastering ArduinoJson" contains a case study of a project that has
+// a complex configuration with nested members.
+// Contrary to this example, the project in the book uses the SPIFFS filesystem.
+// Learn more at https://arduinojson.org/book/
+// Use the coupon code TWENTY for a 20% discount ❤❤❤❤❤

examples/JsonFilterExample/JsonFilterExample.ino

@@ -0,0 +1,63 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright Benoit Blanchon 2014-2021
+// MIT License
+//
+// This example shows how to use DeserializationOpion::Filter
+//
+// https://arduinojson.org/v6/example/filter/
+
+#include <ArduinoJson.h>
+
+void setup() {
+  // Initialize serial port
+  Serial.begin(9600);
+  while (!Serial) continue;
+
+  // The huge input: an extract from OpenWeatherMap response
+  const __FlashStringHelper* input_json = F(
+      "{\"cod\":\"200\",\"message\":0,\"list\":[{\"dt\":1581498000,\"main\":{"
+      "\"temp\":3.23,\"feels_like\":-3.63,\"temp_min\":3.23,\"temp_max\":4.62,"
+      "\"pressure\":1014,\"sea_level\":1014,\"grnd_level\":1010,\"humidity\":"
+      "58,\"temp_kf\":-1.39},\"weather\":[{\"id\":800,\"main\":\"Clear\","
+      "\"description\":\"clear "
+      "sky\",\"icon\":\"01d\"}],\"clouds\":{\"all\":0},\"wind\":{\"speed\":6."
+      "19,\"deg\":266},\"sys\":{\"pod\":\"d\"},\"dt_txt\":\"2020-02-12 "
+      "09:00:00\"},{\"dt\":1581508800,\"main\":{\"temp\":6.09,\"feels_like\":-"
+      "1.07,\"temp_min\":6.09,\"temp_max\":7.13,\"pressure\":1015,\"sea_"
+      "level\":1015,\"grnd_level\":1011,\"humidity\":48,\"temp_kf\":-1.04},"
+      "\"weather\":[{\"id\":800,\"main\":\"Clear\",\"description\":\"clear "
+      "sky\",\"icon\":\"01d\"}],\"clouds\":{\"all\":9},\"wind\":{\"speed\":6."
+      "64,\"deg\":268},\"sys\":{\"pod\":\"d\"},\"dt_txt\":\"2020-02-12 "
+      "12:00:00\"}],\"city\":{\"id\":2643743,\"name\":\"London\",\"coord\":{"
+      "\"lat\":51.5085,\"lon\":-0.1257},\"country\":\"GB\",\"population\":"
+      "1000000,\"timezone\":0,\"sunrise\":1581492085,\"sunset\":1581527294}}");
+
+  // The filter: it contains "true" for each value we want to keep
+  StaticJsonDocument<200> filter;
+  filter["list"][0]["dt"] = true;
+  filter["list"][0]["main"]["temp"] = true;
+
+  // Deserialize the document
+  StaticJsonDocument<400> doc;
+  deserializeJson(doc, input_json, DeserializationOption::Filter(filter));
+
+  // Print the result
+  serializeJsonPretty(doc, Serial);
+}
+
+void loop() {
+  // not used in this example
+}
+
+// See also
+// --------
+//
+// https://arduinojson.org/ contains the documentation for all the functions
+// used above. It also includes an FAQ that will help you solve any
+// deserialization problem.
+//
+// The book "Mastering ArduinoJson" contains a tutorial on deserialization.
+// It begins with a simple example, like the one above, and then adds more
+// features like deserializing directly from a file or an HTTP request.
+// Learn more at https://arduinojson.org/book/
+// Use the coupon code TWENTY for a 20% discount ❤❤❤❤❤

examples/JsonGeneratorExample/JsonGeneratorExample.ino

@@ -1,32 +1,54 @@
-// Copyright Benoit Blanchon 2014
+// ArduinoJson - https://arduinojson.org
+// Copyright Benoit Blanchon 2014-2021
 // MIT License
 //
-// Arduino JSON library
-// https://github.com/bblanchon/ArduinoJson
+// This example shows how to generate a JSON document with ArduinoJson.
+//
+// https://arduinojson.org/v6/example/generator/
 
 #include <ArduinoJson.h>
 
 void setup() {
+  // Initialize Serial port
   Serial.begin(9600);
+  while (!Serial) continue;
 
-  StaticJsonBuffer<200> jsonBuffer;
+  // Allocate the JSON document
+  //
+  // Inside the brackets, 200 is the RAM allocated to this document.
+  // Don't forget to change this value to match your requirement.
+  // Use https://arduinojson.org/v6/assistant to compute the capacity.
+  StaticJsonDocument<200> doc;
 
-  JsonObject& root = jsonBuffer.createObject();
-  root["sensor"] = "gps";
-  root["time"] = 1351824120;
+  // StaticJsonObject allocates memory on the stack, it can be
+  // replaced by DynamicJsonDocument which allocates in the heap.
+  //
+  // DynamicJsonDocument  doc(200);
 
-  JsonArray& data = root.createNestedArray("data");
-  data.add(48.756080, 6);  // 6 is the number of decimals to print
-  data.add(2.302038, 6);   // if not specified, 2 digits are printed
+  // Add values in the document
+  //
+  doc["sensor"] = "gps";
+  doc["time"] = 1351824120;
 
-  root.printTo(Serial);
-  // This prints:
+  // Add an array.
+  //
+  JsonArray data = doc.createNestedArray("data");
+  data.add(48.756080);
+  data.add(2.302038);
+
+  // Generate the minified JSON and send it to the Serial port.
+  //
+  serializeJson(doc, Serial);
+  // The above line prints:
   // {"sensor":"gps","time":1351824120,"data":[48.756080,2.302038]}
 
+  // Start a new line
   Serial.println();
 
-  root.prettyPrintTo(Serial);
-  // This prints:
+  // Generate the prettified JSON and send it to the Serial port.
+  //
+  serializeJsonPretty(doc, Serial);
+  // The above line prints:
   // {
   //   "sensor": "gps",
   //   "time": 1351824120,
@@ -39,4 +61,17 @@ void setup() {
 
 void loop() {
   // not used in this example
-}
+}
+
+// See also
+// --------
+//
+// https://arduinojson.org/ contains the documentation for all the functions
+// used above. It also includes an FAQ that will help you solve any
+// serialization problem.
+//
+// The book "Mastering ArduinoJson" contains a tutorial on serialization.
+// It begins with a simple example, like the one above, and then adds more
+// features like serializing directly to a file or an HTTP request.
+// Learn more at https://arduinojson.org/book/
+// Use the coupon code TWENTY for a 20% discount ❤❤❤❤❤

examples/JsonHttpClient/JsonHttpClient.ino

@@ -0,0 +1,126 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright Benoit Blanchon 2014-2021
+// MIT License
+//
+// This example shows how to parse a JSON document in an HTTP response.
+// It uses the Ethernet library, but can be easily adapted for Wifi.
+//
+// It performs a GET resquest on https://arduinojson.org/example.json
+// Here is the expected response:
+// {
+//   "sensor": "gps",
+//   "time": 1351824120,
+//   "data": [
+//     48.756080,
+//     2.302038
+//   ]
+// }
+//
+// https://arduinojson.org/v6/example/http-client/
+
+#include <ArduinoJson.h>
+#include <Ethernet.h>
+#include <SPI.h>
+
+void setup() {
+  // Initialize Serial port
+  Serial.begin(9600);
+  while (!Serial) continue;
+
+  // Initialize Ethernet library
+  byte mac[] = {0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED};
+  if (!Ethernet.begin(mac)) {
+    Serial.println(F("Failed to configure Ethernet"));
+    return;
+  }
+  delay(1000);
+
+  Serial.println(F("Connecting..."));
+
+  // Connect to HTTP server
+  EthernetClient client;
+  client.setTimeout(10000);
+  if (!client.connect("arduinojson.org", 80)) {
+    Serial.println(F("Connection failed"));
+    return;
+  }
+
+  Serial.println(F("Connected!"));
+
+  // Send HTTP request
+  client.println(F("GET /example.json HTTP/1.0"));
+  client.println(F("Host: arduinojson.org"));
+  client.println(F("Connection: close"));
+  if (client.println() == 0) {
+    Serial.println(F("Failed to send request"));
+    client.stop();
+    return;
+  }
+
+  // Check HTTP status
+  char status[32] = {0};
+  client.readBytesUntil('\r', status, sizeof(status));
+  // It should be "HTTP/1.0 200 OK" or "HTTP/1.1 200 OK"
+  if (strcmp(status + 9, "200 OK") != 0) {
+    Serial.print(F("Unexpected response: "));
+    Serial.println(status);
+    client.stop();
+    return;
+  }
+
+  // Skip HTTP headers
+  char endOfHeaders[] = "\r\n\r\n";
+  if (!client.find(endOfHeaders)) {
+    Serial.println(F("Invalid response"));
+    client.stop();
+    return;
+  }
+
+  // Allocate the JSON document
+  // Use https://arduinojson.org/v6/assistant to compute the capacity.
+  const size_t capacity = JSON_OBJECT_SIZE(3) + JSON_ARRAY_SIZE(2) + 60;
+  DynamicJsonDocument doc(capacity);
+
+  // Parse JSON object
+  DeserializationError error = deserializeJson(doc, client);
+  if (error) {
+    Serial.print(F("deserializeJson() failed: "));
+    Serial.println(error.f_str());
+    client.stop();
+    return;
+  }
+
+  // Extract values
+  Serial.println(F("Response:"));
+  Serial.println(doc["sensor"].as<const char*>());
+  Serial.println(doc["time"].as<long>());
+  Serial.println(doc["data"][0].as<float>(), 6);
+  Serial.println(doc["data"][1].as<float>(), 6);
+
+  // Disconnect
+  client.stop();
+}
+
+void loop() {
+  // not used in this example
+}
+
+// Performance issue?
+// ------------------
+//
+// EthernetClient is an unbuffered stream, which is not optimal for ArduinoJson.
+// See: https://arduinojson.org/v6/how-to/improve-speed/
+
+// See also
+// --------
+//
+// https://arduinojson.org/ contains the documentation for all the functions
+// used above. It also includes an FAQ that will help you solve any
+// serialization  problem.
+//
+// The book "Mastering ArduinoJson" contains a tutorial on deserialization
+// showing how to parse the response from GitHub's API. In the last chapter,
+// it shows how to parse the huge documents from OpenWeatherMap
+// and Reddit.
+// Learn more at https://arduinojson.org/book/
+// Use the coupon code TWENTY for a 20% discount ❤❤❤❤❤

examples/JsonParserExample/JsonParserExample.ino

@@ -1,31 +1,61 @@
-// Copyright Benoit Blanchon 2014
+// ArduinoJson - https://arduinojson.org
+// Copyright Benoit Blanchon 2014-2021
 // MIT License
 //
-// Arduino JSON library
-// https://github.com/bblanchon/ArduinoJson
+// This example shows how to deserialize a JSON document with ArduinoJson.
+//
+// https://arduinojson.org/v6/example/parser/
 
 #include <ArduinoJson.h>
 
 void setup() {
+  // Initialize serial port
   Serial.begin(9600);
+  while (!Serial) continue;
 
-  StaticJsonBuffer<200> jsonBuffer;
+  // Allocate the JSON document
+  //
+  // Inside the brackets, 200 is the capacity of the memory pool in bytes.
+  // Don't forget to change this value to match your JSON document.
+  // Use https://arduinojson.org/v6/assistant to compute the capacity.
+  StaticJsonDocument<200> doc;
 
+  // StaticJsonDocument<N> allocates memory on the stack, it can be
+  // replaced by DynamicJsonDocument which allocates in the heap.
+  //
+  // DynamicJsonDocument doc(200);
+
+  // JSON input string.
+  //
+  // Using a char[], as shown here, enables the "zero-copy" mode. This mode uses
+  // the minimal amount of memory because the JsonDocument stores pointers to
+  // the input buffer.
+  // If you use another type of input, ArduinoJson must copy the strings from
+  // the input to the JsonDocument, so you need to increase the capacity of the
+  // JsonDocument.
   char json[] =
       "{\"sensor\":\"gps\",\"time\":1351824120,\"data\":[48.756080,2.302038]}";
 
-  JsonObject& root = jsonBuffer.parseObject(json);
+  // Deserialize the JSON document
+  DeserializationError error = deserializeJson(doc, json);
 
-  if (!root.success()) {
-    Serial.println("parseObject() failed");
+  // Test if parsing succeeds.
+  if (error) {
+    Serial.print(F("deserializeJson() failed: "));
+    Serial.println(error.f_str());
     return;
   }
 
-  const char* sensor = root["sensor"];
-  long time = root["time"];
-  double latitude = root["data"][0];
-  double longitude = root["data"][1];
+  // Fetch values.
+  //
+  // Most of the time, you can rely on the implicit casts.
+  // In other case, you can do doc["time"].as<long>();
+  const char* sensor = doc["sensor"];
+  long time = doc["time"];
+  double latitude = doc["data"][0];
+  double longitude = doc["data"][1];
 
+  // Print values.
   Serial.println(sensor);
   Serial.println(time);
   Serial.println(latitude, 6);
@@ -34,4 +64,17 @@ void setup() {
 
 void loop() {
   // not used in this example
-}
+}
+
+// See also
+// --------
+//
+// https://arduinojson.org/ contains the documentation for all the functions
+// used above. It also includes an FAQ that will help you solve any
+// deserialization problem.
+//
+// The book "Mastering ArduinoJson" contains a tutorial on deserialization.
+// It begins with a simple example, like the one above, and then adds more
+// features like deserializing directly from a file or an HTTP request.
+// Learn more at https://arduinojson.org/book/
+// Use the coupon code TWENTY for a 20% discount ❤❤❤❤❤

examples/JsonServer/JsonServer.ino

@@ -0,0 +1,117 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright Benoit Blanchon 2014-2021
+// MIT License
+//
+// This example shows how to implement an HTTP server that sends a JSON document
+// in the response.
+// It uses the Ethernet library but can be easily adapted for Wifi.
+//
+// The JSON document contains the values of the analog and digital pins.
+// It looks like that:
+// {
+//   "analog": [0, 76, 123, 158, 192, 205],
+//   "digital": [1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0]
+// }
+//
+// https://arduinojson.org/v6/example/http-server/
+
+#include <ArduinoJson.h>
+#include <Ethernet.h>
+#include <SPI.h>
+
+byte mac[] = {0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED};
+EthernetServer server(80);
+
+void setup() {
+  // Initialize serial port
+  Serial.begin(9600);
+  while (!Serial) continue;
+
+  // Initialize Ethernet libary
+  if (!Ethernet.begin(mac)) {
+    Serial.println(F("Failed to initialize Ethernet library"));
+    return;
+  }
+
+  // Start to listen
+  server.begin();
+
+  Serial.println(F("Server is ready."));
+  Serial.print(F("Please connect to http://"));
+  Serial.println(Ethernet.localIP());
+}
+
+void loop() {
+  // Wait for an incomming connection
+  EthernetClient client = server.available();
+
+  // Do we have a client?
+  if (!client)
+    return;
+
+  Serial.println(F("New client"));
+
+  // Read the request (we ignore the content in this example)
+  while (client.available()) client.read();
+
+  // Allocate a temporary JsonDocument
+  // Use https://arduinojson.org/v6/assistant to compute the capacity.
+  StaticJsonDocument<500> doc;
+
+  // Create the "analog" array
+  JsonArray analogValues = doc.createNestedArray("analog");
+  for (int pin = 0; pin < 6; pin++) {
+    // Read the analog input
+    int value = analogRead(pin);
+
+    // Add the value at the end of the array
+    analogValues.add(value);
+  }
+
+  // Create the "digital" array
+  JsonArray digitalValues = doc.createNestedArray("digital");
+  for (int pin = 0; pin < 14; pin++) {
+    // Read the digital input
+    int value = digitalRead(pin);
+
+    // Add the value at the end of the array
+    digitalValues.add(value);
+  }
+
+  Serial.print(F("Sending: "));
+  serializeJson(doc, Serial);
+  Serial.println();
+
+  // Write response headers
+  client.println(F("HTTP/1.0 200 OK"));
+  client.println(F("Content-Type: application/json"));
+  client.println(F("Connection: close"));
+  client.print(F("Content-Length: "));
+  client.println(measureJsonPretty(doc));
+  client.println();
+
+  // Write JSON document
+  serializeJsonPretty(doc, client);
+
+  // Disconnect
+  client.stop();
+}
+
+// Performance issue?
+// ------------------
+//
+// EthernetClient is an unbuffered stream, which is not optimal for ArduinoJson.
+// See: https://arduinojson.org/v6/how-to/improve-speed/
+
+// See also
+// --------
+//
+// https://arduinojson.org/ contains the documentation for all the functions
+// used above. It also includes an FAQ that will help you solve any
+// serialization problem.
+//
+// The book "Mastering ArduinoJson" contains a tutorial on serialization.
+// It begins with a simple example, then adds more features like serializing
+// directly to a file or an HTTP client.
+// Learn more at https://arduinojson.org/book/
+// Use the coupon code TWENTY for a 20% discount ❤❤❤❤❤

examples/JsonUdpBeacon/JsonUdpBeacon.ino

@@ -0,0 +1,106 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright Benoit Blanchon 2014-2021
+// MIT License
+//
+// This example shows how to send a JSON document to a UDP socket.
+// At regular interval, it sends a UDP packet that contains the status of
+// analog and digital pins.
+// It looks like that:
+// {
+//   "analog": [0, 76, 123, 158, 192, 205],
+//   "digital": [1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0]
+// }
+//
+// If you want to test this program, you need to be able to receive the UDP
+// packets.
+// For example, you can run netcat on your computer
+// $ ncat -ulp 8888
+// See https://nmap.org/ncat/
+//
+// https://arduinojson.org/v6/example/udp-beacon/
+
+#include <ArduinoJson.h>
+#include <Ethernet.h>
+#include <SPI.h>
+
+byte mac[] = {0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED};
+IPAddress remoteIp(192, 168, 0, 108);  // <- EDIT!!!!
+unsigned short remotePort = 8888;
+unsigned short localPort = 8888;
+EthernetUDP udp;
+
+void setup() {
+  // Initialize serial port
+  Serial.begin(9600);
+  while (!Serial) continue;
+
+  // Initialize Ethernet libary
+  if (!Ethernet.begin(mac)) {
+    Serial.println(F("Failed to initialize Ethernet library"));
+    return;
+  }
+
+  // Enable UDP
+  udp.begin(localPort);
+}
+
+void loop() {
+  // Allocate a temporary JsonDocument
+  // Use https://arduinojson.org/v6/assistant to compute the capacity.
+  StaticJsonDocument<500> doc;
+
+  // Create the "analog" array
+  JsonArray analogValues = doc.createNestedArray("analog");
+  for (int pin = 0; pin < 6; pin++) {
+    // Read the analog input
+    int value = analogRead(pin);
+
+    // Add the value at the end of the array
+    analogValues.add(value);
+  }
+
+  // Create the "digital" array
+  JsonArray digitalValues = doc.createNestedArray("digital");
+  for (int pin = 0; pin < 14; pin++) {
+    // Read the digital input
+    int value = digitalRead(pin);
+
+    // Add the value at the end of the array
+    digitalValues.add(value);
+  }
+
+  // Log
+  Serial.print(F("Sending to "));
+  Serial.print(remoteIp);
+  Serial.print(F(" on port "));
+  Serial.println(remotePort);
+  serializeJson(doc, Serial);
+
+  // Send UDP packet
+  udp.beginPacket(remoteIp, remotePort);
+  serializeJson(doc, udp);
+  udp.println();
+  udp.endPacket();
+
+  // Wait
+  delay(10000);
+}
+
+// Performance issue?
+// ------------------
+//
+// EthernetUDP is an unbuffered stream, which is not optimal for ArduinoJson.
+// See: https://arduinojson.org/v6/how-to/improve-speed/
+
+// See also
+// --------
+//
+// https://arduinojson.org/ contains the documentation for all the functions
+// used above. It also includes an FAQ that will help you solve any
+// serialization problem.
+//
+// The book "Mastering ArduinoJson" contains a tutorial on serialization.
+// It begins with a simple example, then adds more features like serializing
+// directly to a file or any stream.
+// Learn more at https://arduinojson.org/book/
+// Use the coupon code TWENTY for a 20% discount ❤❤❤❤❤

examples/MsgPackParser/MsgPackParser.ino

@@ -0,0 +1,75 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright Benoit Blanchon 2014-2021
+// MIT License
+//
+// This example shows how to deserialize a MessagePack document with
+// ArduinoJson.
+//
+// https://arduinojson.org/v6/example/msgpack-parser/
+
+#include <ArduinoJson.h>
+
+void setup() {
+  // Initialize serial port
+  Serial.begin(9600);
+  while (!Serial) continue;
+
+  // Allocate the JSON document
+  //
+  // Inside the brackets, 200 is the capacity of the memory pool in bytes.
+  // Don't forget to change this value to match your JSON document.
+  // Use https://arduinojson.org/v6/assistant to compute the capacity.
+  StaticJsonDocument<200> doc;
+
+  // StaticJsonObject allocates memory on the stack, it can be
+  // replaced by DynamicJsonObject which allocates in the heap.
+  //
+  // DynamicJsonObject doc(200);
+
+  // MessagePack input string.
+  //
+  // Using a char[], as shown here, enables the "zero-copy" mode. This mode uses
+  // the minimal amount of memory because the JsonDocument stores pointers to
+  // the input buffer.
+  // If you use another type of input, ArduinoJson must copy the strings from
+  // the input to the JsonDocument, so you need to increase the capacity of the
+  // JsonDocument.
+  uint8_t input[] = {131, 166, 115, 101, 110, 115, 111, 114, 163, 103, 112, 115,
+                     164, 116, 105, 109, 101, 206, 80,  147, 50,  248, 164, 100,
+                     97,  116, 97,  146, 203, 64,  72,  96,  199, 58,  188, 148,
+                     112, 203, 64,  2,   106, 146, 230, 33,  49,  169};
+  // This MessagePack document contains:
+  // {
+  //   "sensor": "gps",
+  //   "time": 1351824120,
+  //   "data": [48.75608, 2.302038]
+  // }
+
+  DeserializationError error = deserializeMsgPack(doc, input);
+
+  // Test if parsing succeeded.
+  if (error) {
+    Serial.print("deserializeMsgPack() failed: ");
+    Serial.println(error.f_str());
+    return;
+  }
+
+  // Fetch values.
+  //
+  // Most of the time, you can rely on the implicit casts.
+  // In other case, you can do doc["time"].as<long>();
+  const char* sensor = doc["sensor"];
+  long time = doc["time"];
+  double latitude = doc["data"][0];
+  double longitude = doc["data"][1];
+
+  // Print values.
+  Serial.println(sensor);
+  Serial.println(time);
+  Serial.println(latitude, 6);
+  Serial.println(longitude, 6);
+}
+
+void loop() {
+  // not used in this example
+}

examples/ProgmemExample/ProgmemExample.ino

@@ -0,0 +1,72 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright Benoit Blanchon 2014-2021
+// MIT License
+//
+// This example shows the different ways you can use Flash strings with
+// ArduinoJson.
+//
+// Use Flash strings sparingly, because ArduinoJson duplicates them in the
+// JsonDocument. Prefer plain old char*, as they are more efficient in term of
+// code size, speed, and memory usage.
+//
+// https://arduinojson.org/v6/example/progmem/
+
+#include <ArduinoJson.h>
+
+void setup() {
+#ifdef PROGMEM  // <- check that Flash strings are supported
+
+  DynamicJsonDocument doc(1024);
+
+  // You can use a Flash String as your JSON input.
+  // WARNING: the strings in the input will be duplicated in the JsonDocument.
+  deserializeJson(doc, F("{\"sensor\":\"gps\",\"time\":1351824120,"
+                         "\"data\":[48.756080,2.302038]}"));
+  JsonObject obj = doc.as<JsonObject>();
+
+  // You can use a Flash String to get an element of a JsonObject
+  // No duplication is done.
+  long time = obj[F("time")];
+
+  // You can use a Flash String to set an element of a JsonObject
+  // WARNING: the content of the Flash String will be duplicated in the
+  // JsonDocument.
+  obj[F("time")] = time;
+
+  // You can set a Flash String to a JsonObject or JsonArray:
+  // WARNING: the content of the Flash String will be duplicated in the
+  // JsonDocument.
+  obj["sensor"] = F("gps");
+
+  // It works with serialized() too:
+  obj["sensor"] = serialized(F("\"gps\""));
+  obj["sensor"] = serialized(F("\xA3gps"), 3);
+
+  // You can compare the content of a JsonVariant to a Flash String
+  if (obj["sensor"] == F("gps")) {
+    // ...
+  }
+
+#else
+
+#warning PROGMEM is not supported on this platform
+
+#endif
+}
+
+void loop() {
+  // not used in this example
+}
+
+// See also
+// --------
+//
+// https://arduinojson.org/ contains the documentation for all the functions
+// used above. It also includes an FAQ that will help you solve any memory
+// problem.
+//
+// The book "Mastering ArduinoJson" contains a quick C++ course that explains
+// how your microcontroller stores strings in memory. It also tells why you
+// should not abuse Flash strings with ArduinoJson.
+// Learn more at https://arduinojson.org/book/
+// Use the coupon code TWENTY for a 20% discount ❤❤❤❤❤

examples/StringExample/StringExample.ino

@@ -0,0 +1,77 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright Benoit Blanchon 2014-2021
+// MIT License
+//
+// This example shows the different ways you can use String with ArduinoJson.
+//
+// Use String objects sparingly, because ArduinoJson duplicates them in the
+// JsonDocument. Prefer plain old char[], as they are more efficient in term of
+// code size, speed, and memory usage.
+//
+// https://arduinojson.org/v6/example/string/
+
+#include <ArduinoJson.h>
+
+void setup() {
+  DynamicJsonDocument doc(1024);
+
+  // You can use a String as your JSON input.
+  // WARNING: the string in the input  will be duplicated in the JsonDocument.
+  String input =
+      "{\"sensor\":\"gps\",\"time\":1351824120,\"data\":[48.756080,2.302038]}";
+  deserializeJson(doc, input);
+  JsonObject obj = doc.as<JsonObject>();
+
+  // You can use a String to get an element of a JsonObject
+  // No duplication is done.
+  long time = obj[String("time")];
+
+  // You can use a String to set an element of a JsonObject
+  // WARNING: the content of the String will be duplicated in the JsonDocument.
+  obj[String("time")] = time;
+
+  // You can get a String from a JsonObject or JsonArray:
+  // No duplication is done, at least not in the JsonDocument.
+  String sensor = obj["sensor"];
+
+  // Unfortunately, the following doesn't work (issue #118):
+  // sensor = obj["sensor"]; // <-  error "ambiguous overload for 'operator='"
+  // As a workaround, you need to replace by:
+  sensor = obj["sensor"].as<String>();
+
+  // You can set a String to a JsonObject or JsonArray:
+  // WARNING: the content of the String will be duplicated in the JsonDocument.
+  obj["sensor"] = sensor;
+
+  // It works with serialized() too:
+  obj["sensor"] = serialized(sensor);
+
+  // You can also concatenate strings
+  // WARNING: the content of the String will be duplicated in the JsonDocument.
+  obj[String("sen") + "sor"] = String("gp") + "s";
+
+  // You can compare the content of a JsonObject with a String
+  if (obj["sensor"] == sensor) {
+    // ...
+  }
+
+  // Lastly, you can print the resulting JSON to a String
+  String output;
+  serializeJson(doc, output);
+}
+
+void loop() {
+  // not used in this example
+}
+
+// See also
+// --------
+//
+// https://arduinojson.org/ contains the documentation for all the functions
+// used above. It also includes an FAQ that will help you solve any problem.
+//
+// The book "Mastering ArduinoJson" contains a quick C++ course that explains
+// how your microcontroller stores strings in memory. On several occasions, it
+// shows how you can avoid String in your program.
+// Learn more at https://arduinojson.org/book/
+// Use the coupon code TWENTY for a 20% discount ❤❤❤❤❤

extras/ArduinoJsonConfig.cmake.in

@@ -0,0 +1,4 @@
+@PACKAGE_INIT@
+
+include("${CMAKE_CURRENT_LIST_DIR}/@PROJECT_NAME@Targets.cmake")
+check_required_components("@PROJECT_NAME@")

extras/CompileOptions.cmake

@@ -0,0 +1,94 @@
+if(CMAKE_CXX_COMPILER_ID MATCHES "(GNU|Clang)")
+	add_compile_options(
+		-pedantic
+		-Wall
+		-Wcast-align
+		-Wcast-qual
+		-Wconversion
+		-Wctor-dtor-privacy
+		-Wdisabled-optimization
+		-Werror
+		-Wextra
+		-Wformat=2
+		-Winit-self
+		-Wmissing-include-dirs
+		-Wnon-virtual-dtor
+		-Wold-style-cast
+		-Woverloaded-virtual
+		-Wparentheses
+		-Wredundant-decls
+		-Wshadow
+		-Wsign-promo
+		-Wstrict-aliasing
+		-Wundef
+	)
+
+	if(${COVERAGE})
+		set(CMAKE_CXX_FLAGS "-fprofile-arcs -ftest-coverage")
+	endif()
+
+endif()
+
+if(CMAKE_CXX_COMPILER_ID STREQUAL  "GNU")
+	if((CMAKE_CXX_COMPILER_VERSION VERSION_GREATER 4.8) AND (NOT ${COVERAGE}))
+		add_compile_options(-g -Og)
+	else()
+		add_compile_options(-g -O0)
+	endif()
+
+	add_compile_options(
+		-Wstrict-null-sentinel
+		-Wno-vla # Allow VLA in tests
+	)
+	add_definitions(-DHAS_VARIABLE_LENGTH_ARRAY)
+
+	if(CMAKE_CXX_COMPILER_VERSION VERSION_GREATER 4.5)
+		add_compile_options(-Wlogical-op) # the flag exists in 4.4 but is buggy
+	endif()
+
+	if(CMAKE_CXX_COMPILER_VERSION VERSION_GREATER 4.6)
+		add_compile_options(-Wnoexcept)
+	endif()
+endif()
+
+if(CMAKE_CXX_COMPILER_ID MATCHES "Clang")
+	add_compile_options(
+		-Wc++11-compat
+		-Wdeprecated-register
+		-Wno-vla-extension # Allow VLA in tests
+	)
+	add_definitions(
+		-DHAS_VARIABLE_LENGTH_ARRAY
+		-DSUBSCRIPT_CONFLICTS_WITH_BUILTIN_OPERATOR
+	)
+endif()
+
+if(CMAKE_CXX_COMPILER_ID STREQUAL "Clang")
+	if((CMAKE_CXX_COMPILER_VERSION VERSION_GREATER 4.0) AND (NOT ${COVERAGE}))
+		add_compile_options(-g -Og)
+	else()
+		add_compile_options(-g -O0)
+	endif()
+endif()
+
+if(CMAKE_CXX_COMPILER_ID STREQUAL "AppleClang")
+	if((CMAKE_CXX_COMPILER_VERSION VERSION_GREATER 9.0) AND (NOT ${COVERAGE}))
+		add_compile_options(-g -Og)
+	else()
+		add_compile_options(-g -O0)
+	endif()
+endif()
+
+if(MSVC)
+	add_definitions(-D_CRT_SECURE_NO_WARNINGS)
+	add_compile_options(
+		/W4 # Set warning level
+		/WX # Treats all compiler warnings as errors.
+	)
+
+	if (NOT MSVC_VERSION LESS  1910) #  >= Visual Studio 2017
+		add_compile_options(
+			/Zc:__cplusplus  # Enable updated __cplusplus macro
+		)
+	endif()
+endif()

extras/ci/arduino.sh

@@ -0,0 +1,20 @@
+#!/bin/bash -eux
+
+/sbin/start-stop-daemon --start --quiet --pidfile /tmp/custom_xvfb_1.pid --make-pidfile --background --exec /usr/bin/Xvfb -- :1 -ac -screen 0 1280x1024x16
+sleep 3
+export DISPLAY=:1.0
+
+mkdir -p /tmp/arduino
+curl -sS http://downloads.arduino.cc/arduino-$VERSION-linux64.tar.xz | tar xJ -C /tmp/arduino --strip 1 ||
+curl -sS http://downloads.arduino.cc/arduino-$VERSION-linux64.tgz | tar xz -C /tmp/arduino --strip 1
+export PATH=$PATH:/tmp/arduino/
+
+if [[ "$BOARD" =~ "arduino:samd:" ]]; then
+  arduino --install-boards arduino:samd
+fi
+
+ln -s $PWD /tmp/arduino/libraries/ArduinoJson
+
+for EXAMPLE in $PWD/examples/*/*.ino; do
+	arduino --verify --board $BOARD $EXAMPLE
+done

extras/ci/espidf/CMakeLists.txt

@@ -0,0 +1,8 @@
+# ArduinoJson - https://arduinojson.org
+# Copyright Benoit Blanchon 2014-2021
+# MIT License
+
+cmake_minimum_required(VERSION 3.5)
+
+include($ENV{IDF_PATH}/tools/cmake/project.cmake)
+project(example)

extras/ci/espidf/main/CMakeLists.txt

@@ -0,0 +1,6 @@
+# ArduinoJson - https://arduinojson.org
+# Copyright Benoit Blanchon 2014-2021
+# MIT License
+
+idf_component_register(SRCS "main.cpp"
+                       INCLUDE_DIRS "")

extras/ci/espidf/main/component.mk

@@ -0,0 +1,4 @@
+#
+# "main" pseudo-component makefile.
+#
+# (Uses default behaviour of compiling all source files in directory, adding 'include' to include path.)

extras/ci/espidf/main/main.cpp

@@ -0,0 +1,16 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright Benoit Blanchon 2014-2021
+// MIT License
+
+#include <ArduinoJson.h>
+
+extern "C" void app_main() {
+  char buffer[256];
+  StaticJsonDocument<200> doc;
+
+  doc["hello"] = "world";
+  serializeJson(doc, buffer);
+  deserializeJson(doc, buffer);
+  serializeMsgPack(doc, buffer);
+  deserializeMsgPack(doc, buffer);
+}

extras/ci/particle.sh

@@ -0,0 +1,10 @@
+#!/bin/sh -ex
+
+BOARD=$1
+
+cd "$(dirname "$0")/../../"
+
+cp extras/particle/src/smocktest.ino src/
+cp extras/particle/project.properties ./
+
+particle compile "$BOARD"

extras/fuzzing/CMakeLists.txt

@@ -0,0 +1,59 @@
+# ArduinoJson - https://arduinojson.org
+# Copyright Benoit Blanchon 2014-2021
+# MIT License
+
+if(MSVC)
+	add_compile_options(-D_CRT_SECURE_NO_WARNINGS)
+endif()
+
+add_executable(msgpack_reproducer
+	msgpack_fuzzer.cpp
+	reproducer.cpp
+)
+target_link_libraries(msgpack_reproducer
+	ArduinoJson
+)
+
+add_executable(json_reproducer
+	json_fuzzer.cpp
+	reproducer.cpp
+)
+target_link_libraries(json_reproducer
+	ArduinoJson
+)
+
+macro(add_fuzzer name)	
+	set(FUZZER "${name}_fuzzer")
+	set(CORPUS_DIR "${CMAKE_CURRENT_SOURCE_DIR}/${name}_corpus")
+	set(SEED_CORPUS_DIR "${CMAKE_CURRENT_SOURCE_DIR}/${name}_seed_corpus")
+	add_executable("${FUZZER}"
+		"${name}_fuzzer.cpp"
+	)
+	target_link_libraries("${FUZZER}"
+		ArduinoJson
+	)
+	set_target_properties("${FUZZER}"
+		PROPERTIES 
+			COMPILE_FLAGS  
+				"-fprofile-instr-generate -fcoverage-mapping -fsanitize=fuzzer -fno-sanitize-recover=all"
+			LINK_FLAGS
+				"-fprofile-instr-generate -fcoverage-mapping -fsanitize=fuzzer -fno-sanitize-recover=all"
+	)
+
+	add_test(
+		NAME
+			"${FUZZER}"
+		COMMAND
+			"${FUZZER}" "${CORPUS_DIR}" "${SEED_CORPUS_DIR}" -max_total_time=5 -timeout=1
+	)
+
+	set_tests_properties("${FUZZER}"
+		PROPERTIES
+			LABELS 		"Fuzzing"
+	)
+endmacro()
+
+if (CMAKE_CXX_COMPILER_ID STREQUAL "Clang" AND CMAKE_CXX_COMPILER_VERSION VERSION_GREATER 6)
+	add_fuzzer(json)
+	add_fuzzer(msgpack)
+endif()

extras/fuzzing/Makefile

@@ -0,0 +1,22 @@
+# CAUTION: this file is invoked by https://github.com/google/oss-fuzz
+
+CXXFLAGS += -I../../src -DARDUINOJSON_DEBUG=1
+
+all: \
+	$(OUT)/json_fuzzer \
+	$(OUT)/json_fuzzer_seed_corpus.zip \
+	$(OUT)/json_fuzzer.options \
+	$(OUT)/msgpack_fuzzer \
+	$(OUT)/msgpack_fuzzer_seed_corpus.zip \
+	$(OUT)/msgpack_fuzzer.options
+
+$(OUT)/%_fuzzer: %_fuzzer.cpp $(shell find ../../src -type f)
+	$(CXX) $(CXXFLAGS) $< -o$@ $(LIB_FUZZING_ENGINE)
+
+$(OUT)/%_fuzzer_seed_corpus.zip: %_seed_corpus/*
+	zip -j $@ $?
+
+$(OUT)/%_fuzzer.options:
+	@echo "[libfuzzer]" > $@
+	@echo "max_len = 256" >> $@
+	@echo "timeout = 10" >> $@

extras/fuzzing/json_corpus/.gitignore

@@ -0,0 +1,2 @@
+*
+!.gitignore

extras/fuzzing/json_fuzzer.cpp

@@ -0,0 +1,11 @@
+#include <ArduinoJson.h>
+
+extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
+  DynamicJsonDocument doc(4096);
+  DeserializationError error = deserializeJson(doc, data, size);
+  if (!error) {
+    std::string json;
+    serializeJson(doc, json);
+  }
+  return 0;
+}

extras/fuzzing/json_seed_corpus/Comments.json

@@ -0,0 +1,10 @@
+//comment
+/*comment*/
+[ //comment
+/*comment*/"comment"/*comment*/,//comment
+/*comment*/{//comment
+/* comment*/"key"//comment
+: //comment
+"value"//comment
+}/*comment*/
+]//comment

extras/fuzzing/json_seed_corpus/EmptyArray.json

@@ -0,0 +1 @@
+[]

extras/fuzzing/json_seed_corpus/EmptyObject.json

@@ -0,0 +1 @@
+{}

extras/fuzzing/json_seed_corpus/ExcessiveNesting.json

@@ -0,0 +1 @@
+[1,[2,[3,[4,[5,[6,[7,[8,[9,[10,[11,[12,[13,[14,[15,[16,[17,[18,[19,[20,[21,[22,[23,[24,[25,[26,[27,[28,[29,[30,[31,[32,[33,[34,[35,[36,[37,[38,[39,[40,[41,[42,[43,[44,[45,[46,[47,[48,[49,[50,[51,[52,[53,[54,[55,[56,[57,[58,[59,[60,[61,[62,[63,[64,[65,[66,[67,[68,[69,[70,[71,[72,[73,[74,[75,[76,[77,[78,[79,[80,[81,[82,[83,[84,[85,[86,[87,[88,[89,[90,[91,[92,[93,[94,[95,[96,[97,[98,[99,[100,[101,[102,[103,[104,[105,[106,[107,[108,[109,[110,[111,[112,[113,[114,[115,[116,[117,[118,[119,[120]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]

extras/fuzzing/json_seed_corpus/IntegerOverflow.json

@@ -0,0 +1 @@
+9720730739393920739

extras/fuzzing/json_seed_corpus/Numbers.json

@@ -0,0 +1,24 @@
+[
+  123,
+  -123,
+  123.456,
+  -123.456,
+  12e34,
+  12e-34,
+  12e+34,
+  12E34,
+  12E-34,
+  12E+34,
+  12.34e56,
+  12.34e-56,
+  12.34e+56,
+  12.34E56,
+  12.34E-56,
+  12.34E+56,
+  NaN,
+  -NaN,
+  +NaN,
+  Infinity,
+  +Infinity,
+  -Infinity
+]

extras/fuzzing/json_seed_corpus/OpenWeatherMap.json

@@ -0,0 +1,53 @@
+{
+  "coord": {
+    "lon": -0.13,
+    "lat": 51.51
+  },
+  "weather": [
+    {
+      "id": 301,
+      "main": "Drizzle",
+      "description": "drizzle",
+      "icon": "09n"
+    },
+    {
+      "id": 701,
+      "main": "Mist",
+      "description": "mist",
+      "icon": "50n"
+    },
+    {
+      "id": 741,
+      "main": "Fog",
+      "description": "fog",
+      "icon": "50n"
+    }
+  ],
+  "base": "stations",
+  "main": {
+    "temp": 281.87,
+    "pressure": 1032,
+    "humidity": 100,
+    "temp_min": 281.15,
+    "temp_max": 283.15
+  },
+  "visibility": 2900,
+  "wind": {
+    "speed": 1.5
+  },
+  "clouds": {
+    "all": 90
+  },
+  "dt": 1483820400,
+  "sys": {
+    "type": 1,
+    "id": 5091,
+    "message": 0.0226,
+    "country": "GB",
+    "sunrise": 1483776245,
+    "sunset": 1483805443
+  },
+  "id": 2643743,
+  "name": "London",
+  "cod": 200
+}

extras/fuzzing/json_seed_corpus/Strings.json

@@ -0,0 +1,8 @@
+[
+  "hello",
+  'hello',
+  hello,
+  {"hello":"world"},
+  {'hello':'world'},
+  {hello:world}
+]

extras/fuzzing/json_seed_corpus/WeatherUnderground.json

@@ -0,0 +1,90 @@
+{
+  "response": {
+    "version": "0.1",
+    "termsofService": "http://www.wunderground.com/weather/api/d/terms.html",
+    "features": {
+      "conditions": 1
+    }
+  },
+  "current_observation": {
+    "image": {
+      "url": "http://icons-ak.wxug.com/graphics/wu2/logo_130x80.png",
+      "title": "Weather Underground",
+      "link": "http://www.wunderground.com"
+    },
+    "display_location": {
+      "full": "San Francisco, CA",
+      "city": "San Francisco",
+      "state": "CA",
+      "state_name": "California",
+      "country": "US",
+      "country_iso3166": "US",
+      "zip": "94101",
+      "latitude": "37.77500916",
+      "longitude": "-122.41825867",
+      "elevation": "47.00000000"
+    },
+    "observation_location": {
+      "full": "SOMA - Near Van Ness, San Francisco, California",
+      "city": "SOMA - Near Van Ness, San Francisco",
+      "state": "California",
+      "country": "US",
+      "country_iso3166": "US",
+      "latitude": "37.773285",
+      "longitude": "-122.417725",
+      "elevation": "49 ft"
+    },
+    "estimated": {},
+    "station_id": "KCASANFR58",
+    "observation_time": "Last Updated on June 27, 5:27 PM PDT",
+    "observation_time_rfc822": "Wed, 27 Jun 2012 17:27:13 -0700",
+    "observation_epoch": "1340843233",
+    "local_time_rfc822": "Wed, 27 Jun 2012 17:27:14 -0700",
+    "local_epoch": "1340843234",
+    "local_tz_short": "PDT",
+    "local_tz_long": "America/Los_Angeles",
+    "local_tz_offset": "-0700",
+    "weather": "Partly Cloudy",
+    "temperature_string": "66.3 F (19.1 C)",
+    "temp_f": 66.3,
+    "temp_c": 19.1,
+    "relative_humidity": "65%",
+    "wind_string": "From the NNW at 22.0 MPH Gusting to 28.0 MPH",
+    "wind_dir": "NNW",
+    "wind_degrees": 346,
+    "wind_mph": 22,
+    "wind_gust_mph": "28.0",
+    "wind_kph": 35.4,
+    "wind_gust_kph": "45.1",
+    "pressure_mb": "1013",
+    "pressure_in": "29.93",
+    "pressure_trend": "+",
+    "dewpoint_string": "54 F (12 C)",
+    "dewpoint_f": 54,
+    "dewpoint_c": 12,
+    "heat_index_string": "NA",
+    "heat_index_f": "NA",
+    "heat_index_c": "NA",
+    "windchill_string": "NA",
+    "windchill_f": "NA",
+    "windchill_c": "NA",
+    "feelslike_string": "66.3 F (19.1 C)",
+    "feelslike_f": "66.3",
+    "feelslike_c": "19.1",
+    "visibility_mi": "10.0",
+    "visibility_km": "16.1",
+    "solarradiation": "",
+    "UV": "5",
+    "precip_1hr_string": "0.00 in ( 0 mm)",
+    "precip_1hr_in": "0.00",
+    "precip_1hr_metric": " 0",
+    "precip_today_string": "0.00 in (0 mm)",
+    "precip_today_in": "0.00",
+    "precip_today_metric": "0",
+    "icon": "partlycloudy",
+    "icon_url": "http://icons-ak.wxug.com/i/c/k/partlycloudy.gif",
+    "forecast_url": "http://www.wunderground.com/US/CA/San_Francisco.html",
+    "history_url": "http://www.wunderground.com/history/airport/KCASANFR58/2012/6/27/DailyHistory.html",
+    "ob_url": "http://www.wunderground.com/cgi-bin/findweather/getForecast?query=37.773285,-122.417725"
+  }
+}

extras/fuzzing/msgpack_corpus/.gitignore

@@ -0,0 +1,2 @@
+*
+!.gitignore

extras/fuzzing/msgpack_fuzzer.cpp

@@ -0,0 +1,11 @@
+#include <ArduinoJson.h>
+
+extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
+  DynamicJsonDocument doc(4096);
+  DeserializationError error = deserializeMsgPack(doc, data, size);
+  if (!error) {
+    std::string json;
+    serializeMsgPack(doc, json);
+  }
+  return 0;
+}

extras/fuzzing/msgpack_seed_corpus/false

@@ -0,0 +1 @@
+<EFBFBD>

extras/fuzzing/msgpack_seed_corpus/fixarray

@@ -0,0 +1 @@
+<EFBFBD><EFBFBD>hello<EFBFBD>world

extras/fuzzing/msgpack_seed_corpus/fixint_negative

@@ -0,0 +1 @@
+<EFBFBD>

extras/fuzzing/msgpack_seed_corpus/fixint_positive

@@ -0,0 +1 @@
+

extras/fuzzing/msgpack_seed_corpus/fixmap

@@ -0,0 +1 @@
+<EFBFBD><EFBFBD>one
<01>two

extras/fuzzing/msgpack_seed_corpus/fixstr

@@ -0,0 +1 @@
+<EFBFBD>hello world

extras/fuzzing/msgpack_seed_corpus/float32

@@ -0,0 +1 @@
+<EFBFBD>@H<><48>

extras/fuzzing/msgpack_seed_corpus/float64

@@ -0,0 +1 @@
+<EFBFBD>@	!<21><><EFBFBD>o

extras/fuzzing/msgpack_seed_corpus/int16

@@ -0,0 +1 @@
+<EFBFBD><EFBFBD><EFBFBD>

extras/fuzzing/msgpack_seed_corpus/int32

@@ -0,0 +1 @@
+Ҷi<EFBFBD>.

extras/fuzzing/msgpack_seed_corpus/int64

@@ -0,0 +1 @@
+<EFBFBD>4Vx<56><78><EFBFBD><EFBFBD>

extras/fuzzing/msgpack_seed_corpus/int8

@@ -0,0 +1 @@
+<EFBFBD><EFBFBD>

extras/fuzzing/msgpack_seed_corpus/nil

@@ -0,0 +1 @@
+<EFBFBD>

extras/fuzzing/msgpack_seed_corpus/str8

@@ -0,0 +1 @@
+<EFBFBD>hello

extras/fuzzing/msgpack_seed_corpus/true

@@ -0,0 +1 @@
+<EFBFBD>

extras/fuzzing/msgpack_seed_corpus/uint16

@@ -0,0 +1 @@
+<EFBFBD>09

extras/fuzzing/msgpack_seed_corpus/uint32

@@ -0,0 +1 @@
+<EFBFBD>4Vx

extras/fuzzing/msgpack_seed_corpus/uint64

@@ -0,0 +1 @@
+<EFBFBD>4Vx<56><78><EFBFBD><EFBFBD>

extras/fuzzing/msgpack_seed_corpus/uint8

@@ -0,0 +1 @@
+<EFBFBD><EFBFBD>

extras/fuzzing/reproducer.cpp

@@ -0,0 +1,50 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright Benoit Blanchon 2014-2021
+// MIT License
+
+// This file is NOT use by Google's OSS fuzz
+// I only use it to reproduce the bugs found
+
+#include <stdint.h>  // size_t
+#include <stdio.h>   // fopen et al.
+#include <stdlib.h>  // exit
+#include <iostream>
+#include <vector>
+
+extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size);
+
+std::vector<uint8_t> read(const char* path) {
+  FILE* f = fopen(path, "rb");
+  if (!f) {
+    std::cerr << "Failed to open " << path << std::endl;
+    exit(1);
+  }
+
+  fseek(f, 0, SEEK_END);
+  size_t size = static_cast<size_t>(ftell(f));
+  fseek(f, 0, SEEK_SET);
+
+  std::vector<uint8_t> buffer(size);
+  if (fread(buffer.data(), 1, size, f) != size) {
+    fclose(f);
+    std::cerr << "Failed to read " << path << std::endl;
+    exit(1);
+  }
+
+  fclose(f);
+  return buffer;
+}
+
+int main(int argc, const char* argv[]) {
+  if (argc < 2) {
+    std::cerr << "Usage: msgpack_fuzzer files" << std::endl;
+    return 1;
+  }
+
+  for (int i = 1; i < argc; i++) {
+    std::cout << "Loading " << argv[i] << std::endl;
+    std::vector<uint8_t> buffer = read(argv[i]);
+    LLVMFuzzerTestOneInput(buffer.data(), buffer.size());
+  }
+  return 0;
+}

extras/particle/project.properties

@@ -0,0 +1 @@
+name=ArduinoJsonCI

extras/particle/src/smocktest.ino

@@ -0,0 +1,5 @@
+#include "ArduinoJson.h"
+
+void setup() {}
+
+void loop() {}

extras/scripts/build-arduino-package.sh

@@ -0,0 +1,23 @@
+#!/bin/bash
+
+set -eu
+
+INPUT=$1
+OUTPUT=$2
+
+cd "$INPUT"
+
+# remove existing file
+rm -f "$OUTPUT"
+
+# create zip
+7z a "$OUTPUT" \
+	-xr!.vs \
+	CHANGELOG.md \
+	examples \
+	src \
+	keywords.txt \
+	library.properties \
+	LICENSE.md \
+	README.md \
+	ArduinoJson.h

extras/scripts/build-single-header.sh

@@ -0,0 +1,64 @@
+#!/bin/bash
+
+set -e
+
+RE_RELATIVE_INCLUDE='^#[[:space:]]*include[[:space:]]*"(.*)"'
+RE_ABSOLUTE_INCLUDE='^#[[:space:]]*include[[:space:]]*<(ArduinoJson/.*)>'
+RE_SYSTEM_INCLUDE='^#[[:space:]]*include[[:space:]]*<(.*)>'
+RE_EMPTY='^(#[[:space:]]*pragma[[:space:]]+once)?[[:space:]]*(//.*)?$'
+SRC_DIRECTORY="$(realpath "$(dirname $0)/../../src")"
+
+
+declare -A INCLUDED
+
+process()
+{
+	local PARENT=$1
+	local FOLDER=$(dirname $1)
+	local SHOW_COMMENT=$2
+	while IFS= read -r LINE; do
+		if [[ $LINE =~ $RE_ABSOLUTE_INCLUDE ]]; then
+			local CHILD=${BASH_REMATCH[1]}
+			local CHILD_PATH
+			CHILD_PATH=$(realpath "$SRC_DIRECTORY/$CHILD")
+			echo "$PARENT -> $CHILD" >&2
+			if [[ ! ${INCLUDED[$CHILD_PATH]} ]]; then
+				INCLUDED[$CHILD_PATH]=true
+				process "$CHILD" false
+			fi
+		elif [[ $LINE =~ $RE_RELATIVE_INCLUDE ]]; then
+			local CHILD=${BASH_REMATCH[1]}
+			pushd "$FOLDER" > /dev/null
+			local CHILD_PATH
+			CHILD_PATH=$(realpath "$CHILD")
+			echo "$PARENT -> $CHILD" >&2
+			if [[ ! ${INCLUDED[$CHILD_PATH]} ]]; then
+				INCLUDED[$CHILD_PATH]=true
+				process "$CHILD" false
+			fi
+			popd > /dev/null
+		elif [[ $LINE =~ $RE_SYSTEM_INCLUDE ]]; then
+			local CHILD=${BASH_REMATCH[1]}
+			echo "$PARENT -> <$CHILD>" >&2
+			if [[ ! ${INCLUDED[$CHILD]} ]]; then
+				echo "#include <$CHILD>"
+				INCLUDED[$CHILD]=true
+			fi
+		elif [[ "${SHOW_COMMENT}" = "true" ]] ; then
+			echo "$LINE"
+		elif [[ ! $LINE =~ $RE_EMPTY ]]; then
+			echo "$LINE"
+		fi
+	done < $PARENT
+}
+
+simplify_namespaces() {
+	perl -p0i -e 's|\}  // namespace ARDUINOJSON_NAMESPACE\r?\nnamespace ARDUINOJSON_NAMESPACE \{\r?\n||igs' "$1"
+	rm -f "$1.bak"
+}
+
+INCLUDED=()
+INPUT=$1
+OUTPUT=$2
+process "$INPUT" true > "$OUTPUT"
+simplify_namespaces "$OUTPUT"

extras/scripts/get-release-body.sh

@@ -0,0 +1,14 @@
+#!/bin/bash
+
+set -eu
+
+TAG="$1"
+CHANGELOG="$2"
+
+cat << END
+## Changes
+
+$(awk '/\* /{ FOUND=1; print; next } { if (FOUND) exit}' "$CHANGELOG")
+
+[View version history](https://github.com/bblanchon/ArduinoJson/blob/$TAG/CHANGELOG.md)
+END

extras/scripts/get-release-page.sh

@@ -0,0 +1,18 @@
+#!/bin/bash
+
+set -eu
+
+TAG="$1"
+CHANGELOG="$2"
+FRONTMATTER="$3"
+
+cat << END
+---
+branch: v6
+version: $TAG
+date: '$(date +'%Y-%m-%d')'
+$(cat "$FRONTMATTER")
+---
+
+$(awk '/\* /{ FOUND=1; print; next } { if (FOUND) exit}' "$CHANGELOG")
+END

extras/scripts/publish-particle-library.sh

@@ -0,0 +1,18 @@
+#!/usr/bin/env bash
+
+set -eu
+
+SOURCE_DIR="$(dirname "$0")/../.."
+WORK_DIR=$(mktemp -d)
+trap 'rm -rf "$WORK_DIR"' EXIT
+
+cp "$SOURCE_DIR/README.md" "$WORK_DIR/README.md"
+cp "$SOURCE_DIR/CHANGELOG.md" "$WORK_DIR/CHANGELOG.md"
+cp "$SOURCE_DIR/library.properties" "$WORK_DIR/library.properties"
+cp "$SOURCE_DIR/LICENSE.md" "$WORK_DIR/LICENSE.txt"
+cp -r "$SOURCE_DIR/src" "$WORK_DIR/"
+cp -r "$SOURCE_DIR/examples" "$WORK_DIR/"
+
+cd "$WORK_DIR"
+particle library upload
+particle library publish

extras/scripts/publish.sh

@@ -0,0 +1,68 @@
+#!/usr/bin/env bash
+
+set -eu
+
+cd "$(dirname "$0")/../.."
+
+VERSION="$1"
+DATE=$(date +%F)
+TAG="v$VERSION"
+VERSION_REGEX="[0-9a-z\\.\\-]+"
+
+update_version_in_source () {
+	IFS=".-" read MAJOR MINOR REVISION EXTRA < <(echo "$VERSION")
+	UNDERLINE=$(printf -- '-%.0s' $(seq 1 ${#TAG}))
+
+	sed -i~ -bE "s/version=$VERSION_REGEX/version=$VERSION/; s|ardu-badge.com/ArduinoJson/$VERSION_REGEX|ardu-badge.com/ArduinoJson/$VERSION|; " README.md
+	rm README.md~
+
+	sed -i~ -bE "4s/HEAD/$TAG ($DATE)/; 5s/-+/$UNDERLINE/" CHANGELOG.md
+	rm CHANGELOG.md~
+
+	sed -i~ -bE "s/(project\\s*\\(ArduinoJson\\s+VERSION\\s+).*?\\)/\\1$MAJOR.$MINOR.$REVISION)/" CMakeLists.txt
+	rm CMakeLists.txt~
+
+	sed -i~ -bE "s/\"version\":.*$/\"version\": \"$VERSION\",/" library.json
+	rm library.json~
+
+	sed -i~ -bE "s/version=.*$/version=$VERSION/" library.properties
+	rm library.properties~
+
+	sed -i~ -bE "s/version: .*$/version: $VERSION.{build}/" appveyor.yml
+	rm appveyor.yml~
+
+	sed -i~ -bE \
+		-e "s/ARDUINOJSON_VERSION .*$/ARDUINOJSON_VERSION \"$VERSION\"/" \
+		-e "s/ARDUINOJSON_VERSION_MAJOR .*$/ARDUINOJSON_VERSION_MAJOR $MAJOR/" \
+		-e "s/ARDUINOJSON_VERSION_MINOR .*$/ARDUINOJSON_VERSION_MINOR $MINOR/" \
+		-e "s/ARDUINOJSON_VERSION_REVISION .*$/ARDUINOJSON_VERSION_REVISION $REVISION/" \
+		src/ArduinoJson/version.hpp
+	rm src/ArduinoJson/version.hpp*~
+}
+
+commit_new_version () {
+	git add src/ArduinoJson/version.hpp README.md CHANGELOG.md library.json library.properties appveyor.yml CMakeLists.txt
+	git commit -m "Set version to $VERSION"
+}
+
+add_tag () {
+	CHANGES=$(awk '/\* /{ FOUND=1; print; next } { if (FOUND) exit}' CHANGELOG.md)
+	git tag -m "ArduinoJson $VERSION"$'\n'"$CHANGES" "$TAG"
+}
+
+push () {
+	git push --follow-tags
+}
+
+update_version_in_source
+commit_new_version
+add_tag
+push
+
+extras/scripts/build-arduino-package.sh . "../ArduinoJson-$TAG.zip"
+extras/scripts/build-single-header.sh "src/ArduinoJson.h" "../ArduinoJson-$TAG.h"
+extras/scripts/build-single-header.sh "src/ArduinoJson.hpp" "../ArduinoJson-$TAG.hpp"
+extras/scripts/wandbox/publish.sh "../ArduinoJson-$TAG.h" > "../ArduinoJson-$TAG-wandbox.txt"
+extras/scripts/get-release-page.sh "$TAG" "CHANGELOG.md" "../ArduinoJson-$TAG-wandbox.txt" > "../ArduinoJson-$TAG.md"
+
+echo "You can now copy ../ArduinoJson-$TAG.md into arduinojson.org/collections/_versions/$VERSION.md"