1

.gitignore

@@ -0,0 +1,36 @@
+.gradle
+build/
+!gradle/wrapper/gradle-wrapper.jar
+!**/src/main/**/build/
+!**/src/test/**/build/
+
+### IntelliJ IDEA ###
+.idea
+
+### Kotlin ###
+.kotlin
+
+### Eclipse ###
+.apt_generated
+.classpath
+.factorypath
+.project
+.settings
+.springBeans
+.sts4-cache
+bin/
+!**/src/main/**/bin/
+!**/src/test/**/bin/
+
+### NetBeans ###
+/nbproject/private/
+/nbbuild/
+/dist/
+/nbdist/
+/.nb-gradle/
+
+### VS Code ###
+.vscode/
+
+### Mac OS ###
+.DS_Store

build.gradle.kts

@@ -0,0 +1,29 @@
+plugins {
+    kotlin("jvm") version "2.1.0"
+}
+
+group = "cn.qqck.kotlin"
+version = "1.0-SNAPSHOT"
+
+repositories {
+    // maven { setUrl("https://maven.aliyun.com/repository/public") } // central仓和jcenter仓的聚合仓
+    // maven { setUrl("https://maven.aliyun.com/repository/central") } // central仓和jcenter仓的聚合仓
+    mavenCentral() // 官方仓库作为备用
+    maven { setUrl("https://jitpack.io") } // 官方仓库作为备用
+
+    // maven { setUrl("https://maven.aliyun.com/repository/gradle-plugin") } // 阿里云 Gradle 插件仓库
+    // maven { setUrl("https://plugins.gradle.org/m2/") } // Gradle 插件仓库
+
+    google()
+    gradlePluginPortal()
+}
+
+dependencies {
+
+    // https://github.com/Kotlin/kotlinx.coroutines
+    implementation("org.jetbrains.kotlinx:kotlinx-coroutines-core:1.10.1")
+
+    // https://github.com/square/okhttp
+    implementation("com.squareup.okhttp3:okhttp:4.12.0")
+
+}

gradle.properties

@@ -0,0 +1 @@
+kotlin.code.style=official

settings.gradle.kts

@@ -0,0 +1,2 @@
+rootProject.name = "tools"
+

src/main/kotlin/cn/qqck/kotlin/tools/Base64.kt

@@ -0,0 +1,4 @@
+package cn.qqck.kotlin.tools
+
+fun ByteArray.base64(): String = java.util.Base64.getEncoder().encodeToString(this)
+fun String.base64(): ByteArray = java.util.Base64.getDecoder().decode(this)

src/main/kotlin/cn/qqck/kotlin/tools/ByteArray.kt

@@ -0,0 +1,209 @@
+package cn.qqck.kotlin.tools
+
+fun ByteArray.string(): String = this.toString(java.nio.charset.Charset.defaultCharset())
+
+/**
+ * 压缩当前字节数组，返回压缩后的字节数组。
+ *
+ * @param level 压缩级别，范围为 `0`（不压缩）到 `9`（最佳压缩）。默认为 `java.util.zip.Deflater.BEST_COMPRESSION`。
+ * @return 一个新的字节数组，包含压缩后的数据。如果压缩失败或数据为空，则可能返回空数组。
+ */
+fun ByteArray.compress(level: Int = java.util.zip.Deflater.BEST_COMPRESSION): ByteArray {
+    runDefer {
+        val j_infl = java.util.zip.Deflater(level)
+        defer { j_infl.end() }
+        j_infl.setInput(this@compress)
+        val j_bufs = java.io.ByteArrayOutputStream()
+        defer { j_bufs.close() }
+        val j_out = ByteArray(4096)
+        while (!j_infl.finished()) {
+            val j_size = j_infl.deflate(j_out)
+            if (j_size == 0) break
+            j_bufs.write(j_out, 0, j_size)
+        }
+        return j_bufs.toByteArray()
+    }
+}
+
+/**
+ * 解压缩当前字节数组，返回解压后的数据。
+ * 使用 `java.util.zip.Inflater` 进行解压操作。
+ *
+ * @return 解压后的字节数组。如果解压失败，可能抛出相关异常。
+ */
+fun ByteArray.uncompress(): ByteArray {
+    runDefer {
+        val j_infl = java.util.zip.Inflater()
+        defer { j_infl.end() }
+        j_infl.setInput(this@uncompress)
+        val j_bufs = java.io.ByteArrayOutputStream()
+        defer { j_bufs.close() }
+        val j_out = ByteArray(4096)
+        while (!j_infl.finished()) {
+            val j_size = j_infl.inflate(j_out)
+            if (j_size == 0) break
+            j_bufs.write(j_out, 0, j_size)
+        }
+        return j_bufs.toByteArray()
+    }
+}
+
+/**
+ * 从当前的字节数组复制指定范围的字节，并返回一个新的字节数组。
+ *
+ * @param start 起始位置的索引，从该索引开始复制内容。如果起始位置超出当前数组范围，则返回的数组会包含默认值。
+ * @param size  目标字节数组的大小，即返回的字节数组长度。
+ * @return 包含复制内容的新字节数组，长度为指定的 `size`。
+ */
+fun ByteArray.copyOf(start: Int, size: Int): ByteArray {
+    val j_bufs = ByteArray(size)
+    if (start < this.size) System.arraycopy(this, start, j_bufs, 0, kotlin.math.min(this.size, size))
+    return j_bufs
+}
+
+/**
+ * 对当前字节数组与指定的密钥字节数组进行按位异或运算。
+ * 如果当前字节数组或密钥字节数组为空，则返回一个空的字节数组。
+ *
+ * @param key 用于异或运算的密钥字节数组。如果密钥长度小于当前字节数组长度，会循环使用密钥。
+ * @return 返回异或运算后的字节数组，长度与当前字节数组一致。
+ */
+fun ByteArray.xor(key: ByteArray): ByteArray {
+    if (this.isEmpty() || key.isEmpty()) return ByteArray(0)
+    val j_keysize = key.size
+    return ByteArray(size) { j_i -> (this[j_i].toInt() xor key[j_i % j_keysize].toInt()).toByte() }
+}
+
+/**
+ * 将字节数组的指定位置转换为短整型（Short）。
+ *
+ * @param start 开始读取的字节数组索引位置，默认值为0。
+ * @param big 指定字节序是否为大端字节序（Big-endian）。若为false，则为小端字节序（Little-endian）。默认值为false。
+ * @return 从字节数组中转换得到的短整型（Short）。若字节数组长度不足以读取，则返回0。
+ */
+fun ByteArray.toShort(start: Int = 0, big: Boolean = false): Short {
+    return if (this.size < start + 2) 0 else if (big) {
+        ((this[start].toUByte().toInt() shl 8) or
+                this[start + 1].toUByte().toInt()).toShort()
+    } else {
+        (this[start].toUByte().toInt() or
+                (this[start + 1].toUByte().toInt() shl 8)).toShort()
+    }
+}
+
+/**
+ * 将ByteArray中的指定起始位置的两个字节转换为UShort。
+ *
+ * @param start 起始位置的索引，默认为0。
+ * @param big 表示是否按大端字节序读取，true为大端字节序，false为小端字节序，默认为false。
+ * @return 转换后的UShort值。如果ByteArray的长度不足以读取两个字节，则返回0U。
+ */
+fun ByteArray.toUShort(start: Int = 0, big: Boolean = false): UShort {
+    return if (this.size < start + 2) 0U else if (big) {
+        ((this[start].toUByte().toInt() shl 8) or
+                this[start + 1].toUByte().toInt()).toUShort()
+    } else {
+        (this[start].toUByte().toInt() or
+                (this[start + 1].toUByte().toInt() shl 8)).toUShort()
+    }
+}
+
+/**
+ * 将字节数组的指定部分转换为整数。
+ *
+ * @param start 起始索引，用于指定从字节数组的哪个位置开始读取，默认为0。
+ * @param big 如果为true，则使用大端模式（字节序从高到低），否则使用小端模式（字节序从低到高），默认为false。
+ * @return 转换后的整数值。如果字节数组的长度不足以读取4个字节，将返回0。
+ */
+fun ByteArray.toInt(start: Int = 0, big: Boolean = false): Int {
+    return if (this.size < start + 4) 0 else if (big) {
+        (this[start].toUByte().toInt() shl 24) or
+                (this[start + 1].toUByte().toInt() shl 16) or
+                (this[start + 2].toUByte().toInt() shl 8) or
+                this[start + 3].toUByte().toInt()
+    } else {
+        this[start].toUByte().toInt() or
+                (this[start + 1].toUByte().toInt() shl 8) or
+                (this[start + 2].toUByte().toInt() shl 16) or
+                (this[start + 3].toUByte().toInt() shl 24)
+    }
+}
+
+/**
+ * 将字节数组中的一部分转换为无符号整型 (UInt)。
+ *
+ * @param start 起始索引，默认值为0，用于指定从字节数组的哪一部分开始读取数据。
+ * @param big 是否采用大端模式。true 表示采用大端模式，false 表示采用小端模式。
+ * @return 转换得到的无符号整型。如果字节数组长度不足以读取4个字节，则返回0U。
+ */
+fun ByteArray.toUInt(start: Int = 0, big: Boolean = false): UInt {
+    return if (this.size < start + 4) 0U else if (big) {
+        (this[start].toUByte().toUInt() shl 24) or
+                (this[start + 1].toUByte().toUInt() shl 16) or
+                (this[start + 2].toUByte().toUInt() shl 8) or
+                this[start + 3].toUByte().toUInt()
+    } else {
+        this[start].toUByte().toUInt() or
+                (this[start + 1].toUByte().toUInt() shl 8) or
+                (this[start + 2].toUByte().toUInt() shl 16) or
+                (this[start + 3].toUByte().toUInt() shl 24)
+    }
+}
+
+/**
+ * 将当前字节数组转换为 `Long` 值。
+ *
+ * @param start 起始位置，表示从数组的哪个索引开始读取数据。默认为 0。
+ * @param big 是否使用大端序进行解析。如果为 `true`，则按照大端序解析；否则按照小端序解析。默认为 `false`。
+ * @return 转换后的 `Long` 值。如果字节数组长度不足以解析 `Long`（即从 `start` 开始不足 8 字节），则返回 0。
+ */
+fun ByteArray.toLong(start: Int = 0, big: Boolean = false): Long {
+    return if (this.size < start + 8) 0 else if (big) {
+        (this[start].toUByte().toLong() shl 56) or
+                (this[start + 1].toUByte().toLong() shl 48) or
+                (this[start + 2].toUByte().toLong() shl 40) or
+                (this[start + 3].toUByte().toLong() shl 32) or
+                (this[start + 4].toUByte().toLong() shl 24) or
+                (this[start + 5].toUByte().toLong() shl 16) or
+                (this[start + 6].toUByte().toLong() shl 8) or
+                this[start + 7].toUByte().toLong()
+    } else {
+        this[start].toUByte().toLong() or
+                (this[start + 1].toUByte().toLong() shl 8) or
+                (this[start + 2].toUByte().toLong() shl 16) or
+                (this[start + 3].toUByte().toLong() shl 24) or
+                (this[start + 4].toUByte().toLong() shl 32) or
+                (this[start + 5].toUByte().toLong() shl 40) or
+                (this[start + 6].toUByte().toLong() shl 48) or
+                (this[start + 7].toUByte().toLong() shl 56)
+    }
+}
+
+/**
+ * 将字节数组从指定起始位置转为无符号长整型值 (ULong)。
+ *
+ * @param start 起始位置索引，默认为0。
+ * @param big 是否按大端字节序处理，默认为false，小端字节序。
+ * @return 转换后的无符号长整型值。如果字节数组长度不足以支持转换，则返回0U。
+ */
+fun ByteArray.toULong(start: Int = 0, big: Boolean = false): ULong {
+    return if (this.size < start + 8) 0U else if (big) {
+        (this[start].toUByte().toULong() shl 56) or
+                (this[start + 1].toUByte().toULong() shl 48) or
+                (this[start + 2].toUByte().toULong() shl 40) or
+                (this[start + 3].toUByte().toULong() shl 32) or
+                (this[start + 4].toUByte().toULong() shl 24) or
+                (this[start + 5].toUByte().toULong() shl 16) or
+                (this[start + 6].toUByte().toULong() shl 8) or
+                this[start + 7].toUByte().toULong()
+    } else {
+        this[start].toUByte().toULong() or
+                (this[start + 1].toUByte().toULong() shl 8) or
+                (this[start + 2].toUByte().toULong() shl 16) or
+                (this[start + 3].toUByte().toULong() shl 24) or
+                (this[start + 4].toUByte().toULong() shl 32) or
+                (this[start + 5].toUByte().toULong() shl 40) or
+                (this[start + 6].toUByte().toULong() shl 48) or
+                (this[start + 7].toUByte().toULong() shl 56)
+    }
+}

src/main/kotlin/cn/qqck/kotlin/tools/Extra.kt

@@ -0,0 +1,57 @@
+package cn.qqck.kotlin.tools
+
+class RunTimeScope {
+    private var stop = false
+    fun isstop(): Boolean = this.stop
+    fun stop() {
+        this.stop = true
+    }
+}
+
+/**
+ * 周期性执行块代码直到超时或满足停止条件。
+ *
+ * @param mill 超时时间，单位为毫秒。
+ * @param sleep 每次循环间的休眠时间，默认为10毫秒。
+ * @param block 使用`RunTimeScope`上下文作为接收者的代码块。
+ * @return 返回代码块的最终执行结果。
+ */
+inline fun <T> runTime(mill: Long, sleep: Long = 10, block: RunTimeScope.() -> T): T {
+    val j_timeout = System.currentTimeMillis() + mill
+    val j_runtime = RunTimeScope()
+    while (true) {
+        val j_endTime = j_timeout - System.currentTimeMillis()
+        val j_ret = j_runtime.block()
+        if (j_endTime < 1 || j_runtime.isstop()) return j_ret
+        Thread.sleep(sleep)
+    }
+}
+
+class DeferScope {
+    private val defers = ArrayDeque<() -> Unit>()
+
+    fun defer(block: () -> Unit) {
+        this.defers.addLast(block)
+    }
+
+    fun release() {
+        while (this.defers.isNotEmpty()) this.defers.removeLast()()
+    }
+}
+
+/**
+ * 执行一个带有延迟执行块的作用域代码，并在完成后释放所有延迟任务。
+ *
+ * @param block 需要在延迟作用域中执行的代码块。该代码块在提供的 [DeferScope] 上调用，
+ *              允许使用 `defer` 方法添加延迟执行的任务。
+ * @return 返回代码块执行后的结果。
+ */
+inline fun <T> runDefer(block: DeferScope.() -> T): T {
+    val j_defer = DeferScope()
+    val j_ret = try {
+        j_defer.block()
+    } finally {
+        j_defer.release()
+    }
+    return j_ret
+}

src/main/kotlin/cn/qqck/kotlin/tools/Files.kt

@@ -0,0 +1,94 @@
+package cn.qqck.kotlin.tools
+
+import java.io.File
+import java.nio.ByteBuffer
+import java.nio.channels.FileChannel
+import java.nio.file.Paths
+import java.nio.file.StandardOpenOption
+
+/**
+ * 将字符串内容写入文件。
+ *
+ * @param name 文件名称。
+ * @param dir 文件路径，默认为空，表示当前路径。
+ * @param append 是否以追加模式写入，默认为 false 表示覆盖写入。
+ * @return 写入是否成功，成功返回 true，否则返回 false。
+ */
+fun String.fset(name: String, dir: String? = null, append: Boolean = false): Boolean = this.toByteArray().fset(name, dir, append)
+
+/**
+ * 将当前 ByteArray 的内容写入到指定文件。
+ *
+ * @param name 文件名，当提供 `dir` 参数时，此参数作为文件的相对路径或者文件名；如果 `dir` 未指定，则此参数为完整的文件路径。
+ * @param dir 可选的目录路径。如果指定，将 `name` 作为子路径结合形成完整文件路径。
+ * @param append 如果为 `true`，数据将追加到文件末尾；如果为 `false`，将覆盖文件内容。
+ * @return 返回布尔值，表示文件写入操作是否成功。
+ */
+fun ByteArray.fset(name: String, dir: String? = null, append: Boolean = false): Boolean {
+    val j_name = if (dir == null) Paths.get(name) else Paths.get(dir, name)
+    do {
+        try {
+            val j_c = FileChannel.open(j_name, StandardOpenOption.CREATE, if (append) StandardOpenOption.APPEND else StandardOpenOption.WRITE)
+            do {
+                try {
+                    val j_lock = j_c.lock()
+                    try {
+                        j_c.write(ByteBuffer.wrap(this))
+                        if (!append) j_c.truncate(j_c.position())
+                        return true
+                    } catch (_: Exception) {
+                        return false
+                    } finally {
+                        j_lock.close()
+                        j_c.close()
+                    }
+                } catch (_: java.nio.channels.OverlappingFileLockException) {
+                    Thread.sleep(1)
+                } catch (_: Exception) {
+                    j_c.close()
+                    return false
+                }
+            } while (true)
+        } catch (e: java.nio.file.NoSuchFileException) {
+            if (dir == null || !File(dir).mkdirs()) return false
+        } catch (_: Exception) {
+            return false
+        }
+    } while (true)
+}
+
+/**
+ * 从当前字符串表示的文件路径中读取内容并返回其字节数组。
+ * 如果文件使用过程中出现异常、大小超出限制或读取失败，则返回 null。
+ *
+ * @return 文件内容的字节数组，若读取失败则返回 null。
+ */
+fun String.fget(): ByteArray? {
+    try {
+        val j_c = FileChannel.open(Paths.get(this), StandardOpenOption.WRITE, StandardOpenOption.READ)
+        do {
+            try {
+                val j_lock = j_c.lock()
+                try {
+                    val j_size = j_c.size()
+                    if (j_size > Int.MAX_VALUE) return null
+                    val j_buf = ByteBuffer.allocate(j_size.toInt())
+                    if (j_c.read(j_buf) != j_size.toInt()) return null
+                    return j_buf.array()
+                } catch (_: Exception) {
+                    return null
+                } finally {
+                    j_lock.close()
+                    j_c.close()
+                }
+            } catch (_: java.nio.channels.OverlappingFileLockException) {
+                Thread.sleep(1)
+            } catch (e: Exception) {
+                j_c.close()
+                return null
+            }
+        } while (true)
+    } catch (_: Exception) {
+    }
+    return null
+}

