react-native-nitro-zxing 0.1.0-alpha.0

package/cpp/zxing-core/core/src/HybridBinarizer.cpp

@@ -0,0 +1,315 @@
+/*
+* Copyright 2016 Nu-book Inc.
+* Copyright 2016 ZXing authors
+*/
+// SPDX-License-Identifier: Apache-2.0
+
+#include "HybridBinarizer.h"
+
+#include "BitMatrix.h"
+#include "Matrix.h"
+
+#include <algorithm>
+#include <cstdint>
+#include <fstream>
+#include <memory>
+
+#define USE_NEW_ALGORITHM
+
+namespace ZXing {
+
+// This class uses 5x5 blocks to compute local luminance, where each block is 8x8 pixels.
+// So this is the smallest dimension in each axis we can accept.
+static constexpr int BLOCK_SIZE = 8;
+static constexpr int WINDOW_SIZE = BLOCK_SIZE * (1 + 2 * 2);
+static constexpr int MIN_DYNAMIC_RANGE = 24;
+
+HybridBinarizer::HybridBinarizer(const ImageView& iv) : GlobalHistogramBinarizer(iv) {}
+
+HybridBinarizer::~HybridBinarizer() = default;
+
+bool HybridBinarizer::getPatternRow(int row, int rotation, PatternRow& res) const
+{
+#if 1
+	// This is the original "hybrid" behavior: use GlobalHistogram for the 1D case
+	return GlobalHistogramBinarizer::getPatternRow(row, rotation, res);
+#else
+	// This is an alternative that can be faster in general and perform better in unevenly lit situations like
+	// https://github.com/zxing-cpp/zxing-cpp/blob/master/test/samples/ean13-2/21.png. That said, it fairs
+	// worse in borderline low resolution situations. With the current black box sample set we'd loose 94
+	// test cases while gaining 53 others.
+	auto bits = getBitMatrix();
+	if (bits)
+		GetPatternRow(*bits, row, res, rotation % 180 != 0);
+	return bits != nullptr;
+#endif
+}
+
+using T_t = uint8_t;
+
+/**
+* Applies a single threshold to a block of pixels.
+*/
+static void ThresholdBlock(const uint8_t* __restrict luminances, int xoffset, int yoffset, T_t threshold, int rowStride,
+						   BitMatrix& matrix)
+{
+	for (int y = yoffset; y < yoffset + BLOCK_SIZE; ++y) {
+		auto* src = luminances + y * rowStride + xoffset;
+		auto* const dstBegin = matrix.row(y).begin() + xoffset;
+		// TODO: fix pixelStride > 1 case
+		for (auto* dst = dstBegin; dst < dstBegin + BLOCK_SIZE; ++dst, ++src)
+			*dst = (*src <= threshold) * BitMatrix::SET_V;
+	}
+}
+
+#ifndef USE_NEW_ALGORITHM
+
+/**
+* Calculates a single black point for each block of pixels and saves it away.
+* See the following thread for a discussion of this algorithm:
+*  http://groups.google.com/group/zxing/browse_thread/thread/d06efa2c35a7ddc0
+*/
+static Matrix<T_t> CalculateBlackPoints(const uint8_t* __restrict luminances, int subWidth, int subHeight, int width, int height,
+										int rowStride)
+{
+	Matrix<T_t> blackPoints(subWidth, subHeight);
+
+	for (int y = 0; y < subHeight; y++) {
+		int yoffset = std::min(y * BLOCK_SIZE, height - BLOCK_SIZE);
+		for (int x = 0; x < subWidth; x++) {
+			int xoffset = std::min(x * BLOCK_SIZE, width - BLOCK_SIZE);
+			int sum = 0;
+			uint8_t min = luminances[yoffset * rowStride + xoffset];
+			uint8_t max = min;
+			for (int yy = 0, offset = yoffset * rowStride + xoffset; yy < BLOCK_SIZE; yy++, offset += rowStride) {
+				for (int xx = 0; xx < BLOCK_SIZE; xx++) {
+					auto pixel = luminances[offset + xx];
+					sum += pixel;
+					if (pixel < min)
+						min = pixel;
+					if (pixel > max)
+						max = pixel;
+				}
+				// short-circuit min/max tests once dynamic range is met
+				if (max - min > MIN_DYNAMIC_RANGE) {
+					// finish the rest of the rows quickly
+					for (yy++, offset += rowStride; yy < BLOCK_SIZE; yy++, offset += rowStride) {
+						for (int xx = 0; xx < BLOCK_SIZE; xx++) {
+							sum += luminances[offset + xx];
+						}
+					}
+				}
+			}
+
+			// The default estimate is the average of the values in the block.
+			int average = sum / (BLOCK_SIZE * BLOCK_SIZE);
+			if (max - min <= MIN_DYNAMIC_RANGE) {
+				// If variation within the block is low, assume this is a block with only light or only
+				// dark pixels. In that case we do not want to use the average, as it would divide this
+				// low contrast area into black and white pixels, essentially creating data out of noise.
+				//
+				// The default assumption is that the block is light/background. Since no estimate for
+				// the level of dark pixels exists locally, use half the min for the block.
+				average = min / 2;
+
+				if (y > 0 && x > 0) {
+					// Correct the "white background" assumption for blocks that have neighbors by comparing
+					// the pixels in this block to the previously calculated black points. This is based on
+					// the fact that dark barcode symbology is always surrounded by some amount of light
+					// background for which reasonable black point estimates were made. The bp estimated at
+					// the boundaries is used for the interior.
+
+					// The (min < bp) is arbitrary but works better than other heuristics that were tried.
+					int averageNeighborBlackPoint =
+						(blackPoints(x, y - 1) + (2 * blackPoints(x - 1, y)) + blackPoints(x - 1, y - 1)) / 4;
+					if (min < averageNeighborBlackPoint) {
+						average = averageNeighborBlackPoint;
+					}
+				}
+			}
+			blackPoints(x, y) = average;
+		}
+	}
+	return blackPoints;
+}
+
+/**
+* For each block in the image, calculate the average black point using a 5x5 grid
+* of the blocks around it. Also handles the corner cases (fractional blocks are computed based
+* on the last pixels in the row/column which are also used in the previous block).
+*/
+static std::shared_ptr<BitMatrix> CalculateMatrix(const uint8_t* __restrict luminances, int subWidth, int subHeight, int width,
+												  int height, int rowStride, const Matrix<T_t>& blackPoints)
+{
+	auto matrix = std::make_shared<BitMatrix>(width, height);
+
+#ifdef PRINT_DEBUG
+	Matrix<uint8_t> out(width, height);
+	Matrix<uint8_t> out2(width, height);
+#endif
+
+	for (int y = 0; y < subHeight; y++) {
+		int yoffset = std::min(y * BLOCK_SIZE, height - BLOCK_SIZE);
+		for (int x = 0; x < subWidth; x++) {
+			int xoffset = std::min(x * BLOCK_SIZE, width - BLOCK_SIZE);
+			int left = std::clamp(x, 2, subWidth - 3);
+			int top = std::clamp(y, 2, subHeight - 3);
+			int sum = 0;
+			for (int dy = -2; dy <= 2; ++dy) {
+				for (int dx = -2; dx <= 2; ++dx) {
+					sum += blackPoints(left + dx, top + dy);
+				}
+			}
+			int average = sum / 25;
+			ThresholdBlock(luminances, xoffset, yoffset, average, rowStride, *matrix);
+
+#ifdef PRINT_DEBUG
+			for (int yy = 0; yy < 8; ++yy)
+				for (int xx = 0; xx < 8; ++xx) {
+					out.set(xoffset + xx, yoffset + yy, blackPoints(x, y));
+					out2.set(xoffset + xx, yoffset + yy, average);
+				}
+#endif
+		}
+	}
+
+#ifdef PRINT_DEBUG
+	std::ofstream file("thresholds.pnm");
+	file << "P5\n" << out.width() << ' ' << out.height() << "\n255\n";
+	file.write(reinterpret_cast<const char*>(out.data()), out.size());
+	std::ofstream file2("thresholds_avg.pnm");
+	file2 << "P5\n" << out.width() << ' ' << out.height() << "\n255\n";
+	file2.write(reinterpret_cast<const char*>(out2.data()), out2.size());
+#endif
+
+	return matrix;
+}
+
+#else
+
+// Subdivide the image in blocks of BLOCK_SIZE and calculate one threshold value per block as
+// (max - min > MIN_DYNAMIC_RANGE) ? (max + min) / 2 : 0
+static Matrix<T_t> BlockThresholds(const ImageView iv)
+{
+	int subWidth = (iv.width() + BLOCK_SIZE - 1) / BLOCK_SIZE; // ceil(width/BS)
+	int subHeight = (iv.height() + BLOCK_SIZE - 1) / BLOCK_SIZE; // ceil(height/BS)
+
+	Matrix<T_t> thresholds(subWidth, subHeight);
+
+	for (int y = 0; y < subHeight; y++) {
+		int y0 = std::min(y * BLOCK_SIZE, iv.height() - BLOCK_SIZE);
+		for (int x = 0; x < subWidth; x++) {
+			int x0 = std::min(x * BLOCK_SIZE, iv.width() - BLOCK_SIZE);
+			uint8_t min = 255;
+			uint8_t max = 0;
+			for (int yy = 0; yy < BLOCK_SIZE; yy++) {
+				auto line = iv.data(x0, y0 + yy);
+				for (int xx = 0; xx < BLOCK_SIZE; xx++)
+					UpdateMinMax(min, max, line[xx]);
+			}
+
+			thresholds(x, y) = (max - min > MIN_DYNAMIC_RANGE) ? (int(max) + min) / 2 : 0;
+		}
+	}
+
+	return thresholds;
+}
+
+// Apply gaussian-like smoothing filter over all non-zero thresholds and fill any remaining gaps with nearest neighbor
+static Matrix<T_t> SmoothThresholds(Matrix<T_t>&& in)
+{
+	Matrix<T_t> out(in.width(), in.height());
+
+	constexpr int R = WINDOW_SIZE / BLOCK_SIZE / 2;
+	for (int y = 0; y < in.height(); y++) {
+		for (int x = 0; x < in.width(); x++) {
+			int left = std::clamp(x, R, in.width() - R - 1);
+			int top = std::clamp(y, R, in.height() - R - 1);
+
+			int sum = in(x, y) * 2;
+			int n = (sum > 0) * 2;
+			auto add = [&](int x, int y) {
+				int t = in(x, y);
+				sum += t;
+				n += t > 0;
+			};
+
+			for (int dy = -R; dy <= R; ++dy)
+				for (int dx = -R; dx <= R; ++dx)
+					add(left + dx, top + dy);
+
+			out(x, y) = n > 0 ? sum / n : 0;
+		}
+	}
+
+	// flood fill any remaining gaps of (very large) no-contrast regions
+	auto last = out.begin() - 1;
+	for (auto* i = out.begin(); i != out.end(); ++i) {
+		if (*i) {
+			if (last != i - 1)
+				std::fill(last + 1, i, *i);
+			last = i;
+		}
+	}
+	std::fill(last + 1, out.end(), *(std::max(last, out.begin())));
+
+	return out;
+}
+
+static std::shared_ptr<BitMatrix> ThresholdImage(const ImageView iv, const Matrix<T_t>& thresholds)
+{
+	auto matrix = std::make_shared<BitMatrix>(iv.width(), iv.height());
+
+#ifdef PRINT_DEBUG
+	Matrix<uint8_t> out(iv.width(), iv.height());
+#endif
+
+	for (int y = 0; y < thresholds.height(); y++) {
+		int yoffset = std::min(y * BLOCK_SIZE, iv.height() - BLOCK_SIZE);
+		for (int x = 0; x < thresholds.width(); x++) {
+			int xoffset = std::min(x * BLOCK_SIZE, iv.width() - BLOCK_SIZE);
+			ThresholdBlock(iv.data(), xoffset, yoffset, thresholds(x, y), iv.rowStride(), *matrix);
+
+#ifdef PRINT_DEBUG
+			for (int yy = 0; yy < 8; ++yy)
+				for (int xx = 0; xx < 8; ++xx)
+					out.set(xoffset + xx, yoffset + yy, thresholds(x, y));
+#endif
+		}
+	}
+
+#ifdef PRINT_DEBUG
+	std::ofstream file("thresholds_new.pnm");
+	file << "P5\n" << out.width() << ' ' << out.height() << "\n255\n";
+	file.write(reinterpret_cast<const char*>(out.data()), out.size());
+#endif
+
+	return matrix;
+}
+
+#endif
+
+std::shared_ptr<const BitMatrix> HybridBinarizer::getBlackMatrix() const
+{
+	if (width() >= WINDOW_SIZE && height() >= WINDOW_SIZE) {
+#ifdef USE_NEW_ALGORITHM
+		auto thrs = SmoothThresholds(BlockThresholds(_buffer));
+		if (std::ranges::max(thrs) == 0)
+			return GlobalHistogramBinarizer::getBlackMatrix();
+		return ThresholdImage(_buffer, thrs);
+#else
+		const uint8_t* luminances = _buffer.data();
+		int subWidth = (width() + BLOCK_SIZE - 1) / BLOCK_SIZE; // ceil(width/BS)
+		int subHeight = (height() + BLOCK_SIZE - 1) / BLOCK_SIZE; // ceil(height/BS)
+		auto blackPoints =
+			CalculateBlackPoints(luminances, subWidth, subHeight, width(), height(), _buffer.rowStride());
+
+		return CalculateMatrix(luminances, subWidth, subHeight, width(), height(), _buffer.rowStride(), blackPoints);
+#endif
+	} else {
+		// If the image is too small, fall back to the global histogram approach.
+		return GlobalHistogramBinarizer::getBlackMatrix();
+	}
+}
+
+} // ZXing

