fix.删除多余的关卡选项

https://github.com/MaaAssistantArknights/MaaAssistantArknights/issues/720
https://github.com/MaaAssistantArknights/MaaAssistantArknights/issues/115
https://github.com/MaaAssistantArknights/MaaAssistantArknights/issues/766

.editorconfig

@@ -5,7 +5,7 @@ root = true
 indent_style = space
 insert_final_newline = true
 charset = utf-8
-end_of_line = crlf
+end_of_line = lf
 
 [*.json]
 

.gitattributes

@@ -0,0 +1,11 @@
+*        text=auto
+*.cs     text eol=crlf
+*.xaml   text eol=crlf
+
+*.cpp    text eol=lf
+*.hpp    text eol=lf
+*.h      text eol=lf
+
+*.json   text eol=lf
+*.md     text eol=lf
+*.yaml   text eol=lf

.github/ISSUE_TEMPLATE/-----bug-report-.md

@@ -0,0 +1,16 @@
+---
+name: 问题反馈（Bug report）
+about: 识别错误、操作异常、连接错误等
+title: ''
+labels: bug
+assignees: ''
+
+---
+
+！！！请尽可能详细的描述你遇到的问题，并附上助手软件目录下的 `asst.log` 日志文件！！！
+
+！！！日志文件是可以直接拖拽进来的，没有日志文件的 bug 反馈我们会直接关掉！！！
+
+最好再能说明下使用的模拟器、并附上出错时的游戏和软件的截图（要是没截到就算啦_(:з」∠)_
+
+Thanks♪(･ω･)ﾉ

.github/ISSUE_TEMPLATE/-----feature-request-.md

@@ -0,0 +1,10 @@
+---
+name: 需求建议（Feature request）
+about: 新功能、建议等
+title: ''
+labels: enhancement
+assignees: ''
+
+---
+
+

.github/ISSUE_TEMPLATE/---others-.md

@@ -0,0 +1,10 @@
+---
+name: 其他（Others)
+about: 其他议题
+title: ''
+labels: ''
+assignees: ''
+
+---
+
+

.github/workflows/deploy-docs.yml

@@ -0,0 +1,30 @@
+name: deploy-docs
+
+on:
+  push:
+    branches:
+      - master
+    paths:
+      - "docs/*"
+  workflow_dispatch:
+
+jobs:
+  deploy-to-azure:
+    runs-on: ubuntu-latest
+    name: Build and Deploy Job
+    steps:
+      - uses: actions/checkout@v2
+        with:
+          submodules: true
+      - name: Build And Deploy
+        id: builddeploy
+        uses: Azure/static-web-apps-deploy@v1
+        with:
+          azure_static_web_apps_api_token: ${{ secrets.AZURE_STATIC_WEB_APPS_API_TOKEN_GENTLE_DESERT_00290F400 }}
+          repo_token: ${{ secrets.GITHUB_TOKEN }} # Used for Github integrations (i.e. PR comments)
+          action: "upload"
+          ###### Repository/Build Configurations - These values can be configured to match your app requirements. ######
+          # For more information regarding Static Web App workflow configurations, please visit: https://aka.ms/swaworkflowconfig
+          app_location: "/docs" # App source code path
+          api_location: "" # Api source code path - optional
+          output_location: ".vuepress/dist" # Built app content directory - optional

.github/workflows/dev-build.yml

@@ -0,0 +1,69 @@
+# ------------------------------------------------------------------------------
+# <auto-generated>
+#
+#     This code was generated.
+#
+#     - To turn off auto-generation set:
+#
+#         [GitHubActions (AutoGenerate = false)]
+#
+#     - To trigger manual generation invoke:
+#
+#         nuke --generate-configuration GitHubActions_dev-build --host GitHubActions
+#
+# </auto-generated>
+# ------------------------------------------------------------------------------
+
+name: dev-build
+
+on:
+  push:
+    branches-ignore:
+      - master
+    paths:
+      - 'src/MeoAssistant/**'
+      - 'src/MeoAssistantBuilder/**'
+      - 'src/MeoAsstGui/**'
+      - '3rdparty/**'
+      - 'include/**'
+      - 'resource/**'
+      - MeoAssistantArknights.sln
+  pull_request:
+    branches:
+      - dev
+    paths:
+      - 'src/MeoAssistant/**'
+      - 'src/MeoAssistantBuilder/**'
+      - 'src/MeoAsstGui/**'
+      - '3rdparty/**'
+      - 'include/**'
+      - 'resource/**'
+      - MeoAssistantArknights.sln
+  workflow_dispatch:
+    inputs:
+      Reason:
+        description: "Reason"
+        required: true
+
+jobs:
+  windows-latest:
+    name: windows-latest
+    runs-on: windows-latest
+    steps:
+      - uses: actions/checkout@v1
+      - name: Cache .nuke/temp, ~/.nuget/packages
+        uses: actions/cache@v2
+        with:
+          path: |
+            .nuke/temp
+            ~/.nuget/packages
+          key: ${{ runner.os }}-${{ hashFiles('**/global.json', '**/*.csproj') }}
+      - name: Run './build.cmd DevBuild'
+        run: ./build.cmd DevBuild
+        env:
+          Reason: ${{ github.event.inputs.Reason }}
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+      - uses: actions/upload-artifact@v1
+        with:
+          name: artifacts
+          path: artifacts

.github/workflows/release-maa-resource.yml

@@ -0,0 +1,48 @@
+# ------------------------------------------------------------------------------
+# <auto-generated>
+#
+#     This code was generated.
+#
+#     - To turn off auto-generation set:
+#
+#         [GitHubActions (AutoGenerate = false)]
+#
+#     - To trigger manual generation invoke:
+#
+#         nuke --generate-configuration GitHubActions_release-maa-resource --host GitHubActions
+#
+# </auto-generated>
+# ------------------------------------------------------------------------------
+
+name: release-maa-resource
+
+on:
+  push:
+    branches:
+      - master
+    paths:
+      - 'resource/**'
+      - '3rdparty/resource/**'
+
+jobs:
+  windows-latest:
+    name: windows-latest
+    runs-on: windows-latest
+    steps:
+      - uses: actions/checkout@v1
+      - name: Cache .nuke/temp, ~/.nuget/packages
+        uses: actions/cache@v2
+        with:
+          path: |
+            .nuke/temp
+            ~/.nuget/packages
+          key: ${{ runner.os }}-${{ hashFiles('**/global.json', '**/*.csproj') }}
+      - name: Run './build.cmd ReleaseMaaResource'
+        run: ./build.cmd ReleaseMaaResource
+        env:
+          PUBLISH_GH_PAT: ${{ secrets.PUBLISH_GH_PAT }}
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+      - uses: actions/upload-artifact@v1
+        with:
+          name: artifacts
+          path: artifacts

.github/workflows/release-maa.yml

@@ -0,0 +1,45 @@
+# ------------------------------------------------------------------------------
+# <auto-generated>
+#
+#     This code was generated.
+#
+#     - To turn off auto-generation set:
+#
+#         [GitHubActions (AutoGenerate = false)]
+#
+#     - To trigger manual generation invoke:
+#
+#         nuke --generate-configuration GitHubActions_release-maa --host GitHubActions
+#
+# </auto-generated>
+# ------------------------------------------------------------------------------
+
+name: release-maa
+
+on:
+  push:
+    tags:
+      - 'v*'
+
+jobs:
+  windows-latest:
+    name: windows-latest
+    runs-on: windows-latest
+    steps:
+      - uses: actions/checkout@v1
+      - name: Cache .nuke/temp, ~/.nuget/packages
+        uses: actions/cache@v2
+        with:
+          path: |
+            .nuke/temp
+            ~/.nuget/packages
+          key: ${{ runner.os }}-${{ hashFiles('**/global.json', '**/*.csproj') }}
+      - name: Run './build.cmd ReleaseMaa'
+        run: ./build.cmd ReleaseMaa
+        env:
+          PUBLISH_GH_PAT: ${{ secrets.PUBLISH_GH_PAT }}
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+      - uses: actions/upload-artifact@v1
+        with:
+          name: artifacts
+          path: artifacts

.gitignore

@@ -1,3 +1,6 @@
+# docs
+docs/node_modules
+docs/.vuepress/.temp
 # Prerequisites
 *.d
 
@@ -430,5 +433,11 @@ FodyWeavers.xsd
 
 screen.png
 adb_screen.png
-tools/*.png
+tools/**/*.png
 resource/infrast
