peachsim 0.1.940 → 0.1.1400

package/kotlin/ExpoSources/dev/peach/expo/PeachExpoRuntime.kt

@@ -0,0 +1,513 @@
+@file:OptIn(kotlin.io.encoding.ExperimentalEncodingApi::class)
+
+package dev.peach.expo
+
+import android.content.Context
+import android.content.res.Configuration
+import android.content.res.Resources
+import android.util.DisplayMetrics
+import kotlin.math.roundToInt
+import android.util.Log
+import expo.modules.kotlin.AppContext
+import expo.modules.kotlin.Promise
+import expo.modules.kotlin.classcomponent.ClassDefinitionData
+import expo.modules.kotlin.exception.CodedException
+import expo.modules.kotlin.exception.FunctionCallException
+import expo.modules.kotlin.exception.UnexpectedException
+import expo.modules.kotlin.exception.exceptionDecorator
+import expo.modules.kotlin.exception.toCodedException
+import expo.modules.kotlin.functions.AnyFunction
+import expo.modules.kotlin.functions.AsyncFunctionWithPromiseComponent
+import expo.modules.kotlin.functions.SuspendFunctionComponent
+import expo.modules.kotlin.functions.SyncFunctionComponent
+import expo.modules.kotlin.functions.UntypedAsyncFunctionComponent
+import expo.modules.kotlin.jni.JavaScriptTypedArray
+import expo.modules.kotlin.jni.TypedArrayKind
+import expo.modules.kotlin.modules.Module
+import expo.modules.kotlin.modules.ModuleDefinitionData
+import expo.modules.kotlin.objects.ObjectDefinitionData
+import expo.modules.kotlin.sharedobjects.SharedObject
+import expo.modules.kotlin.sharedobjects.SharedObjectClass
+import expo.modules.kotlin.sharedobjects.SharedObjectId
+import expo.modules.kotlin.sharedobjects.SharedRef
+import expo.modules.kotlin.typedarray.RawTypedArrayHolder
+import expo.modules.kotlin.views.ExpoView
+import expo.modules.kotlin.views.ViewManagerDefinition
+import kotlin.io.encoding.Base64
+import kotlinx.coroutines.launch
+import org.json.JSONArray
+import org.json.JSONObject
+
+// the module registry of one Kotlin/Wasm process (ModuleRegistry and
+// ModuleHolder), answering the tenant's Expo requests over the Expo wire that
+// ExpoWire in sootsim-swift's ExpoModulesCore owns. The tenant installer is
+// shared with the Swift process; only this side differs.
+object PeachExpoRuntime {
+    private class Holder(val name: String, val module: Module, val definition: ModuleDefinitionData) {
+        val functions: Map<String, AnyFunction> = functionsOf(definition.objectDefinition)
+        val classes: Map<String, ClassDefinitionData> = definition.classData.associateBy { it.name }
+        val views: Map<String, ViewManagerDefinition> = definition.views.associateBy { it.name }
+    }
+
+    // a view React Native created, with the props it last received
+    private class MountedView(val module: String, val definition: ViewManagerDefinition, val view: ExpoView) {
+        var props: Map<*, *>? = null
+    }
+
+    private val viewResources = Resources(Configuration(), DisplayMetrics(), emptyMap(), emptyMap(), emptyMap(), emptyMap())
+    private object PeachContext : Context() {
+        override val resources: Resources get() = viewResources
+        override val theme = Resources.Theme()
+    }
+
+    internal fun configureViewDevice(density: Float, locale: String, night: Boolean) {
+        val metrics = viewResources.displayMetrics.apply {
+            densityDpi = (density * DisplayMetrics.DENSITY_DEFAULT).roundToInt()
+            this.density = densityDpi / DisplayMetrics.DENSITY_DEFAULT.toFloat()
+        }
+        val configuration = Configuration().apply {
+            localeTag = locale
+            uiMode = Configuration.UI_MODE_TYPE_NORMAL or
+                if (night) Configuration.UI_MODE_NIGHT_YES else Configuration.UI_MODE_NIGHT_NO
+        }
+        viewResources.configuration.setTo(configuration)
+    }
+
+    private fun functionsOf(definition: ObjectDefinitionData): Map<String, AnyFunction> =
+        definition.syncFunctions + definition.asyncFunctions
+
+    private sealed class Settled {
+        class Value(val value: Any?) : Settled()
+        class Failure(val error: CodedException) : Settled()
+    }
+
+    private val appContext = AppContext()
+    private val sharedObjects = appContext.runtime.sharedObjectRegistry
+    // the typed arrays the current request decoded, in wire order
+    private val requestArrays = mutableListOf<JavaScriptTypedArray>()
+    private val holders = LinkedHashMap<String, Holder>()
+    private val mountedViews = HashMap<String, MountedView>()
+    private val events = mutableListOf<String>()
+    private val settled = mutableMapOf<Int, Settled>()
+    private val pending = mutableSetOf<Int>()
+    private var nextCall = 1
+    private var notify: (() -> Unit)? = null
+
+    fun register(modules: List<Pair<() -> Module, String?>>) {
+        for ((create, override) in modules) {
+            val module = create()
+            module.context = appContext
+            val definition = module.definition()
+            val name = override ?: definition.name
+            check(name !in holders) { "duplicate Expo module: $name" }
+            val holder = Holder(name, module, definition)
+            module.emitter = { event, body ->
+                events.add(wireObject(listOf("module" to name, "name" to event, "body" to body)))
+                notify?.invoke()
+            }
+            holders[name] = holder
+            for (data in definition.classData) {
+                if (data.ownerClass != Unit::class) sharedObjects.addClass(data.ownerClass, SharedObjectClass(name, data.name))
+            }
+            for (body in definition.onCreate) body()
+        }
+        sharedObjects.emitter = { native, event, payload ->
+            events.add(wireObject(listOf("object" to native, "name" to event, "args" to payload)))
+            notify?.invoke()
+        }
+    }
+
+    internal fun sharedObject(id: SharedObjectId): SharedObject = sharedObjects.toNativeObject(id)
+
+    internal fun mountedView(id: String): ExpoView =
+        mountedViews[id]?.view ?: throw CodedException("Unable to find the Expo view $id")
+
+    // the tenant's wake-up: an event or a settled call is waiting
+    fun listen(listener: () -> Unit) {
+        notify = listener
+    }
+
+    fun dispatch(payload: String): String {
+        requestArrays.clear()
+        val reply = try {
+            "\"ok\":true,\"value\":${request(decode(JSONArray("[$payload]").opt(0)))}"
+        } catch (error: Throwable) {
+            val coded = error.toCodedException()
+            "\"ok\":false,\"error\":{\"message\":${quote(coded.message ?: "")},\"code\":${quote(coded.code)}}"
+        }
+        // JSI typed arrays share the caller's memory: what a synchronous body
+        // wrote reaches the caller's array before the call returns
+        val writes = requestArrays.filter { it.dirty }
+        requestArrays.clear()
+        if (writes.isEmpty()) return "{$reply}"
+        return "{$reply,\"writes\":${writes.joinToString(",", "[", "]") { "[${it.ordinal},${quote(Base64.encode(it.bytes))}]" }}}"
+    }
+
+    private fun request(value: Any?): String {
+        val fields = value as? Map<*, *> ?: throw UnexpectedException("invalid Expo request")
+        val operation = fields["operation"] as? String
+        when (operation) {
+            "metadata" -> return metadata()
+            "events" -> {
+                val drained = events.joinToString(",", "[", "]")
+                events.clear()
+                return drained
+            }
+            "dropView" -> {
+                val mounted = mountedViews.remove(fields["id"] as? String ?: throw UnexpectedException("invalid Expo view"))
+                mounted?.definition?.onViewDestroys?.invoke(mounted.view)
+                return "null"
+            }
+            "poll" -> {
+                val id = (fields["id"] as? Double)?.toInt() ?: throw UnexpectedException("invalid Expo poll")
+                if (id in pending) return wireObject(listOf("pending" to id.toDouble()))
+                return reply(settled.remove(id) ?: throw UnexpectedException("unknown Expo call $id"))
+            }
+        }
+        if (operation == "release") {
+            val id = (fields["id"] as? Double)?.toInt() ?: throw UnexpectedException("invalid Expo release")
+            sharedObjects.delete(SharedObjectId(id))
+            return "null"
+        }
+        val name = fields["module"] as? String ?: throw UnexpectedException("invalid Expo request")
+        val holder = holders[name] ?: throw CodedException("ERR_MODULE_NOT_FOUND", "Module '$name' not found", null)
+        if ("view" in fields) return viewRequest(holder, operation, fields)
+        val className = fields["class"] as? String
+        if (className != null) return classRequest(holder, className, operation, fields)
+        val member = fields["member"] as? String ?: throw UnexpectedException("invalid Expo request")
+        val definition = holder.definition.objectDefinition
+        return when (operation) {
+            "get" -> {
+                definition.constants[member]?.let { constant ->
+                    if (!constant.evaluated) {
+                        constant.value = constant.getter?.body?.invoke(emptyArray())
+                        constant.evaluated = true
+                    }
+                    return wireObject(listOf("value" to constant.value))
+                }
+                val getter = definition.properties[member]?.getter ?: return wireObject(listOf("value" to Undefined))
+                wireObject(listOf("value" to getter.body(emptyArray())))
+            }
+            "set" -> {
+                val setter = definition.properties[member]?.setter ?: return wireObject(listOf("value" to Undefined))
+                setter.body(setter.convertArgs(listOf(fields["value"])))
+                wireObject(listOf("value" to Undefined))
+            }
+            "call" -> {
+                val function = holder.functions[member]
+                    ?: throw CodedException("ERR_FUNCTION_NOT_FOUND", "Function '$member' not found in module '$name'", null)
+                val args = fields["args"] as? List<*> ?: throw UnexpectedException("invalid Expo arguments")
+                call(name, function, args)
+            }
+            else -> throw UnexpectedException("invalid Expo operation $operation")
+        }
+    }
+
+    // a view's props, which create the view the first time, or one of its
+    // async functions, whose first argument is the view when it takes the owner
+    private fun viewRequest(holder: Holder, operation: String?, fields: Map<*, *>): String {
+        val id = fields["id"] as? String ?: throw UnexpectedException("invalid Expo view")
+        val viewName = fields["view"] as? String ?: throw UnexpectedException("invalid Expo view")
+        if (operation == "viewProps") {
+            configureViewDevice(
+                (fields["density"] as? Double)?.toFloat() ?: throw UnexpectedException("missing Expo view device density"),
+                fields["locale"] as? String ?: throw UnexpectedException("missing Expo view device locale"),
+                fields["night"] as? Boolean ?: throw UnexpectedException("missing Expo view device theme"),
+            )
+            val props = fields["props"] as? Map<*, *> ?: throw UnexpectedException("invalid Expo view props")
+            val mounted = mountedViews.getOrPut(id) {
+                val definition = holder.views[viewName] ?: throw UnexpectedException("View '$viewName' not found in module '${holder.name}'")
+                val view = definition.createView(PeachContext, appContext)
+                view.callbacks = definition.callbacks
+                view.emitter = { event, body ->
+                    events.add(wireObject(listOf("view" to id, "module" to holder.name, "name" to event, "body" to body)))
+                    notify?.invoke()
+                }
+                MountedView(holder.name, definition, view)
+            }
+            updateView(mounted, props)
+            return "null"
+        }
+        val mounted = mountedViews[id]?.takeIf { it.module == holder.name && it.definition.name == viewName }
+            ?: throw CodedException("Unable to find the $viewName view $id")
+        val member = fields["member"] as? String ?: throw UnexpectedException("invalid Expo request")
+        if (operation != "call") throw UnexpectedException("invalid Expo operation $operation")
+        val function = mounted.definition.asyncFunctions[member]
+            ?: throw CodedException("ERR_FUNCTION_NOT_FOUND", "Function '$member' not found in view '$viewName'", null)
+        val args = fields["args"] as? List<*> ?: throw UnexpectedException("invalid Expo arguments")
+        return call("${holder.name}.$viewName", function, if (function.takesOwner) listOf(mounted.view) + args else args)
+    }
+
+    // Fabric's first props hold only the props React set; later ones each
+    // prop that changed, a removed one as null. a failed prop is logged and
+    // the rest still apply, then the view hears that its props updated
+    private fun updateView(mounted: MountedView, props: Map<*, *>) {
+        val last = mounted.props
+        val changed = mounted.definition.props.values.filter { prop ->
+            if (last == null) prop.name in props else last[prop.name] != props[prop.name]
+        }
+        mounted.props = props
+        if (last != null && changed.isEmpty()) return
+        for (prop in changed) {
+            try {
+                prop.set(props[prop.name], mounted.view)
+            } catch (error: Throwable) {
+                Log.e("ExpoModulesCore", error.message ?: error.toString())
+            }
+        }
+        mounted.definition.onViewDidUpdateProps?.invoke(mounted.view)
+    }
+
+    // a Class member: the constructor, a static function, or an instance's
+    // function or property, whose first argument is `this` when it takes the owner
+    private fun classRequest(holder: Holder, className: String, operation: String?, fields: Map<*, *>): String {
+        val data = holder.classes[className] ?: throw UnexpectedException("Class '$className' not found in module '${holder.name}'")
+        val args = fields["args"] as? List<*> ?: emptyList<Any?>()
+        val owner = fields["this"]
+        if (operation == "construct") {
+            val constructor = data.constructor ?: return "[0,null]"
+            val native = exceptionDecorator({ FunctionCallException("constructor", "${holder.name}.$className", it) }) {
+                constructor.body(constructor.convertArgs(args))
+            }
+            if (native !is SharedObject) return "[0,null]"
+            if (native.runtime == null) native.runtime = appContext.runtime
+            val id = sharedObjects.add(native).value
+            return "[$id,${encode((native as? SharedRef<*>)?.nativeRefType)}]"
+        }
+        val member = fields["member"] as? String ?: throw UnexpectedException("invalid Expo request")
+        val withOwner = { function: AnyFunction, rest: List<Any?> -> if (function.takesOwner) listOf(owner) + rest else rest }
+        return when (operation) {
+            "get" -> {
+                val getter = data.objectDefinition.properties[member]?.getter ?: return wireObject(listOf("value" to Undefined))
+                wireObject(listOf("value" to getter.body(getter.convertArgs(withOwner(getter, emptyList())))))
+            }
+            "set" -> {
+                val setter = data.objectDefinition.properties[member]?.setter ?: return wireObject(listOf("value" to Undefined))
+                setter.body(setter.convertArgs(withOwner(setter, listOf(fields["value"]))))
+                wireObject(listOf("value" to Undefined))
+            }
+            "call" -> {
+                val function = if ("this" in fields) functionsOf(data.objectDefinition)[member]
+                else data.staticSyncFunctions[member] ?: data.staticAsyncFunctions[member]
+                function ?: throw CodedException("ERR_FUNCTION_NOT_FOUND", "Function '$member' not found in class '$className'", null)
+                call("${holder.name}.$className", function, withOwner(function, args))
+            }
+            else -> throw UnexpectedException("invalid Expo operation $operation")
+        }
+    }
+
+    private fun call(module: String, function: AnyFunction, args: List<Any?>): String {
+        if (function is SyncFunctionComponent) {
+            val value = exceptionDecorator({ FunctionCallException(function.name, module, it) }) {
+                function.body(function.convertArgs(args))
+            }
+            return wireObject(listOf("value" to value))
+        }
+        val id = nextCall++
+        pending.add(id)
+        val settle = { result: Settled ->
+            if (pending.remove(id)) {
+                settled[id] = result
+                notify?.invoke()
+            }
+        }
+        val promise = object : Promise {
+            override fun resolve(value: Any?) = settle(Settled.Value(value))
+            override fun reject(code: String?, message: String?, cause: Throwable?) =
+                settle(Settled.Failure(CodedException(code ?: "UnknownCode", message, cause)))
+        }
+        val fail = { error: Throwable ->
+            settle(Settled.Failure(FunctionCallException(function.name, module, error.toCodedException())))
+        }
+        // android runs async bodies on its modules queue, after the call returns
+        appContext.modulesQueue.launch {
+            try {
+                val converted = function.convertArgs(args)
+                when (function) {
+                    is UntypedAsyncFunctionComponent -> promise.resolve(function.body(converted))
+                    is AsyncFunctionWithPromiseComponent -> function.body(converted, promise)
+                    is SuspendFunctionComponent -> promise.resolve(function.body(this, converted))
+                }
+            } catch (error: Throwable) {
+                fail(error)
+            }
+        }
+        return wireObject(listOf("pending" to id.toDouble()))
+    }
+
+    private fun reply(result: Settled): String = when (result) {
+        is Settled.Value -> wireObject(listOf("value" to result.value))
+        is Settled.Failure -> throw result.error
+    }
+
+    private fun functionMetadata(functions: Map<String, AnyFunction>): List<Any?> =
+        functions.keys.sorted().map { name ->
+            val function = functions.getValue(name)
+            Wire(wireObject(listOf("name" to name, "async" to (function !is SyncFunctionComponent), "enumerable" to function.isEnumerable)))
+        }
+
+    private fun metadata(): String = holders.keys.sorted().map { holders.getValue(it) }.map { holder ->
+        val definition = holder.definition.objectDefinition
+        val properties = definition.constants.keys.sorted().map { Wire(wireObject(listOf("name" to it, "get" to true, "set" to false))) } +
+            definition.properties.keys.sorted().map { name ->
+                val property = definition.properties.getValue(name)
+                Wire(wireObject(listOf("name" to name, "get" to (property.getter != null), "set" to (property.setter != null))))
+            }
+        Wire(wireObject(listOf(
+            "name" to holder.name,
+            "definitionName" to holder.definition.name,
+            "constants" to Wire(wireObject(definition.legacyConstantsProvider().entries.sortedBy { it.key }.map { it.key to it.value })),
+            "functions" to functionMetadata(holder.functions),
+            "properties" to properties,
+            "events" to definition.eventNames,
+            "views" to holder.definition.views.map { view ->
+                Wire(wireObject(listOf(
+                    "name" to view.name,
+                    "props" to view.props.keys.sorted(),
+                    "events" to view.callbacks,
+                    "functions" to functionMetadata(view.asyncFunctions),
+                )))
+            },
+            "classes" to holder.definition.classData.sortedBy { it.name }.map { data ->
+                val instance = data.objectDefinition
+                Wire(wireObject(listOf(
+                    "name" to data.name,
+                    "functions" to functionMetadata(functionsOf(instance)),
+                    "staticFunctions" to functionMetadata(data.staticSyncFunctions + data.staticAsyncFunctions),
+                    "properties" to instance.properties.keys.sorted().map { name ->
+                        val property = instance.properties.getValue(name)
+                        Wire(wireObject(listOf("name" to name, "get" to (property.getter != null), "set" to (property.setter != null))))
+                    },
+                )))
+            },
+        )))
+    }.let { encode(it) }
+
+    // javascript undefined, and an already encoded wire value
+    private object Undefined
+    private class Wire(val json: String)
+
+    private fun decode(value: Any?): Any? = when (value) {
+        null, JSONObject.NULL -> null
+        is Boolean, is String -> value
+        is Number -> value.toDouble()
+        is JSONArray -> List(value.length()) { decode(value.opt(it)) }
+        is JSONObject -> {
+            val keys = value.keys().asSequence().toList()
+            if (keys.size != 1) throw UnexpectedException("invalid Expo wire value")
+            val raw = value.opt(keys[0])
+            when (keys[0]) {
+                "k" -> {
+                    val pairs = raw as? JSONArray ?: throw UnexpectedException("invalid Expo wire object")
+                    val fields = LinkedHashMap<String, Any?>()
+                    for (index in 0 until pairs.length()) {
+                        val pair = pairs.opt(index) as? JSONArray ?: throw UnexpectedException("invalid Expo wire object")
+                        fields[pair.opt(0) as? String ?: throw UnexpectedException("invalid Expo wire object")] = decode(pair.opt(1))
+                    }
+                    fields
+                }
+                // a missing argument reaches the converters as null
+                "u" -> null
+                "n" -> when (raw) {
+                    "-0" -> -0.0
+                    "NaN" -> Double.NaN
+                    "Infinity" -> Double.POSITIVE_INFINITY
+                    "-Infinity" -> Double.NEGATIVE_INFINITY
+                    else -> throw UnexpectedException("invalid Expo wire number")
+                }
+                "ab" -> Base64.decode(raw as? String ?: throw UnexpectedException("invalid Expo wire bytes"))
+                "t" -> {
+                    val pair = raw as? JSONArray ?: throw UnexpectedException("invalid Expo wire typed array")
+                    val kind = TypedArrayKind.entries.firstOrNull { it.name == pair.opt(0) }
+                        ?: throw UnexpectedException("invalid Expo wire typed array")
+                    val bytes = Base64.decode(pair.opt(1) as? String ?: throw UnexpectedException("invalid Expo wire bytes"))
+                    val offset = pair.opt(2) as? Number ?: throw UnexpectedException("invalid Expo wire typed array")
+                    val byteOffset = offset.toInt()
+                    val width = JavaScriptTypedArray.elementSize(kind)
+                    if (pair.length() != 3 || offset.toDouble() != byteOffset.toDouble() || byteOffset < 0 || byteOffset % width != 0 || bytes.size % width != 0)
+                        throw UnexpectedException("invalid Expo wire typed array")
+                    JavaScriptTypedArray(kind, bytes, requestArrays.size, byteOffset).also { requestArrays.add(it) }
+                }
+                "so" -> SharedObjectId((raw as? Number)?.toInt() ?: throw UnexpectedException("invalid Expo shared object"))
+                else -> throw UnexpectedException("Expo wire value '${keys[0]}' is not supported in Kotlin yet")
+            }
+        }
+        else -> throw UnexpectedException("invalid Expo wire value")
+    }
+
+    private fun wireObject(fields: List<Pair<String, Any?>>): String =
+        fields.joinToString(",", "{\"k\":[", "]}") { (key, value) -> "[${quote(key)},${encode(value)}]" }
+
+    // JSTypeConverterProvider's conversions to javascript
+    private fun encode(value: Any?): String = when (value) {
+        null, Unit -> "null"
+        Undefined -> "{\"u\":0}"
+        is Wire -> value.json
+        is String -> quote(value)
+        is Boolean -> value.toString()
+        is Char -> quote(value.toString())
+        is Number -> number(value.toDouble())
+        is Map<*, *> -> wireObject(value.entries.map { (key, item) -> key.toString() to item })
+        is Collection<*> -> value.joinToString(",", "[", "]") { encode(it) }
+        is Array<*> -> value.joinToString(",", "[", "]") { encode(it) }
+        is Pair<*, *> -> "[${encode(value.first)},${encode(value.second)}]"
+        is IntArray -> value.joinToString(",", "[", "]") { number(it.toDouble()) }
+        is LongArray -> value.joinToString(",", "[", "]") { number(it.toDouble()) }
+        is DoubleArray -> value.joinToString(",", "[", "]") { number(it) }
+        is FloatArray -> value.joinToString(",", "[", "]") { number(it.toDouble()) }
+        is BooleanArray -> value.joinToString(",", "[", "]") { it.toString() }
+        // a ByteArray reaches JavaScript as a Uint8Array, as on Android
+        is ByteArray -> typedArray(TypedArrayKind.Uint8Array, value, 0)
+        is JavaScriptTypedArray -> typedArray(value.kind, value.bytes, value.byteOffset)
+        is RawTypedArrayHolder -> typedArray(value.rawArray.kind, value.rawArray.bytes, value.rawArray.byteOffset)
+        is SharedObject -> sharedObjectWire(value)
+        else -> {
+            val converted = PeachExpoTypes.toJS(value)
+            if (converted === PeachExpoTypes.Unconverted)
+                throw UnexpectedException("Cannot convert '${value::class.simpleName}' to a JavaScript value")
+            encode(converted)
+        }
+    }
+
+    private fun typedArray(kind: TypedArrayKind, bytes: ByteArray, byteOffset: Int): String =
+        "{\"t\":[${quote(kind.name)},${quote(Base64.encode(bytes))},$byteOffset]}"
+
+    // a native object JavaScript already holds is that object; a new one gets an
+    // instance of its exported class, or a plain object for an unexported
+    // SharedRef, as convertSharedObject does
+    private fun sharedObjectWire(native: SharedObject): String {
+        val exported = sharedObjects.classOf(native)
+        if (native.sharedObjectId.value == 0) {
+            if (exported == null && native !is SharedRef<*>)
+                throw UnexpectedException("Could not find JavaScript class for shared object: $native")
+            if (native.runtime == null) native.runtime = appContext.runtime
+            sharedObjects.add(native)
+        }
+        val refType = (native as? SharedRef<*>)?.nativeRefType
+        return "{\"so\":[${native.sharedObjectId.value},${encode(exported?.module)},${encode(exported?.name)},${encode(refType)}]}"
+    }
+
+    private fun number(value: Double): String = when {
+        value.isNaN() -> "{\"n\":\"NaN\"}"
+        value == Double.POSITIVE_INFINITY -> "{\"n\":\"Infinity\"}"
+        value == Double.NEGATIVE_INFINITY -> "{\"n\":\"-Infinity\"}"
+        value == 0.0 && 1.0 / value < 0 -> "{\"n\":\"-0\"}"
+        value == value.toLong().toDouble() && kotlin.math.abs(value) < 1e15 -> value.toLong().toString()
+        else -> value.toString()
+    }
+
+    private fun quote(value: String): String {
+        val out = StringBuilder("\"")
+        for (c in value) {
+            when (c) {
+                '"' -> out.append("\\\"")
+                '\\' -> out.append("\\\\")
+                '\n' -> out.append("\\n")
+                '\r' -> out.append("\\r")
+                '\t' -> out.append("\\t")
+                else -> if (c.code < 0x20) out.append("\\u").append(c.code.toString(16).padStart(4, '0')) else out.append(c)
+            }
+        }
+        return out.append('"').toString()
+    }
+}