Revert ArrayBuffer to toByteArray conversion change and use linear wasm memory (#5550)

Measurements of copying ArrayBuffer (1kk elements) to ByteArray:
```
kotlinx-browser toByteArray: ~4-5ms
fastArrayBufferToByteArray: ~800µs
```

## Testing
N/A

## Release Notes
N/A

Author: eymar

components/resources/library/src/wasmJsMain/kotlin/org/jetbrains/compose/resources/ResourceReader.wasmJs.kt

@@ -4,10 +4,21 @@ import kotlinx.browser.window
 import kotlinx.coroutines.await
 import org.khronos.webgl.ArrayBuffer
 import org.khronos.webgl.Int8Array
-import org.khronos.webgl.toByteArray
+import org.w3c.fetch.Response
 import org.w3c.files.Blob
 import org.w3c.xhr.XMLHttpRequest
 import kotlin.js.Promise
+import kotlin.wasm.unsafe.UnsafeWasmMemoryApi
+import kotlin.wasm.unsafe.withScopedMemoryAllocator
+
+@JsFun(
+    """ (src, size, dstAddr) => {
+        const mem8 = new Int8Array(wasmExports.memory.buffer, dstAddr, size);
+        mem8.set(src);
+    }
+"""
+)
+private external fun jsExportInt8ArrayToWasm(src: Int8Array, size: Int, dstAddr: Int)
 
 @JsFun("(blob) => blob.arrayBuffer()")
 private external fun jsExportBlobAsArrayBuffer(blob: Blob): Promise<ArrayBuffer>
@@ -48,7 +59,7 @@ internal object DefaultWasmResourceReader : ResourceReader {
 
     private suspend fun Blob.asByteArray(): ByteArray {
         val buffer: ArrayBuffer = jsExportBlobAsArrayBuffer(this).await()
-        return Int8Array(buffer).toByteArray()
+        return fastArrayBufferToByteArray(buffer)
     }
 }
 
@@ -74,11 +85,24 @@ private object TestWasmResourceReader : ResourceReader {
         request.overrideMimeType("text/plain; charset=x-user-defined")
         request.send()
         if (request.status == 200.toShort()) {
-            return requestResponseAsByteArray(request).toByteArray()
+            return requestResponseAsByteArray(request).asByteArray()
         }
         println("Request status is not 200 - $resPath, status: ${request.status}")
         throw MissingResourceException(resPath)
     }
+
+    private fun Int8Array.asByteArray(): ByteArray {
+        val array = this
+        val size = array.length
+
+        @OptIn(UnsafeWasmMemoryApi::class)
+        return withScopedMemoryAllocator { allocator ->
+            val memBuffer = allocator.allocate(size)
+            val dstAddress = memBuffer.address.toInt()
+            jsExportInt8ArrayToWasm(array, size, dstAddress)
+            ByteArray(size) { i -> (memBuffer + i).loadByte() }
+        }
+    }
 }
 
 // For blocking XmlHttpRequest the response can be only in text form, so we convert it to bytes manually

components/resources/library/src/wasmJsMain/kotlin/org/jetbrains/compose/resources/WasmByteArrayUtils.kt

@@ -0,0 +1,43 @@
+package org.jetbrains.compose.resources
+
+import org.khronos.webgl.ArrayBuffer
+import kotlin.wasm.unsafe.Pointer
+import kotlin.wasm.unsafe.UnsafeWasmMemoryApi
+import kotlin.wasm.unsafe.withScopedMemoryAllocator
+
+@OptIn(UnsafeWasmMemoryApi::class, ExperimentalWasmJsInterop::class)
+internal fun fastArrayBufferToByteArray(arrayBuffer: ArrayBuffer): ByteArray {
+    val size = arrayBuffer.byteLength
+    return withScopedMemoryAllocator { allocator ->
+        val bufferPtr = allocator.allocate(size)
+        copyArrayBufferToWasmMemory(arrayBuffer, bufferPtr.address.toInt())
+        readFromLinearMemory(bufferPtr, 0, size)
+    }
+}
+
+//language=js
+@OptIn(ExperimentalWasmJsInterop::class)
+private fun copyArrayBufferToWasmMemory(ab: ArrayBuffer, ptr: Int): Unit = js("""{
+      const data = new Uint8Array(ab);
+      new Uint8Array(wasmExports.memory.buffer).set(data, ptr);
+}""")
+
+@OptIn(UnsafeWasmMemoryApi::class)
+private fun readFromLinearMemory(base: Pointer, offset: Int, length: Int): ByteArray {
+    val bytes = ByteArray(length)
+    val src = base + offset
+    val intCount = length / 4
+    var idx = 0
+    for (i in 0 until intCount) {
+        val value = (src + idx).loadInt()
+        bytes[idx] = (value and 0xFF).toByte()
+        bytes[idx + 1] = ((value shr 8) and 0xFF).toByte()
+        bytes[idx + 2] = ((value shr 16) and 0xFF).toByte()
+        bytes[idx + 3] = ((value shr 24) and 0xFF).toByte()
+        idx += 4
+    }
+    for (i in idx until length) {
+        bytes[i] = (src + i).loadByte()
+    }
+    return bytes
+}