+.vscode
+!3rdparty/tools/*
+
+# Nuke
+.nuke/temp/*
+/tools/ItemMappingCvt/Arknights-Bot-Resource

.nuke/build.schema.json

@@ -0,0 +1,137 @@
+{
+  "$schema": "http://json-schema.org/draft-04/schema#",
+  "title": "Build Schema",
+  "$ref": "#/definitions/build",
+  "definitions": {
+    "build": {
+      "type": "object",
+      "properties": {
+        "Continue": {
+          "type": "boolean",
+          "description": "Indicates to continue a previously failed build attempt"
+        },
+        "Help": {
+          "type": "boolean",
+          "description": "Shows the help text for this build assembly"
+        },
+        "Host": {
+          "type": "string",
+          "description": "Host for execution. Default is 'automatic'",
+          "enum": [
+            "AppVeyor",
+            "AzurePipelines",
+            "Bamboo",
+            "Bitrise",
+            "GitHubActions",
+            "GitLab",
+            "Jenkins",
+            "Rider",
+            "SpaceAutomation",
+            "TeamCity",
+            "Terminal",
+            "TravisCI",
+            "VisualStudio",
+            "VSCode"
+          ]
+        },
+        "NoLogo": {
+          "type": "boolean",
+          "description": "Disables displaying the NUKE logo"
+        },
+        "Partition": {
+          "type": "string",
+          "description": "Partition to use on CI"
+        },
+        "Plan": {
+          "type": "boolean",
+          "description": "Shows the execution plan (HTML)"
+        },
+        "Profile": {
+          "type": "array",
+          "description": "Defines the profiles to load",
+          "items": {
+            "type": "string"
+          }
+        },
+        "Root": {
+          "type": "string",
+          "description": "Root directory during build execution"
+        },
+        "Skip": {
+          "type": "array",
+          "description": "List of targets to be skipped. Empty list skips all dependencies",
+          "items": {
+            "type": "string",
+            "enum": [
+              "Default",
+              "DevBuild",
+              "ReleaseMaa",
+              "ReleaseMaaCore",
+              "ReleaseMaaResource",
+              "SetMaaChangeLog",
+              "SetPackageBundled",
+              "SetVersion",
+              "UseCleanArtifact",
+              "UseCleanRelease",
+              "UseCommitVersion",
+              "UseMaaChangeLog",
+              "UseMaaCore",
+              "UseMaaDevBundle",
+              "UseMaaLegacyBundle",
+              "UseMaaResource",
+              "UseMaaResourceChangeLog",
+              "UsePublishArtifact",
+              "UsePublishRelease",
+              "UseTagVersion",
+              "WithCompileCoreRelease",
+              "WithCompileResourceRelease",
+              "WithCompileWpfRelease"
+            ]
+          }
+        },
+        "Target": {
+          "type": "array",
+          "description": "List of targets to be invoked. Default is '{default_target}'",
+          "items": {
+            "type": "string",
+            "enum": [
+              "Default",
+              "DevBuild",
+              "ReleaseMaa",
+              "ReleaseMaaCore",
+              "ReleaseMaaResource",
+              "SetMaaChangeLog",
+              "SetPackageBundled",
+              "SetVersion",
+              "UseCleanArtifact",
+              "UseCleanRelease",
+              "UseCommitVersion",
+              "UseMaaChangeLog",
+              "UseMaaCore",
+              "UseMaaDevBundle",
+              "UseMaaLegacyBundle",
+              "UseMaaResource",
+              "UseMaaResourceChangeLog",
+              "UsePublishArtifact",
+              "UsePublishRelease",
+              "UseTagVersion",
+              "WithCompileCoreRelease",
+              "WithCompileResourceRelease",
+              "WithCompileWpfRelease"
+            ]
+          }
+        },
+        "Verbosity": {
+          "type": "string",
+          "description": "Logging verbosity during build execution. Default is 'Normal'",
+          "enum": [
+            "Minimal",
+            "Normal",
+            "Quiet",
+            "Verbose"
+          ]
+        }
+      }
+    }
+  }
+}

.nuke/parameters.json

@@ -0,0 +1,4 @@
+{
+  "$schema": "./build.schema.json",
+  "Solution": "tools/MaaBuilder.sln"
+}

.vscode/settings.json

@@ -0,0 +1,10 @@
+{
+    "json.schemas": [
+        {
+            "fileMatch": [
+                "resource/tasks.json"
+            ],
+            "url": "./docs/maa_tasks_schema.json"
+        }
+    ]
+}

3rdparty/include/Arknights-Tile-Pos/TileCalc.hpp

@@ -0,0 +1,202 @@
+#pragma once
+
+#include <string>
+#include <vector>
+#include <cmath>
+#include <fstream>
+#include <iostream>
+
+#include <opencv2/core.hpp>
+#include <meojson/json.hpp>
+
+namespace Map
+{
+    struct Tile
+    {
+        int heightType = 0;
+        int buildableType = 0;
+        std::string tileKey;
+    };
+
+    class Level
+    {
+    public:
+        Level(const json::value& data);
+        int get_width() const { return width; }
+        int get_height() const { return height; }
+        Tile get_item(int y, int x) const { return tiles[y][x]; }
+        std::vector<cv::Point3d> view;
+        std::string stageId;
+        std::string	code;
+        std::string	levelId;
+        std::string	name;
+    private:
+        int height = 0;
+        int width = 0;
+        std::vector<std::vector<Tile>> tiles;
+    };
+    class TileCalc
+    {
+    public:
+        TileCalc(int width, int height, const std::string& dir);
+        bool run(const std::string& code_or_name, bool side, std::vector<std::vector<cv::Point2d>>& out_pos, std::vector<std::vector<Tile>>& out_tiles) const;
+    private:
+        int width = 0;
+        int height = 0;
+        const double degree = atan(1.0) * 4 / 180;
+        std::vector<Level> levels;
+        cv::Mat MatrixP = cv::Mat(4, 4, CV_64F);
+        cv::Mat MatrixX = cv::Mat(4, 4, CV_64F);
+        cv::Mat MatrixY = cv::Mat(4, 4, CV_64F);
+        bool adapter(double& x, double& y) const;
+    };
+
+    inline void InitMat4x4(cv::Mat& m, double(*num)[4])
+    {
+        for (int i = 0; i < m.rows; i++)
+            for (int j = 0; j < m.cols; j++)
+                m.at<double>(i, j) = num[i][j];
+    }
+
+    inline Level::Level(const json::value& data)
+    {
+        Level::stageId = data.at("stageId").as_string();
+        Level::code = data.at("code").as_string();
+        Level::levelId = data.at("levelId").as_string();
+        Level::name = data.get("name", "null");
+        Level::height = data.at("height").as_integer();
+        Level::width = data.at("width").as_integer();
+        for (const json::value& point_data : data.at("view").as_array()) {
+            cv::Point3d tmp;
+            auto point_array = point_data.as_array();
+            tmp.x = point_array[0].as_double();
+            tmp.y = point_array[1].as_double();
+            tmp.z = point_array[2].as_double();
+            Level::view.emplace_back(std::move(tmp));
+        }
+        for (const json::value& row : data.at("tiles").as_array()) {
+            std::vector<Tile> tmp;
+            tmp.reserve(Level::width);
+            for (const json::value& tile : row.as_array()) {
+                tmp.emplace_back(Tile{
+                    tile.at("heightType").as_integer(),
+                    tile.at("buildableType").as_integer(),
+                    tile.get("tileKey", std::string()) });
+            }
+            tiles.emplace_back(std::move(tmp));
+        }
+    }
+
+    inline TileCalc::TileCalc(int width, int height, const std::string& dir)
+    {
+        TileCalc::width = width;
+        TileCalc::height = height;
+        double ratio = static_cast<double>(height) / width;
+        double matrixP[4][4]{
+            { ratio / tan(20 * degree), 0, 0, 0},
+            { 0, 1 / tan(20 * degree), 0, 0},
+            { 0, 0, -(1000 + 0.3) / (1000 - 0.3), -(1000 * 0.3 * 2) / (1000 - 0.3)},
+            { 0, 0, -1, 0 }
+        };
+        InitMat4x4(TileCalc::MatrixP, matrixP);
+        double matrixX[4][4]{
+                    { 1, 0, 0, 0},
+                    { 0, cos(30 * degree), -sin(30 * degree), 0},
+                    { 0, -sin(30 * degree), -cos(30 * degree), 0},
+                    { 0, 0, 0, 1}
+        };
+        InitMat4x4(TileCalc::MatrixX, matrixX);
+        double matrixY[4][4]{
+                    { cos(10 * degree), 0, sin(10 * degree), 0},
+                    { 0, 1, 0, 0},
+                    { -sin(10 * degree), 0, cos(10 * degree), 0},
+                    { 0, 0, 0, 1}
+        };
+        InitMat4x4(TileCalc::MatrixY, matrixY);
+        std::ifstream ifs(dir, std::ios::in);
+        if (!ifs.is_open()) {
+            std::cerr << "Read resource failed" << std::endl;
+            throw "Read resource failed";
+        }
+        std::stringstream iss;
+        iss << ifs.rdbuf();
+        ifs.close();
+        std::string content = iss.str();
+        auto ret = json::parse(content);
+        if (!ret) {
+            std::cerr << "Parsing failed" << std::endl;
+            throw "Parsing failed";
+        }
+        for (const json::value& item : ret.value().as_array()) {
+            TileCalc::levels.emplace_back(item);
+        }
+    }
+
+    inline bool TileCalc::adapter(double& x, double& y) const
+    {
+        const double fromRatio = 9.0 / 16;
+        const double toRatio = 3.0 / 4;
+        double ratio = static_cast<double>(height) / width;
+        if (ratio < fromRatio - 0.00001) {
+            x = 0;
+            y = 0;
+            return false;
+        }
+        double t = (ratio - fromRatio) / (toRatio - fromRatio);
+        x = -1.4 * t;
+        y = -2.8 * t;
+        return true;
+    }
+
+    inline bool TileCalc::run(const std::string& code_or_name, bool side, std::vector<std::vector<cv::Point2d>>& out_pos, std::vector<std::vector<Tile>>& out_tiles) const
+    {
+        for (const Map::Level& level : TileCalc::levels) {
+            if (level.code != code_or_name &&
+                level.name != code_or_name &&
+                level.levelId != code_or_name &&
+                level.stageId != code_or_name) {
+                continue;
+            }
+            auto [x, y, z] = level.view[side ? 1 : 0];
+            double adapter_y = 0, adapter_z = 0;
+            TileCalc::adapter(adapter_y, adapter_z);
+            double matrix[4][4]{
+                { 1, 0, 0, -x},
+                { 0, 1, 0, -y - adapter_y},
+                { 0, 0, 1, -z - adapter_z},
+                { 0, 0, 0, 1}
+            };
+            auto raw = cv::Mat(cv::Size(4, 4), CV_64F);
+            auto Finall_Matrix = cv::Mat(cv::Size(4, 4), CV_64F);
+            InitMat4x4(raw, matrix);
+            if (side) {
+                Finall_Matrix = TileCalc::MatrixP * TileCalc::MatrixX * TileCalc::MatrixY * raw;
+            }
+            else {
+                Finall_Matrix = TileCalc::MatrixP * TileCalc::MatrixX * raw;
+            }
+            int h = level.get_height();
+            int w = level.get_width();
+            auto map_point = cv::Mat(cv::Size(1, 4), CV_64F);
+            map_point.at<double>(3, 0) = 1;
+            auto tmp_pos = std::vector<cv::Point2d>(w);
+            auto tmp_tiles = std::vector<Tile>(w);
+            for (int i = 0; i < h; i++) {
+                for (int j = 0; j < w; j++) {
+                    tmp_tiles[j] = level.get_item(i, j);
+                    map_point.at<double>(0, 0) = j - (w - 1) / 2.0;
+                    map_point.at<double>(1, 0) = (h - 1) / 2.0 - i;
+                    map_point.at<double>(2, 0) = tmp_tiles[j].heightType * -0.4;
+                    cv::Mat view_point = Finall_Matrix * map_point;
+                    view_point = view_point / view_point.at<double>(3, 0);
+                    view_point = (view_point + 1) / 2;
+                    tmp_pos[j] = cv::Point2d(view_point.at<double>(0, 0) * TileCalc::width, (1 - view_point.at<double>(1, 0)) * TileCalc::height);
+                }
+                out_pos.emplace_back(tmp_pos);
+                out_tiles.emplace_back(tmp_tiles);
+            }
+            return true;
+        }
+        return false;
+    }
+}

3rdparty/include/PaddleOCR/paddle_ocr.h

@@ -13,26 +13,43 @@ typedef unsigned char uint8_t;
 extern "C" {
 #endif
 
-OCRAPI_PORT paddle_ocr_t* OCR_CALL PaddleOcrCreate(
-    const char* det_model_dir, const char* rec_model_dir,
-    const char* char_list_file, const char* cls_model_dir);
+    OCRAPI_PORT paddle_ocr_t* OCR_CALL PaddleOcrCreate(
+        const char* det_model_dir, const char* rec_model_dir,
+        const char* char_list_file, const char* cls_model_dir);
 
-void OCRAPI PaddleOcrDestroy(paddle_ocr_t* ocr_ptr);
+    void OCRAPI PaddleOcrDestroy(paddle_ocr_t* ocr_ptr);
 
-OCR_ERROR OCRAPI PaddleOcrDet(
-    paddle_ocr_t* ocr_ptr, const uint8_t* encode_buf, size_t encode_buf_size,
-    int* out_boxes, size_t* out_boxes_size,
-    double* out_times, size_t* out_times_size);
+    OCR_ERROR OCRAPI PaddleOcrDet(
+        paddle_ocr_t* ocr_ptr, const uint8_t* encode_buf, size_t encode_buf_size,
+        int* out_boxes, size_t* out_boxes_size,
+        double* out_times, size_t* out_times_size);
 
-OCR_ERROR OCRAPI PaddleOcrRec(
-    paddle_ocr_t* ocr_ptr, const uint8_t* encode_buf, size_t encode_buf_size,
-    char** out_strs, float* out_scores, size_t* out_size,
-    double* out_times, size_t* out_times_size);
+    OCR_ERROR OCRAPI PaddleOcrDetWithData(
+        paddle_ocr_t* ocr_ptr, int rows, int cols, int type, void* data,
+        int* out_boxes, size_t* out_boxes_size,
+        double* out_times, size_t* out_times_size);
 
-OCR_ERROR OCRAPI PaddleOcrSystem(
-    paddle_ocr_t* ocr_ptr, const uint8_t* encode_buf, size_t encode_buf_size, bool with_cls,
-    int* out_boxes, char** out_strs, float* out_scores, size_t* out_size,
-    double* out_times, size_t* out_times_size);
+    OCR_ERROR OCRAPI PaddleOcrRec(
+        paddle_ocr_t* ocr_ptr, const uint8_t* encode_buf, size_t encode_buf_size,
+        char** out_strs, float* out_scores, size_t* out_size,
+        double* out_times, size_t* out_times_size);
+
+    OCR_ERROR OCRAPI PaddleOcrRecWithData(
+        paddle_ocr_t* ocr_ptr, int rows, int cols, int type, void* data,
+        char** out_strs, float* out_scores, size_t* out_size,
+        double* out_times, size_t* out_times_size);
+
+    OCR_ERROR OCRAPI PaddleOcrSystem(
+        paddle_ocr_t* ocr_ptr, const uint8_t* encode_buf, size_t encode_buf_size,
+        bool with_cls,
+        int* out_boxes, char** out_strs, float* out_scores, size_t* out_size,
+        double* out_times, size_t* out_times_size);
+
+    OCR_ERROR OCRAPI PaddleOcrSystemWithData(
+        paddle_ocr_t* ocr_ptr, int rows, int cols, int type, void* data,
+        bool with_cls,
+        int* out_boxes, char** out_strs, float* out_scores, size_t* out_size,
+        double* out_times, size_t* out_times_size);
 
 #ifdef __cplusplus
 }

3rdparty/include/cpp-base64/base64.hpp

@@ -0,0 +1,310 @@
+/*
+   base64.cpp and base64.h
+
+   base64 encoding and decoding with C++.
+   More information at
+     https://renenyffenegger.ch/notes/development/Base64/Encoding-and-decoding-base-64-with-cpp
+
+   Version: 2.rc.08 (release candidate)
+
+   Copyright (C) 2004-2017, 2020, 2021 René Nyffenegger
+
+   This source code is provided 'as-is', without any express or implied
+   warranty. In no event will the author be held liable for any damages
+   arising from the use of this software.
+
+   Permission is granted to anyone to use this software for any purpose,
+   including commercial applications, and to alter it and redistribute it
+   freely, subject to the following restrictions:
+
+   1. The origin of this source code must not be misrepresented; you must not
+      claim that you wrote the original source code. If you use this source code
+      in a product, an acknowledgment in the product documentation would be
+      appreciated but is not required.
+
+   2. Altered source versions must be plainly marked as such, and must not be
+      misrepresented as being the original source code.
+
+   3. This notice may not be removed or altered from any source distribution.
+
+   René Nyffenegger rene.nyffenegger@adp-gmbh.ch
+
+*/
+#ifndef BASE64_H_C0CE2A47_D10E_42C9_A27C_C883944E704A
+#define BASE64_H_C0CE2A47_D10E_42C9_A27C_C883944E704A
+
+#include <string>
+
+#if __cplusplus >= 201703L
+#include <string_view>
+#endif  // __cplusplus >= 201703L
+
+std::string base64_encode     (std::string const& s, bool url = false);
+std::string base64_encode_pem (std::string const& s);
+std::string base64_encode_mime(std::string const& s);
+
+std::string base64_decode(std::string const& s, bool remove_linebreaks = false);
+std::string base64_encode(unsigned char const*, size_t len, bool url = false);
+
+#if __cplusplus >= 201703L
+//
+// Interface with std::string_view rather than const std::string&
+// Requires C++17
+// Provided by Yannic Bonenberger (https://github.com/Yannic)
+//
+std::string base64_encode     (std::string_view s, bool url = false);
+std::string base64_encode_pem (std::string_view s);
+std::string base64_encode_mime(std::string_view s);
+
+std::string base64_decode(std::string_view s, bool remove_linebreaks = false);
+#endif  // __cplusplus >= 201703L
+
+#include <algorithm>
+#include <stdexcept>
+
+ //
+ // Depending on the url parameter in base64_chars, one of
+ // two sets of base64 characters needs to be chosen.
+ // They differ in their last two characters.
+ //
+static const char* base64_chars[2] = {
+             "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
+             "abcdefghijklmnopqrstuvwxyz"
+             "0123456789"
+             "+/",
+
+             "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
+             "abcdefghijklmnopqrstuvwxyz"
+             "0123456789"
+             "-_"};
+
+static unsigned int pos_of_char(const unsigned char chr) {
+ //
+ // Return the position of chr within base64_encode()
+ //
+
+    if      (chr >= 'A' && chr <= 'Z') return chr - 'A';
+    else if (chr >= 'a' && chr <= 'z') return chr - 'a' + ('Z' - 'A')               + 1;
+    else if (chr >= '0' && chr <= '9') return chr - '0' + ('Z' - 'A') + ('z' - 'a') + 2;
+    else if (chr == '+' || chr == '-') return 62; // Be liberal with input and accept both url ('-') and non-url ('+') base 64 characters (
+    else if (chr == '/' || chr == '_') return 63; // Ditto for '/' and '_'
+    else
+ //
+ // 2020-10-23: Throw std::exception rather than const char*
+ //(Pablo Martin-Gomez, https://github.com/Bouska)
+ //
+    throw std::runtime_error("Input is not valid base64-encoded data.");
+}
+
+static std::string insert_linebreaks(std::string str, size_t distance) {
+ //
+ // Provided by https://github.com/JomaCorpFX, adapted by me.
+ //
+    if (!str.length()) {
+        return "";
+    }
+
+    size_t pos = distance;
+
+    while (pos < str.size()) {
+        str.insert(pos, "\n");
+        pos += distance + 1;
+    }
+
+    return str;
+}
+
+template <typename String, unsigned int line_length>
+static std::string encode_with_line_breaks(String s) {
+  return insert_linebreaks(base64_encode(s, false), line_length);
+}
+
+template <typename String>
+static std::string encode_pem(String s) {
+  return encode_with_line_breaks<String, 64>(s);
+}
+
+template <typename String>
+static std::string encode_mime(String s) {
+  return encode_with_line_breaks<String, 76>(s);
+}
+
+template <typename String>
+static std::string encode(String s, bool url) {
+  return base64_encode(reinterpret_cast<const unsigned char*>(s.data()), s.length(), url);
+}
+
+std::string base64_encode(unsigned char const* bytes_to_encode, size_t in_len, bool url) {
+
+    size_t len_encoded = (in_len +2) / 3 * 4;
+
+    unsigned char trailing_char = url ? '.' : '=';
+
+ //
+ // Choose set of base64 characters. They differ
+ // for the last two positions, depending on the url
+ // parameter.
+ // A bool (as is the parameter url) is guaranteed
+ // to evaluate to either 0 or 1 in C++ therefore,
+ // the correct character set is chosen by subscripting
+ // base64_chars with url.
+ //
+    const char* base64_chars_ = base64_chars[url];
+
+    std::string ret;
+    ret.reserve(len_encoded);
+
+    unsigned int pos = 0;
+
+    while (pos < in_len) {
+        ret.push_back(base64_chars_[(bytes_to_encode[pos + 0] & 0xfc) >> 2]);
+
+        if (pos+1 < in_len) {
+           ret.push_back(base64_chars_[((bytes_to_encode[pos + 0] & 0x03) << 4) + ((bytes_to_encode[pos + 1] & 0xf0) >> 4)]);
+
+           if (pos+2 < in_len) {
+              ret.push_back(base64_chars_[((bytes_to_encode[pos + 1] & 0x0f) << 2) + ((bytes_to_encode[pos + 2] & 0xc0) >> 6)]);
+              ret.push_back(base64_chars_[  bytes_to_encode[pos + 2] & 0x3f]);
+           }
+           else {
+              ret.push_back(base64_chars_[(bytes_to_encode[pos + 1] & 0x0f) << 2]);
+              ret.push_back(trailing_char);
+           }
+        }
+        else {
+
+            ret.push_back(base64_chars_[(bytes_to_encode[pos + 0] & 0x03) << 4]);
+            ret.push_back(trailing_char);
+            ret.push_back(trailing_char);
+        }
+
+        pos += 3;
+    }
+
+
+    return ret;
+}
+
+template <typename String>
+static std::string decode(String encoded_string, bool remove_linebreaks) {
+ //
+ // decode(…) is templated so that it can be used with String = const std::string&
+ // or std::string_view (requires at least C++17)
+ //
+
+    if (encoded_string.empty()) return std::string();
+
+    if (remove_linebreaks) {
+
+       std::string copy(encoded_string);
+
+       copy.erase(std::remove(copy.begin(), copy.end(), '\n'), copy.end());
+
+       return base64_decode(copy, false);
+    }
+
+    size_t length_of_string = encoded_string.length();
+    size_t pos = 0;
+
+ //
+ // The approximate length (bytes) of the decoded string might be one or
+ // two bytes smaller, depending on the amount of trailing equal signs
+ // in the encoded string. This approximation is needed to reserve
+ // enough space in the string to be returned.
+ //
+    size_t approx_length_of_decoded_string = length_of_string / 4 * 3;
+    std::string ret;
+    ret.reserve(approx_length_of_decoded_string);
+
+    while (pos < length_of_string) {
+    //
+    // Iterate over encoded input string in chunks. The size of all
+    // chunks except the last one is 4 bytes.
+    //
+    // The last chunk might be padded with equal signs or dots
+    // in order to make it 4 bytes in size as well, but this
+    // is not required as per RFC 2045.
+    //
+    // All chunks except the last one produce three output bytes.
+    //
+    // The last chunk produces at least one and up to three bytes.
+    //
+
+       size_t pos_of_char_1 = pos_of_char(encoded_string[pos+1] );
+
+    //
+    // Emit the first output byte that is produced in each chunk:
+    //
+       ret.push_back(static_cast<std::string::value_type>( ( (pos_of_char(encoded_string[pos+0]) ) << 2 ) + ( (pos_of_char_1 & 0x30 ) >> 4)));
+
+       if ( ( pos + 2 < length_of_string  )       &&  // Check for data that is not padded with equal signs (which is allowed by RFC 2045)
+              encoded_string[pos+2] != '='        &&
+              encoded_string[pos+2] != '.'            // accept URL-safe base 64 strings, too, so check for '.' also.
+          )
+       {
+       //
+       // Emit a chunk's second byte (which might not be produced in the last chunk).
+       //
+          unsigned int pos_of_char_2 = pos_of_char(encoded_string[pos+2] );
+          ret.push_back(static_cast<std::string::value_type>( (( pos_of_char_1 & 0x0f) << 4) + (( pos_of_char_2 & 0x3c) >> 2)));
+
+          if ( ( pos + 3 < length_of_string )     &&
+                 encoded_string[pos+3] != '='     &&
+                 encoded_string[pos+3] != '.'
+             )
+          {
+          //
+          // Emit a chunk's third byte (which might not be produced in the last chunk).
+          //
+             ret.push_back(static_cast<std::string::value_type>( ( (pos_of_char_2 & 0x03 ) << 6 ) + pos_of_char(encoded_string[pos+3])   ));
+          }
+       }
+
+       pos += 4;
+    }
+
+    return ret;
+}
+
+std::string base64_decode(std::string const& s, bool remove_linebreaks) {
+   return decode(s, remove_linebreaks);
+}
+
+std::string base64_encode(std::string const& s, bool url) {
+   return encode(s, url);
+}
+
+std::string base64_encode_pem (std::string const& s) {
+   return encode_pem(s);
+}
+
+std::string base64_encode_mime(std::string const& s) {
+   return encode_mime(s);
+}
+
+#if __cplusplus >= 201703L
+//
+// Interface with std::string_view rather than const std::string&
+// Requires C++17
+// Provided by Yannic Bonenberger (https://github.com/Yannic)
+//
+
+std::string base64_encode(std::string_view s, bool url) {
+   return encode(s, url);
+}
+
+std::string base64_encode_pem(std::string_view s) {
+   return encode_pem(s);
+}
+
+std::string base64_encode_mime(std::string_view s) {
+   return encode_mime(s);
+}
+
+std::string base64_decode(std::string_view s, bool remove_linebreaks) {
+   return decode(s, remove_linebreaks);
+}
+
+#endif  // __cplusplus >= 201703L
+
+#endif /* BASE64_H_C0CE2A47_D10E_42C9_A27C_C883944E704A */