package/cpp/zxing-core/core/src/HybridBinarizer.h

@@ -0,0 +1,40 @@
+/*
+* Copyright 2016 Nu-book Inc.
+* Copyright 2016 ZXing authors
+*/
+// SPDX-License-Identifier: Apache-2.0
+
+#pragma once
+
+#include "GlobalHistogramBinarizer.h"
+
+namespace ZXing {
+
+/**
+* This class implements a local thresholding algorithm, which while slower than the
+* GlobalHistogramBinarizer, is fairly efficient for what it does. It is designed for
+* high frequency images of barcodes with black data on white backgrounds. For this application,
+* it does a much better job than a global blackpoint with severe shadows and gradients.
+* However it tends to produce artifacts on lower frequency images and is therefore not
+* a good general purpose binarizer for uses outside ZXing.
+*
+* This class extends GlobalHistogramBinarizer, using the older histogram approach for 1D readers,
+* and the newer local approach for 2D readers. 1D decoding using a per-row histogram is already
+* inherently local, and only fails for horizontal gradients. We can revisit that problem later,
+* but for now it was not a win to use local blocks for 1D.
+*
+* This Binarizer is the default for the unit tests and the recommended class for library users.
+*
+* @author dswitkin@google.com (Daniel Switkin)
+*/
+class HybridBinarizer : public GlobalHistogramBinarizer
+{
+public:
+	explicit HybridBinarizer(const ImageView& iv);
+	~HybridBinarizer() override;
+
+	bool getPatternRow(int row, int rotation, PatternRow &res) const override;
+	std::shared_ptr<const BitMatrix> getBlackMatrix() const override;
+};
+
+} // ZXing