src/main/kotlin/cn/qqck/kotlin/tools/Hex.kt

@@ -0,0 +1,69 @@
+package cn.qqck.kotlin.tools
+
+private val m_hexLittle = charArrayOf('0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f')
+private val m_hexUpper = charArrayOf('0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F')
+
+/**
+ * 将当前字节数组转换为对应的十六进制字符串表示。
+ *
+ * @param upper 是否使用大写字母表示十六进制字符，默认为false（小写字母）。
+ * @return 转换后的十六进制字符串。如果字节数组为空，则返回空字符串。
+ */
+fun ByteArray.hex(upper: Boolean = false): String {
+    if (this.isEmpty()) return ""
+    val j_str = StringBuilder(this.size * 2) // 一个字节对应两个16进制数，所以长度为字节数组乘2
+    if (upper) {
+        for (j_byte in this) {
+            j_str.append(m_hexUpper[j_byte.toInt() ushr 4 and 0xf])
+            j_str.append(m_hexUpper[j_byte.toInt() and 0xf])
+        }
+    } else {
+        for (j_byte in this) {
+            j_str.append(m_hexLittle[j_byte.toInt() ushr 4 and 0xf])
+            j_str.append(m_hexLittle[j_byte.toInt() and 0xf])
+        }
+    }
+    return j_str.toString()
+}
+
+private val reverseHexTable = intArrayOf(
+    255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+    255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+    255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+    0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 255, 255, 255, 255, 255, 255, 255, 10, 11, 12, 13,
+    14, 15, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+    255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 10, 11, 12, 13, 14,
+    15, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+    255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+    255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+    255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+    255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+    255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+    255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+    255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+    255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+    255, 255, 255, 255, 255, 255, 255, 255, 255, 255
+)
+
+/**
+ * 将当前字符串解析为十六进制格式并返回对应的字节数组。
+ *
+ * @param replace 是否替换字符串中的空白字符（包括空格、回车、换行和制表符）。默认为 false。
+ * @return 如果字符串为空或长度为奇数，返回空字节数组；否则返回解析后的十六进制字节数组。
+ */
+fun String.hex(replace: Boolean = false): ByteArray {
+    if (this.isEmpty() || this.length % 2 == 1) return ByteArray(0)
+    var j_i = 0
+    val j_src = if (replace) this.replace(" ", "").replace("\r", "").replace("\n", "").replace("\t", "").toByteArray() else this.toByteArray()
+    val j_buf = ByteArray(j_src.size / 2)
+    var j_src_i = 0
+    while (j_src_i < j_src.size) {
+        val j_left = reverseHexTable[j_src[j_src_i].toInt()]
+        val j_right = reverseHexTable[j_src[j_src_i + 1].toInt()]
+        if (j_left > 0x0f || j_right > 0x0f) return ByteArray(0)
+        j_buf[j_i] = (j_left shl 4 or j_right).toByte()
+        j_i++
+        j_src_i += 2
+    }
+    return j_buf
+}

src/main/kotlin/cn/qqck/kotlin/tools/Json.kt

@@ -0,0 +1,13 @@
+package cn.qqck.kotlin.tools
+
+fun ByteArray.json(): dev.botta.json.values.JsonValue {
+    return this.string().json()
+}
+
+fun String.json(): dev.botta.json.values.JsonValue {
+    return try {
+        dev.botta.json.Json.parse(this)
+    } catch (_: Exception) {
+        dev.botta.json.values.JsonObject()
+    }
+}

src/main/kotlin/cn/qqck/kotlin/tools/KeyStore.kt

@@ -0,0 +1,34 @@
+package cn.qqck.kotlin.tools
+
+import java.io.ByteArrayInputStream
+import java.security.KeyFactory
+import java.security.cert.CertificateFactory
+import java.security.spec.PKCS8EncodedKeySpec
+
+object KeyStore {
+    fun pem2ks(cert: String, key: String, alias: String, password: String, type: String = "jks"): java.security.KeyStore? = try {
+        val j_keystore = java.security.KeyStore.getInstance(type)
+        j_keystore.load(null, null)
+        j_keystore.setKeyEntry(
+            alias,
+            KeyFactory.getInstance("RSA").generatePrivate(
+                PKCS8EncodedKeySpec(
+                    key.replace("-----BEGIN PRIVATE KEY-----", "")
+                        .replace("-----END PRIVATE KEY-----", "")
+                        .replace("\n", "")
+                        .replace(" ", "")
+                        .base64()
+                )
+            ),
+            password.toCharArray(),
+            CertificateFactory
+                .getInstance("X.509")
+                .generateCertificates(ByteArrayInputStream(cert.toByteArray()))
+                .toTypedArray()
+        )
+        j_keystore
+    } catch (e: Exception) {
+        e.printStackTrace()
+        null
+    }
+}

src/main/kotlin/cn/qqck/kotlin/tools/Md5.kt

@@ -0,0 +1,4 @@
+package cn.qqck.kotlin.tools
+
+fun ByteArray.md5(): ByteArray = java.security.MessageDigest.getInstance("MD5").digest(this)
+fun String.md5(): ByteArray = java.security.MessageDigest.getInstance("MD5").digest(this.toByteArray())

src/main/kotlin/cn/qqck/kotlin/tools/Okhttp.kt

@@ -0,0 +1,212 @@
+package cn.qqck.kotlin.tools
+
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.runBlocking
+import okhttp3.*
+import java.security.KeyStore
+import java.security.SecureRandom
+import java.security.cert.X509Certificate
+import java.time.Duration
+import java.util.concurrent.TimeUnit
+import javax.net.ssl.*
+
+object Okhttp {
+    private val ConnectionPool: ConnectionPool = ConnectionPool(0, 1, TimeUnit.MILLISECONDS) // 禁用连接池
+    private val SSLSocketFactory: SSLSocketFactory
+    private val X509TrustManager: X509TrustManager
+
+    init {
+        val j_sslct = SSLContext.getInstance("SSL")
+        j_sslct.init(null, arrayOf<TrustManager>(object : X509TrustManager {
+            override fun checkClientTrusted(chain: Array<X509Certificate>, authType: String) {
+            }
+
+            override fun checkServerTrusted(chain: Array<X509Certificate>, authType: String) {
+            }
+
+            override fun getAcceptedIssuers(): Array<X509Certificate> {
+                return arrayOf()
+            }
+        }), SecureRandom())
+        this.SSLSocketFactory = j_sslct.socketFactory
+
+        val trustManagerFactory = TrustManagerFactory.getInstance(TrustManagerFactory.getDefaultAlgorithm())
+        trustManagerFactory.init(null as KeyStore?)
+        val trustManagers = trustManagerFactory.trustManagers
+        check(!(trustManagers.size != 1 || trustManagers[0] !is X509TrustManager)) { "Unexpected default trust managers:" + trustManagers.contentToString() }
+        this.X509TrustManager = trustManagers[0] as X509TrustManager
+    }
+
+    class Option {
+        /**
+         * 重定向，默认为 false
+         */
+        private var redirects = false
+
+        /**
+         * 重定向，默认为 false
+         */
+        fun redirects(): Boolean {
+            return this.redirects
+        }
+
+        /**
+         * 重定向，默认为 false
+         */
+        fun redirects(v: Boolean): Option {
+            this.redirects = v
+            return this
+        }
+
+        /**
+         * SSL验证，默认为 false
+         */
+        private var SSLVerification = false
+
+        /**
+         * SSL验证，默认为 false
+         */
+        fun SSLVerification(): Boolean {
+            return this.redirects
+        }
+
+        /**
+         * SSL验证，默认为 false
+         */
+        fun SSLVerification(v: Boolean): Option {
+            this.SSLVerification = v
+            return this
+        }
+
+        /**
+         * 请求超时时间，默认为 60s
+         */
+        private var Timeout = Duration.ofSeconds(60)
+
+        /**
+         * 请求超时时间，默认为 60s
+         */
+        fun Timeout(): Duration {
+            return this.Timeout
+        }
+
+        /**
+         * 请求超时时间，默认为 60s
+         */
+        fun Timeout(v: Duration): Option {
+            this.Timeout = v
+            return this
+        }
+    }
+
+    data class Body(
+        /**
+         * @see Response.code
+         */
+        val code: Int,
+        /**
+         * @see Response.protocol
+         */
+        val protocol: String,
+        /**
+         * @see Response.message
+         */
+        val message: String,
+        /**
+         * @see Response.headers
+         */
+        val headers: Headers,
+        /**
+         * @see Response.body
+         */
+        val body: ByteArray?,
+    ) {
+        override fun toString(): String {
+            return "Body(code=${code}, protocol='${protocol}', message='${message}', headers=${headers}, body=${body?.size})"
+        }
+
+        override fun equals(other: Any?): Boolean {
+            if (other == null) return false
+            if (this === other) return true
+            if (javaClass != other.javaClass) return false
+            other as Body
+            if (code != other.code) return false
+            if (protocol != other.protocol) return false
+            if (message != other.message) return false
+            if (headers != other.headers) return false
+            if (body == null) return other.body == null
+            if (other.body == null) return false
+            return body.contentEquals(other.body)
+        }
+
+        override fun hashCode(): Int {
+            var j_hash = code
+            j_hash += protocol.hashCode()
+            j_hash += message.hashCode()
+            j_hash += headers.hashCode()
+            j_hash += body?.hashCode() ?: 0
+            return j_hash
+        }
+    }
+
+    /**
+     *
+     * POST示例：
+     * ```
+     * Okhttp.call("http://www.baidu.com") {
+     *     it.post("asd".toRequestBody("multipart/form-data".toMediaTypeOrNull()))
+     * }
+     * ```
+     * 文件上传示例：
+     * ```
+     * Okhttp.call("http://www.baidu.com") {
+     *     it.post(
+     *         MultipartBody.Builder().setType(MultipartBody.FORM) // 上传的文件名称——参数不可省
+     *             .addFormDataPart(
+     *                 "file",
+     *                 "adasdsa",
+     *                 File("${filesDir}/config.json").asRequestBody("image/jpeg".toMediaTypeOrNull())
+     *             )
+     *             .addFormDataPart("参数2", "参数2的值")
+     *             .addFormDataPart("参数3", "参数3的值")
+     *             .build()
+     *     )
+     * }
+     * ```
+     */
+    fun call(url: String, option: Option = Option(), pre: (build: Request.Builder) -> Unit = {}): Body? = runBlocking {
+        val j_client = OkHttpClient.Builder()
+        j_client.connectionPool(ConnectionPool)
+        if (!option.redirects()) j_client.followSslRedirects(false).followRedirects(false) // 禁止重定向
+        if (!option.SSLVerification()) j_client.sslSocketFactory(SSLSocketFactory, X509TrustManager).hostnameVerifier { _, _ -> true } // 忽略 ssl 证书
+        j_client.callTimeout(option.Timeout())
+        j_client.readTimeout(option.Timeout()) // 读取超时
+        val j_req = Request.Builder().url(url)
+        pre(j_req)
+        val j_call = j_client.build().newCall(j_req.build())
+        var j_body: Body? = null
+        launch {
+            try {
+                j_body = this@Okhttp.call_response(j_call.execute())
+            } catch (e: Exception) {
+                // e.printStackTrace()
+            }
+        }.join()
+        j_call.cancel()
+        j_call.clone()
+        return@runBlocking j_body
+    }
+
+    private fun call_response(r: Response): Body {
+        val j_body = Body(r.code, r.protocol.toString(), r.message, r.headers, r.body?.bytes())
+        r.close()
+        return j_body
+    }
+
+    fun isNet(): Boolean {
+        val j_op = Option().Timeout(Duration.ofSeconds(3))
+        this.call("http://www.aliyun.com/111", j_op)?.also { if (it.code == 301) return true }
+        this.call("http://www.baidu.com/111", j_op)?.also { if (it.code == 404) return true }
+        return false
+    }
+}

src/main/kotlin/cn/qqck/kotlin/tools/Proxy.kt