3rdparty/include/meojson/json.h

@@ -1,7 +0,0 @@
-#pragma once
-
-#include "json_parser.h"
-#include "json_value.h"
-#include "json_object.h"
-#include "json_array.h"
-#include "json_exception.h"

3rdparty/include/meojson/json_array.h

@@ -1,97 +0,0 @@
-#pragma once
-
-#include <string>
-#include <vector>
-#include <initializer_list>
-
-namespace json
-{
-    class value;
-
-    class array
-    {
-    public:
-        using raw_array = std::vector<value>;
-        using iterator = raw_array::iterator;
-        using const_iterator = raw_array::const_iterator;
-        using reverse_iterator = raw_array::reverse_iterator;
-        using const_reverse_iterator = raw_array::const_reverse_iterator;
-
-        array() = default;
-        array(const array& rhs) = default;
-        array(array&& rhs) noexcept = default;
-        array(const raw_array& arr);
-        array(raw_array&& arr) noexcept;
-        array(std::initializer_list<raw_array::value_type> init_list);
-        template<typename ArrayType>
-        array(ArrayType arr) {
-            static_assert(
-                std::is_constructible<json::value, typename ArrayType::value_type>::value,
-                "Parameter can't be used to construct a json::value");
-            for (auto&& ele : arr) {
-                _array_data.emplace_back(std::move(ele));
-            }
-        }
-
-        ~array() noexcept = default;
-
-        bool empty() const noexcept { return _array_data.empty(); }
-        size_t size() const noexcept { return _array_data.size(); }
-        bool exist(size_t pos) const { return _array_data.size() < pos; }
-        const value& at(size_t pos) const;
-        const std::string to_string() const;
-        const std::string format(std::string shift_str = "    ", size_t basic_shift_count = 0) const;
-
-        const bool get(size_t pos, bool default_value) const;
-        const int get(size_t pos, int default_value) const;
-        const long get(size_t pos, long default_value) const;
-        const unsigned long get(size_t pos, unsigned default_value) const;
-        const long long get(size_t pos, long long default_value) const;
-        const unsigned long long get(size_t pos, unsigned long long default_value) const;
-        const float get(size_t pos, float default_value) const;
-        const double get(size_t pos, double default_value) const;
-        const long double get(size_t pos, long double default_value) const;
-        const std::string get(size_t pos, std::string default_value) const;
-        const std::string get(size_t pos, const char* default_value) const;
-
-        template <typename... Args>
-        decltype(auto) emplace_back(Args &&... args)
-        {
-            static_assert(
-                std::is_constructible<raw_array::value_type, Args...>::value,
-                "Parameter can't be used to construct a raw_array::value_type");
-            return _array_data.emplace_back(std::forward<Args>(args)...);
-        }
-
-        void clear() noexcept;
-        // void earse(size_t pos);
-
-        iterator begin() noexcept;
-        iterator end() noexcept;
-        const_iterator begin() const noexcept;
-        const_iterator end() const noexcept;
-        const_iterator cbegin() const noexcept;
-        const_iterator cend() const noexcept;
-
-        reverse_iterator rbegin() noexcept;
-        reverse_iterator rend() noexcept;
-        const_reverse_iterator rbegin() const noexcept;
-        const_reverse_iterator rend() const noexcept;
-        const_reverse_iterator crbegin() const noexcept;
-        const_reverse_iterator crend() const noexcept;
-
-        const value& operator[](size_t pos) const;
-        value& operator[](size_t pos);
-
-        array& operator=(const array&) = default;
-        array& operator=(array&&) noexcept = default;
-
-        // const raw_array &raw_data() const;
-
-    private:
-        raw_array _array_data;
-    };
-
-    std::ostream& operator<<(std::ostream& out, const array& arr);
-
-} // namespace json

