update README for v.1.0.3

Author: FunnySaltyFish

README.md

@@ -13,9 +13,18 @@
 [中文](README_CN.md)
 
 ## Introduction
-This library helps to parse partial JSON (that is, incomplete JSON) in Kotlin. It is implemented in **pure Kotlin** so that can be used in KMP project.
+This library helps to **parse and repair partial JSON** (that is, incomplete JSON) in Kotlin. Perfect for handling streaming JSON from LLMs like ChatGPT. It is implemented in **pure Kotlin** so that can be used in KMP project.
+
+## Features
+- **Parse** incomplete JSON strings into usable objects
+- **Complete/Repair** partial JSON to valid JSON format
+- Handle streaming JSON data in real-time
+- Pure Kotlin implementation for KMP compatibility
+- Robust error handling for malformed JSON
 
 ## Usage
+
+### Parse Partial JSON
 ```kotlin
 import com.funnysaltyfish.partialjsonparser.PartialJsonParser
 
@@ -25,7 +34,24 @@ println(map) // {key=Hello, }
 println(map?.get("key")) // Hello,
 ```
 
-The method will throw `JsonParseException` if the JSON is invalid. In some extreme cases, it might also throw `IndexOutOfBoundsException`.
+### Complete/Repair Partial JSON
+```kotlin
+import com.funnysaltyfish.partialjsonparser.PartialJsonParser
+
+val partialJson = "{\"key\":\"Hello, "
+val completedJson = PartialJsonParser.complete(partialJson)
+println(completedJson) // {"key":"Hello, "}
+
+// More examples
+val incomplete = "{\"name\":\"John\", \"age\":"
+val repaired = PartialJsonParser.complete(incomplete)
+println(repaired) // {"name":"John"}
+```
+
+The `parse` method will throw `JsonParseException` if the JSON is invalid. The `complete` method repairs partial JSON into valid JSON format by removing incomplete elements.
+
+(In some extreme cases, it might also throw `IndexOutOfBoundsException`, which should not occur although. If that did happen, feel free to open an issue with your sample.)
+
 
 Actually, `parse` is just a combination of `tokenize` and `parseTokens`, you can use them separately if you want
 