@@ -0,0 +1,413 @@
+package cn.qqck.kotlin.tools
+
+import kotlin.concurrent.withLock
+
+class Proxy {
+    enum class Type {
+        Direct,
+        Http,
+        Socks5,
+    }
+
+    data class Info(
+        var addr: String = "",
+        var port: Int = 0,
+        var user: String = "",
+        var pass: String = "",
+        var type: Type = Type.Http,
+        var timeout: Long = 0,
+    ) {
+
+        /**
+         * 判断代理是否有效且时间是否未到期
+         */
+        fun isValid(): Boolean {
+            if (this.addr == "" || this.port < 1 || this.port > 65535) return false
+            return this.timeout == -1L || System.currentTimeMillis() < this.timeout
+        }
+
+        /**
+         * 代理是否需要授权
+         */
+        fun authorization(): Boolean {
+            return this.user != "" && this.pass != ""
+        }
+
+        /**
+         * 编码为"Type://user:pass@host:port"，例如："Http://user:pass@127.0.0.1:808"、"socks5://user:pass@127.0.0.1:808"
+         */
+        override fun toString(): String {
+            if (this.addr == "") return ""
+            val j_buf = StringBuilder(64)
+            j_buf.append(
+                when (this.type) {
+                    Type.Direct -> "direct://"
+                    Type.Http -> "http://"
+                    Type.Socks5 -> "socks5://"
+                }
+            )
+            if (this.authorization()) {
+                j_buf.append(this.user)
+                j_buf.append(":")
+                j_buf.append(this.pass)
+                j_buf.append("@")
+            }
+            j_buf.append(this.addr)
+            j_buf.append(":")
+            j_buf.append(this.port)
+            return j_buf.toString()
+        }
+    }
+
+    /**
+     * 代理池
+     */
+    class Pool {
+        private val lock = java.util.concurrent.locks.ReentrantLock()
+
+        /**
+         * 提取链接或直连地址
+         */
+        private var url: String = ""
+
+        /**
+         * 提取链接或直连地址
+         */
+        fun url(): String {
+            lock.withLock {
+                return this.url
+            }
+        }
+
+        /**
+         * 提取链接或直连地址
+         */
+        fun url(value: String): Pool {
+            lock.withLock { this.url = value }
+            return this
+        }
+
+
+        /**
+         * 提取链接是否为隧道直连地址
+         */
+        private var url_tunnel: Boolean = false
+
+        /**
+         * 提取链接是否为隧道直连地址
+         */
+        fun url_tunnel(): Boolean {
+            lock.withLock { return this.url_tunnel }
+        }
+
+        /**
+         * 提取链接是否为隧道直连地址
+         */
+        fun url_tunnel(value: Boolean): Pool {
+            lock.withLock { this.url_tunnel = value }
+            return this
+        }
+
+
+        /**
+         * 请求 Url 的最少间隔，默认不限制，单位：毫秒
+         */
+        private var url_space: Long = 0
+
+        /**
+         * 请求 Url 的最少间隔，默认不限制，单位：毫秒
+         */
+        fun url_space(): Long {
+            lock.withLock { return this.url_space }
+        }
+
+        /**
+         * 请求 Url 的最少间隔，默认不限制，单位：毫秒
+         */
+        fun url_space(value: Long): Pool {
+            lock.withLock { this.url_space = value }
+            return this
+        }
+
+
+        /**
+         * 代理类型，默认[Type.Http]
+         */
+        private var type: Type = Type.Http
+
+        /**
+         * 代理类型，默认[Type.Http]
+         */
+        fun type(): Type {
+            lock.withLock { return this.type }
+        }
+
+        /**
+         * 代理类型，默认[Type.Http]
+         */
+        fun type(value: Type): Pool {
+            lock.withLock { this.type = value }
+            return this
+        }
+
+
+        /**
+         * 认证账号，如果代理需要身份认证的情况下填写
+         */
+        private var user: String = ""
+
+        /**
+         * 认证账号，如果代理需要身份认证的情况下填写
+         */
+        fun user(): String {
+            lock.withLock { return this.user }
+        }
+
+        /**
+         * 认证账号，如果代理需要身份认证的情况下填写
+         */
+        fun user(value: String): Pool {
+            lock.withLock { this.user = value }
+            return this
+        }
+
+
+        /**
+         * 认证密码，如果代理需要身份认证的情况下填写
+         */
+        private var pass: String = ""
+
+        /**
+         * 认证密码，如果代理需要身份认证的情况下填写
+         */
+        fun pass(): String {
+            lock.withLock { return this.pass }
+        }
+
+        /**
+         * 认证密码，如果代理需要身份认证的情况下填写
+         */
+        fun pass(value: String): Pool {
+            lock.withLock { this.pass = value }
+            return this
+        }
+
+
+        /**
+         * 代理有效时长，默认30秒，单位：毫秒
+         */
+        private var valid_time: Long = 1000 * 30
+
+        /**
+         * 代理有效时长，默认30秒，单位：毫秒
+         */
+        fun valid_time(): Long {
+            lock.withLock { return this.valid_time }
+        }
+
+        /**
+         * 代理有效时长，默认30秒，单位：毫秒
+         */
+        fun valid_time(value: Long): Pool {
+            lock.withLock { this.valid_time = value }
+            return this
+        }
+
+
+        /**
+         * 代理池内有效时间低于该值就视为无效代理，默认10秒，单位：毫秒
+         */
+        private var release_time: Long = 1000 * 10
+
+        /**
+         * 代理池内有效时间低于该值就视为无效代理，默认10秒，单位：毫秒
+         */
+        fun release_time(): Long {
+            lock.withLock { return this.release_time }
+        }
+
+        /**
+         * 代理池内有效时间低于该值就视为无效代理，默认为10秒，单位：毫秒
+         */
+        fun release_time(value: Long): Pool {
+            lock.withLock { this.release_time = value }
+            return this
+        }
+
+
+        // -------------------------------------------------------------------------
+
+
+        /**
+         * 代理池列表
+         */
+        private var get_list = ArrayDeque<Info>()
+
+        /**
+         * 当前代理池剩余[Info]数量
+         */
+        fun size(): Int {
+            return lock.withLock { this.get_list.size }
+        }
+
+        /**
+         * 最后请求 Url 的时间，单位：毫秒
+         */
+        private var get_request_time: Long = 0
+
+        /**
+         * 已使用计数
+         */
+        private var get_i: Int = 0
+
+        /**
+         * 单个 IP 最多使用次数，默认为：1
+         */
+        private var get_max: Int = 1
+
+        /**
+         * 单个 IP 最多使用次数，默认为：1
+         */
+        fun get_max(): Int {
+            lock.withLock { return this.get_max }
+        }
+
+        /**
+         * 单个 IP 最多使用次数，默认为：1
+         */
+        fun get_max(value: Int): Pool {
+            lock.withLock { this.get_max = if (value < 1) 1 else value }
+            return this
+        }
+
+        /**
+         * 已提取计数
+         */
+        private var get_count = 0L
+
+        /**
+         * 已提取计数
+         */
+        fun get_count(): Long {
+            lock.withLock { return this.get_count }
+        }
+
+        /**
+         * 当前代理
+         */
+        private var get_info: Info = Info()
+
+
+        /**
+         * 重置代理池缓存信息
+         */
+        fun reset(): Pool {
+            lock.withLock {
+                this.get_list.clear()
+                this.get_request_time = 0
+                this.get_i = 0
+                this.get_count = 0
+                this.get_info = Info()
+            }
+            return this
+        }
+
+        /**
+         * 获取一个有效的代理信息。
+         * 方法会根据当前配置及代理池状态，返回一个可用的 `Info` 对象。
+         * 如果当前代理池为空或无可用代理信息，可能返回 `null`。
+         *
+         * @return 一个有效的 `Info` 对象，若无可用代理则返回 `null`。
+         */
+        fun get(): Info? {
+            lock.withLock {
+                if (this.url_tunnel) {
+                    val j_adp = this.url.toAddrPort() ?: return null
+                    this.get_count++
+                    return Info(j_adp.addr, j_adp.port, this.user, this.pass, this.type, System.currentTimeMillis() + this.valid_time - this.release_time)
+                }
+                if (!this.get_info.isValid() || this.get_i >= this.get_max) {
+                    if (this.get_list.isEmpty()) this.get_url()
+                    if (this.get_list.isEmpty()) return null
+                    while (this.get_list.isNotEmpty()) {
+                        this.get_info = this.get_list.removeAt(0)
+                        if (this.get_info.isValid()) {
+                            this.get_i = 1
+                            this.get_count++
+                            return this.get_info
+                        }
+                    }
+                    return null
+                }
+                this.get_i++
+                return this.get_info
+            }
+        }
+
+        private val url_item_sps = arrayOf(" ", "|", ":", "/")
+        private fun get_url() {
+            if (this.url == "") return
+            var j_time = System.currentTimeMillis()
+            if (j_time - this.get_request_time < this.url_space) return
+            Okhttp.call(this.url, Okhttp.Option().redirects(true))?.also {
+                if (it.code != 200) return
+                val j_response = it.body?.string() ?: return
+                this.get_request_time = j_time
+                j_time = System.currentTimeMillis() + this.valid_time - this.release_time
+                (if (j_response.contains("\r\n")) {
+                    j_response.split("\r\n")
+                } else if (j_response.contains("\\r\\n")) {
+                    j_response.split("\\r\\n")
+                } else if (j_response.contains("\r")) {
+                    j_response.split("\r")
+                } else if (j_response.contains("\\r")) {
+                    j_response.split("\\r")
+                } else if (j_response.contains("\n")) {
+                    j_response.split("\n")
+                } else if (j_response.contains("\\n")) {
+                    j_response.split("\\n")
+                } else if (j_response.contains("\\t")) {
+                    j_response.split("\\t")
+                } else if (j_response.contains("\t")) {
+                    j_response.split("\t")
+                } else if (j_response.contains("<br/>")) {
+                    j_response.split("<br/>")
+                } else if (j_response.contains("    ")) {
+                    j_response.split("    ")
+                } else if (j_response.contains("   ")) {
+                    j_response.split("   ")
+                } else if (j_response.contains("  ")) {
+                    j_response.split("  ")
+                } else {
+                    listOf(j_response)
+                }).forEach { j_item ->
+                    if (j_item.isEmpty()) return@forEach
+                    val j_info = Info("", 0, this.user, this.pass, this.type, j_time)
+                    for (j_sp in this.url_item_sps) if (j_item.indexOf(j_sp) > -1) {
+                        val j_items = j_item.split(j_sp)
+                        if (j_items.size == 3) {
+                            val j_adp = j_items[0].toAddrPort() ?: return@forEach
+                            j_info.addr = j_adp.addr
+                            j_info.port = j_adp.port
+                            j_info.user = j_items[1]
+                            j_info.pass = j_items[2]
+                            this.get_list.add(j_info)
+                            return@forEach
+                        } else if (j_items.size == 4) {
+                            j_info.addr = j_items[0]
+                            j_info.port = j_items[1].toIntOrNull() ?: return@forEach
+                            j_info.user = j_items[2]
+                            j_info.pass = j_items[3]
+                            this.get_list.add(j_info)
+                            return@forEach
+                        }
+                    }
+                    val j_adp = j_item.toAddrPort() ?: return@forEach
+                    j_info.addr = j_adp.addr
+                    j_info.port = j_adp.port
+                    this.get_list.add(j_info)
+                }
+            }
+        }
+    }
+}

src/main/kotlin/cn/qqck/kotlin/tools/Rand.kt

@@ -0,0 +1,308 @@
+package cn.qqck.kotlin.tools
+
+val Random = kotlin.random.Random(System.nanoTime())
+
+object Rand {
+
+    /**
+     * 生成一个指定范围内的随机整数。
+     *
+     * @param min 随机数的最小值，包含在范围内。
+     * @param max 随机数的最大值，包含在范围内。
+     * @return 指定范围内的随机整数。
+     */
+    fun int(min: Int, max: Int): Int = Random.nextInt(max) % (max - min + 1) + min
+
+    /**
+     * 生成指定范围内的随机Long类型数值。
+     *
+     * @param min 随机数的最小值（包含）。
+     * @param max 随机数的最大值（包含）。
+     * @return 一个位于[min, max]范围内的随机Long值。
+     */
+    fun long(min: Long, max: Long): Long = Random.nextLong(max) % (max - min + 1) + min
+
+    /**
+     * 生成指定大小的随机字节数组。
+     *
+     * @param size 随机字节数组的大小，必须是非负整数。
+     * @return 生成的随机字节数组，其长度等于指定的大小。
+     */
+    fun bytes(size: Int): ByteArray = Random.nextBytes(size)
+
+    object str {
+        fun az(size: Int, ex: CharArray? = null): String {
+            val j_str = CharArray(size)
+            if (ex == null || ex.isEmpty()) {
+                for (j_i in j_str.indices) j_str[j_i] = Random.nextInt(97, 123).toChar() // 123 是 'z' 的下一个字符
+            } else {
+                val j_ex_size = ex.size
+                for (j_i in j_str.indices) j_str[j_i] = when (Random.nextInt(2)) {
+                    0 -> Random.nextInt(97, 123).toChar() // 123 是 'z' 的下一个字符
+                    else -> ex[Random.nextInt(0, j_ex_size)]
+                }
+            }
+            return String(j_str)
+        }
+
+        fun AZ(size: Int, ex: CharArray? = null): String {
+            val j_str = CharArray(size)
+            if (ex == null || ex.isEmpty()) {
+                for (j_i in j_str.indices) j_str[j_i] = Random.nextInt(65, 91).toChar() // 91 是 'Z' 的下一个字符
+            } else {
+                val j_ex_size = ex.size
+                for (j_i in j_str.indices) j_str[j_i] = when (Random.nextInt(2)) {
+                    0 -> Random.nextInt(65, 91).toChar() // 91 是 'Z' 的下一个字符
+                    else -> ex[Random.nextInt(0, j_ex_size)]
+                }
+            }
+            return String(j_str)
+        }
+
+        fun aZ(size: Int, ex: CharArray? = null): String {
+            val j_str = CharArray(size)
+            if (ex == null || ex.isEmpty()) {
+                for (j_i in j_str.indices) j_str[j_i] = when (Random.nextInt(2)) {
+                    0 -> Random.nextInt(97, 123).toChar() // 123 是 'z' 的下一个字符
+                    else -> Random.nextInt(65, 91).toChar() // 91 是 'Z' 的下一个字符
+                }
+            } else {
+                val j_ex_size = ex.size
+                for (j_i in j_str.indices) j_str[j_i] = when (Random.nextInt(3)) {
+                    0 -> Random.nextInt(97, 123).toChar() // 123 是 'z' 的下一个字符
+                    1 -> Random.nextInt(65, 91).toChar() // 91 是 'Z' 的下一个字符
+                    else -> ex[Random.nextInt(0, j_ex_size)]
+                }
+            }
+            return String(j_str)
+        }
+
+        fun num(size: Int, ex: CharArray? = null): String {
+            val j_str = CharArray(size)
+            if (ex == null || ex.isEmpty()) {
+                for (j_i in j_str.indices) j_str[j_i] = Random.nextInt(48, 58).toChar() // 58 是 '9' 的下一个字符
+            } else {
+                val j_ex_size = ex.size
+                for (j_i in j_str.indices) j_str[j_i] = when (Random.nextInt(2)) {
+                    0 -> Random.nextInt(48, 58).toChar() // 58 是 '9' 的下一个字符
+                    else -> ex[Random.nextInt(0, j_ex_size)]
+                }
+            }
+            return String(j_str)
+        }
+
+        fun num_az(size: Int, ex: CharArray? = null): String {
+            val j_str = CharArray(size)
+            if (ex == null || ex.isEmpty()) {
+                for (j_i in j_str.indices) j_str[j_i] = when (Random.nextInt(2)) {
+                    0 -> Random.nextInt(48, 58).toChar() // 58 是 '9' 的下一个字符
+                    else -> Random.nextInt(97, 123).toChar() // 123 是 'z' 的下一个字符
+                }
+            } else {
+                val j_ex_size = ex.size
+                for (j_i in j_str.indices) j_str[j_i] = when (Random.nextInt(3)) {
+                    0 -> Random.nextInt(48, 58).toChar() // 58 是 '9' 的下一个字符
+                    1 -> Random.nextInt(97, 123).toChar() // 123 是 'z' 的下一个字符
+                    else -> ex[Random.nextInt(0, j_ex_size)]
+                }
+            }
+            return String(j_str)
+        }
+
+        fun num_AZ(size: Int, ex: CharArray? = null): String {
+            val j_str = CharArray(size)
+            if (ex == null || ex.isEmpty()) {
+                for (j_i in j_str.indices) j_str[j_i] = when (Random.nextInt(2)) {
+                    0 -> Random.nextInt(48, 58).toChar() // 58 是 '9' 的下一个字符
+                    else -> Random.nextInt(65, 91).toChar()  // 91 是 'Z' 的下一个字符
+                }
+            } else {
+                val j_ex_size = ex.size
+                for (j_i in j_str.indices) j_str[j_i] = when (Random.nextInt(3)) {
+                    0 -> Random.nextInt(48, 58).toChar() // 58 是 '9' 的下一个字符
+                    1 -> Random.nextInt(65, 91).toChar()  // 91 是 'Z' 的下一个字符
+                    else -> ex[Random.nextInt(0, j_ex_size)]
+                }
+            }
+            return String(j_str)
+        }
+
+        fun num_aZ(size: Int, ex: CharArray? = null): String {
+            val j_str = CharArray(size)
+            if (ex == null || ex.isEmpty()) {
+                for (j_i in j_str.indices) j_str[j_i] = when (Random.nextInt(3)) {
+                    0 -> Random.nextInt(48, 58).toChar() // 58 是 '9' 的下一个字符
+                    1 -> Random.nextInt(97, 123).toChar() // 123 是 'z' 的下一个字符
+                    else -> Random.nextInt(65, 91).toChar()  // 91 是 'Z' 的下一个字符
+                }
+            } else {
+                val j_ex_size = ex.size
+                for (j_i in j_str.indices) j_str[j_i] = when (Random.nextInt(4)) {
+                    0 -> Random.nextInt(48, 58).toChar() // 58 是 '9' 的下一个字符
+                    1 -> Random.nextInt(97, 123).toChar() // 123 是 'z' 的下一个字符
+                    2 -> Random.nextInt(65, 91).toChar()  // 91 是 'Z' 的下一个字符
+                    else -> ex[Random.nextInt(0, j_ex_size)]
+                }
+            }
+            return String(j_str)
+        }
+
+        fun ascii(size: Int, ex: CharArray? = null): String {
+            val j_str = CharArray(size)
+            if (ex == null || ex.isEmpty()) {
+                for (j_i in j_str.indices) j_str[j_i] = Random.nextInt(33, 127).toChar() // 所有单字节字符
+            } else {
+                val j_ex_size = ex.size
+                for (j_i in j_str.indices) j_str[j_i] = when (Random.nextInt(2)) {
+                    0 -> Random.nextInt(33, 127).toChar() // 所有单字节字符
+                    else -> ex[Random.nextInt(0, j_ex_size)]
+                }
+            }
+            return String(j_str)
+        }
+
+        fun china(size: Int, ex: CharArray? = null): String {
+            val j_str = CharArray(size)
+            if (ex == null || ex.isEmpty()) {
+                // java内部使用unicode编码，汉字的Unicode编码范围为\u4E00-\u9FCB \uF900-\uFA2D,如果不在这个范围内就不是汉字。
+                for (j_i in j_str.indices) j_str[j_i] = Random.nextInt(0x4E00, 0x9FCB + 1).toChar()
+            } else {
+                val j_ex_size = ex.size
+                for (j_i in j_str.indices) j_str[j_i] = when (Random.nextInt(2)) {
+                    // java内部使用unicode编码，汉字的Unicode编码范围为\u4E00-\u9FCB \uF900-\uFA2D,如果不在这个范围内就不是汉字。
+                    0 -> Random.nextInt(0x4E00, 0x9FCB + 1).toChar()
+                    else -> ex[Random.nextInt(0, j_ex_size)]
+                }
+            }
+            return String(j_str)
+        }
+
+    }
+
+    private val _hexLittle = "0123456789abcdef".toByteArray()
+    private val _hexBig = "0123456789ABCDEF".toByteArray()
+
+    /**
+     * 生成随机 mac
+     * @param big 是否大写 mac
+     */
+    fun mac(big: Boolean = false): String {
+        val j_buf = ByteArray(17)
+        if (big) {
+            j_buf[0] = _hexBig[Random.nextInt(16)]
+            j_buf[1] = _hexBig[Random.nextInt(16)]
+            j_buf[2] = 58
+            j_buf[3] = _hexBig[Random.nextInt(16)]
+            j_buf[4] = _hexBig[Random.nextInt(16)]
+            j_buf[5] = 58
+            j_buf[6] = _hexBig[Random.nextInt(16)]
+            j_buf[7] = _hexBig[Random.nextInt(16)]
+            j_buf[8] = 58
+            j_buf[9] = _hexBig[Random.nextInt(16)]
+            j_buf[10] = _hexBig[Random.nextInt(16)]
+            j_buf[11] = 58
+            j_buf[12] = _hexBig[Random.nextInt(16)]
+            j_buf[13] = _hexBig[Random.nextInt(16)]
+            j_buf[14] = 58
+            j_buf[15] = _hexBig[Random.nextInt(16)]
+            j_buf[16] = _hexBig[Random.nextInt(16)]
+        } else {
+            j_buf[0] = _hexLittle[Random.nextInt(16)]
+            j_buf[1] = _hexLittle[Random.nextInt(16)]
+            j_buf[2] = 58
+            j_buf[3] = _hexLittle[Random.nextInt(16)]
+            j_buf[4] = _hexLittle[Random.nextInt(16)]
+            j_buf[5] = 58
+            j_buf[6] = _hexLittle[Random.nextInt(16)]
+            j_buf[7] = _hexLittle[Random.nextInt(16)]
+            j_buf[8] = 58
+            j_buf[9] = _hexLittle[Random.nextInt(16)]
+            j_buf[10] = _hexLittle[Random.nextInt(16)]
+            j_buf[11] = 58
+            j_buf[12] = _hexLittle[Random.nextInt(16)]
+            j_buf[13] = _hexLittle[Random.nextInt(16)]
+            j_buf[14] = 58
+            j_buf[15] = _hexLittle[Random.nextInt(16)]
+            j_buf[16] = _hexLittle[Random.nextInt(16)]
+        }
+        return String(j_buf)
+    }
+
+    /**
+     * 生成随机 androidId
+     * @param big 是否大写 androidId
+     */
+    fun androidId(big: Boolean = false): String {
+        val j_buf = ByteArray(16)
+        if (big) {
+            j_buf[0] = _hexBig[Random.nextInt(16)]
+            j_buf[1] = _hexBig[Random.nextInt(16)]
+            j_buf[2] = _hexBig[Random.nextInt(16)]
+            j_buf[3] = _hexBig[Random.nextInt(16)]
+            j_buf[4] = _hexBig[Random.nextInt(16)]
+            j_buf[5] = _hexBig[Random.nextInt(16)]
+            j_buf[6] = _hexBig[Random.nextInt(16)]
+            j_buf[7] = _hexBig[Random.nextInt(16)]
+            j_buf[8] = _hexBig[Random.nextInt(16)]
+            j_buf[9] = _hexBig[Random.nextInt(16)]
+            j_buf[10] = _hexBig[Random.nextInt(16)]
+            j_buf[11] = _hexBig[Random.nextInt(16)]
+            j_buf[12] = _hexBig[Random.nextInt(16)]
+            j_buf[13] = _hexBig[Random.nextInt(16)]
+            j_buf[14] = _hexBig[Random.nextInt(16)]
+            j_buf[15] = _hexBig[Random.nextInt(16)]
+        } else {
+            j_buf[0] = _hexLittle[Random.nextInt(16)]
+            j_buf[1] = _hexLittle[Random.nextInt(16)]
+            j_buf[2] = _hexLittle[Random.nextInt(16)]
+            j_buf[3] = _hexLittle[Random.nextInt(16)]
+            j_buf[4] = _hexLittle[Random.nextInt(16)]
+            j_buf[5] = _hexLittle[Random.nextInt(16)]
+            j_buf[6] = _hexLittle[Random.nextInt(16)]
+            j_buf[7] = _hexLittle[Random.nextInt(16)]
+            j_buf[8] = _hexLittle[Random.nextInt(16)]
+            j_buf[9] = _hexLittle[Random.nextInt(16)]
+            j_buf[10] = _hexLittle[Random.nextInt(16)]
+            j_buf[11] = _hexLittle[Random.nextInt(16)]
+            j_buf[12] = _hexLittle[Random.nextInt(16)]
+            j_buf[13] = _hexLittle[Random.nextInt(16)]
+            j_buf[14] = _hexLittle[Random.nextInt(16)]
+            j_buf[15] = _hexLittle[Random.nextInt(16)]
+        }
+        return String(j_buf)
+    }
+
+    /**
+     * 随机生成 imei
+     *
+     * @param pre 指定起始部分 imei
+     */
+    fun imei(pre: String = ""): String {
+        var j_sum = 0 // the control j_sum of digits
+        val j_final = ByteArray(15)
+
+        // 计算前面几位
+        for (j_i in pre.indices) {
+            var j_toAdd = pre[j_i].code - 48
+            j_final[j_i] = _hexLittle[j_toAdd]
+            if ((j_i + 1) % 2 == 0) { // special proc for every 2nd one
+                j_toAdd *= 2
+                if (j_toAdd >= 10) j_toAdd = (j_toAdd % 10) + 1
+            }
+            j_sum += j_toAdd // and even add them here!
+        }
+
+        // 生成后面几位
+        for (j_i in pre.length..<14) { // generating all the base digits
+            var j_toAdd = if (j_i == 0) Random.nextInt(9) + 1 else Random.nextInt(10)
+            j_final[j_i] = _hexLittle[j_toAdd]
+            if ((j_i + 1) % 2 == 0) { // special proc for every 2nd one
+                j_toAdd *= 2
+                if (j_toAdd >= 10) j_toAdd = (j_toAdd % 10) + 1
+            }
+            j_sum += j_toAdd // and even add them here!
+        }
+        j_final[14] = _hexLittle[(j_sum * 9) % 10] // calculating the control digit
+        return String(j_final)
+    }
+}