3rdparty/include/meojson/json_aux.h

@@ -1,97 +0,0 @@
-#pragma once
-
-#include <string>
-#include "json_value.h"
-
-namespace json
-{
-    static std::string unescape_string(std::string&& str)
-    {
-        std::string replace_str;
-        std::string escape_str = std::move(str);
-
-        for (size_t pos = 0; pos < escape_str.size(); ++pos)
-        {
-            switch (escape_str[pos]) {
-            case '\"':
-                replace_str = R"(\")";
-                break;
-            case '\\':
-                replace_str = R"(\\)";
-                break;
-            case '\b':
-                replace_str = R"(\b)";
-                break;
-            case '\f':
-                replace_str = R"(\f)";
-                break;
-            case '\n':
-                replace_str = R"(\n)";
-                break;
-            case '\r':
-                replace_str = R"(\r)";
-                break;
-            case '\t':
-                replace_str = R"(\t)";
-                break;
-            default:
-                continue;
-                break;
-            }
-            escape_str.replace(pos, 1, replace_str);
-            ++pos;
-        }
-        return escape_str;
-    }
-
-    static std::string unescape_string(const std::string& str)
-    {
-        return unescape_string(std::string(str));
-    }
-
-    static std::string escape_string(std::string&& str)
-    {
-        std::string escape_str = std::move(str);
-
-        for (size_t pos = 0; pos + 1 < escape_str.size(); ++pos)
-        {
-            if (escape_str[pos] != '\\') {
-                continue;
-            }
-            std::string replace_str;
-            switch (escape_str[pos + 1]) {
-            case '"':
-                replace_str = "\"";
-                break;
-            case '\\':
-                replace_str = "\\";
-                break;
-            case 'b':
-                replace_str = "\b";
-                break;
-            case 'f':
-                replace_str = "\f";
-                break;
-            case 'n':
-                replace_str = "\n";
-                break;
-            case 'r':
-                replace_str = "\r";
-                break;
-            case 't':
-                replace_str = "\t";
-                break;
-            default:
-                return std::string();
-                break;
-            }
-            escape_str.replace(pos, 2, replace_str);
-        }
-        return escape_str;
-    }
-
-    static std::string escape_string(const std::string& str)
-    {
-        return escape_string(std::string(str));
-    }
-}