@@ -44,6 +70,8 @@ implementation("io.github.funnysaltyfish:partial-json-parser:1.0.3")
 ```
 
 ## Examples
+
+### Parse Examples
 Below are some examples: (originJsonString -> parsed map)
 ```
 {"ke                      -> {}
@@ -62,7 +90,32 @@ Below are some examples: (originJsonString -> parsed map)
 {"k":[{"k2":1, "k3":2     -> {k=[{k2=1.0, k3=2.0}]}
 ```
 
-To see more examples, please run `ParseTest.kt`.
+### Complete/Repair Examples
+Below are examples of JSON completion/repair: (partial JSON -> completed JSON)
+```
+{"key                                   -> {}
+{"key":                                 -> {}
+{"key":"te                              -> {"key":"te"}
+{"key":"text", "key2                    -> {"key":"text"}
+{"key":"text", "key2":"t                -> {"key":"text","key2":"t"}
+{"key":123,                             -> {"key":123}
+{"key":[1,2,3                           -> {"key":[1,2,3]}
+{"key":[                                -> {"key":[]}
+{"key":{"inner                          -> {"key":{}}
+{"key":{"inner":"val",                  -> {"key":{"inner":"val"}}
+[1,2,3                                  -> [1,2,3]
+["a","b                                 -> ["a","b"]
+[{"key":"val                            -> [{"key":"val"}]
+[{"key":"val",                          -> [{"key":"val"}]
+{"a":{"b":{"c":"val                     -> {"a":{"b":{"c":"val"}}}
+{"a":{"b":[1,2,{"c":"val                -> {"a":{"b":[1,2,{"c":"val"}]}}
+{"a":[{"b":{"c":"val                    -> {"a":[{"b":{"c":"val"}}]}
+{"outer":{"inner":{"key":"value", "key2 -> {"outer":{"inner":{"key":"value"}}}
+{"numbers":[1,2.5,3], "incomplete":     -> {"numbers":[1,2.5,3]}
+{"a":1, "b":                            -> {"a":1}
+```
+
+To see more examples, please run `ParseTest.kt` and `CompleteTest.kt`.
 
 ## Origin Source
 Interestingly, the code is converted from the TypeScript library [here](https://github.com/SimonTart/json-fragment-parser) by GitHub Copilot, I make it suitable for Kotlin style, modify some extreme cases, write some tests and publish it to Maven Central. Thanks for it.

README_CN.md

@@ -12,11 +12,18 @@
 
 ## 简介
 
-这个库帮助在 Kotlin 中解析部分JSON（即不完整的JSON，比如由类似 ChatGPT 的大语言模型在流式返回中生成的）。它是用 **纯 Kotlin** 实现的，可在 KMP 项目中使用。
+这个库帮助在 Kotlin 中**解析和修复部分JSON**（即不完整的JSON，比如由类似 ChatGPT 的大语言模型在流式返回中生成的）。特别适合处理来自 LLM 的流式 JSON 数据。它是用 **纯 Kotlin** 实现的，可在 KMP 项目中使用。
+
+## 特性
+- **解析**不完整的 JSON 字符串为可用对象
+- **补全/修复**部分 JSON 为有效的 JSON 格式
+- 实时处理流式 JSON 数据
+- 纯 Kotlin 实现，支持 KMP
+- 强健的错误处理机制
 
 ## 用法
 
-使用起来就一行：
+### 解析部分 JSON
 
 ```kotlin
 import com.funnysaltyfish.partialjsonparser.PartialJsonParser
@@ -27,8 +34,24 @@ println(map) // {key=Hello, }
 println(map?.get("key")) // Hello,
 ```
 
-如果 JSON 无效，则该方法将抛出 `JsonParseException`。在某些极端情况下，它也可能抛出 `IndexOutOfBoundsException`
-（理论上说不会出现这种情况，如果有欢迎 issue 和 PR）。
+### 补全/修复部分 JSON
+
+```kotlin
+import com.funnysaltyfish.partialjsonparser.PartialJsonParser
+
+val partialJson = "{\"key\":\"Hello, "
+val completedJson = PartialJsonParser.complete(partialJson)
+println(completedJson) // {"key":"Hello, "}
+
+// 更多例子
+val incomplete = "{\"name\":\"John\", \"age\":"
+val repaired = PartialJsonParser.complete(incomplete)
+println(repaired) // {"name":"John"}
+```
+
+`parse` 方法在 JSON 无效时会抛出 `JsonParseException`。`complete` 方法通过移除不完整的元素将部分 JSON 修复为有效的 JSON 格式。
+
+在某些极端情况下，它也可能抛出 `IndexOutOfBoundsException`（理论上说不会出现这种情况，如果有欢迎 issue 和 PR）。
 
 实际上，`parse` 只是 `tokenize` 和 `parseTokens` 的组合，你也可以分开用：
 
@@ -49,6 +72,7 @@ implementation("io.github.funnysaltyfish:partial-json-parser:1.0.3")
 
 ## 示例
 
+### 解析示例
 以下是一些示例：（原始JSON字符串 -> 解析后的map）
 ```
 {"ke                      -> {}
@@ -67,7 +91,32 @@ implementation("io.github.funnysaltyfish:partial-json-parser:1.0.3")
 {"k":[{"k2":1, "k3":2     -> {k=[{k2=1.0, k3=2.0}]}
 ```
 
-总的原则是，我们会尽可能多的解析出信息。你可以运行 ParseTest.kt 文件来查看更多情况
+### 补全/修复示例
+以下是 JSON 补全/修复的示例：（部分 JSON -> 补全后的 JSON）
+```
+{"key                                   -> {}
+{"key":                                 -> {}
+{"key":"te                              -> {"key":"te"}
+{"key":"text", "key2                    -> {"key":"text"}
+{"key":"text", "key2":"t                -> {"key":"text","key2":"t"}
+{"key":123,                             -> {"key":123}
+{"key":[1,2,3                           -> {"key":[1,2,3]}
+{"key":[                                -> {"key":[]}
+{"key":{"inner                          -> {"key":{}}
+{"key":{"inner":"val",                  -> {"key":{"inner":"val"}}
+[1,2,3                                  -> [1,2,3]
+["a","b                                 -> ["a","b"]
+[{"key":"val                            -> [{"key":"val"}]
+[{"key":"val",                          -> [{"key":"val"}]
+{"a":{"b":{"c":"val                     -> {"a":{"b":{"c":"val"}}}
+{"a":{"b":[1,2,{"c":"val                -> {"a":{"b":[1,2,{"c":"val"}]}}
+{"a":[{"b":{"c":"val                    -> {"a":[{"b":{"c":"val"}}]}
+{"outer":{"inner":{"key":"value", "key2 -> {"outer":{"inner":{"key":"value"}}}
+{"numbers":[1,2.5,3], "incomplete":     -> {"numbers":[1,2.5,3]}
+{"a":1, "b":                            -> {"a":1}
+```
+
+总的原则是，我们会尽可能多的解析出信息。你可以运行 ParseTest.kt 和 CompleteTest.kt 文件来查看更多情况
 
 ## 特别鸣谢
 这个库的代码是从 [这个 TypeScript 库](https://github.com/SimonTart/json-fragment-parser) 来的，用的 GitHub Copilot 一点点转换的, 我将它的代码略作调整以符合 Kotlin 风格、优化了一些极端情况、写了测试以及完成了发布。由衷的感谢一下！