src/main/kotlin/cn/qqck/kotlin/tools/SizeUnits.kt

@@ -0,0 +1,58 @@
+package cn.qqck.kotlin.tools
+
+private val units = arrayOf("B", "KB", "MB", "GB", "TB")
+
+/**
+ * 将当前 Short 类型值转换为单位表示的字符串形式。
+ *
+ * @return 表示该值的单位字符串，例如以 B, KB, MB 等单位表示的结果。
+ */
+fun Short.toUnits(): String = this.toULong().toUnits()
+
+/**
+ * 将当前无符号短整型（UShort）数值转换为便于人类阅读的字符串表示，通常用于表示存储单位（如 B、KB、MB 等）。
+ *
+ * @return 转换后的字符串表示形式，示例格式为 "12.34 KB"。如果值为 0，则返回 "0 B"。
+ */
+fun UShort.toUnits(): String = this.toULong().toUnits()
+
+/**
+ * 将当前整型值转换为以适当单位表示的字符串。
+ *
+ * @return 转换后的字符串，表示适当单位的人类可读格式，例如B（字节）、KB（千字节）、MB（兆字节）等。
+ */
+fun Int.toUnits(): String = this.toULong().toUnits()
+
+/**
+ * 将当前无符号整型数值转换为人类可读的单位格式字符串。
+ *
+ * 例如，将内存大小或文件大小等数值表示为带单位的字符串形式（如KB, MB, GB等）。
+ *
+ * @return 转换后的带单位格式的字符串。
+ */
+fun UInt.toUnits(): String = this.toULong().toUnits()
+
+/**
+ * 将当前 Long 类型的数值转换为以适当单位表示的字符串。
+ *
+ * @return 转换后的字符串形式，表示大小的数值单位（例如 "1.00 KB", "1.00 MB" 等）。
+ */
+fun Long.toUnits(): String = this.toULong().toUnits()
+
+/**
+ * 将当前的无符号长整型值转换为以单位（如B、KB、MB等）表示的字符串。
+ *
+ * 该方法会根据数值的大小，自动选择合适的单位，将数值转换为更易读的形式。
+ *
+ * @return 表示转换后的带单位的字符串，例如 "12.34 KB" 或 "1.00 MB"。
+ */
+fun ULong.toUnits(): String {
+    if (this < 0u) return "0 B"
+    var j_size = this.toDouble()
+    var j_i = 0
+    while (j_size >= 1024 && j_i < units.size - 1) {
+        j_size /= 1024
+        j_i++
+    }
+    return String.format("%.2f %s", j_size, units[j_i])
+}

src/main/kotlin/cn/qqck/kotlin/tools/String.kt

@@ -0,0 +1,139 @@
+package cn.qqck.kotlin.tools
+
+fun String.bytes() = this.toByteArray()
+
+/**
+ * 从当前字符串中获取指定子字符串前的内容。
+ *
+ * @param find 要查找的子字符串。如果子字符串不存在，返回值将为 null。
+ * @return 当前字符串中位于指定子字符串之前的部分。如果子字符串未找到，返回 null。
+ */
+fun String.left(find: String): String? {
+    val j_index = this.indexOf(find)
+    if (j_index == -1) return null
+    return this.substring(0, j_index)
+}
+
+/**
+ * 返回从指定字符串 `find` 的出现位置开始一直到目标字符串末尾的子字符串。
+ * 如果目标字符串中未找到 `find`，返回 `null`。
+ *
+ * @param find 要查找的字符串。
+ * @return 如果找到，则返回从 `find` 结束位置到目标字符串末尾的子字符串；否则返回 `null`。
+ */
+fun String.right(find: String): String? {
+    val j_index = this.indexOf(find)
+    if (j_index == -1) return null
+    return this.substring(j_index + find.length, this.length)
+}
+
+/**
+ * 统计子字符串在当前字符串中出现的次数。
+ *
+ * @param sub 要统计的子字符串。
+ * @return 子字符串在当前字符串中出现的次数。如果子字符串为空或不存在，则返回0。
+ */
+fun String.count(sub: String): Int {
+    var j_count = 0
+    var j_index = this.indexOf(sub)
+    while (j_index > -1) {
+        j_count++
+        j_index = this.indexOf(sub, j_index + sub.length)
+    }
+    return j_count
+}
+
+/**
+ * 获取当前字符串中从指定左边界字符串到右边界字符串之间的子字符串。
+ *
+ * @param left 左边界字符串，如果找不到该字符串则返回null。
+ * @param right 右边界字符串，如果找不到该字符串则返回null。
+ * @return 位于左边界字符串之后，右边界字符串之前的子字符串。
+ *         如果任意边界字符串未找到，返回null。
+ */
+fun String.sub(left: String, right: String): String? {
+    var j_left = this.indexOf(left)
+    if (j_left == -1) return null
+    j_left += left.length
+    val j_right = this.indexOf(right, j_left)
+    if (j_right == -1) return null
+    return this.substring(j_left, j_right)
+}
+
+/**
+ * 判断当前字符串是否仅包含数字字符（0-9）。
+ *
+ * @return 如果字符串不为空且仅包含数字字符，则返回true；否则返回false。
+ */
+fun String.is09(): Boolean {
+    if (this.isEmpty()) return false
+    return this.all { it.isDigit() }
+}
+
+/**
+ * 判断当前字符串是否为有效的十六进制字符串。
+ *
+ * 十六进制字符串的定义为仅包含以下字符：'0'-'9'、'a'-'f' 或 'A'-'F'。
+ *
+ * @return 如果字符串为有效的十六进制字符串，返回 true；否则返回 false。
+ */
+fun String.isHex(): Boolean {
+    if (this.isEmpty()) return false
+    return this.all { it.isDigit() || (it in 'a'..'f') || (it in 'A'..'F') }
+}
+
+/**
+ * 检查当前字符串是否为合法的十六进制字符串。
+ * 字符串中的每个字符必须是数字（0-9）或小写字母（a-f）。
+ *
+ * @return 如果字符串为合法的十六进制字符串，返回 true；否则返回 false。
+ */
+fun String.ishex(): Boolean {
+    if (this.isEmpty()) return false
+    return this.all { it.isDigit() || (it in 'a'..'f') }
+}
+
+/**
+ * 判断当前字符串是否为有效的十六进制字符串。
+ *
+ * 此方法会验证字符串中是否仅包含合法的十六进制字符（0-9，A-F）。
+ *
+ * @return 如果字符串是有效的十六进制字符串则返回 true，否则返回 false。
+ */
+fun String.isHEX(): Boolean {
+    if (this.isEmpty()) return false
+    return this.all { it.isDigit() || (it in 'A'..'F') }
+}
+
+/**
+ * 判断当前字符串是否全部由 ASCII 可打印字符组成（从 '!' 到 '~' 的范围）。
+ *
+ * @return 如果字符串非空且全部由 ASCII 可打印字符组成，返回 true；否则返回 false。
+ */
+fun String.isEx(): Boolean {
+    if (this.isEmpty()) return false
+    return this.all { it in '!'..'~' }
+}
+
+data class AddrPort(val addr: String, val port: Int)
+
+/**
+ * 将当前字符串解析为主机地址和端口号，返回一个包含地址和端口的 AddrPort 对象。
+ * 支持的格式包括：
+ * - IPv6地址:端口
+ * - 主机名或IPv4地址:端口
+ *
+ * @return 如果解析成功，返回包含地址和端口的 AddrPort 对象；如果解析失败或格式无效，则返回 null。
+ */
+fun String.toAddrPort(): AddrPort? {
+    if (this.isBlank()) return null
+    Regex("\\[([a-fA-F0-9:]+)]:(\\d+)").matchEntire(this)?.also {
+        val j_port = it.groupValues[2].toIntOrNull()
+        if (j_port != null && j_port in 1..65535) return AddrPort(it.groupValues[1], j_port)
+    }
+    Regex("([a-zA-Z0-9.-]+):(\\d+)").matchEntire(this)?.also {
+        val j_port = it.groupValues[2].toIntOrNull()
+        if (j_port != null && j_port in 1..65535) return AddrPort(it.groupValues[1], j_port)
+    }
+    return null
+}

src/main/kotlin/cn/qqck/kotlin/tools/Ulid.kt