package/cpp/zxing-core/core/src/ImageView.h

@@ -0,0 +1,168 @@
+/*
+* Copyright 2019 Axel Waggershauser
+*/
+// SPDX-License-Identifier: Apache-2.0
+
+#pragma once
+
+#include <algorithm>
+#include <cstdint>
+#include <cstdio>
+#include <memory>
+#include <stdexcept>
+
+namespace ZXing {
+
+/// @brief Supported image formats for ImageView. The format encodes the pixel format and layout information.
+enum class ImageFormat : uint32_t
+{
+	None = 0,
+	Lum  = 0x01000000,
+	LumA = 0x02000000,
+	RGB  = 0x03000102,
+	BGR  = 0x03020100,
+	RGBA = 0x04000102,
+	ARGB = 0x04010203,
+	BGRA = 0x04020100,
+	ABGR = 0x04030201,
+	RGBX [[deprecated("use RGBA")]] = RGBA,
+	XRGB [[deprecated("use ARGB")]] = ARGB,
+	BGRX [[deprecated("use BGRA")]] = BGRA,
+	XBGR [[deprecated("use ABGR")]] = ABGR,
+};
+
+/// @cond INTERNAL
+constexpr inline int PixStride(ImageFormat format) { return (static_cast<uint32_t>(format) >> 3*8) & 0xFF; }
+constexpr inline int RedIndex(ImageFormat format) { return (static_cast<uint32_t>(format) >> 2*8) & 0xFF; }
+constexpr inline int GreenIndex(ImageFormat format) { return (static_cast<uint32_t>(format) >> 1*8) & 0xFF; }
+constexpr inline int BlueIndex(ImageFormat format) { return (static_cast<uint32_t>(format) >> 0*8) & 0xFF; }
+
+constexpr inline uint8_t RGBToLum(unsigned r, unsigned g, unsigned b)
+{
+	// .299R + 0.587G + 0.114B (YUV/YIQ for PAL and NTSC),
+	// (306*R) >> 10 is approximately equal to R*0.299, and so on.
+	// 0x200 >> 10 is 0.5, it implements rounding.
+	return static_cast<uint8_t>((306 * r + 601 * g + 117 * b + 0x200) >> 10);
+}
+/// @endcond
+
+/**
+ * @brief Simple class that stores a non-owning const pointer to image data plus layout and format information.
+ */
+class ImageView
+{
+/// @cond INTERNAL
+protected:
+	const uint8_t* _data = nullptr;
+	ImageFormat _format = ImageFormat::None;
+	int _width = 0, _height = 0, _pixStride = 0, _rowStride = 0;
+/// @endcond
+
+public:
+	/**
+	 * ImageView default constructor creates a 'null' image view
+	 */
+	ImageView() = default;
+
+	/**
+	 * ImageView constructor
+	 *
+	 * @param data  pointer to image buffer
+	 * @param width  image width in pixels
+	 * @param height  image height in pixels
+	 * @param format  image/pixel format
+	 * @param rowStride  optional row stride in bytes, default is width * pixStride
+	 * @param pixStride  optional pixel stride in bytes, default is calculated from format
+	 */
+	ImageView(const uint8_t* data, int width, int height, ImageFormat format, int rowStride = 0, int pixStride = 0)
+		: _data(data),
+		  _format(format),
+		  _width(width),
+		  _height(height),
+		  _pixStride(pixStride ? pixStride : PixStride(format)),
+		  _rowStride(rowStride ? rowStride : width * _pixStride)
+	{
+		if (_data == nullptr)
+			throw std::invalid_argument("Can not construct an ImageView from a NULL pointer");
+
+		if (_width <= 0 || _height <= 0)
+			throw std::invalid_argument("Neither width nor height of ImageView can be less or equal to 0");
+	}
+
+	/**
+	 * ImageView constructor with bounds checking.
+	 *
+	 * This constructor checks if the provided size is consistent with the width, height, row stride and pixel stride
+	 * parameters to prevent out of bounds access when using the ImageView.
+	 *
+	 * @param data  pointer to image buffer
+	 * @param size  size of the image buffer in bytes
+	 * @param width  image width in pixels
+	 * @param height  image height in pixels
+	 * @param format  image/pixel format
+	 * @param rowStride  optional row stride in bytes, default is width * pixStride
+	 * @param pixStride  optional pixel stride in bytes, default is calculated from format
+	 */
+	ImageView(const uint8_t* data, int size, int width, int height, ImageFormat format, int rowStride = 0, int pixStride = 0)
+		: ImageView(data, width, height, format, rowStride, pixStride)
+	{
+		if (_rowStride < 0 || _pixStride < 0 || size < _height * _rowStride)
+			throw std::invalid_argument("ImageView parameters are inconsistent (out of bounds)");
+	}
+
+	int width() const { return _width; }
+	int height() const { return _height; }
+	int pixStride() const { return _pixStride; }
+	int rowStride() const { return _rowStride; }
+	ImageFormat format() const { return _format; }
+
+	const uint8_t* data() const { return _data; }
+	const uint8_t* data(int x, int y) const { return _data + y * _rowStride + x * _pixStride; }
+
+	/// Create a new ImageView that is a cropped version of this one.
+	/// Negative width/height will be interpreted as "until the end of the line/image".
+	ImageView cropped(int left, int top, int width, int height) const
+	{
+		left   = std::clamp(left, 0, _width - 1);
+		top    = std::clamp(top, 0, _height - 1);
+		width  = width <= 0 ? (_width - left) : std::min(_width - left, width);
+		height = height <= 0 ? (_height - top) : std::min(_height - top, height);
+		return {data(left, top), width, height, _format, _rowStride, _pixStride};
+	}
+
+	/// Create a new ImageView that is a rotated version of this one.
+	/// Rotation is clockwise and only supports 90 degree steps.
+	ImageView rotated(int degree) const
+	{
+		switch ((degree + 360) % 360) {
+		case 90:  return {data(0, _height - 1), _height, _width, _format, _pixStride, -_rowStride};
+		case 180: return {data(_width - 1, _height - 1), _width, _height, _format, -_rowStride, -_pixStride};
+		case 270: return {data(_width - 1, 0), _height, _width, _format, -_pixStride, _rowStride};
+		default:  return *this;
+		}
+	}
+
+	/// Create a new ImageView that is a subsampled version of this one.
+	/// The subsampled image will have width/height of original divided by scale.
+	ImageView subsampled(int scale) const
+	{
+		return {_data, _width / scale, _height / scale, _format, _rowStride * scale, _pixStride * scale};
+	}
+
+};
+
+/**
+ * @brief Simple class that inherits ImageView but owns the image data and frees it on destruction.
+ */
+class Image : public ImageView
+{
+	std::unique_ptr<uint8_t[]> _memory;
+	Image(std::unique_ptr<uint8_t[]>&& data, int w, int h, ImageFormat f) : ImageView(data.get(), w, h, f), _memory(std::move(data)) {}
+
+public:
+	Image() = default;
+	Image(int w, int h, ImageFormat f = ImageFormat::Lum) : Image(std::make_unique<uint8_t[]>(w * h * PixStride(f)), w, h, f) {}
+};
+
+} // ZXing
+