3rdparty/include/meojson/json_exception.h

@@ -1,27 +0,0 @@
-#pragma once
-
-#include <exception>
-#include <string>
-
-namespace json
-{
-    class exception : public std::exception
-    {
-    public:
-        exception() = default;
-        exception(const std::string& msg);
-
-        exception(const exception&) = default;
-        exception& operator=(const exception&) = default;
-        exception(exception&&) = default;
-        exception& operator=(exception&&) = default;
-
-        virtual ~exception() noexcept override = default;
-
-        virtual const char* what() const noexcept override;
-
-    private:
-        std::string m_msg;
-    };
-
-} // namespace json

3rdparty/include/meojson/json_object.h

@@ -1,88 +0,0 @@
-#pragma once
-
-#include <string>
-#include <unordered_map>
-#include <initializer_list>
-
-#include "json_value.h"
-
-namespace json
-{
-	class object
-	{
-	public:
-		using raw_object = std::unordered_map<std::string, value>;
-		using iterator = raw_object::iterator;
-		using const_iterator = raw_object::const_iterator;
-
-		object() = default;
-		object(const object& rhs) = default;
-		object(object&& rhs) = default;
-		object(const raw_object& raw_obj);
-		object(raw_object&& raw_obj);
-		object(std::initializer_list<raw_object::value_type> init_list);
-		template<typename MapType>
-		object(MapType map) {
-			static_assert(
-				std::is_constructible<raw_object::value_type, typename MapType::value_type>::value,
-				"Parameter can't be used to construct a json::object::raw_object::value_type");
-			for (auto&& ele : map) {
-				_object_data.emplace(std::move(ele));
-			}
-		}
-		
-		~object() = default;
-
-		bool empty() const noexcept { return _object_data.empty(); }
-		size_t size() const noexcept { return _object_data.size(); }
-		bool exist(const std::string& key) const { return _object_data.find(key) != _object_data.cend(); }
-		const value& at(const std::string& key) const;
-		const std::string to_string() const;
-		const std::string format(std::string shift_str = "    ", size_t basic_shift_count = 0) const;
-
-		const bool get(const std::string& key, bool default_value) const;
-		const int get(const std::string& key, int default_value) const;
-		const long get(const std::string& key, long default_value) const;
-		const unsigned long get(const std::string& key, unsigned default_value) const;
-		const long long get(const std::string& key, long long default_value) const;
-		const unsigned long long get(const std::string& key, unsigned long long default_value) const;
-		const float get(const std::string& key, float default_value) const;
-		const double get(const std::string& key, double default_value) const;
-		const long double get(const std::string& key, long double default_value) const;
-		const std::string get(const std::string& key, std::string default_value) const;
-		const std::string get(const std::string& key, const char* default_value) const;
-
-		template <typename... Args>
-		decltype(auto) emplace(Args &&... args)
-		{
-			static_assert(
-				std::is_constructible<raw_object::value_type, Args...>::value,
-				"Parameter can't be used to construct a raw_object::value_type");
-			return _object_data.emplace(std::forward<Args>(args)...);
-		}
-
-		void clear() noexcept;
-		bool earse(const std::string& key);
-
-		iterator begin() noexcept;
-		iterator end() noexcept;
-		const_iterator begin() const noexcept;
-		const_iterator end() const noexcept;
-		const_iterator cbegin() const noexcept;
-		const_iterator cend() const noexcept;
-
-		value& operator[](const std::string& key);
-		value& operator[](std::string&& key);
-
-		object& operator=(const object&) = default;
-		object& operator=(object&&) = default;
-
-		// const raw_object &raw_data() const;
-
-	private:
-		raw_object _object_data;
-	};
-
-	std::ostream& operator<<(std::ostream& out, const json::object& obj);
-
-} // namespace json

3rdparty/include/meojson/json_parser.h

@@ -1,50 +0,0 @@
-#pragma once
-
-#include <string>
-#include <optional>
-
-namespace json
-{
-    class value;
-    class object;
-    class array;
-    enum class value_type : char;
-
-    class parser
-    {
-    public:
-        ~parser() noexcept = default;
-
-        static std::optional<value> parse(const std::string& content);
-
-    private:
-        parser(
-            const std::string::const_iterator& cbegin,
-            const std::string::const_iterator& cend) noexcept
-            : _cur(cbegin), _end(cend) {}
-
-        std::optional<value> parse();
-        value parse_value();
-
-        value parse_null();
-        value parse_boolean();
-        value parse_number();
-        // parse and return a json::value whose type is value_type::String
-        value parse_string();
-        value parse_array();
-        value parse_object();
-
-        // parse and return a std::string
-        std::optional<std::string> parse_stdstring();
-
-        bool skip_whitespace() noexcept;
-        bool skip_digit() noexcept;
-
-    private:
-        std::string::const_iterator _cur;
-        std::string::const_iterator _end;
-    };
-
-    std::optional<value> parse(const std::string& content);
-
-} // namespace json

3rdparty/include/meojson/json_value.h

@@ -1,160 +0,0 @@
-#pragma once
-
-#include <string>
-#include <ostream>
-// #include <iostream>
-#include <memory>
-
-namespace json
-{
-    enum class value_type : char
-    {
-        Invalid,
-        Null,
-        Boolean,
-        String,
-        Number,
-        Array,
-        Object,
-        NUM_T
-    };
-
-    class array;
-    class object;
-
-    class value
-    {
-        using unique_array = std::unique_ptr<array>;
-        using unique_object = std::unique_ptr<object>;
-
-    public:
-        value();
-        value(const value& rhs);
-        value(value&& rhs) noexcept;
-
-        value(bool b);
-
-        value(int num);
-        value(unsigned num);
-        value(long num);
-        value(unsigned long num);
-        value(long long num);
-        value(unsigned long long num);
-        value(float num);
-        value(double num);
-        value(long double num);
-
-        value(const char* str);
-        value(const std::string& str);
-        value(std::string&& str);
-
-        value(const array& arr);
-        value(array&& arr);
-        // value(std::initializer_list<value> init_list); // for array
-
-        value(const object& obj);
-        value(object&& obj);
-        // error: conversion from ‘<brace-enclosed initializer list>’ to ‘json::value’ is ambiguous
-        // value(std::initializer_list<std::pair<std::string, value>> init_list); // for object
-
-        // Constructed from raw data
-        template <typename... Args>
-        value(value_type type, Args &&...args)
-            : _type(type),
-            _raw_data(std::forward<Args>(args)...)
-        {
-            static_assert(
-                std::is_constructible<std::string, Args...>::value,
-                "Parameter can't be used to construct a std::string");
-        }
-
-        // Prohibit conversion of other types to value
-        template <typename T>
-        value(T) = delete;
-
-        ~value();
-
-        bool valid() const noexcept { return _type != value_type::Invalid ? true : false; }
-        bool empty() const noexcept { return (_type == value_type::Null && _raw_data.compare("null") == 0) ? true : false; }
-        bool is_null() const noexcept { return empty(); }
-        bool is_number() const noexcept { return _type == value_type::Number; }
-        bool is_boolean() const noexcept { return _type == value_type::Boolean; }
-        bool is_string() const noexcept { return _type == value_type::String; }
-        bool is_array() const noexcept { return _type == value_type::Array; }
-        bool is_object() const noexcept { return _type == value_type::Object; }
-        bool exist(const std::string& key) const;
-        bool exist(size_t pos) const;
-        value_type type() const noexcept { return _type; }
-        const value& at(size_t pos) const;
-        const value& at(const std::string& key) const;
-
-        template <typename Type>
-        decltype(auto) get(const std::string& key, Type default_value) const
-        {
-            return is_object() ? as_object().get(key, default_value) : default_value;
-        }
-        template <typename Type>
-        decltype(auto) get(size_t pos, Type default_value) const
-        {
-            return is_array() ? as_array().get(pos, default_value) : default_value;
-        }
-
-        const bool as_boolean() const;
-        const int as_integer() const;
-        // const unsigned as_unsigned() const;
-        const long as_long() const;
-        const unsigned long as_unsigned_long() const;
-        const long long as_long_long() const;
-        const unsigned long long as_unsigned_long_long() const;
-        const float as_float() const;
-        const double as_double() const;
-        const long double as_long_double() const;
-        const std::string as_string() const;
-        const array& as_array() const;
-        const object& as_object() const;
-
-        array& as_array();
-        object& as_object();
-
-        // return raw string
-        const std::string to_string() const;
-        const std::string format(std::string shift_str = "    ", size_t basic_shift_count = 0) const;
-
-        value& operator=(const value& rhs);
-        value& operator=(value&&) noexcept;
-
-        const value& operator[](size_t pos) const;
-        value& operator[](size_t pos);
-        value& operator[](const std::string& key);
-        value& operator[](std::string&& key);
-        //explicit operator bool() const noexcept { return valid(); }
-
-        explicit operator bool() const { return as_boolean(); }
-        explicit operator int() const { return as_integer(); }
-        explicit operator long() const { return as_long(); }
-        explicit operator unsigned long() const { return as_unsigned_long(); }
-        explicit operator long long() const { return as_long_long(); }
-        explicit operator unsigned long long() const { return as_unsigned_long_long(); }
-        explicit operator float() const { return as_float(); }
-        explicit operator double() const { return as_double(); }
-        explicit operator long double() const { return as_long_double(); }
-        explicit operator std::string() const { return as_string(); }
-
-    private:
-        template <typename T>
-        static std::unique_ptr<T> copy_unique_ptr(const std::unique_ptr<T>& t)
-        {
-            return t == nullptr ? nullptr : std::make_unique<T>(*t);
-        }
-
-        value_type _type = value_type::Null;
-        std::string _raw_data = "null"; // If the value_type is Object or Array, the _raw_data will be a empty string.
-        unique_array _array_ptr;
-        unique_object _object_ptr;
-    };
-
-    const value invalid_value();
-    std::ostream& operator<<(std::ostream& out, const value& val);
-    // std::istream &operator>>(std::istream &in, value &val);
-
-} // namespace json