@@ -0,0 +1,260 @@
+package cn.qqck.kotlin.tools
+
+// 摘自：https://github.com/JonasSchubert/kULID
+
+/**
+ * MIT License
+ *
+ * Copyright (c) 2019-2021 GuepardoApps (Jonas Schubert)
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+import kotlin.experimental.and
+import kotlin.random.Random
+
+class ULID {
+    companion object {
+        /**
+         * The default entropy size
+         */
+        private const val DEFAULT_ENTROPY_SIZE = 10
+
+        /**
+         * Maximum allowed timestamp value.
+         */
+        const val TIMESTAMP_MAX = 0x0000ffffffffffffL
+
+        /**
+         * Minimum allowed timestamp value.
+         */
+        const val TIMESTAMP_MIN = 0x0L
+
+        /**
+         * ULID string length.
+         */
+        private const val ULID_LENGTH = 26
+
+        /**
+         * Base32 characters mapping
+         */
+        private val charMapping = charArrayOf(
+            0x30.toChar(), 0x31.toChar(), 0x32.toChar(), 0x33.toChar(), 0x34.toChar(), 0x35.toChar(),
+            0x36.toChar(), 0x37.toChar(), 0x38.toChar(), 0x39.toChar(), 0x41.toChar(), 0x42.toChar(),
+            0x43.toChar(), 0x44.toChar(), 0x45.toChar(), 0x46.toChar(), 0x47.toChar(), 0x48.toChar(),
+            0x4a.toChar(), 0x4b.toChar(), 0x4d.toChar(), 0x4e.toChar(), 0x50.toChar(), 0x51.toChar(),
+            0x52.toChar(), 0x53.toChar(), 0x54.toChar(), 0x56.toChar(), 0x57.toChar(), 0x58.toChar(),
+            0x59.toChar(), 0x5a.toChar()
+        )
+
+        /**
+         * `char` to `byte` O(1) mapping with alternative chars mapping
+         */
+        private val charToByteMapping = byteArrayOf(
+            0xff.toByte(), 0xff.toByte(), 0xff.toByte(), 0xff.toByte(), 0xff.toByte(), 0xff.toByte(),
+            0xff.toByte(), 0xff.toByte(), 0xff.toByte(), 0xff.toByte(), 0xff.toByte(), 0xff.toByte(),
+            0xff.toByte(), 0xff.toByte(), 0xff.toByte(), 0xff.toByte(), 0xff.toByte(), 0xff.toByte(),
+            0xff.toByte(), 0xff.toByte(), 0xff.toByte(), 0xff.toByte(), 0xff.toByte(), 0xff.toByte(),
+            0xff.toByte(), 0xff.toByte(), 0xff.toByte(), 0xff.toByte(), 0xff.toByte(), 0xff.toByte(),
+            0xff.toByte(), 0xff.toByte(), 0xff.toByte(), 0xff.toByte(), 0xff.toByte(), 0xff.toByte(),
+            0xff.toByte(), 0xff.toByte(), 0xff.toByte(), 0xff.toByte(), 0xff.toByte(), 0xff.toByte(),
+            0xff.toByte(), 0xff.toByte(), 0xff.toByte(), 0xff.toByte(), 0xff.toByte(), 0xff.toByte(),
+            0x00.toByte(), 0x01.toByte(), 0x02.toByte(), 0x03.toByte(), 0x04.toByte(), 0x05.toByte(),
+            0x06.toByte(), 0x07.toByte(), 0x08.toByte(), 0x09.toByte(), 0xff.toByte(), 0xff.toByte(),
+            0xff.toByte(), 0xff.toByte(), 0xff.toByte(), 0xff.toByte(), 0xff.toByte(), 0x0a.toByte(),
+            0x0b.toByte(), 0x0c.toByte(), 0x0d.toByte(), 0x0e.toByte(), 0x0f.toByte(), 0x10.toByte(),
+            0x11.toByte(), 0xff.toByte(), 0x12.toByte(), 0x13.toByte(), 0xff.toByte(), 0x14.toByte(),
+            0x15.toByte(), 0xff.toByte(), 0x16.toByte(), 0x17.toByte(), 0x18.toByte(), 0x19.toByte(),
+            0x1a.toByte(), 0xff.toByte(), 0x1b.toByte(), 0x1c.toByte(), 0x1d.toByte(), 0x1e.toByte(),
+            0x1f.toByte(), 0xff.toByte(), 0xff.toByte(), 0xff.toByte(), 0xff.toByte(), 0xff.toByte(),
+            0xff.toByte(), 0x0a.toByte(), 0x0b.toByte(), 0x0c.toByte(), 0x0d.toByte(), 0x0e.toByte(),
+            0x0f.toByte(), 0x10.toByte(), 0x11.toByte(), 0xff.toByte(), 0x12.toByte(), 0x13.toByte(),
+            0xff.toByte(), 0x14.toByte(), 0x15.toByte(), 0xff.toByte(), 0x16.toByte(), 0x17.toByte(),
+            0x18.toByte(), 0x19.toByte(), 0x1a.toByte(), 0xff.toByte(), 0x1b.toByte(), 0x1c.toByte(),
+            0x1d.toByte(), 0x1e.toByte(), 0x1f.toByte(), 0xff.toByte(), 0xff.toByte(), 0xff.toByte(),
+            0xff.toByte(), 0xff.toByte(), 0xff.toByte(), 0xff.toByte(), 0xff.toByte(), 0xff.toByte(),
+            0xff.toByte(), 0xff.toByte(), 0xff.toByte(), 0xff.toByte(), 0xff.toByte(), 0xff.toByte(),
+            0xff.toByte(), 0xff.toByte(), 0xff.toByte(), 0xff.toByte(), 0xff.toByte(), 0xff.toByte(),
+            0xff.toByte(), 0xff.toByte(), 0xff.toByte(), 0xff.toByte(), 0xff.toByte(), 0xff.toByte(),
+            0xff.toByte(), 0xff.toByte(), 0xff.toByte(), 0xff.toByte(), 0xff.toByte(), 0xff.toByte(),
+            0xff.toByte(), 0xff.toByte(), 0xff.toByte(), 0xff.toByte(), 0xff.toByte(), 0xff.toByte(),
+            0xff.toByte(), 0xff.toByte(), 0xff.toByte(), 0xff.toByte(), 0xff.toByte(), 0xff.toByte(),
+            0xff.toByte(), 0xff.toByte(), 0xff.toByte(), 0xff.toByte(), 0xff.toByte(), 0xff.toByte(),
+            0xff.toByte(), 0xff.toByte(), 0xff.toByte(), 0xff.toByte(), 0xff.toByte(), 0xff.toByte(),
+            0xff.toByte(), 0xff.toByte(), 0xff.toByte(), 0xff.toByte(), 0xff.toByte(), 0xff.toByte(),
+            0xff.toByte(), 0xff.toByte(), 0xff.toByte(), 0xff.toByte(), 0xff.toByte(), 0xff.toByte(),
+            0xff.toByte(), 0xff.toByte(), 0xff.toByte(), 0xff.toByte(), 0xff.toByte(), 0xff.toByte(),
+            0xff.toByte(), 0xff.toByte(), 0xff.toByte(), 0xff.toByte(), 0xff.toByte(), 0xff.toByte(),
+            0xff.toByte(), 0xff.toByte(), 0xff.toByte(), 0xff.toByte(), 0xff.toByte(), 0xff.toByte(),
+            0xff.toByte(), 0xff.toByte(), 0xff.toByte(), 0xff.toByte(), 0xff.toByte(), 0xff.toByte(),
+            0xff.toByte(), 0xff.toByte(), 0xff.toByte(), 0xff.toByte(), 0xff.toByte(), 0xff.toByte(),
+            0xff.toByte(), 0xff.toByte(), 0xff.toByte(), 0xff.toByte(), 0xff.toByte(), 0xff.toByte(),
+            0xff.toByte(), 0xff.toByte(), 0xff.toByte(), 0xff.toByte(), 0xff.toByte(), 0xff.toByte(),
+            0xff.toByte(), 0xff.toByte(), 0xff.toByte(), 0xff.toByte(), 0xff.toByte(), 0xff.toByte(),
+            0xff.toByte(), 0xff.toByte(), 0xff.toByte(), 0xff.toByte(), 0xff.toByte(), 0xff.toByte(),
+            0xff.toByte(), 0xff.toByte(), 0xff.toByte(), 0xff.toByte(), 0xff.toByte(), 0xff.toByte(),
+            0xff.toByte(), 0xff.toByte(), 0xff.toByte(), 0xff.toByte()
+        )
+
+        /**
+         * Generate ULID string from provided string
+         * @param string         String
+         * @return               ULID string
+         */
+        fun fromString(string: String): String = if (!isValid(string)) {
+            throw IllegalArgumentException("Invalid string value for an ulid")
+        } else {
+            string
+        }
+
+        /**
+         * Generate random ULID string using [kotlin.random.Random] instance.
+         * @return               ULID string
+         */
+        fun random(): String = generate(System.currentTimeMillis(), Random.nextBytes(DEFAULT_ENTROPY_SIZE))
+
+        /**
+         * Generate ULID from Unix epoch timestamp in millisecond and entropy bytes.
+         * Throws [java.lang.IllegalArgumentException] if timestamp is less than {@value #MIN_TIME},
+         * is more than {@value #MAX_TIME}, or entropy bytes is null or less than 10 bytes.
+         * @param time           Unix epoch timestamp in millisecond
+         * @param entropy        Entropy bytes
+         * @return               ULID string
+         */
+        fun generate(time: Long, entropy: ByteArray?): String {
+            if (time < TIMESTAMP_MIN || time > TIMESTAMP_MAX || entropy == null || entropy.size < DEFAULT_ENTROPY_SIZE) {
+                throw IllegalArgumentException("Time is too long, or entropy is less than 10 bytes or null")
+            }
+
+            val chars = CharArray(ULID_LENGTH)
+
+            // time
+            chars[0] = charMapping[time.ushr(45).toInt() and 0x1f]
+            chars[1] = charMapping[time.ushr(40).toInt() and 0x1f]
+            chars[2] = charMapping[time.ushr(35).toInt() and 0x1f]
+            chars[3] = charMapping[time.ushr(30).toInt() and 0x1f]
+            chars[4] = charMapping[time.ushr(25).toInt() and 0x1f]
+            chars[5] = charMapping[time.ushr(20).toInt() and 0x1f]
+            chars[6] = charMapping[time.ushr(15).toInt() and 0x1f]
+            chars[7] = charMapping[time.ushr(10).toInt() and 0x1f]
+            chars[8] = charMapping[time.ushr(5).toInt() and 0x1f]
+            chars[9] = charMapping[time.toInt() and 0x1f]
+
+            // entropy
+            chars[10] = charMapping[(entropy[0].toShort() and 0xff).toInt().ushr(3)]
+            chars[11] = charMapping[(entropy[0].toInt() shl 2 or (entropy[1].toShort() and 0xff).toInt().ushr(6) and 0x1f)]
+            chars[12] = charMapping[((entropy[1].toShort() and 0xff).toInt().ushr(1) and 0x1f)]
+            chars[13] = charMapping[(entropy[1].toInt() shl 4 or (entropy[2].toShort() and 0xff).toInt().ushr(4) and 0x1f)]
+            chars[14] = charMapping[(entropy[2].toInt() shl 5 or (entropy[3].toShort() and 0xff).toInt().ushr(7) and 0x1f)]
+            chars[15] = charMapping[((entropy[3].toShort() and 0xff).toInt().ushr(2) and 0x1f)]
+            chars[16] = charMapping[(entropy[3].toInt() shl 3 or (entropy[4].toShort() and 0xff).toInt().ushr(5) and 0x1f)]
+            chars[17] = charMapping[(entropy[4].toInt() and 0x1f)]
+            chars[18] = charMapping[(entropy[5].toShort() and 0xff).toInt().ushr(3)]
+            chars[19] = charMapping[(entropy[5].toInt() shl 2 or (entropy[6].toShort() and 0xff).toInt().ushr(6) and 0x1f)]
+            chars[20] = charMapping[((entropy[6].toShort() and 0xff).toInt().ushr(1) and 0x1f)]
+            chars[21] = charMapping[(entropy[6].toInt() shl 4 or (entropy[7].toShort() and 0xff).toInt().ushr(4) and 0x1f)]
+            chars[22] = charMapping[(entropy[7].toInt() shl 5 or (entropy[8].toShort() and 0xff).toInt().ushr(7) and 0x1f)]
+            chars[23] = charMapping[((entropy[8].toShort() and 0xff).toInt().ushr(2) and 0x1f)]
+            chars[24] = charMapping[(entropy[8].toInt() shl 3 or (entropy[9].toShort() and 0xff).toInt().ushr(5) and 0x1f)]
+            chars[25] = charMapping[(entropy[9].toInt() and 0x1f)]
+
+            return String(chars)
+        }
+
+        /**
+         * Checks ULID string validity.
+         * @param ulid           ULID nullable string
+         * @return               true if ULID string is valid
+         */
+        fun isValid(ulid: String?): Boolean {
+            if (ulid == null || ulid.length != ULID_LENGTH) {
+                return false
+            }
+
+            for (char in ulid) {
+                if (char.code < 0
+                    || char.code > charToByteMapping.size
+                    || charToByteMapping[char.code] == 0xff.toByte()
+                ) {
+                    return false
+                }
+            }
+
+            return true
+        }
+
+        /**
+         * Extract and return the timestamp part from ULID. Expects a valid ULID string.
+         * Call [ULID.isValid] and check validity before calling this method if you
+         * do not trust the origin of the ULID string.
+         * @param ulid           ULID string
+         * @return               Unix epoch timestamp in millisecond
+         */
+        fun getTimestamp(ulid: CharSequence): Long {
+            return (charToByteMapping[ulid[0].code].toLong() shl 45
+                    or (charToByteMapping[ulid[1].code].toLong() shl 40)
+                    or (charToByteMapping[ulid[2].code].toLong() shl 35)
+                    or (charToByteMapping[ulid[3].code].toLong() shl 30)
+                    or (charToByteMapping[ulid[4].code].toLong() shl 25)
+                    or (charToByteMapping[ulid[5].code].toLong() shl 20)
+                    or (charToByteMapping[ulid[6].code].toLong() shl 15)
+                    or (charToByteMapping[ulid[7].code].toLong() shl 10)
+                    or (charToByteMapping[ulid[8].code].toLong() shl 5)
+                    or charToByteMapping[ulid[9].code].toLong())
+        }
+
+        /**
+         * Extract and return the entropy part from ULID. Expects a valid ULID string.
+         * Call [ULID.isValid] and check validity before calling this method if you
+         * do not trust the origin of the ULID string.
+         * @param ulid           ULID string
+         * @return               Entropy bytes
+         */
+        fun getEntropy(ulid: CharSequence): ByteArray {
+            val bytes = ByteArray(DEFAULT_ENTROPY_SIZE)
+
+            bytes[0] = (charToByteMapping[ulid[10].code].toInt() shl 3
+                    or (charToByteMapping[ulid[11].code] and 0xff.toByte()).toInt().ushr(2)).toByte()
+            bytes[1] = (charToByteMapping[ulid[11].code].toInt() shl 6
+                    or (charToByteMapping[ulid[12].code].toInt() shl 1)
+                    or (charToByteMapping[ulid[13].code] and 0xff.toByte()).toInt().ushr(4)).toByte()
+            bytes[2] = (charToByteMapping[ulid[13].code].toInt() shl 4
+                    or (charToByteMapping[ulid[14].code] and 0xff.toByte()).toInt().ushr(1)).toByte()
+            bytes[3] = (charToByteMapping[ulid[14].code].toInt() shl 7
+                    or (charToByteMapping[ulid[15].code].toInt() shl 2)
+                    or (charToByteMapping[ulid[16].code] and 0xff.toByte()).toInt().ushr(3)).toByte()
+            bytes[4] = (charToByteMapping[ulid[16].code].toInt() shl 5
+                    or (charToByteMapping[ulid[17].code].toInt())).toByte()
+            bytes[5] = (charToByteMapping[ulid[18].code].toInt() shl 3
+                    or (charToByteMapping[ulid[19].code] and 0xff.toByte()).toInt().ushr(2)).toByte()
+            bytes[6] = (charToByteMapping[ulid[19].code].toInt() shl 6
+                    or (charToByteMapping[ulid[20].code].toInt() shl 1)
+                    or (charToByteMapping[ulid[21].code] and 0xff.toByte()).toInt().ushr(4)).toByte()
+            bytes[7] = (charToByteMapping[ulid[21].code].toInt() shl 4
+                    or (charToByteMapping[ulid[22].code] and 0xff.toByte()).toInt().ushr(1)).toByte()
+            bytes[8] = (charToByteMapping[ulid[22].code].toInt() shl 7
+                    or (charToByteMapping[ulid[23].code].toInt() shl 2)
+                    or (charToByteMapping[ulid[24].code] and 0xff.toByte()).toInt().ushr(3)).toByte()
+            bytes[9] = (charToByteMapping[ulid[24].code].toInt() shl 5
+                    or (charToByteMapping[ulid[25].code].toInt())).toByte()
+
+            return bytes
+        }
+    }
+}

src/main/kotlin/cn/qqck/kotlin/tools/Url.kt

@@ -0,0 +1,4 @@
+package cn.qqck.kotlin.tools
+
+fun String.enurl(): String = java.net.URLEncoder.encode(this, "utf-8")
+fun String.deurl(): String = java.net.URLDecoder.decode(this, "utf-8")

src/main/kotlin/dev/botta/json/Json.kt

@@ -0,0 +1,95 @@
+package dev.botta.json
+
+import dev.botta.json.parser.JsonParser
+import dev.botta.json.values.*
+import java.io.Reader
+import java.util.Base64
+
+object Json {
+    val NULL: JsonValue = JsonLiteral.NULL
+    val TRUE: JsonValue = JsonLiteral.TRUE
+    val FALSE: JsonValue = JsonLiteral.FALSE
+
+    fun value(value: Any?): JsonValue {
+        when (value) {
+            null -> return this.NULL
+            is JsonValue -> return value
+            is Int -> return this.value(value)
+            is Long -> return this.value(value)
+            is Float -> return this.value(value)
+            is Double -> return this.value(value)
+            is Boolean -> return this.value(value)
+            is String -> return this.value(value)
+            is ByteArray -> return this.value(value)
+            is List<*> -> return JsonArray(value.map { this.value(it) })
+            is Map<*, *> -> {
+                val json = JsonObject()
+                value.forEach { (key, value) ->
+                    json[key as String] = this.value(value)
+                }
+                return json
+            }
+
+            else -> return this.value("${value}")
+        }
+    }
+
+    fun value(value: Int) = JsonNumber(value.toString(10))
+
+    fun value(value: Long) = JsonNumber(value.toString(10))
+
+    fun value(value: Float): JsonValue {
+        require(!value.isInfinite() && !value.isNaN()) { "Infinite and NaN values not permitted in JSON" }
+        return JsonNumber(this.cutOffPointZero(value.toString()))
+    }
+
+    fun value(value: Double): JsonValue {
+        require(!value.isInfinite() && !value.isNaN()) { "Infinite and NaN values not permitted in JSON" }
+        return JsonNumber(this.cutOffPointZero(value.toString()))
+    }
+
+    fun value(value: Boolean) = if (value) this.TRUE else this.FALSE
+
+    fun value(string: String?) = string?.let { JsonString(it) } ?: this.NULL
+    fun value(byteArray: ByteArray?) = byteArray?.let { JsonString(Base64.getEncoder().encodeToString(it)) } ?: this.NULL
+
+    fun array() = JsonArray()
+
+    fun array(values: List<Any?>): JsonArray {
+        val array = JsonArray()
+        values.forEach { array.add(this.value(it)) }
+        return array
+    }
+
+    fun array(vararg values: Int) = this.array(values.toList())
+
+    fun array(vararg values: Long) = this.array(values.toList())
+
+    fun array(vararg values: Float) = this.array(values.toList())
+
+    fun array(vararg values: Double) = this.array(values.toList())
+
+    fun array(vararg values: Boolean) = this.array(values.toList())
+
+    fun array(vararg values: String?) = this.array(values.toList())
+
+    fun array(vararg values: JsonValue) = this.array(values.toList())
+
+    fun array(vararg values: Any?) = this.array(values.toList())
+
+    fun obj() = JsonObject()
+
+    fun obj(pairs: List<Pair<String, Any?>>) = JsonObject(pairs)
+
+    fun obj(vararg pairs: Pair<String, Any?>) = JsonObject(pairs.toList())
+
+    fun parse(string: String) = JsonParser().parse(string)
+
+    fun parse(reader: Reader) = JsonParser().parse(reader)
+
+    private fun cutOffPointZero(string: String): String {
+        return if (string.endsWith(".0")) {
+            string.substring(0, string.length - 2)
+        } else string
+    }
+}