package/cpp/zxing-core/core/src/JSON.cpp

@@ -0,0 +1,154 @@
+/*
+* Copyright 2025 Axel Waggershauser
+*/
+// SPDX-License-Identifier: Apache-2.0
+
+#include "JSON.h"
+
+#include "ZXAlgorithms.h"
+
+#include <string_view>
+
+// This code is trying to find the value of a key-value pair in a string of those.
+// The input could be valid JSON, like '{"key": "val"}' or a stripped down version like
+// 'key:val'. This is also compatible with the string serialization of a python dictionary.
+// For convenience, also 'key=val' is supported, key is checked case insensitive and '_' is ignored.
+// This could easily be done with the following regex (see below).
+// But using std::regex adds 140k+ to the binary size. ctre is _very_ nice to use and has
+// the same binary footprint as the hand-roled code below! But I don't want to add
+// 5k lines of c++ code for that.
+
+// #define ZXING_USE_CTRE
+#ifdef ZXING_USE_CTRE
+#pragma GCC diagnostic ignored "-Wundef" // see https://github.com/hanickadot/compile-time-regular-expressions/issues/340
+#include "ctre.hpp"
+#pragma GCC diagnostic error "-Wundef"
+
+static constexpr auto PATTERN =
+	ctll::fixed_string{R"(["']?([[:alpha:]][[:alnum:]]*)["']?\s*(?:[:]\s*["']?([[:alnum:]]+)["']?)?(?:,|\}|$))"};
+#endif
+
+namespace ZXing {
+
+// Trim whitespace and quotes/braces from both ends
+inline std::string_view Trim(std::string_view sv)
+{
+	return TrimWS(sv, " \t\n\r\"'{}");
+}
+
+inline bool IsEqualIgnoreCaseAndUnderscore(std::string_view a, std::string_view b)
+{
+	return IsEqualIgnoreCaseAnd(a, b, "_");
+}
+
+std::string_view JsonFind(std::string_view json, std::string_view key)
+{
+#ifdef ZXING_USE_CTRE
+	for (auto [ma, mk, mv] : ctre::search_all<PATTERN>(json))
+		if (IsEqualCaseInsensitive(key, mk))
+			return mv.size() ? mv.to_view() : std::string_view(mk.data(), 0);
+
+	return {};
+#else
+	json = Trim(json);
+
+	// TODO: use something like ForEachToken here?
+	while (!json.empty()) {
+		auto posComma = json.find(',');
+		auto pair = Trim(json.substr(0, posComma));
+
+		if (IsEqualIgnoreCaseAndUnderscore(pair, key))
+			return {pair.data(), 0}; // return non-null data to signal that we found the key
+
+		auto posSep = pair.find_first_of(":=");
+
+		if (posSep != std::string_view::npos && IsEqualIgnoreCaseAndUnderscore(Trim(pair.substr(0, posSep)), key))
+			return Trim(pair.substr(posSep + 1));
+
+		json = (posComma == std::string_view::npos) ? std::string_view{} : json.substr(posComma + 1);
+	}
+
+	return {};
+#endif
+}
+
+std::string JsonEscapeStr(std::string_view str)
+{
+	std::string res;
+	res.reserve(str.size() + 10);
+
+	for (unsigned char c : str) {
+		switch (c) {
+		case '\"': res += "\\\""; break;
+		case '\\': res += "\\\\"; break;
+		case '\b': res += "\\b"; break;
+		case '\f': res += "\\f"; break;
+		case '\n': res += "\\n"; break;
+		case '\r': res += "\\r"; break;
+		case '\t': res += "\\t"; break;
+		default:
+			if (c <= 0x1F) {
+				char buf[7];
+				std::snprintf(buf, sizeof(buf), "\\u%04X", c);
+				res += buf;
+			} else {
+				res += c;
+			}
+			break;
+		}
+	}
+
+	return res;
+}
+
+std::string JsonUnEscapeStr(std::string_view str)
+{
+	std::string res;
+	res.reserve(str.size());
+
+	for (size_t i = 0; i < str.size(); ++i) {
+		char c = str[i];
+		if (c == '\\') {
+			if (++i >= str.size())
+				throw std::runtime_error("Invalid escape sequence");
+
+			char esc = str[i];
+			switch (esc) {
+			case '"': res += '\"'; break;
+			case '\\': res += '\\'; break;
+			case '/': res += '/'; break;
+			case 'b': res += '\b'; break;
+			case 'f': res += '\f'; break;
+			case 'n': res += '\n'; break;
+			case 'r': res += '\r'; break;
+			case 't': res += '\t'; break;
+			case 'u': {
+				if (i + 4 >= str.size())
+					throw std::runtime_error("Incomplete \\u escape");
+
+				uint32_t code = 0;
+				auto first = str.data() + i + 1;
+				auto last = first + 4;
+
+				auto [ptr, ec] = std::from_chars(first, last, code, 16);
+				if (ec != std::errc() || ptr != last)
+					throw std::runtime_error("Failed to parse hex code");
+
+				if (code > 0x1F)
+					throw std::runtime_error("Unexpected code point in \\u escape");
+
+				res += static_cast<char>(code);
+				i += 4;
+				break;
+			}
+			default: throw std::runtime_error("Unknown escape sequence");
+			}
+		} else {
+			res += c;
+		}
+	}
+
+	return res;
+}
+
+} // ZXing