3rdparty/include/penguin-stats-recognize/penguin_wasm.h

@@ -1,19 +0,0 @@
-#pragma once
-
-#include "port.h"
-
-typedef unsigned char      uint8_t;
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-    PENGUINAPI_PORT const char* PENGUIN_CALL get_info();
-    void PENGUINAPI load_server(const char* server);
-    void PENGUINAPI load_json(const char* stage_index, const char* hash_index);
-    void PENGUINAPI load_templ(const char* itemId, const uint8_t* buffer, size_t size);
-    PENGUINAPI_PORT const char* PENGUIN_CALL recognize(const uint8_t* buffer, size_t size);
-
-#ifdef __cplusplus
-}
-#endif

3rdparty/include/penguin-stats-recognize/port.h

@@ -1,37 +0,0 @@
-#pragma once
-
-// The way how the function is called
-#if !defined(PENGUIN_CALL)
-#if defined(_WIN32)
-#define PENGUIN_CALL __stdcall
-#else
-#define PENGUIN_CALL
-#endif /* _WIN32 */
-#endif /* PENGUIN_CALL */
-
-// The function exported symbols
-#if defined _WIN32 || defined __CYGWIN__
-#define PENGUIN_DLL_IMPORT __declspec(dllimport)
-#define PENGUIN_DLL_EXPORT __declspec(dllexport)
-#define PENGUIN_DLL_LOCAL
-#else
-#if __GNUC__ >= 4
-#define PENGUIN_DLL_IMPORT __attribute__ ((visibility ("default")))
-#define PENGUIN_DLL_EXPORT __attribute__ ((visibility ("default")))
-#define PENGUIN_DLL_LOCAL  __attribute__ ((visibility ("hidden")))
-#else
-#define PENGUIN_DLL_IMPORT
-#define PENGUIN_DLL_EXPORT
-#define PENGUIN_DLL_LOCAL
-#endif
-#endif
-
-#ifdef PENGUIN_DLL_EXPORTS // defined if we are building the DLL (instead of using it)
-#define PENGUINAPI_PORT PENGUIN_DLL_EXPORT
-#else
-#define PENGUINAPI_PORT PENGUIN_DLL_IMPORT
-#endif // PENGUIN_DLL_EXPORTS
-
-#define PENGUINAPI PENGUINAPI_PORT PENGUIN_CALL
-
-#define PENGUINLOCAL PENGUIN_DLL_LOCAL PENGUIN_CALL

3rdparty/include/zlib/config.hpp

@@ -0,0 +1,5 @@
+#pragma once
+
+#ifndef ZLIB_CONST
+#define ZLIB_CONST
+#endif

3rdparty/include/zlib/decompress.hpp

@@ -0,0 +1,99 @@
+#include "config.hpp"
+
+// std
+#include <limits>
+#include <stdexcept>
+#include <string>
+
+namespace gzip
+{
+    // zlib
+#include "zlib.h"
+
+    class Decompressor
+    {
+        std::size_t max_;
+
+    public:
+        Decompressor(std::size_t max_bytes = 1000000000) // by default refuse operation if compressed data is > 1GB
+            : max_(max_bytes)
+        {}
+
+        template <typename OutputType>
+        void decompress(OutputType& output,
+                        const uchar* data,
+                        std::size_t size) const
+        {
+            z_stream inflate_s;
+
+            inflate_s.zalloc = Z_NULL;
+            inflate_s.zfree = Z_NULL;
+            inflate_s.opaque = Z_NULL;
+            inflate_s.avail_in = 0;
+            inflate_s.next_in = Z_NULL;
+
+            // The windowBits parameter is the base two logarithm of the window size (the size of the history buffer).
+            // It should be in the range 8..15 for this version of the library.
+            // Larger values of this parameter result in better compression at the expense of memory usage.
+            // This range of values also changes the decoding type:
+            //  -8 to -15 for raw deflate
+            //  8 to 15 for zlib
+            // (8 to 15) + 16 for gzip
+            // (8 to 15) + 32 to automatically detect gzip/zlib header
+            constexpr int window_bits = 15 + 32; // auto with windowbits of 15
+
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wold-style-cast"
+            if (inflateInit2(&inflate_s, window_bits) != Z_OK) {
+                throw std::runtime_error("inflate init failed");
+            }
+#pragma GCC diagnostic pop
+            inflate_s.next_in = reinterpret_cast<z_const Bytef*>(data);
+
+#ifdef DEBUG
+            // Verify if size (long type) input will fit into unsigned int, type used for zlib's avail_in
+            std::uint64_t size_64 = size * 2;
+            if (size_64 > std::numeric_limits<unsigned int>::max()) {
+                inflateEnd(&inflate_s);
+                throw std::runtime_error("size arg is too large to fit into unsigned int type x2");
+            }
+#endif
+            if (size > max_ || (size * 2) > max_) {
+                inflateEnd(&inflate_s);
+                throw std::runtime_error("size may use more memory than intended when decompressing");
+            }
+            inflate_s.avail_in = static_cast<unsigned int>(size);
+            std::size_t size_uncompressed = 0;
+            do {
+                std::size_t resize_to = size_uncompressed + 2 * size;
+                if (resize_to > max_) {
+                    inflateEnd(&inflate_s);
+                    throw std::runtime_error("size of output string will use more memory then intended when decompressing");
+                }
+                output.resize(resize_to);
+                inflate_s.avail_out = static_cast<unsigned int>(2 * size);
+                inflate_s.next_out = reinterpret_cast<Bytef*>(&output[0] + size_uncompressed);
+                int ret = inflate(&inflate_s, Z_FINISH);
+                if (ret != Z_STREAM_END && ret != Z_OK && ret != Z_BUF_ERROR) {
+                    std::string error_msg = inflate_s.msg;
+                    inflateEnd(&inflate_s);
+                    //throw std::runtime_error(error_msg);
+                    output.clear();
+                    return;
+                }
+
+                size_uncompressed += (2 * size - inflate_s.avail_out);
+            } while (inflate_s.avail_out == 0);
+            inflateEnd(&inflate_s);
+            output.resize(size_uncompressed);
+        }
+    };
+
+    inline std::vector<uchar> decompress(const uchar* data, std::size_t size)
+    {
+        Decompressor decomp;
+        std::vector<uchar> output;
+        decomp.decompress(output, data, size);
+        return output;
+    }
+} // namespace gzip

3rdparty/include/zlib/zconf.h