src/main/kotlin/dev/botta/json/README.md

@@ -0,0 +1,269 @@
+[![Maven](https://img.shields.io/maven-central/v/dev.botta/json.svg)](https://search.maven.org/#search%7Cgav%7C1%7Cg%3A%22dev.botta%22%20AND%20a%3A%22json%22)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+[![CI Status](https://github.com/nbottarini/json-kt/actions/workflows/main.yml/badge.svg?branch=master)](https://github.com/nbottarini/json-kt/actions?query=branch%3Amaster+workflow%3Aci)
+
+# https://github.com/nbottarini/json-kt
+
+# Json
+
+Small and fast kotlin library for reading and writing json.
+
+## Installation
+
+#### Gradle (Kotlin)
+
+```kotlin
+repositories {
+    mavenCentral()
+}
+
+dependencies {
+    implementation("dev.botta:json:1.0.0")
+}
+```
+
+#### Gradle (Groovy)
+
+```groovy
+repositories {
+    mavenCentral()
+}
+
+dependencies {
+    implementation 'dev.botta:json:1.0.0'
+}
+```
+
+#### Maven
+
+```xml
+
+<dependency>
+    <groupId>dev.botta</groupId>
+    <artifactId>json</artifactId>
+    <version>1.0.0</version>
+</dependency>
+```
+
+## Usage
+
+Given the following sample json:
+
+```json
+{
+  "name": "John",
+  "lastname": "Hanks",
+  "purchases": [
+    {
+      "id": 1,
+      "productName": "Gaming Keyboard",
+      "price": 200.5
+    },
+    {
+      "id": 1,
+      "productName": "Razer Headset",
+      "price": 79.9
+    }
+  ]
+}
+```
+
+```kotlin
+val json = Json.parse(input) // input can be a string with your json or a java.io.Reader
+
+val name = json.path("name")?.asString() // returns "John"
+val keyboardPrice = json.path("purchases[0].price")?.asFloat() // returns 200.5
+
+val name = json.path("name")?.asBoolean() // returns null
+val name = json.path("name")?.asBoolean("some-default") // returns "some-default"
+```
+
+### Json class
+
+The Json class is the main entrypoint to the library. It allows you to parse and build json.
+
+All json values are represented with the class JsonValue. There are many possible types of values (each one represented in
+its own class that inherits from JsonValue):
+
+- Ints, Longs, Floats, Doubles are represented in JsonNumber
+- Null, True, False are represented in JsonLiteral
+- Strings are represented in JsonString
+- Arrays are represented in JsonArray
+- Objects are represented in JsonObject
+
+The Json class allows to build instances of each type:
+
+```kotlin
+// Boolean values
+Json.TRUE
+Json.value(true)
+Json.FALSE
+Json.value(false)
+
+// Null value
+Json.NULL
+Json.value(null)
+
+// Numeric values
+Json.value(50)
+Json.value(50L)
+Json.value(3.14f)
+Json.value(3.14)
+
+// Strings
+Json.value("Some string")
+
+// Arrays
+Json.value(listOf(1, 2, 3))
+Json.array(1, 2, 3)
+Json.array(true, "some string", 3.14)
+Json.array(1, Json.array(2, 3))
+listOf(1, 2, 3).toJson()
+
+// Objects
+Json.value(mapOf("name" to "John", "lastname" to "Lennon"))
+Json.obj("name" to "John", "lastname" to "Lennon")
+Json.obj("name" to "John", "emails" to Json.array("email1@example.com", "email1@example.com"))
+Json.obj("name" to "John", "emails" to listOf("email1@example.com", "email1@example.com"))
+mapOf("name" to "John", "lastname" to "Lennon").toJson()
+```
+
+### Json values
+
+Json values can be converted to string:
+
+```kotlin
+Json.obj("name" to "John", "lastname" to "Lennon").toString()
+// returns {"name":"John","lastname":"Lennon"}
+
+Json.obj("name" to "John", "lastname" to "Lennon").toPrettyString()
+// returns:
+// { 
+//   "name": "John",
+//   "lastname": "Lennon"
+// }
+
+// Pretty printing can be customized:
+Json.array(1, 2, 3).toString(PrettyPrint.indentWithSpaces(2))
+Json.array(1, 2, 3).toString(PrettyPrint.indentWithTabs())
+Json.array(1, 2, 3).toString(PrettyPrint.singleLine())
+
+// You can convert lists and maps directly to json strings
+listOf(1, 2, 3).toJsonString()
+mapOf("name" to "John", "lastname" to "Lennon").toJsonString()
+```
+
+Json values allows to convert the value to Java/Kotlin types:
+
+```kotlin
+Json.value(23).asInt()
+Json.value(23L).asLong()
+Json.value(3.14f).asFloat()
+Json.value(3.14).asDouble()
+Json.value("foo").asString()
+Json.value(true).asBoolean()
+```
+
+Value conversion returns null if the value is incompatible. You can also provide a default value in that case:
+
+```kotlin
+Json.value(true).asInt() // returns null
+Json.value(true).asInt(23) // returns default value 23
+
+Json.value("23").asInt() // returns 23
+Json.value(23L).asInt() // returns 23
+```
+
+You can also cast to JsonArray and JsonObject to traverse the json tree:
+
+```kotlin
+json.asObject()["name"]
+json.asArray()[2]
+```
+
+Or you can use the path method for traversing:
+
+```kotlin
+json.path("user.purchases[2].product.price")?.asFloat()
+```
+
+You can also assert for each type:
+
+```kotlin
+json.isObject()
+json.isArray()
+json.isNumber()
+json.isString()
+json.isBoolean()
+json.isTrue()
+json.isFalse()
+json.isNull()
+```
+
+### Json arrays
+
+JsonArray implements MutableList<JsonValue> interface, so you can have all common list behaviours.
+
+```kotlin
+val array = Json.array(1, 2, 3)
+
+array.size() // 3
+array.isEmpty() // false
+array.add(4)
+array.add(1, 4) // Adds 4 at index 1
+array.addAll(listOf(4, 5, 6))
+array.addAll(1, listOf(4, 5, 6)) // Adds values 4, 5, 6 at index 1
+array[0] // returns 1
+array.get(0)
+array[0] = 2
+array.set(0, 2)
+array.with(4).with(5).with(6) // Adds values with a fluent interface
+array.with(4, 5, 6)
+array.remove(2) // Removes value 2
+array.removeAll(listOf(2, 3))
+array.retainAll(listOf(1, 2))
+array.clear()
+array.contains(2)
+array.containsAll(listOf(1, 2))
+array.indexOf(3)
+array.lastIndexOf(2)
+```
+
+You can also convert lists to arrays:
+
+```kotlin
+listOf(1, 2, 3).toJson()
+Json.array(listOf(1, 2, 3))
+```
+
+### Json objects
+
+JsonObject implements MutableMap<String, JsonValue> interface, so you can have all common map behaviours.
+
+```kotlin
+val obj = Json.obj("name" to "John", "lastname" to "Lennon")
+
+obj.size() // 2
+obj.isEmpty() // false
+obj.entries() // List of map entries
+obj.keys() // name, lastname
+obj.values() // John, Lennon
+obj["name"] // "John"
+obj.get("name")
+obj["name"] = "Paul"
+obj.set("name", "Paul")
+obj.with("age" to 40) // add values with fluent interface
+obj.with("age" to 40, "instrument" to "guitar")
+obj.merge(Json.obj("name" to "Paul", "instrument" to "bass")) // Merges values with another object
+obj.containsKey("name")
+obj.containsValue("Paul")
+obj.remove("name")
+obj.clear()
+```
+
+You can also convert maps to objects:
+
+```kotlin
+mapOf("name" to "John", "lastname" to "Lennon").toJson()
+Json.obj(listOf("name" to "John", "lastname" to "Lennon"))
+```

src/main/kotlin/dev/botta/json/extensions/ListExtensions.kt

@@ -0,0 +1,9 @@
+package dev.botta.json.extensions
+
+import dev.botta.json.writer.WriterConfig
+
+fun <T : Any?> List<T>.toJson() = dev.botta.json.Json.array(this)
+
+fun <T : Any?> List<T>.toJsonString() = toJson().toString()
+
+fun <T : Any?> List<T>.toJsonString(config: WriterConfig) = toJson().toString(config)

src/main/kotlin/dev/botta/json/extensions/MapExtensions.kt

@@ -0,0 +1,9 @@
+package dev.botta.json.extensions
+
+import dev.botta.json.writer.WriterConfig
+
+fun <T : Any?> Map<String, T>.toJson() = dev.botta.json.Json.value(this).asObject()!!
+
+fun <T : Any?> Map<String, T>.toJsonString() = toJson().toString()
+
+fun <T : Any?> Map<String, T>.toJsonString(config: WriterConfig) = toJson().toString(config)

src/main/kotlin/dev/botta/json/parser/DefaultJsonParserHandler.kt

@@ -0,0 +1,66 @@
+package dev.botta.json.parser
+
+import dev.botta.json.values.*
+
+class DefaultJsonParserHandler : JsonParserHandler {
+    override var value: JsonValue = dev.botta.json.Json.NULL
+        private set
+    private var parser: JsonParser? = null
+    override val location get() = parser!!.location
+
+    override fun setParser(parser: JsonParser) {
+        this.parser = parser
+    }
+
+    override fun startNull() {}
+
+    override fun startArray() = JsonArray()
+
+    override fun startObject() = JsonObject()
+
+    override fun endNull() {
+        value = dev.botta.json.Json.NULL
+    }
+
+    override fun startBoolean() {}
+
+    override fun endBoolean(bool: Boolean) {
+        value = if (bool) dev.botta.json.Json.TRUE else dev.botta.json.Json.FALSE
+    }
+
+    override fun startString() {}
+
+    override fun endString(string: String) {
+        value = JsonString(string)
+    }
+
+    override fun startNumber() {}
+
+    override fun endNumber(string: String) {
+        value = JsonNumber(string)
+    }
+
+    override fun endArray(array: JsonArray) {
+        value = array
+    }
+
+    override fun startArrayValue(array: JsonArray) {}
+
+    override fun endObject(obj: JsonObject) {
+        value = obj
+    }
+
+    override fun startObjectName(obj: JsonObject) {}
+
+    override fun endObjectName(obj: JsonObject, name: String) {}
+
+    override fun startObjectValue(obj: JsonObject, name: String) {}
+
+    override fun endArrayValue(array: JsonArray) {
+        array.add(value)
+    }
+
+    override fun endObjectValue(obj: JsonObject, name: String) {
+        obj[name] = value
+    }
+}

src/main/kotlin/dev/botta/json/parser/JsonParseError.kt

@@ -0,0 +1,9 @@
+package dev.botta.json.parser
+
+class JsonParseError private constructor(message: String, val location: Location, cause: Throwable? = null) :
+    Exception(message, cause) {
+
+    constructor(message: String, location: Location) : this("$message at $location", location, cause = null)
+
+    constructor(message: String, cause: Throwable? = null) : this(message, Location(0, 0, 0), cause)
+}

src/main/kotlin/dev/botta/json/parser/JsonParser.kt

@@ -0,0 +1,368 @@
+package dev.botta.json.parser
+
+/*
+Copyright (c) 2013, 2014 EclipseSource
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+*/
+
+import dev.botta.json.values.JsonValue
+import java.io.Reader
+import java.io.StringReader
+import kotlin.math.max
+import kotlin.math.min
+
+/**
+ * A streaming parser for JSON text. The parser reports all events to a given handler.
+ */
+class JsonParser(private val handler: JsonParserHandler = DefaultJsonParserHandler()) {
+    private var reader: Reader? = null
+    private lateinit var buffer: CharArray
+    private var bufferOffset = 0
+    private var index = 0
+    private var fill = 0
+    private var line = 0
+    private var lineOffset = 0
+    private var current = 0
+    private var captureBuffer: StringBuilder? = null
+    private var captureStart = 0
+    private var nestingLevel = 0
+    val location: Location
+        get() {
+            val offset = bufferOffset + index - 1
+            val column = offset - lineOffset + 1
+            return Location(offset, line, column)
+        }
+    /*
+     * |                      bufferOffset
+     *                        v
+     * [a|b|c|d|e|f|g|h|i|j|k|l|m|n|o|p|q|r|s|t]        < input
+     *                       [l|m|n|o|p|q|r|s|t|?|?]    < buffer
+     *                          ^               ^
+     *                       |  index           fill
+     */
+
+    init {
+        handler.setParser(this)
+    }
+
+    fun parse(string: String): JsonValue {
+        val bufferSize = max(MIN_BUFFER_SIZE, min(DEFAULT_BUFFER_SIZE, string.length))
+        parse(StringReader(string), bufferSize)
+        return handler.value
+    }
+
+    fun parse(reader: Reader, buffersize: Int = DEFAULT_BUFFER_SIZE): JsonValue {
+        if (buffersize <= 0) throw IllegalArgumentException("buffersize is zero or negative")
+        this.reader = reader
+        buffer = CharArray(buffersize)
+        bufferOffset = 0
+        index = 0
+        fill = 0
+        line = 1
+        lineOffset = 0
+        current = 0
+        captureStart = -1
+        read()
+        skipWhiteSpace()
+        readValue()
+        skipWhiteSpace()
+        if (!isEndOfText) throw error("Unexpected character")
+        return handler.value
+    }
+
+    private fun readValue() {
+        when (current.toChar()) {
+            'n' -> readNull()
+            't' -> readTrue()
+            'f' -> readFalse()
+            '"' -> readString()
+            '[' -> readArray()
+            '{' -> readObject()
+            '-', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9' -> readNumber()
+            else -> throw expected("value")
+        }
+    }
+
+    private fun readArray() {
+        val array = handler.startArray()
+        read()
+        if (++nestingLevel > MAX_NESTING_LEVEL) throw error("Nesting too deep")
+        skipWhiteSpace()
+        if (readChar(']')) {
+            nestingLevel--
+            handler.endArray(array)
+            return
+        }
+        do {
+            skipWhiteSpace()
+            handler.startArrayValue(array)
+            readValue()
+            handler.endArrayValue(array)
+            skipWhiteSpace()
+        } while (readChar(','))
+        if (!readChar(']')) throw expected("',' or ']'")
+        nestingLevel--
+        handler.endArray(array)
+    }
+
+    private fun readObject() {
+        val obj = handler.startObject()
+        read()
+        if (++nestingLevel > MAX_NESTING_LEVEL) throw error("Nesting too deep")
+        skipWhiteSpace()
+        if (readChar('}')) {
+            nestingLevel--
+            handler.endObject(obj)
+            return
+        }
+        do {
+            skipWhiteSpace()
+            handler.startObjectName(obj)
+            val name: String = readName()
+            handler.endObjectName(obj, name)
+            skipWhiteSpace()
+            if (!readChar(':')) throw expected("':'")
+            skipWhiteSpace()
+            handler.startObjectValue(obj, name)
+            readValue()
+            handler.endObjectValue(obj, name)
+            skipWhiteSpace()
+        } while (readChar(','))
+        if (!readChar('}')) throw expected("',' or '}'")
+        nestingLevel--
+        handler.endObject(obj)
+    }
+
+    private fun readName(): String {
+        if (current != '"'.code) throw expected("name")
+        return readStringInternal()
+    }
+
+    private fun readNull() {
+        handler.startNull()
+        read()
+        readRequiredChar('u')
+        readRequiredChar('l')
+        readRequiredChar('l')
+        handler.endNull()
+    }
+
+    private fun readTrue() {
+        handler.startBoolean()
+        read()
+        readRequiredChar('r')
+        readRequiredChar('u')
+        readRequiredChar('e')
+        handler.endBoolean(true)
+    }
+
+    private fun readFalse() {
+        handler.startBoolean()
+        read()
+        readRequiredChar('a')
+        readRequiredChar('l')
+        readRequiredChar('s')
+        readRequiredChar('e')
+        handler.endBoolean(false)
+    }
+
+    private fun readRequiredChar(ch: Char) {
+        if (!readChar(ch)) throw expected("'$ch'")
+    }
+
+    private fun readString() {
+        handler.startString()
+        handler.endString(readStringInternal())
+    }
+
+    private fun readStringInternal(): String {
+        read()
+        startCapture()
+        while (current != '"'.code) {
+            if (current == '\\'.code) {
+                pauseCapture()
+                readEscape()
+                startCapture()
+            } else if (current < 0x20) {
+                throw expected("valid string character")
+            } else {
+                read()
+            }
+        }
+        val string = endCapture()
+        read()
+        return string
+    }
+
+    private fun readEscape() {
+        read()
+        when (current.toChar()) {
+            '"', '/', '\\' -> captureBuffer!!.append(current.toChar())
+            'b' -> captureBuffer!!.append('\b')
+            //            'f' -> captureBuffer!!.append('\f')
+            'n' -> captureBuffer!!.append('\n')
+            'r' -> captureBuffer!!.append('\r')
+            't' -> captureBuffer!!.append('\t')
+            'u' -> {
+                val hexChars = CharArray(4)
+                var i = 0
+                while (i < 4) {
+                    read()
+                    if (!isHexDigit) throw expected("hexadecimal digit")
+                    hexChars[i] = current.toChar()
+                    i++
+                }
+                captureBuffer!!.append(String(hexChars).toInt(16).toChar())
+            }
+
+            else -> throw expected("valid escape sequence")
+        }
+        read()
+    }
+
+    private fun readNumber() {
+        handler.startNumber()
+        startCapture()
+        readChar('-')
+        val firstDigit: Int = current
+        if (!readDigit()) throw expected("digit")
+        if (firstDigit != '0'.code) {
+            while (readDigit()) {
+            }
+        }
+        readFraction()
+        readExponent()
+        handler.endNumber(endCapture())
+    }
+
+    private fun readFraction(): Boolean {
+        if (!readChar('.')) {
+            return false
+        }
+        if (!readDigit()) throw expected("digit")
+        while (readDigit()) {
+        }
+        return true
+    }
+
+    private fun readExponent(): Boolean {
+        if (!readChar('e') && !readChar('E')) {
+            return false
+        }
+        if (!readChar('+')) {
+            readChar('-')
+        }
+        if (!readDigit()) throw expected("digit")
+        while (readDigit()) {
+        }
+        return true
+    }
+
+    private fun readChar(ch: Char): Boolean {
+        if (current != ch.code) return false
+        read()
+        return true
+    }
+
+    private fun readDigit(): Boolean {
+        if (!isDigit) return false
+        read()
+        return true
+    }
+
+    private fun skipWhiteSpace() {
+        while (isWhiteSpace) {
+            read()
+        }
+    }
+
+    private fun read() {
+        if (index == fill) {
+            if (captureStart != -1) {
+                captureBuffer!!.append(buffer, captureStart, fill - captureStart)
+                captureStart = 0
+            }
+            bufferOffset += fill
+            fill = reader!!.read(buffer, 0, buffer.size)
+            index = 0
+            if (fill == -1) {
+                current = -1
+                index++
+                return
+            }
+        }
+        if (current == '\n'.code) {
+            line++
+            lineOffset = bufferOffset + index
+        }
+        current = buffer[index++].code
+    }
+
+    private fun startCapture() {
+        if (captureBuffer == null) {
+            captureBuffer = StringBuilder()
+        }
+        captureStart = index - 1
+    }
+
+    private fun pauseCapture() {
+        val end = if (current == -1) index else index - 1
+        captureBuffer!!.append(buffer, captureStart, end - captureStart)
+        captureStart = -1
+    }
+
+    private fun endCapture(): String {
+        val start = captureStart
+        val end = index - 1
+        captureStart = -1
+        if (captureBuffer!!.isNotEmpty()) {
+            captureBuffer!!.append(buffer, start, end - start)
+            val captured = captureBuffer.toString()
+            captureBuffer!!.setLength(0)
+            return captured
+        }
+        return String(buffer, start, end - start)
+    }
+
+    private fun expected(expected: String): JsonParseError {
+        if (isEndOfText) return error("Unexpected end of input")
+        return error("Expected $expected")
+    }
+
+    private fun error(message: String) = JsonParseError(message, location)
+
+    private val isWhiteSpace
+        get() = (current == ' '.code) || (current == '\t'.code) || (current == '\n'.code) || (current == '\r'.code)
+
+    private val isDigit get() = current >= '0'.code && current <= '9'.code
+
+    private val isHexDigit
+        get() = (current >= '0'.code && current <= '9'.code
+                ) || (current >= 'a'.code && current <= 'f'.code
+                ) || (current >= 'A'.code && current <= 'F'.code)
+
+    private val isEndOfText get() = current == -1
+
+    companion object {
+        private const val MAX_NESTING_LEVEL = 1000
+        private const val MIN_BUFFER_SIZE = 10
+        private const val DEFAULT_BUFFER_SIZE = 1024
+    }
+}

src/main/kotlin/dev/botta/json/parser/JsonParserHandler.kt

@@ -0,0 +1,74 @@
+package dev.botta.json.parser
+
+/*
+Copyright (c) 2013, 2014 EclipseSource
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+*/
+
+import dev.botta.json.values.JsonArray
+import dev.botta.json.values.JsonObject
+import dev.botta.json.values.JsonValue
+
+interface JsonParserHandler {
+    //    var value: JsonValue? = null
+    //        protected set
+    //    var parser: JsonParser? = null
+    //    val location get() = parser!!.location
+    val value: JsonValue
+    val location: Location
+
+    fun setParser(parser: JsonParser)
+
+    fun startNull()
+
+    fun endNull()
+
+    fun startBoolean()
+
+    fun endBoolean(bool: Boolean)
+
+    fun startString()
+
+    fun endString(string: String)
+
+    fun startNumber()
+
+    fun endNumber(string: String)
+
+    fun startArray(): JsonArray
+
+    fun endArray(array: JsonArray)
+
+    fun startArrayValue(array: JsonArray)
+
+    fun endArrayValue(array: JsonArray)
+
+    fun startObject(): JsonObject
+
+    fun endObject(obj: JsonObject)
+
+    fun startObjectName(obj: JsonObject)
+
+    fun endObjectName(obj: JsonObject, name: String)
+
+    fun startObjectValue(obj: JsonObject, name: String)
+
+    fun endObjectValue(obj: JsonObject, name: String)
+}

src/main/kotlin/dev/botta/json/parser/Location.kt

@@ -0,0 +1,10 @@
+package dev.botta.json.parser
+
+class Location(val offset: Int, val line: Int, val column: Int) {
+    override fun toString() = "$line:$column"
+
+    override fun hashCode() = offset
+
+    override fun equals(other: Any?) =
+        other is Location && other.offset == offset && other.line == line && other.column == column
+}

src/main/kotlin/dev/botta/json/values/JsonArray.kt

@@ -0,0 +1,217 @@
+package dev.botta.json.values
+
+import dev.botta.json.writer.JsonWriter
+
+class JsonArray(values: List<Any?> = listOf()) : JsonValue(), MutableList<JsonValue> {
+    private val values = mutableListOf<JsonValue>()
+    override val isArray get() = true
+    override val size get() = values.size
+
+    constructor(vararg values: Any?) : this(values.toList())
+
+    init {
+        if (values is JsonArray) {
+            this.values.add(values)
+        } else {
+            this.values.addAll(values.map { dev.botta.json.Json.value(it) })
+        }
+    }
+
+    override fun add(element: JsonValue) = values.add(element)
+
+    fun add(element: Int) = add(dev.botta.json.Json.value(element))
+
+    fun add(element: Long) = add(dev.botta.json.Json.value(element))
+
+    fun add(element: Float) = add(dev.botta.json.Json.value(element))
+
+    fun add(element: Double) = add(dev.botta.json.Json.value(element))
+
+    fun add(element: Boolean) = add(dev.botta.json.Json.value(element))
+
+    fun add(element: String?) = add(dev.botta.json.Json.value(element))
+
+    override fun add(index: Int, element: JsonValue) {
+        values.add(index, element)
+    }
+
+    fun add(index: Int, element: Int) {
+        values.add(index, dev.botta.json.Json.value(element))
+    }
+
+    fun add(index: Int, element: Long) {
+        values.add(index, dev.botta.json.Json.value(element))
+    }
+
+    fun add(index: Int, element: Float) {
+        values.add(index, dev.botta.json.Json.value(element))
+    }
+
+    fun add(index: Int, element: Double) {
+        values.add(index, dev.botta.json.Json.value(element))
+    }
+
+    fun add(index: Int, element: Boolean) {
+        values.add(index, dev.botta.json.Json.value(element))
+    }
+
+    fun add(index: Int, element: String?) {
+        values.add(index, dev.botta.json.Json.value(element))
+    }
+
+    override fun addAll(index: Int, elements: Collection<JsonValue>) = values.addAll(index, elements)
+
+    @JvmName("addAllAny")
+    fun addAll(index: Int, elements: Collection<Any?>) = values.addAll(index, elements.map { dev.botta.json.Json.value(it) })
+
+    override fun addAll(elements: Collection<JsonValue>) = values.addAll(elements)
+
+    @JvmName("addAllAny")
+    fun addAll(elements: Collection<Any?>) = addAll(elements.map { dev.botta.json.Json.value(it) })
+
+    override fun set(index: Int, element: JsonValue) = values.set(index, element)
+
+    operator fun set(index: Int, element: Int) = values.set(index, dev.botta.json.Json.value(element))
+
+    operator fun set(index: Int, element: Long) = values.set(index, dev.botta.json.Json.value(element))
+
+    operator fun set(index: Int, element: Float) = values.set(index, dev.botta.json.Json.value(element))
+
+    operator fun set(index: Int, element: Double) = values.set(index, dev.botta.json.Json.value(element))
+
+    operator fun set(index: Int, element: Boolean) = values.set(index, dev.botta.json.Json.value(element))
+
+    operator fun set(index: Int, element: String?) = values.set(index, dev.botta.json.Json.value(element))
+
+    fun with(vararg elements: JsonValue) = apply { addAll(elements) }
+
+    fun with(vararg elements: Any?) = apply { elements.forEach { add(dev.botta.json.Json.value(it)) } }
+
+    fun with(vararg elements: Int) = apply { elements.forEach { add(it) } }
+
+    fun with(vararg elements: Long) = apply { elements.forEach { add(it) } }
+
+    fun with(vararg elements: Float) = apply { elements.forEach { add(it) } }
+
+    fun with(vararg elements: Double) = apply { elements.forEach { add(it) } }
+
+    fun with(vararg elements: Boolean) = apply { elements.forEach { add(it) } }
+
+    fun with(vararg elements: String?) = apply { elements.forEach { add(it) } }
+
+    override fun remove(element: JsonValue) = values.remove(element)
+
+    fun remove(element: Int) = remove(dev.botta.json.Json.value(element))
+
+    fun remove(element: Long) = remove(dev.botta.json.Json.value(element))
+
+    fun remove(element: Float) = remove(dev.botta.json.Json.value(element))
+
+    fun remove(element: Double) = remove(dev.botta.json.Json.value(element))
+
+    fun remove(element: Boolean) = remove(dev.botta.json.Json.value(element))
+
+    fun remove(element: String?) = remove(dev.botta.json.Json.value(element))
+
+    override fun removeAll(elements: Collection<JsonValue>) = values.removeAll(elements)
+
+    @JvmName("removeAllAny")
+    fun removeAll(elements: Collection<Any?>) = removeAll(elements.map { dev.botta.json.Json.value(it) })
+
+    override fun removeAt(index: Int) = values.removeAt(index)
+
+    override fun retainAll(elements: Collection<JsonValue>) = values.retainAll(elements)
+
+    @JvmName("retainAllAny")
+    fun retainAll(elements: Collection<Any?>) = retainAll(elements.map { dev.botta.json.Json.value(it) })
+
+    override fun clear() {
+        values.clear()
+    }
+
+    override fun asArray() = this
+
+    override fun contains(element: JsonValue) = values.contains(element)
+
+    fun contains(element: Int) = contains(dev.botta.json.Json.value(element))
+
+    fun contains(element: Long) = contains(dev.botta.json.Json.value(element))
+
+    fun contains(element: Float) = contains(dev.botta.json.Json.value(element))
+
+    fun contains(element: Double) = contains(dev.botta.json.Json.value(element))
+
+    fun contains(element: Boolean) = contains(dev.botta.json.Json.value(element))
+
+    fun contains(element: String?) = contains(dev.botta.json.Json.value(element))
+
+    override fun containsAll(elements: Collection<JsonValue>) = values.containsAll(elements)
+
+    @JvmName("containsAllAny")
+    fun containsAll(elements: Collection<Any?>) = containsAll(elements.map { dev.botta.json.Json.value(it) })
+
+    override fun indexOf(element: JsonValue) = values.indexOf(element)
+
+    fun indexOf(element: Int) = indexOf(dev.botta.json.Json.value(element))
+
+    fun indexOf(element: Long) = indexOf(dev.botta.json.Json.value(element))
+
+    fun indexOf(element: Float) = indexOf(dev.botta.json.Json.value(element))
+
+    fun indexOf(element: Double) = indexOf(dev.botta.json.Json.value(element))
+
+    fun indexOf(element: String?) = indexOf(dev.botta.json.Json.value(element))
+
+    fun indexOf(element: Boolean) = indexOf(dev.botta.json.Json.value(element))
+
+    override fun isEmpty() = values.isEmpty()
+
+    override fun lastIndexOf(element: JsonValue) = values.lastIndexOf(element)
+
+    fun lastIndexOf(element: Int) = lastIndexOf(dev.botta.json.Json.value(element))
+
+    fun lastIndexOf(element: Long) = lastIndexOf(dev.botta.json.Json.value(element))
+
+    fun lastIndexOf(element: Float) = lastIndexOf(dev.botta.json.Json.value(element))
+
+    fun lastIndexOf(element: Double) = lastIndexOf(dev.botta.json.Json.value(element))
+
+    fun lastIndexOf(element: String?) = lastIndexOf(dev.botta.json.Json.value(element))
+
+    fun lastIndexOf(element: Boolean) = lastIndexOf(dev.botta.json.Json.value(element))
+
+    override fun iterator() = values.iterator()
+
+    override fun listIterator() = values.listIterator()
+
+    override fun listIterator(index: Int) = values.listIterator(index)
+
+    override fun subList(fromIndex: Int, toIndex: Int) = values.subList(fromIndex, toIndex)
+
+    override fun get(index: Int) = values[index]
+
+    override fun write(writer: JsonWriter) {
+        writer.writeArrayOpen()
+        values.forEachIndexed { index, element ->
+            element.write(writer)
+            if (index != values.lastIndex) {
+                writer.writeArraySeparator()
+            }
+        }
+        writer.writeArrayClose()
+    }
+
+    override fun path(path: String): JsonValue? {
+        if (!path.startsWith("[")) return null // throw IllegalArgumentException("Invalid path $path")
+        val endIndex = path.indexOf(']')
+        if (endIndex == -1) return null // throw IllegalArgumentException("Invalid path $path")
+        val arrayIndex = path.substring(1, endIndex).toIntOrNull() ?: return null // throw IllegalArgumentException("Invalid path $path")
+        val value = get(arrayIndex)
+        if (endIndex == path.lastIndex) return value
+        return value.path(path.substring(endIndex + 1))
+    }
+
+    override fun hashCode() = values.hashCode()
+
+    override fun equals(other: Any?) = other is JsonArray && other.values == values
+}

src/main/kotlin/dev/botta/json/values/JsonLiteral.kt

@@ -0,0 +1,31 @@
+package dev.botta.json.values
+
+import dev.botta.json.writer.JsonWriter
+
+class JsonLiteral internal constructor(private val value: String) : JsonValue() {
+    override val isNull = value == "null"
+    override val isTrue = value == "true"
+    override val isFalse = value == "false"
+    override val isBoolean get() = isTrue || isFalse
+
+    override fun asBoolean(): Boolean? {
+        if (isNull) return null
+        return isTrue
+    }
+
+    override fun equals(other: Any?) = other is JsonLiteral && other.value == value
+
+    override fun hashCode() = value.hashCode()
+
+    override fun toString() = value
+
+    override fun write(writer: JsonWriter) {
+        writer.writeLiteral(value)
+    }
+
+    companion object {
+        val NULL = JsonLiteral("null")
+        val TRUE = JsonLiteral("true")
+        val FALSE = JsonLiteral("false")
+    }
+}

src/main/kotlin/dev/botta/json/values/JsonNumber.kt

@@ -0,0 +1,27 @@
+package dev.botta.json.values
+
+import dev.botta.json.writer.JsonWriter
+
+class JsonNumber internal constructor(private val value: String) : JsonValue() {
+    override val isNumber get() = true
+
+    override fun asInt() = value.toIntOrNull()
+
+    override fun asLong() = value.toLongOrNull()
+
+    override fun asFloat() = value.toFloatOrNull()
+
+    override fun asDouble() = value.toDoubleOrNull()
+
+    override fun asString() = value
+
+    override fun hashCode() = value.hashCode()
+
+    override fun equals(other: Any?) = other is JsonNumber && other.value == value
+
+    override fun toString() = value
+
+    override fun write(writer: JsonWriter) {
+        writer.writeNumber(value)
+    }
+}

src/main/kotlin/dev/botta/json/values/JsonObject.kt

@@ -0,0 +1,125 @@
+package dev.botta.json.values
+
+import dev.botta.json.writer.JsonWriter
+
+class JsonObject(pairs: List<Pair<String, Any?>> = listOf()) : JsonValue(), MutableMap<String, JsonValue> {
+    private val map = mutableMapOf<String, JsonValue>()
+    override val size get() = map.size
+    override val entries get() = map.entries
+    override val keys get() = map.keys
+    override val values get() = map.values
+    override val isObject get() = true
+
+    constructor(vararg pairs: Pair<String, Any?>) : this(pairs.toList())
+
+    init {
+        pairs.forEach { map[it.first] = dev.botta.json.Json.value(it.second) }
+    }
+
+    fun with(key: String, value: Int) = apply { with(key, dev.botta.json.Json.value(value)) }
+
+    fun with(key: String, value: Long) = apply { with(key, dev.botta.json.Json.value(value)) }
+
+    fun with(key: String, value: Float) = apply { with(key, dev.botta.json.Json.value(value)) }
+
+    fun with(key: String, value: Double) = apply { with(key, dev.botta.json.Json.value(value)) }
+
+    fun with(key: String, value: Boolean) = apply { with(key, dev.botta.json.Json.value(value)) }
+
+    fun with(key: String, value: String?) = apply { with(key, dev.botta.json.Json.value(value)) }
+
+    fun with(key: String, value: Any?) = apply { with(key, dev.botta.json.Json.value(value)) }
+
+    fun with(key: String, value: JsonValue) = apply { map[key] = value }
+
+    fun with(vararg pairs: Pair<String, Any?>) = apply { pairs.forEach { with(it.first, it.second) } }
+
+    operator fun set(key: String, value: Int) = set(key, dev.botta.json.Json.value(value))
+
+    operator fun set(key: String, value: Long) = set(key, dev.botta.json.Json.value(value))
+
+    operator fun set(key: String, value: Float) = set(key, dev.botta.json.Json.value(value))
+
+    operator fun set(key: String, value: Double) = set(key, dev.botta.json.Json.value(value))
+
+    operator fun set(key: String, value: Boolean) = set(key, dev.botta.json.Json.value(value))
+
+    operator fun set(key: String, value: String?) = set(key, dev.botta.json.Json.value(value))
+
+    operator fun set(key: String, value: JsonValue) = map.put(key, value)
+
+    fun merge(obj: JsonObject) {
+        putAll(obj)
+    }
+
+    override fun get(key: String) = map[key]
+
+    override fun path(path: String): JsonValue? {
+        val startIndex = if (path.startsWith(".")) 1 else 0
+        var endIndex = path.indexOfAny(arrayOf('.', '[').toCharArray(), startIndex)
+        if (endIndex == -1) endIndex = path.length
+        val key = path.substring(startIndex, endIndex)
+        if (key.isBlank()) return null // throw IllegalArgumentException("Invalid path $path")
+        val value = get(key) ?: return null
+        if (endIndex == path.length) return value
+        return value.path(path.substring(endIndex))
+    }
+
+    override fun write(writer: JsonWriter) {
+        writer.writeObjectOpen()
+        val namesIterator: Iterator<String> = keys.iterator()
+        val valuesIterator: Iterator<JsonValue> = values.iterator()
+        if (namesIterator.hasNext()) {
+            writer.writeString(namesIterator.next())
+            writer.writeMemberSeparator()
+            valuesIterator.next().write(writer)
+            while (namesIterator.hasNext()) {
+                writer.writeObjectSeparator()
+                writer.writeString(namesIterator.next())
+                writer.writeMemberSeparator()
+                valuesIterator.next().write(writer)
+            }
+        }
+        writer.writeObjectClose()
+    }
+
+    override fun asObject() = this
+
+    override fun containsKey(key: String) = map.containsKey(key)
+
+    override fun containsValue(value: JsonValue) = map.containsValue(value)
+
+    override fun isEmpty() = map.isEmpty()
+
+    override fun clear() {
+        map.clear()
+    }
+
+    override fun put(key: String, value: JsonValue) = map.put(key, value)
+
+    override fun putAll(from: Map<out String, JsonValue>) {
+        map.putAll(from)
+    }
+
+    override fun remove(key: String) = map.remove(key)
+
+    override fun hashCode() = map.hashCode()
+
+    override fun equals(other: Any?) = other is JsonObject && other.map == map
+
+    fun getStringOrThrow(key: String) = get(key)?.asString() ?: throw IllegalAccessError("$key not found or is not a String")
+
+    fun getIntOrThrow(key: String) = get(key)?.asInt() ?: throw IllegalAccessError("$key not found or is not an Int")
+
+    fun getLongOrThrow(key: String) = get(key)?.asLong() ?: throw IllegalAccessError("$key not found or is not an Long")
+
+    fun getFloatOrThrow(key: String) = get(key)?.asFloat() ?: throw IllegalAccessError("$key not found or is not an Float")
+
+    fun getDoubleOrThrow(key: String) = get(key)?.asDouble() ?: throw IllegalAccessError("$key not found or is not an Double")
+
+    fun getBooleanOrThrow(key: String) = get(key)?.asBoolean() ?: throw IllegalAccessError("$key not found or is not an Boolean")
+
+    fun getObjectOrThrow(key: String) = get(key)?.asObject() ?: throw IllegalAccessError("$key not found or is not an JsonObject")
+
+    fun getArrayOrThrow(key: String) = get(key)?.asArray() ?: throw IllegalAccessError("$key not found or is not an JsonArray")
+}

src/main/kotlin/dev/botta/json/values/JsonString.kt

@@ -0,0 +1,17 @@
+package dev.botta.json.values
+
+import dev.botta.json.writer.JsonWriter
+
+class JsonString internal constructor(private val value: String) : JsonValue() {
+    override val isString = true
+
+    override fun asString() = value
+
+    override fun equals(other: Any?) = other is JsonString && other.value == value
+
+    override fun hashCode() = value.hashCode()
+
+    override fun write(writer: JsonWriter) {
+        writer.writeString(value)
+    }
+}

src/main/kotlin/dev/botta/json/values/JsonValue.kt

@@ -0,0 +1,86 @@
+package dev.botta.json.values
+
+import dev.botta.json.writer.BufferedWriter
+import dev.botta.json.writer.JsonWriter
+import dev.botta.json.writer.PrettyPrint
+import dev.botta.json.writer.WriterConfig
+import java.io.Serializable
+import java.io.StringWriter
+
+abstract class JsonValue : Serializable {
+    open val isObject get() = false
+    open val isArray get() = false
+    open val isNumber get() = false
+    open val isString get() = false
+    open val isBoolean get() = false
+    open val isTrue get() = false
+    open val isFalse get() = false
+    open val isNull get() = false
+
+    open fun asObject(): JsonObject? {
+        return null
+    }
+
+    fun asObject(default: JsonObject) = asObject() ?: default
+
+    open fun asArray(): JsonArray? {
+        return null
+    }
+
+    fun asArray(default: JsonArray) = asArray() ?: default
+
+    open fun asInt(): Int? {
+        return null
+    }
+
+    fun asInt(default: Int) = asInt() ?: default
+
+    open fun asLong(): Long? {
+        return null
+    }
+
+    fun asLong(default: Long) = asLong() ?: default
+
+    open fun asFloat(): Float? {
+        return null
+    }
+
+    fun asFloat(default: Float) = asFloat() ?: default
+
+    open fun asDouble(): Double? {
+        return null
+    }
+
+    fun asDouble(default: Double) = asDouble() ?: default
+
+    open fun asString(): String? {
+        return null
+    }
+
+    fun asString(default: String) = asString() ?: default
+
+    open fun asBoolean(): Boolean? {
+        return null
+    }
+
+    fun asBoolean(default: Boolean) = asBoolean() ?: default
+
+    open fun path(path: String): JsonValue? {
+        if (path.isEmpty()) return this
+        return null
+    }
+
+    override fun toString() = toString(WriterConfig.MINIMAL)
+
+    fun toPrettyString() = toString(PrettyPrint.indentWithSpaces(2))
+
+    fun toString(config: WriterConfig): String {
+        val writer = StringWriter()
+        val buffer = BufferedWriter(writer, 128)
+        write(config.createWriter(buffer))
+        buffer.flush()
+        return writer.toString()
+    }
+
+    abstract fun write(writer: JsonWriter)
+}

src/main/kotlin/dev/botta/json/writer/BufferedWriter.kt

@@ -0,0 +1,58 @@
+package dev.botta.json.writer
+
+import java.io.Writer
+
+/**
+ * A lightweight writing buffer to reduce the amount of write operations to be performed on the
+ * underlying writer. This implementation is not thread-safe. It deliberately deviates from the
+ * contract of Writer. In particular, it does not flush or close the wrapped writer nor does it
+ * ensure that the wrapped writer is open.
+ */
+internal class BufferedWriter(private val writer: Writer, bufferSize: Int = 16) : Writer() {
+    private val buffer = CharArray(bufferSize)
+    private var fill = 0
+
+    override fun write(c: Int) {
+        if (fill > buffer.size - 1) {
+            flush()
+        }
+        buffer[fill++] = c.toChar()
+    }
+
+    override fun write(cbuf: CharArray, off: Int, len: Int) {
+        if (fill > buffer.size - len) {
+            flush()
+            if (len > buffer.size) {
+                writer.write(cbuf, off, len)
+                return
+            }
+        }
+        System.arraycopy(cbuf, off, buffer, fill, len)
+        fill += len
+    }
+
+    override fun write(str: String, off: Int, len: Int) {
+        if (fill > buffer.size - len) {
+            flush()
+            if (len > buffer.size) {
+                writer.write(str, off, len)
+                return
+            }
+        }
+        str.toCharArray(buffer, fill, off, off + len)
+        fill += len
+    }
+
+    /**
+     * Flushes the internal buffer but does not flush the wrapped writer.
+     */
+    override fun flush() {
+        writer.write(buffer, 0, fill)
+        fill = 0
+    }
+
+    /**
+     * Does not close or flush the wrapped writer.
+     */
+    override fun close() {}
+}

src/main/kotlin/dev/botta/json/writer/JsonStringWriter.kt

@@ -0,0 +1,62 @@
+package dev.botta.json.writer
+
+import java.io.Writer
+
+internal class JsonStringWriter {
+    fun write(value: String, writer: Writer) {
+        val length = value.length
+        var start = 0
+        for (index in 0 until length) {
+            val replacement = getReplacementChars(value[index])
+            if (replacement != null) {
+                writer.write(value, start, index - start)
+                writer.write(replacement)
+                start = index + 1
+            }
+        }
+        writer.write(value, start, length - start)
+    }
+
+    companion object {
+        private const val CONTROL_CHARACTERS_END = 0x001f
+        private val QUOT_CHARS = charArrayOf('\\', '"')
+        private val BS_CHARS = charArrayOf('\\', '\\')
+        private val LF_CHARS = charArrayOf('\\', 'n')
+        private val CR_CHARS = charArrayOf('\\', 'r')
+        private val TAB_CHARS = charArrayOf('\\', 't')
+
+        // In JavaScript, U+2028 and U+2029 characters count as line endings and must be encoded.
+        // http://stackoverflow.com/questions/2965293/javascript-parse-error-on-u2028-unicode-character
+        private val UNICODE_2028_CHARS = charArrayOf('\\', 'u', '2', '0', '2', '8')
+        private val UNICODE_2029_CHARS = charArrayOf('\\', 'u', '2', '0', '2', '9')
+        private val HEX_DIGITS = charArrayOf(
+            '0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
+            'a', 'b', 'c', 'd', 'e', 'f'
+        )
+
+        private fun getReplacementChars(ch: Char): CharArray? {
+            if (ch > '\\') {
+                if (ch < '\u2028' || ch > '\u2029') {
+                    // The lower range contains 'a' .. 'z'. Only 2 checks required.
+                    return null
+                }
+                return if (ch == '\u2028') UNICODE_2028_CHARS else UNICODE_2029_CHARS
+            }
+            if (ch == '\\') return BS_CHARS
+            if (ch > '"') {
+                // This range contains '0' .. '9' and 'A' .. 'Z'. Need 3 checks to get here.
+                return null
+            }
+            if (ch == '"') return QUOT_CHARS
+            if (ch.code > CONTROL_CHARACTERS_END) return null
+            if (ch == '\n') return LF_CHARS
+            if (ch == '\r') return CR_CHARS
+            return if (ch == '\t') {
+                TAB_CHARS
+            } else charArrayOf(
+                '\\', 'u', '0', '0', HEX_DIGITS[ch.code shr 4 and 0x000f],
+                HEX_DIGITS[ch.code and 0x000f]
+            )
+        }
+    }
+}

src/main/kotlin/dev/botta/json/writer/JsonWriter.kt

@@ -0,0 +1,14 @@
+package dev.botta.json.writer
+
+interface JsonWriter {
+    fun writeLiteral(value: String)
+    fun writeNumber(string: String)
+    fun writeString(string: String)
+    fun writeArrayOpen()
+    fun writeArrayClose()
+    fun writeArraySeparator()
+    fun writeObjectOpen()
+    fun writeObjectClose()
+    fun writeMemberSeparator()
+    fun writeObjectSeparator()
+}

src/main/kotlin/dev/botta/json/writer/MinimalJsonWriter.kt

@@ -0,0 +1,49 @@
+package dev.botta.json.writer
+
+import java.io.Writer
+
+open class MinimalJsonWriter(private val writer: Writer) : JsonWriter {
+    private val jsonStringWriter = JsonStringWriter()
+
+    override fun writeLiteral(value: String) {
+        writer.write(value)
+    }
+
+    override fun writeNumber(string: String) {
+        writer.write(string)
+    }
+
+    override fun writeString(string: String) {
+        writer.write('"'.code)
+        jsonStringWriter.write(string, writer)
+        writer.write('"'.code)
+    }
+
+    override fun writeArrayOpen() {
+        writer.write('['.code)
+    }
+
+    override fun writeArrayClose() {
+        writer.write(']'.code)
+    }
+
+    override fun writeArraySeparator() {
+        writer.write(','.code)
+    }
+
+    override fun writeObjectOpen() {
+        writer.write('{'.code)
+    }
+
+    override fun writeObjectClose() {
+        writer.write('}'.code)
+    }
+
+    override fun writeMemberSeparator() {
+        writer.write(':'.code)
+    }
+
+    override fun writeObjectSeparator() {
+        writer.write(','.code)
+    }
+}

src/main/kotlin/dev/botta/json/writer/PrettyPrint.kt

@@ -0,0 +1,21 @@
+package dev.botta.json.writer
+
+import java.io.Writer
+import java.util.*
+
+class PrettyPrint private constructor(private val indentChars: CharArray?) : WriterConfig() {
+    override fun createWriter(writer: Writer) = PrettyPrintWriter(writer, indentChars)
+
+    companion object {
+        fun singleLine() = PrettyPrint(null)
+
+        fun indentWithSpaces(number: Int): PrettyPrint {
+            require(number >= 0) { "number is negative" }
+            val chars = CharArray(number)
+            Arrays.fill(chars, ' ')
+            return PrettyPrint(chars)
+        }
+
+        fun indentWithTabs() = PrettyPrint(charArrayOf('\t'))
+    }
+}

src/main/kotlin/dev/botta/json/writer/PrettyPrintWriter.kt

@@ -0,0 +1,76 @@
+package dev.botta.json.writer
+
+import java.io.Writer
+
+class PrettyPrintWriter(private val writer: Writer, private val indentChars: CharArray?) : JsonWriter {
+    private val jsonStringWriter = JsonStringWriter()
+    private var indent = 0
+
+    override fun writeLiteral(value: String) {
+        writer.write(value)
+    }
+
+    override fun writeNumber(string: String) {
+        writer.write(string)
+    }
+
+    override fun writeString(string: String) {
+        writer.write('"'.code)
+        jsonStringWriter.write(string, writer)
+        writer.write('"'.code)
+    }
+
+    override fun writeArrayOpen() {
+        indent++
+        writer.write('['.code)
+        writeNewLine()
+    }
+
+    override fun writeArrayClose() {
+        indent--
+        writeNewLine()
+        writer.write(']'.code)
+    }
+
+    override fun writeArraySeparator() {
+        writer.write(','.code)
+        if (!writeNewLine()) {
+            writer.write(' '.code)
+        }
+    }
+
+    override fun writeObjectOpen() {
+        indent++
+        writer.write('{'.code)
+        writeNewLine()
+    }
+
+    override fun writeObjectClose() {
+        indent--
+        writeNewLine()
+        writer.write('}'.code)
+    }
+
+    override fun writeMemberSeparator() {
+        writer.write(':'.code)
+        writer.write(' '.code)
+    }
+
+    override fun writeObjectSeparator() {
+        writer.write(','.code)
+        if (!writeNewLine()) {
+            writer.write(' '.code)
+        }
+    }
+
+    private fun writeNewLine(): Boolean {
+        if (indentChars == null) {
+            return false
+        }
+        writer.write('\n'.code)
+        for (i in 0 until indent) {
+            writer.write(indentChars)
+        }
+        return true
+    }
+}

src/main/kotlin/dev/botta/json/writer/WriterConfig.kt

@@ -0,0 +1,13 @@
+package dev.botta.json.writer
+
+import java.io.Writer
+
+abstract class WriterConfig {
+    abstract fun createWriter(writer: Writer): JsonWriter
+
+    companion object {
+        var MINIMAL = object : WriterConfig() {
+            override fun createWriter(writer: Writer) = MinimalJsonWriter(writer)
+        }
+    }
+}

src/test/kotlin/Main.kt

@@ -0,0 +1,13 @@
+import cn.qqck.kotlin.tools.Rand
+
+fun main() {
+    println(Rand.str.az(128))
+    println(Rand.str.AZ(128))
+    println(Rand.str.aZ(128))
+    println(Rand.str.num(128))
+    println(Rand.str.num_az(128))
+    println(Rand.str.num_AZ(128))
+    println(Rand.str.num_aZ(128))
+    println(Rand.str.ascii(128))
+    println(Rand.str.china(128))
+}