@@ -0,0 +1,536 @@
+/* zconf.h -- configuration of the zlib compression library
+ * Copyright (C) 1995-2016 Jean-loup Gailly, Mark Adler
+ * For conditions of distribution and use, see copyright notice in zlib.h
+ */
+
+/* @(#) $Id$ */
+
+#ifndef ZCONF_H
+#define ZCONF_H
+/* #undef Z_PREFIX */
+/* #undef Z_HAVE_UNISTD_H */
+
+/*
+ * If you *really* need a unique prefix for all types and library functions,
+ * compile with -DZ_PREFIX. The "standard" zlib should be compiled without it.
+ * Even better than compiling with -DZ_PREFIX would be to use configure to set
+ * this permanently in zconf.h using "./configure --zprefix".
+ */
+#ifdef Z_PREFIX     /* may be set to #if 1 by ./configure */
+#  define Z_PREFIX_SET
+
+/* all linked symbols and init macros */
+#  define _dist_code            z__dist_code
+#  define _length_code          z__length_code
+#  define _tr_align             z__tr_align
+#  define _tr_flush_bits        z__tr_flush_bits
+#  define _tr_flush_block       z__tr_flush_block
+#  define _tr_init              z__tr_init
+#  define _tr_stored_block      z__tr_stored_block
+#  define _tr_tally             z__tr_tally
+#  define adler32               z_adler32
+#  define adler32_combine       z_adler32_combine
+#  define adler32_combine64     z_adler32_combine64
+#  define adler32_z             z_adler32_z
+#  ifndef Z_SOLO
+#    define compress              z_compress
+#    define compress2             z_compress2
+#    define compressBound         z_compressBound
+#  endif
+#  define crc32                 z_crc32
+#  define crc32_combine         z_crc32_combine
+#  define crc32_combine64       z_crc32_combine64
+#  define crc32_z               z_crc32_z
+#  define deflate               z_deflate
+#  define deflateBound          z_deflateBound
+#  define deflateCopy           z_deflateCopy
+#  define deflateEnd            z_deflateEnd
+#  define deflateGetDictionary  z_deflateGetDictionary
+#  define deflateInit           z_deflateInit
+#  define deflateInit2          z_deflateInit2
+#  define deflateInit2_         z_deflateInit2_
+#  define deflateInit_          z_deflateInit_
+#  define deflateParams         z_deflateParams
+#  define deflatePending        z_deflatePending
+#  define deflatePrime          z_deflatePrime
+#  define deflateReset          z_deflateReset
+#  define deflateResetKeep      z_deflateResetKeep
+#  define deflateSetDictionary  z_deflateSetDictionary
+#  define deflateSetHeader      z_deflateSetHeader
+#  define deflateTune           z_deflateTune
+#  define deflate_copyright     z_deflate_copyright
+#  define get_crc_table         z_get_crc_table
+#  ifndef Z_SOLO
+#    define gz_error              z_gz_error
+#    define gz_intmax             z_gz_intmax
+#    define gz_strwinerror        z_gz_strwinerror
+#    define gzbuffer              z_gzbuffer
+#    define gzclearerr            z_gzclearerr
+#    define gzclose               z_gzclose
+#    define gzclose_r             z_gzclose_r
+#    define gzclose_w             z_gzclose_w
+#    define gzdirect              z_gzdirect
+#    define gzdopen               z_gzdopen
+#    define gzeof                 z_gzeof
+#    define gzerror               z_gzerror
+#    define gzflush               z_gzflush
+#    define gzfread               z_gzfread
+#    define gzfwrite              z_gzfwrite
+#    define gzgetc                z_gzgetc
+#    define gzgetc_               z_gzgetc_
+#    define gzgets                z_gzgets
+#    define gzoffset              z_gzoffset
+#    define gzoffset64            z_gzoffset64
+#    define gzopen                z_gzopen
+#    define gzopen64              z_gzopen64
+#    ifdef _WIN32
+#      define gzopen_w              z_gzopen_w
+#    endif
+#    define gzprintf              z_gzprintf
+#    define gzputc                z_gzputc
+#    define gzputs                z_gzputs
+#    define gzread                z_gzread
+#    define gzrewind              z_gzrewind
+#    define gzseek                z_gzseek
+#    define gzseek64              z_gzseek64
+#    define gzsetparams           z_gzsetparams
+#    define gztell                z_gztell
+#    define gztell64              z_gztell64
+#    define gzungetc              z_gzungetc
+#    define gzvprintf             z_gzvprintf
+#    define gzwrite               z_gzwrite
+#  endif
+#  define inflate               z_inflate
+#  define inflateBack           z_inflateBack
+#  define inflateBackEnd        z_inflateBackEnd
+#  define inflateBackInit       z_inflateBackInit
+#  define inflateBackInit_      z_inflateBackInit_
+#  define inflateCodesUsed      z_inflateCodesUsed
+#  define inflateCopy           z_inflateCopy
+#  define inflateEnd            z_inflateEnd
+#  define inflateGetDictionary  z_inflateGetDictionary
+#  define inflateGetHeader      z_inflateGetHeader
+#  define inflateInit           z_inflateInit
+#  define inflateInit2          z_inflateInit2
+#  define inflateInit2_         z_inflateInit2_
+#  define inflateInit_          z_inflateInit_
+#  define inflateMark           z_inflateMark
+#  define inflatePrime          z_inflatePrime
+#  define inflateReset          z_inflateReset
+#  define inflateReset2         z_inflateReset2
+#  define inflateResetKeep      z_inflateResetKeep
+#  define inflateSetDictionary  z_inflateSetDictionary
+#  define inflateSync           z_inflateSync
+#  define inflateSyncPoint      z_inflateSyncPoint
+#  define inflateUndermine      z_inflateUndermine
+#  define inflateValidate       z_inflateValidate
+#  define inflate_copyright     z_inflate_copyright
+#  define inflate_fast          z_inflate_fast
+#  define inflate_table         z_inflate_table
+#  ifndef Z_SOLO
+#    define uncompress            z_uncompress
+#    define uncompress2           z_uncompress2
+#  endif
+#  define zError                z_zError
+#  ifndef Z_SOLO
+#    define zcalloc               z_zcalloc
+#    define zcfree                z_zcfree
+#  endif
+#  define zlibCompileFlags      z_zlibCompileFlags
+#  define zlibVersion           z_zlibVersion
+
+/* all zlib typedefs in zlib.h and zconf.h */
+#  define Byte                  z_Byte
+#  define Bytef                 z_Bytef
+#  define alloc_func            z_alloc_func
+#  define charf                 z_charf
+#  define free_func             z_free_func
+#  ifndef Z_SOLO
+#    define gzFile                z_gzFile
+#  endif
+#  define gz_header             z_gz_header
+#  define gz_headerp            z_gz_headerp
+#  define in_func               z_in_func
+#  define intf                  z_intf
+#  define out_func              z_out_func
+#  define uInt                  z_uInt
+#  define uIntf                 z_uIntf
+#  define uLong                 z_uLong
+#  define uLongf                z_uLongf
+#  define voidp                 z_voidp
+#  define voidpc                z_voidpc
+#  define voidpf                z_voidpf
+
+/* all zlib structs in zlib.h and zconf.h */
+#  define gz_header_s           z_gz_header_s
+#  define internal_state        z_internal_state
+
+#endif
+
+#if defined(__MSDOS__) && !defined(MSDOS)
+#  define MSDOS
+#endif
+#if (defined(OS_2) || defined(__OS2__)) && !defined(OS2)
+#  define OS2
+#endif
+#if defined(_WINDOWS) && !defined(WINDOWS)
+#  define WINDOWS
+#endif
+#if defined(_WIN32) || defined(_WIN32_WCE) || defined(__WIN32__)
+#  ifndef WIN32
+#    define WIN32
+#  endif
+#endif
+#if (defined(MSDOS) || defined(OS2) || defined(WINDOWS)) && !defined(WIN32)
+#  if !defined(__GNUC__) && !defined(__FLAT__) && !defined(__386__)
+#    ifndef SYS16BIT
+#      define SYS16BIT
+#    endif
+#  endif
+#endif
+
+/*
+ * Compile with -DMAXSEG_64K if the alloc function cannot allocate more
+ * than 64k bytes at a time (needed on systems with 16-bit int).
+ */
+#ifdef SYS16BIT
+#  define MAXSEG_64K
+#endif
+#ifdef MSDOS
+#  define UNALIGNED_OK
+#endif
+
+#ifdef __STDC_VERSION__
+#  ifndef STDC
+#    define STDC
+#  endif
+#  if __STDC_VERSION__ >= 199901L
+#    ifndef STDC99
+#      define STDC99
+#    endif
+#  endif
+#endif
+#if !defined(STDC) && (defined(__STDC__) || defined(__cplusplus))
+#  define STDC
+#endif
+#if !defined(STDC) && (defined(__GNUC__) || defined(__BORLANDC__))
+#  define STDC
+#endif
+#if !defined(STDC) && (defined(MSDOS) || defined(WINDOWS) || defined(WIN32))
+#  define STDC
+#endif
+#if !defined(STDC) && (defined(OS2) || defined(__HOS_AIX__))
+#  define STDC
+#endif
+
+#if defined(__OS400__) && !defined(STDC)    /* iSeries (formerly AS/400). */
+#  define STDC
+#endif
+
+#ifndef STDC
+#  ifndef const /* cannot use !defined(STDC) && !defined(const) on Mac */
+#    define const       /* note: need a more gentle solution here */
+#  endif
+#endif
+
+#if defined(ZLIB_CONST) && !defined(z_const)
+#  define z_const const
+#else
+#  define z_const
+#endif
+
+#ifdef Z_SOLO
+   typedef unsigned long z_size_t;
+#else
+#  define z_longlong long long
+#  if defined(NO_SIZE_T)
+     typedef unsigned NO_SIZE_T z_size_t;
+#  elif defined(STDC)
+#    include <stddef.h>
+     typedef size_t z_size_t;
+#  else
+     typedef unsigned long z_size_t;
+#  endif
+#  undef z_longlong
+#endif
+
+/* Maximum value for memLevel in deflateInit2 */
+#ifndef MAX_MEM_LEVEL
+#  ifdef MAXSEG_64K
+#    define MAX_MEM_LEVEL 8
+#  else
+#    define MAX_MEM_LEVEL 9
+#  endif
+#endif
+
+/* Maximum value for windowBits in deflateInit2 and inflateInit2.
+ * WARNING: reducing MAX_WBITS makes minigzip unable to extract .gz files
+ * created by gzip. (Files created by minigzip can still be extracted by
+ * gzip.)
+ */
+#ifndef MAX_WBITS
+#  define MAX_WBITS   15 /* 32K LZ77 window */
+#endif
+
+/* The memory requirements for deflate are (in bytes):
+            (1 << (windowBits+2)) +  (1 << (memLevel+9))
+ that is: 128K for windowBits=15  +  128K for memLevel = 8  (default values)
+ plus a few kilobytes for small objects. For example, if you want to reduce
+ the default memory requirements from 256K to 128K, compile with
+     make CFLAGS="-O -DMAX_WBITS=14 -DMAX_MEM_LEVEL=7"
+ Of course this will generally degrade compression (there's no free lunch).
+
+   The memory requirements for inflate are (in bytes) 1 << windowBits
+ that is, 32K for windowBits=15 (default value) plus about 7 kilobytes
+ for small objects.
+*/
+
+                        /* Type declarations */
+
+#ifndef OF /* function prototypes */
+#  ifdef STDC
+#    define OF(args)  args
+#  else
+#    define OF(args)  ()
+#  endif
+#endif
+
+#ifndef Z_ARG /* function prototypes for stdarg */
+#  if defined(STDC) || defined(Z_HAVE_STDARG_H)
+#    define Z_ARG(args)  args
+#  else
+#    define Z_ARG(args)  ()
+#  endif
+#endif
+
+/* The following definitions for FAR are needed only for MSDOS mixed
+ * model programming (small or medium model with some far allocations).
+ * This was tested only with MSC; for other MSDOS compilers you may have
+ * to define NO_MEMCPY in zutil.h.  If you don't need the mixed model,
+ * just define FAR to be empty.
+ */
+#ifdef SYS16BIT
+#  if defined(M_I86SM) || defined(M_I86MM)
+     /* MSC small or medium model */
+#    define SMALL_MEDIUM
+#    ifdef _MSC_VER
+#      define FAR _far
+#    else
+#      define FAR far
+#    endif
+#  endif
+#  if (defined(__SMALL__) || defined(__MEDIUM__))
+     /* Turbo C small or medium model */
+#    define SMALL_MEDIUM
+#    ifdef __BORLANDC__
+#      define FAR _far
+#    else
+#      define FAR far
+#    endif
+#  endif
+#endif
+
+#if defined(WINDOWS) || defined(WIN32)
+   /* If building or using zlib as a DLL, define ZLIB_DLL.
+    * This is not mandatory, but it offers a little performance increase.
+    */
+#  ifdef ZLIB_DLL
+#    if defined(WIN32) && (!defined(__BORLANDC__) || (__BORLANDC__ >= 0x500))
+#      ifdef ZLIB_INTERNAL
+#        define ZEXTERN extern __declspec(dllexport)
+#      else
+#        define ZEXTERN extern __declspec(dllimport)
+#      endif
+#    endif
+#  endif  /* ZLIB_DLL */
+   /* If building or using zlib with the WINAPI/WINAPIV calling convention,
+    * define ZLIB_WINAPI.
+    * Caution: the standard ZLIB1.DLL is NOT compiled using ZLIB_WINAPI.
+    */
+#  ifdef ZLIB_WINAPI
+#    ifdef FAR
+#      undef FAR
+#    endif
+#    include <windows.h>
+     /* No need for _export, use ZLIB.DEF instead. */
+     /* For complete Windows compatibility, use WINAPI, not __stdcall. */
+#    define ZEXPORT WINAPI
+#    ifdef WIN32
+#      define ZEXPORTVA WINAPIV
+#    else
+#      define ZEXPORTVA FAR CDECL
+#    endif
+#  endif
+#endif
+
+#if defined (__BEOS__)
+#  ifdef ZLIB_DLL
+#    ifdef ZLIB_INTERNAL
+#      define ZEXPORT   __declspec(dllexport)
+#      define ZEXPORTVA __declspec(dllexport)
+#    else
+#      define ZEXPORT   __declspec(dllimport)
+#      define ZEXPORTVA __declspec(dllimport)
+#    endif
+#  endif
+#endif
+
+#ifndef ZEXTERN
+#  define ZEXTERN extern
+#endif
+#ifndef ZEXPORT
+#  define ZEXPORT
+#endif
+#ifndef ZEXPORTVA
+#  define ZEXPORTVA
+#endif
+
+#ifndef FAR
+#  define FAR
+#endif
+
+#if !defined(__MACTYPES__)
+typedef unsigned char  Byte;  /* 8 bits */
+#endif
+typedef unsigned int   uInt;  /* 16 bits or more */
+typedef unsigned long  uLong; /* 32 bits or more */
+
+#ifdef SMALL_MEDIUM
+   /* Borland C/C++ and some old MSC versions ignore FAR inside typedef */
+#  define Bytef Byte FAR
+#else
+   typedef Byte  FAR Bytef;
+#endif
+typedef char  FAR charf;
+typedef int   FAR intf;
+typedef uInt  FAR uIntf;
+typedef uLong FAR uLongf;
+
+#ifdef STDC
+   typedef void const *voidpc;
+   typedef void FAR   *voidpf;
+   typedef void       *voidp;
+#else
+   typedef Byte const *voidpc;
+   typedef Byte FAR   *voidpf;
+   typedef Byte       *voidp;
+#endif
+
+#if !defined(Z_U4) && !defined(Z_SOLO) && defined(STDC)
+#  include <limits.h>
+#  if (UINT_MAX == 0xffffffffUL)
+#    define Z_U4 unsigned
+#  elif (ULONG_MAX == 0xffffffffUL)
+#    define Z_U4 unsigned long
+#  elif (USHRT_MAX == 0xffffffffUL)
+#    define Z_U4 unsigned short
+#  endif
+#endif
+
+#ifdef Z_U4
+   typedef Z_U4 z_crc_t;
+#else
+   typedef unsigned long z_crc_t;
+#endif
+
+#ifdef HAVE_UNISTD_H    /* may be set to #if 1 by ./configure */
+#  define Z_HAVE_UNISTD_H
+#endif
+
+#ifdef HAVE_STDARG_H    /* may be set to #if 1 by ./configure */
+#  define Z_HAVE_STDARG_H
+#endif
+
+#ifdef STDC
+#  ifndef Z_SOLO
+#    include <sys/types.h>      /* for off_t */
+#  endif
+#endif
+
+#if defined(STDC) || defined(Z_HAVE_STDARG_H)
+#  ifndef Z_SOLO
+#    include <stdarg.h>         /* for va_list */
+#  endif
+#endif
+
+#ifdef _WIN32
+#  ifndef Z_SOLO
+#    include <stddef.h>         /* for wchar_t */
+#  endif
+#endif
+
+/* a little trick to accommodate both "#define _LARGEFILE64_SOURCE" and
+ * "#define _LARGEFILE64_SOURCE 1" as requesting 64-bit operations, (even
+ * though the former does not conform to the LFS document), but considering
+ * both "#undef _LARGEFILE64_SOURCE" and "#define _LARGEFILE64_SOURCE 0" as
+ * equivalently requesting no 64-bit operations
+ */
+#if defined(_LARGEFILE64_SOURCE) && -_LARGEFILE64_SOURCE - -1 == 1
+#  undef _LARGEFILE64_SOURCE
+#endif
+
+#if defined(__WATCOMC__) && !defined(Z_HAVE_UNISTD_H)
+#  define Z_HAVE_UNISTD_H
+#endif
+#ifndef Z_SOLO
+#  if defined(Z_HAVE_UNISTD_H) || defined(_LARGEFILE64_SOURCE)
+#    include <unistd.h>         /* for SEEK_*, off_t, and _LFS64_LARGEFILE */
+#    ifdef VMS
+#      include <unixio.h>       /* for off_t */
+#    endif
+#    ifndef z_off_t
+#      define z_off_t off_t
+#    endif
+#  endif
+#endif
+
+#if defined(_LFS64_LARGEFILE) && _LFS64_LARGEFILE-0
+#  define Z_LFS64
+#endif
+
+#if defined(_LARGEFILE64_SOURCE) && defined(Z_LFS64)
+#  define Z_LARGE64
+#endif
+
+#if defined(_FILE_OFFSET_BITS) && _FILE_OFFSET_BITS-0 == 64 && defined(Z_LFS64)
+#  define Z_WANT64
+#endif
+
+#if !defined(SEEK_SET) && !defined(Z_SOLO)
+#  define SEEK_SET        0       /* Seek from beginning of file.  */
+#  define SEEK_CUR        1       /* Seek from current position.  */
+#  define SEEK_END        2       /* Set file pointer to EOF plus "offset" */
+#endif
+
+#ifndef z_off_t
+#  define z_off_t long
+#endif
+
+#if !defined(_WIN32) && defined(Z_LARGE64)
+#  define z_off64_t off64_t
+#else
+#  if defined(_WIN32) && !defined(__GNUC__) && !defined(Z_SOLO)
+#    define z_off64_t __int64
+#  else
+#    define z_off64_t z_off_t
+#  endif
+#endif
+
+/* MVS linker does not support external names larger than 8 bytes */
+#if defined(__MVS__)
+  #pragma map(deflateInit_,"DEIN")
+  #pragma map(deflateInit2_,"DEIN2")
+  #pragma map(deflateEnd,"DEEND")
+  #pragma map(deflateBound,"DEBND")
+  #pragma map(inflateInit_,"ININ")
+  #pragma map(inflateInit2_,"ININ2")
+  #pragma map(inflateEnd,"INEND")
+  #pragma map(inflateSync,"INSY")
+  #pragma map(inflateSetDictionary,"INSEDI")
+  #pragma map(compressBound,"CMBND")
+  #pragma map(inflate_table,"INTABL")
+  #pragma map(inflate_fast,"INFA")
+  #pragma map(inflate_copyright,"INCOPY")
+#endif
+
+#endif /* ZCONF_H */

3rdparty/resource/PaddleOCR/det/version.txt

@@ -0,0 +1 @@
+ch_PP-OCRv2_det_infer

3rdparty/resource/PaddleOCR/rec/version.txt

@@ -0,0 +1 @@
+ch_ppocr_mobile_v2.0_rec_slim_infer