gofront 1.6.1 → 1.8.0

package/src/backend/wasm/stdlib/bytes.js

@@ -2,6 +2,45 @@
 // FunctionEmitter mixin: bytes package functions and bytes.Buffer methods.
 
 export class BytesEmitter {
+	emitBytesNewBuffer(call, _targetWasmType) {
+		const structInfo = this.mod.getStructType("bytes.Buffer");
+		const byteElemGo = { kind: "basic", name: "byte" };
+		const sliceInfo = this.mod.getSliceType(byteElemGo);
+		const sliceW = {
+			kind: "ref",
+			nullable: true,
+			typeIndex: sliceInfo.typeIndex,
+		};
+		this.emitExpr(call.args[0], sliceW);
+		if (structInfo.fields.length > 1) {
+			this.pushInstruction({ op: "i64.const", value: 0n });
+			this.pushInstruction({ op: "i64.const", value: 0n });
+		}
+		this.pushInstruction({
+			op: "struct.new",
+			typeIndex: structInfo.typeIndex,
+		});
+	}
+
+	emitBytesNewBufferString(call, _targetWasmType) {
+		const structInfo = this.mod.getStructType("bytes.Buffer");
+		const sTmp = this.acquireTemp("externref");
+		this.emitExpr(call.args[0], "externref");
+		this.pushInstruction({ op: "local.set", index: sTmp });
+
+		this.pushInstruction({ op: "local.get", index: sTmp });
+		this._emitStringToByteSlice({ elem: { kind: "basic", name: "byte" } });
+		this.releaseTemp(sTmp, "externref");
+		if (structInfo.fields.length > 1) {
+			this.pushInstruction({ op: "i64.const", value: 0n });
+			this.pushInstruction({ op: "i64.const", value: 0n });
+		}
+		this.pushInstruction({
+			op: "struct.new",
+			typeIndex: structInfo.typeIndex,
+		});
+	}
+
 	emitBytesBufferMethodCall(method, recvExpr, args, targetWasmType) {
 		const structInfo = this.mod.getStructType("bytes.Buffer");
 		const bufW = {
@@ -44,6 +83,30 @@ export class BytesEmitter {
 			return sTmp;
 		};
 
+		const setLastOp = (opVal) => {
+			if (structInfo.fields.length > 1) {
+				this.pushInstruction({ op: "local.get", index: bTmp });
+				this.pushInstruction({ op: "i64.const", value: BigInt(opVal) });
+				this.pushInstruction({
+					op: "struct.set",
+					typeIndex: structInfo.typeIndex,
+					fieldIndex: 1,
+				});
+			}
+		};
+		const setLastRuneLen = (lenLocal) => {
+			if (structInfo.fields.length > 2) {
+				this.pushInstruction({ op: "local.get", index: bTmp });
+				this.pushInstruction({ op: "local.get", index: lenLocal });
+				this.pushInstruction("i64.extend_i32_u");
+				this.pushInstruction({
+					op: "struct.set",
+					typeIndex: structInfo.typeIndex,
+					fieldIndex: 2,
+				});
+			}
+		};
+
 		switch (method) {
 			case "Len": {
 				const sTmp = getBufSlice();
@@ -86,6 +149,7 @@ export class BytesEmitter {
 					typeIndex: structInfo.typeIndex,
 					fieldIndex: 0,
 				});
+				setLastOp(0);
 				this.releaseTemp(bTmp, bufW);
 				return;
 			}
@@ -221,6 +285,7 @@ export class BytesEmitter {
 				});
 
 				this.pushInstruction({ op: "ref.null", heapType: "any" });
+				setLastOp(0);
 
 				this.releaseTemp(newCapTmp, "i32");
 				this.releaseTemp(newOffTmp, "i32");
@@ -316,6 +381,7 @@ export class BytesEmitter {
 				this.pushInstruction({ op: "local.get", index: pLenTmp });
 				this.pushInstruction("i64.extend_i32_u");
 				this.pushInstruction({ op: "ref.null", heapType: "any" });
+				setLastOp(0);
 
 				this.releaseTemp(newCapTmp, "i32");
 				this.releaseTemp(newOffTmp, "i32");
@@ -640,117 +706,1105 @@ export class BytesEmitter {
 				this.pushInstruction({ op: "local.get", index: newLenTmp });
 				this.pushInstruction({ op: "local.get", index: newCapTmp });
 				this.pushInstruction({
-					op: "struct.new",
+					op: "struct.new",
+					typeIndex: sliceInfo.typeIndex,
+				});
+				this.pushInstruction({
+					op: "struct.set",
+					typeIndex: structInfo.typeIndex,
+					fieldIndex: 0,
+				});
+
+				this.pushInstruction({ op: "local.get", index: rLenTmp });
+				this.pushInstruction("i64.extend_i32_u");
+				this.pushInstruction({ op: "ref.null", heapType: "any" });
+				setLastOp(0);
+
+				this.releaseTemp(newCapTmp, "i32");
+				this.releaseTemp(newOffTmp, "i32");
+				this.releaseTemp(newArrTmp, arrW);
+				this.releaseTemp(newLenTmp, "i32");
+				this.releaseTemp(oldCapTmp, "i32");
+				this.releaseTemp(oldLenTmp, "i32");
+				this.releaseTemp(oldOffTmp, "i32");
+				this.releaseTemp(oldArrTmp, arrW);
+				this.releaseTemp(rLenTmp, "i32");
+				this.releaseTemp(rTmp, "i32");
+				this.releaseTemp(bTmp, bufW);
+				return;
+			}
+			case "Grow": {
+				const nTmp = this.acquireTemp("i32");
+				this._emitI32Arg(args[0]);
+				this.pushInstruction({ op: "local.set", index: nTmp });
+
+				this.pushInstruction({ op: "local.get", index: nTmp });
+				this.pushInstruction({ op: "i32.const", value: 0 });
+				this.pushInstruction("i32.lt_s");
+				this.pushInstruction({ op: "if", blockType: "void" });
+				this.emitPanic("bytes.Buffer.Grow: negative count");
+				this.pushInstruction("end");
+
+				this.pushInstruction({ op: "local.get", index: nTmp });
+				this.pushInstruction({ op: "i32.const", value: 0 });
+				this.pushInstruction("i32.gt_s");
+				this.pushInstruction({ op: "if", blockType: "void" });
+
+				const sTmp = getBufSlice();
+				const oldArrTmp = this.acquireTemp(arrW);
+				const oldOffTmp = this.acquireTemp("i32");
+				const oldLenTmp = this.acquireTemp("i32");
+				const oldCapTmp = this.acquireTemp("i32");
+				this._emitSliceUnpack(sTmp, sliceInfo, {
+					arr: oldArrTmp,
+					off: oldOffTmp,
+					len: oldLenTmp,
+					cap: oldCapTmp,
+				});
+				this.releaseTemp(sTmp, sliceW);
+
+				const targetCapTmp = this.acquireTemp("i32");
+				this.pushInstruction({ op: "local.get", index: oldLenTmp });
+				this.pushInstruction({ op: "local.get", index: nTmp });
+				this.pushInstruction("i32.add");
+				this.pushInstruction({ op: "local.set", index: targetCapTmp });
+
+				this.pushInstruction({ op: "local.get", index: targetCapTmp });
+				this.pushInstruction({ op: "local.get", index: oldCapTmp });
+				this.pushInstruction("i32.gt_u");
+				this.pushInstruction({ op: "if", blockType: "void" });
+
+				const newArrTmp = this.acquireTemp(arrW);
+				const newOffTmp = this.acquireTemp("i32");
+				const newCapTmp = this.acquireTemp("i32");
+
+				this._emitGrowSlice({
+					arrInfo,
+					elemGoType: byteGo,
+					oldArrTmp,
+					oldOffTmp,
+					oldLenTmp,
+					oldCapTmp,
+					newArrTmp,
+					newOffTmp,
+					newLenTmp: targetCapTmp,
+					newCapTmp,
+				});
+
+				this.pushInstruction({ op: "local.get", index: bTmp });
+				this.pushInstruction({ op: "local.get", index: newArrTmp });
+				this.pushInstruction({ op: "local.get", index: newOffTmp });
+				this.pushInstruction({ op: "local.get", index: oldLenTmp });
+				this.pushInstruction({ op: "local.get", index: newCapTmp });
+				this.pushInstruction({
+					op: "struct.new",
+					typeIndex: sliceInfo.typeIndex,
+				});
+				this.pushInstruction({
+					op: "struct.set",
+					typeIndex: structInfo.typeIndex,
+					fieldIndex: 0,
+				});
+
+				this.releaseTemp(newCapTmp, "i32");
+				this.releaseTemp(newOffTmp, "i32");
+				this.releaseTemp(newArrTmp, arrW);
+				this.pushInstruction("end");
+
+				this.releaseTemp(targetCapTmp, "i32");
+				this.releaseTemp(oldCapTmp, "i32");
+				this.releaseTemp(oldLenTmp, "i32");
+				this.releaseTemp(oldOffTmp, "i32");
+				this.releaseTemp(oldArrTmp, arrW);
+				this.pushInstruction("end");
+
+				setLastOp(0);
+				this.releaseTemp(nTmp, "i32");
+				this.releaseTemp(bTmp, bufW);
+				return;
+			}
+			case "Read": {
+				const pTmp = this.acquireTemp(sliceW);
+				this.emitExpr(args[0], sliceW);
+				this.pushInstruction({ op: "local.set", index: pTmp });
+
+				this._emitBufferReadCore(bTmp, pTmp);
+				this.releaseTemp(pTmp, sliceW);
+				this.releaseTemp(bTmp, bufW);
+				return;
+			}
+			case "ReadByte": {
+				const sTmp = getBufSlice();
+				const arrTmp = this.acquireTemp(arrW);
+				const offTmp = this.acquireTemp("i32");
+				const lenTmp = this.acquireTemp("i32");
+				const capTmp = this.acquireTemp("i32");
+				this._emitSliceUnpack(sTmp, sliceInfo, {
+					arr: arrTmp,
+					off: offTmp,
+					len: lenTmp,
+					cap: capTmp,
+				});
+				this.releaseTemp(sTmp, sliceW);
+
+				const resByteTmp = this.acquireTemp("i32");
+				const resErrTmp = this.acquireTemp("anyref");
+
+				this.pushInstruction({ op: "local.get", index: lenTmp });
+				this.pushInstruction("i32.eqz");
+				this.pushInstruction({ op: "if", blockType: "void" });
+				this.pushInstruction({ op: "i32.const", value: 0 });
+				this.pushInstruction({ op: "local.set", index: resByteTmp });
+				this.emitIoConst("EOF", "anyref");
+				this.pushInstruction({ op: "local.set", index: resErrTmp });
+				setLastOp(0);
+				this.pushInstruction("else");
+
+				this.pushInstruction({ op: "local.get", index: arrTmp });
+				this.pushInstruction({ op: "local.get", index: offTmp });
+				this.pushInstruction({ op: "array.get", typeIndex: arrInfo.typeIndex });
+				this.pushInstruction({ op: "local.set", index: resByteTmp });
+
+				this.pushInstruction({ op: "ref.null", heapType: "any" });
+				this.pushInstruction({ op: "local.set", index: resErrTmp });
+
+				// update b.buf: (arrTmp, offTmp + 1, lenTmp - 1, capTmp - 1)
+				this.pushInstruction({ op: "local.get", index: bTmp });
+				this.pushInstruction({ op: "local.get", index: arrTmp });
+				this.pushInstruction({ op: "local.get", index: offTmp });
+				this.pushInstruction({ op: "i32.const", value: 1 });
+				this.pushInstruction("i32.add");
+				this.pushInstruction({ op: "local.get", index: lenTmp });
+				this.pushInstruction({ op: "i32.const", value: 1 });
+				this.pushInstruction("i32.sub");
+				this.pushInstruction({ op: "local.get", index: capTmp });
+				this.pushInstruction({ op: "i32.const", value: 1 });
+				this.pushInstruction("i32.sub");
+				this.pushInstruction({
+					op: "struct.new",
+					typeIndex: sliceInfo.typeIndex,
+				});
+				this.pushInstruction({
+					op: "struct.set",
+					typeIndex: structInfo.typeIndex,
+					fieldIndex: 0,
+				});
+				setLastOp(1);
+				this.pushInstruction("end");
+
+				this.pushInstruction({ op: "local.get", index: resByteTmp });
+				this.pushInstruction({ op: "local.get", index: resErrTmp });
+
+				this.releaseTemp(resErrTmp, "anyref");
+				this.releaseTemp(resByteTmp, "i32");
+				this.releaseTemp(capTmp, "i32");
+				this.releaseTemp(lenTmp, "i32");
+				this.releaseTemp(offTmp, "i32");
+				this.releaseTemp(arrTmp, arrW);
+				this.releaseTemp(bTmp, bufW);
+				return;
+			}
+			case "UnreadByte": {
+				const resErrTmp = this.acquireTemp("anyref");
+				if (structInfo.fields.length > 1) {
+					this.pushInstruction({ op: "local.get", index: bTmp });
+					this.pushInstruction({
+						op: "struct.get",
+						typeIndex: structInfo.typeIndex,
+						fieldIndex: 1,
+					});
+					this.pushInstruction({ op: "i64.const", value: 1n });
+					this.pushInstruction("i64.ne");
+					this.pushInstruction({ op: "if", blockType: "void" });
+					this._emitNewError(
+						"bytes.Buffer: UnreadByte: previous operation was not a successful read",
+					);
+					this.pushInstruction({ op: "local.set", index: resErrTmp });
+					this.pushInstruction("else");
+
+					const sTmp = getBufSlice();
+					const arrTmp = this.acquireTemp(arrW);
+					const offTmp = this.acquireTemp("i32");
+					const lenTmp = this.acquireTemp("i32");
+					const capTmp = this.acquireTemp("i32");
+					this._emitSliceUnpack(sTmp, sliceInfo, {
+						arr: arrTmp,
+						off: offTmp,
+						len: lenTmp,
+						cap: capTmp,
+					});
+					this.releaseTemp(sTmp, sliceW);
+
+					// update b.buf: (arrTmp, offTmp - 1, lenTmp + 1, capTmp + 1)
+					this.pushInstruction({ op: "local.get", index: bTmp });
+					this.pushInstruction({ op: "local.get", index: arrTmp });
+					this.pushInstruction({ op: "local.get", index: offTmp });
+					this.pushInstruction({ op: "i32.const", value: 1 });
+					this.pushInstruction("i32.sub");
+					this.pushInstruction({ op: "local.get", index: lenTmp });
+					this.pushInstruction({ op: "i32.const", value: 1 });
+					this.pushInstruction("i32.add");
+					this.pushInstruction({ op: "local.get", index: capTmp });
+					this.pushInstruction({ op: "i32.const", value: 1 });
+					this.pushInstruction("i32.add");
+					this.pushInstruction({
+						op: "struct.new",
+						typeIndex: sliceInfo.typeIndex,
+					});
+					this.pushInstruction({
+						op: "struct.set",
+						typeIndex: structInfo.typeIndex,
+						fieldIndex: 0,
+					});
+					setLastOp(0);
+
+					this.pushInstruction({ op: "ref.null", heapType: "any" });
+					this.pushInstruction({ op: "local.set", index: resErrTmp });
+
+					this.releaseTemp(capTmp, "i32");
+					this.releaseTemp(lenTmp, "i32");
+					this.releaseTemp(offTmp, "i32");
+					this.releaseTemp(arrTmp, arrW);
+					this.pushInstruction("end");
+				} else {
+					this._emitNewError(
+						"bytes.Buffer: UnreadByte: previous operation was not a successful read",
+					);
+					this.pushInstruction({ op: "local.set", index: resErrTmp });
+				}
+
+				this.pushInstruction({ op: "local.get", index: resErrTmp });
+				this.releaseTemp(resErrTmp, "anyref");
+				this.releaseTemp(bTmp, bufW);
+				return;
+			}
+			case "ReadRune": {
+				const sTmp = getBufSlice();
+				const arrTmp = this.acquireTemp(arrW);
+				const offTmp = this.acquireTemp("i32");
+				const lenTmp = this.acquireTemp("i32");
+				const capTmp = this.acquireTemp("i32");
+				this._emitSliceUnpack(sTmp, sliceInfo, {
+					arr: arrTmp,
+					off: offTmp,
+					len: lenTmp,
+					cap: capTmp,
+				});
+				this.releaseTemp(sTmp, sliceW);
+
+				const resRuneTmp = this.acquireTemp("i32");
+				const resSizeTmp = this.acquireTemp("i64");
+				const resErrTmp = this.acquireTemp("anyref");
+
+				this.pushInstruction({ op: "local.get", index: lenTmp });
+				this.pushInstruction("i32.eqz");
+				this.pushInstruction({ op: "if", blockType: "void" });
+				this.pushInstruction({ op: "i32.const", value: 0 });
+				this.pushInstruction({ op: "local.set", index: resRuneTmp });
+				this.pushInstruction({ op: "i64.const", value: 0n });
+				this.pushInstruction({ op: "local.set", index: resSizeTmp });
+				this.emitIoConst("EOF", "anyref");
+				this.pushInstruction({ op: "local.set", index: resErrTmp });
+				setLastOp(0);
+				this.pushInstruction("else");
+
+				const cpTmp = this.acquireTemp("i32");
+				const runeLenTmp = this.acquireTemp("i32");
+				const zeroTmp = this.acquireTemp("i32");
+				this.pushInstruction({ op: "i32.const", value: 0 });
+				this.pushInstruction({ op: "local.set", index: zeroTmp });
+
+				this._emitDecodeUtf8Rune({
+					arrTmp,
+					offTmp,
+					idxTmp: zeroTmp,
+					lenTmp,
+					outRuneTmp: cpTmp,
+					outLenTmp: runeLenTmp,
+					arrTypeIndex: arrInfo.typeIndex,
+				});
+				this.releaseTemp(zeroTmp, "i32");
+
+				// update b.buf: (arrTmp, offTmp + runeLenTmp, lenTmp - runeLenTmp, capTmp - runeLenTmp)
+				this.pushInstruction({ op: "local.get", index: bTmp });
+				this.pushInstruction({ op: "local.get", index: arrTmp });
+				this.pushInstruction({ op: "local.get", index: offTmp });
+				this.pushInstruction({ op: "local.get", index: runeLenTmp });
+				this.pushInstruction("i32.add");
+				this.pushInstruction({ op: "local.get", index: lenTmp });
+				this.pushInstruction({ op: "local.get", index: runeLenTmp });
+				this.pushInstruction("i32.sub");
+				this.pushInstruction({ op: "local.get", index: capTmp });
+				this.pushInstruction({ op: "local.get", index: runeLenTmp });
+				this.pushInstruction("i32.sub");
+				this.pushInstruction({
+					op: "struct.new",
+					typeIndex: sliceInfo.typeIndex,
+				});
+				this.pushInstruction({
+					op: "struct.set",
+					typeIndex: structInfo.typeIndex,
+					fieldIndex: 0,
+				});
+
+				setLastOp(2);
+				setLastRuneLen(runeLenTmp);
+
+				this.pushInstruction({ op: "local.get", index: cpTmp });
+				this.pushInstruction({ op: "local.set", index: resRuneTmp });
+				this.pushInstruction({ op: "local.get", index: runeLenTmp });
+				this.pushInstruction("i64.extend_i32_u");
+				this.pushInstruction({ op: "local.set", index: resSizeTmp });
+				this.pushInstruction({ op: "ref.null", heapType: "any" });
+				this.pushInstruction({ op: "local.set", index: resErrTmp });
+
+				this.releaseTemp(runeLenTmp, "i32");
+				this.releaseTemp(cpTmp, "i32");
+				this.pushInstruction("end");
+
+				this.pushInstruction({ op: "local.get", index: resRuneTmp });
+				this.pushInstruction({ op: "local.get", index: resSizeTmp });
+				this.pushInstruction({ op: "local.get", index: resErrTmp });
+
+				this.releaseTemp(resErrTmp, "anyref");
+				this.releaseTemp(resSizeTmp, "i64");
+				this.releaseTemp(resRuneTmp, "i32");
+				this.releaseTemp(capTmp, "i32");
+				this.releaseTemp(lenTmp, "i32");
+				this.releaseTemp(offTmp, "i32");
+				this.releaseTemp(arrTmp, arrW);
+				this.releaseTemp(bTmp, bufW);
+				return;
+			}
+			case "UnreadRune": {
+				const resErrTmp = this.acquireTemp("anyref");
+				if (structInfo.fields.length > 2) {
+					this.pushInstruction({ op: "local.get", index: bTmp });
+					this.pushInstruction({
+						op: "struct.get",
+						typeIndex: structInfo.typeIndex,
+						fieldIndex: 1,
+					});
+					this.pushInstruction({ op: "i64.const", value: 2n });
+					this.pushInstruction("i64.ne");
+					this.pushInstruction({ op: "if", blockType: "void" });
+					this._emitNewError(
+						"bytes.Buffer: UnreadRune: previous operation was not a successful ReadRune",
+					);
+					this.pushInstruction({ op: "local.set", index: resErrTmp });
+					this.pushInstruction("else");
+
+					const lastRuneLenTmp = this.acquireTemp("i32");
+					this.pushInstruction({ op: "local.get", index: bTmp });
+					this.pushInstruction({
+						op: "struct.get",
+						typeIndex: structInfo.typeIndex,
+						fieldIndex: 2,
+					});
+					this.pushInstruction("i32.wrap_i64");
+					this.pushInstruction({ op: "local.set", index: lastRuneLenTmp });
+
+					const sTmp = getBufSlice();
+					const arrTmp = this.acquireTemp(arrW);
+					const offTmp = this.acquireTemp("i32");
+					const lenTmp = this.acquireTemp("i32");
+					const capTmp = this.acquireTemp("i32");
+					this._emitSliceUnpack(sTmp, sliceInfo, {
+						arr: arrTmp,
+						off: offTmp,
+						len: lenTmp,
+						cap: capTmp,
+					});
+					this.releaseTemp(sTmp, sliceW);
+
+					// update b.buf: (arrTmp, offTmp - lastRuneLenTmp, lenTmp + lastRuneLenTmp, capTmp + lastRuneLenTmp)
+					this.pushInstruction({ op: "local.get", index: bTmp });
+					this.pushInstruction({ op: "local.get", index: arrTmp });
+					this.pushInstruction({ op: "local.get", index: offTmp });
+					this.pushInstruction({ op: "local.get", index: lastRuneLenTmp });
+					this.pushInstruction("i32.sub");
+					this.pushInstruction({ op: "local.get", index: lenTmp });
+					this.pushInstruction({ op: "local.get", index: lastRuneLenTmp });
+					this.pushInstruction("i32.add");
+					this.pushInstruction({ op: "local.get", index: capTmp });
+					this.pushInstruction({ op: "local.get", index: lastRuneLenTmp });
+					this.pushInstruction("i32.add");
+					this.pushInstruction({
+						op: "struct.new",
+						typeIndex: sliceInfo.typeIndex,
+					});
+					this.pushInstruction({
+						op: "struct.set",
+						typeIndex: structInfo.typeIndex,
+						fieldIndex: 0,
+					});
+					setLastOp(0);
+
+					this.pushInstruction({ op: "ref.null", heapType: "any" });
+					this.pushInstruction({ op: "local.set", index: resErrTmp });
+
+					this.releaseTemp(capTmp, "i32");
+					this.releaseTemp(lenTmp, "i32");
+					this.releaseTemp(offTmp, "i32");
+					this.releaseTemp(arrTmp, arrW);
+					this.releaseTemp(lastRuneLenTmp, "i32");
+					this.pushInstruction("end");
+				} else {
+					this._emitNewError(
+						"bytes.Buffer: UnreadRune: previous operation was not a successful ReadRune",
+					);
+					this.pushInstruction({ op: "local.set", index: resErrTmp });
+				}
+
+				this.pushInstruction({ op: "local.get", index: resErrTmp });
+				this.releaseTemp(resErrTmp, "anyref");
+				this.releaseTemp(bTmp, bufW);
+				return;
+			}
+			case "ReadBytes":
+			case "ReadString": {
+				const isStr = method === "ReadString";
+				const delimTmp = this.acquireTemp("i32");
+				this._emitI32Arg(args[0]);
+				this.pushInstruction({ op: "local.set", index: delimTmp });
+
+				const sTmp = getBufSlice();
+				const arrTmp = this.acquireTemp(arrW);
+				const offTmp = this.acquireTemp("i32");
+				const lenTmp = this.acquireTemp("i32");
+				const capTmp = this.acquireTemp("i32");
+				this._emitSliceUnpack(sTmp, sliceInfo, {
+					arr: arrTmp,
+					off: offTmp,
+					len: lenTmp,
+					cap: capTmp,
+				});
+				this.releaseTemp(sTmp, sliceW);
+
+				// Find delim
+				const kTmp = this.acquireTemp("i32");
+				const matchTmp = this.acquireTemp("i32");
+				this.pushInstruction({ op: "i32.const", value: 0 });
+				this.pushInstruction({ op: "local.set", index: kTmp });
+				this.pushInstruction({ op: "i32.const", value: -1 });
+				this.pushInstruction({ op: "local.set", index: matchTmp });
+
+				this.pushInstruction({ op: "block", blockType: "void" });
+				this.pushInstruction({ op: "loop", blockType: "void" });
+				this.pushInstruction({ op: "local.get", index: kTmp });
+				this.pushInstruction({ op: "local.get", index: lenTmp });
+				this.pushInstruction("i32.ge_s");
+				this.pushInstruction({ op: "br_if", depth: 1 });
+
+				this.pushInstruction({ op: "local.get", index: arrTmp });
+				this.pushInstruction({ op: "local.get", index: offTmp });
+				this.pushInstruction({ op: "local.get", index: kTmp });
+				this.pushInstruction("i32.add");
+				this.pushInstruction({ op: "array.get", typeIndex: arrInfo.typeIndex });
+				this.pushInstruction({ op: "local.get", index: delimTmp });
+				this.pushInstruction("i32.eq");
+				this.pushInstruction({ op: "if", blockType: "void" });
+				this.pushInstruction({ op: "local.get", index: kTmp });
+				this.pushInstruction({ op: "local.set", index: matchTmp });
+				this.pushInstruction({ op: "br", depth: 2 });
+				this.pushInstruction("end");
+
+				this.pushInstruction({ op: "local.get", index: kTmp });
+				this.pushInstruction({ op: "i32.const", value: 1 });
+				this.pushInstruction("i32.add");
+				this.pushInstruction({ op: "local.set", index: kTmp });
+				this.pushInstruction({ op: "br", depth: 0 });
+				this.pushInstruction("end");
+				this.pushInstruction("end");
+				this.releaseTemp(kTmp, "i32");
+				this.releaseTemp(delimTmp, "i32");
+
+				const resLineTmp = isStr ? null : this.acquireTemp(sliceW);
+				const resStrTmp = isStr ? this.acquireTemp("externref") : null;
+				const resErrTmp = this.acquireTemp("anyref");
+
+				this.pushInstruction({ op: "local.get", index: matchTmp });
+				this.pushInstruction({ op: "i32.const", value: 0 });
+				this.pushInstruction("i32.ge_s");
+				this.pushInstruction({ op: "if", blockType: "void" });
+
+				const lineLenTmp = this.acquireTemp("i32");
+				this.pushInstruction({ op: "local.get", index: matchTmp });
+				this.pushInstruction({ op: "i32.const", value: 1 });
+				this.pushInstruction("i32.add");
+				this.pushInstruction({ op: "local.set", index: lineLenTmp });
+
+				if (isStr) {
+					this._emitBytesSliceToString(
+						arrTmp,
+						offTmp,
+						lineLenTmp,
+						arrInfo.typeIndex,
+					);
+					this.pushInstruction({ op: "local.set", index: resStrTmp });
+				} else {
+					this.pushInstruction({ op: "local.get", index: arrTmp });
+					this.pushInstruction({ op: "local.get", index: offTmp });
+					this.pushInstruction({ op: "local.get", index: lineLenTmp });
+					this.pushInstruction({ op: "local.get", index: lineLenTmp });
+					this.pushInstruction({
+						op: "struct.new",
+						typeIndex: sliceInfo.typeIndex,
+					});
+					this.pushInstruction({ op: "local.set", index: resLineTmp });
+				}
+				this.pushInstruction({ op: "ref.null", heapType: "any" });
+				this.pushInstruction({ op: "local.set", index: resErrTmp });
+
+				// update b.buf: (arrTmp, offTmp + lineLenTmp, lenTmp - lineLenTmp, capTmp - lineLenTmp)
+				this.pushInstruction({ op: "local.get", index: bTmp });
+				this.pushInstruction({ op: "local.get", index: arrTmp });
+				this.pushInstruction({ op: "local.get", index: offTmp });
+				this.pushInstruction({ op: "local.get", index: lineLenTmp });
+				this.pushInstruction("i32.add");
+				this.pushInstruction({ op: "local.get", index: lenTmp });
+				this.pushInstruction({ op: "local.get", index: lineLenTmp });
+				this.pushInstruction("i32.sub");
+				this.pushInstruction({ op: "local.get", index: capTmp });
+				this.pushInstruction({ op: "local.get", index: lineLenTmp });
+				this.pushInstruction("i32.sub");
+				this.pushInstruction({
+					op: "struct.new",
+					typeIndex: sliceInfo.typeIndex,
+				});
+				this.pushInstruction({
+					op: "struct.set",
+					typeIndex: structInfo.typeIndex,
+					fieldIndex: 0,
+				});
+				setLastOp(1);
+				this.releaseTemp(lineLenTmp, "i32");
+
+				this.pushInstruction("else");
+
+				// Not found
+				if (isStr) {
+					this._emitBytesSliceToString(
+						arrTmp,
+						offTmp,
+						lenTmp,
+						arrInfo.typeIndex,
+					);
+					this.pushInstruction({ op: "local.set", index: resStrTmp });
+				} else {
+					this.pushInstruction({ op: "local.get", index: arrTmp });
+					this.pushInstruction({ op: "local.get", index: offTmp });
+					this.pushInstruction({ op: "local.get", index: lenTmp });
+					this.pushInstruction({ op: "local.get", index: lenTmp });
+					this.pushInstruction({
+						op: "struct.new",
+						typeIndex: sliceInfo.typeIndex,
+					});
+					this.pushInstruction({ op: "local.set", index: resLineTmp });
+				}
+				this.emitIoConst("EOF", "anyref");
+				this.pushInstruction({ op: "local.set", index: resErrTmp });
+
+				this.pushInstruction({ op: "local.get", index: bTmp });
+				this.pushInstruction({
+					op: "global.get",
+					index: sliceInfo.emptyGlobalIndex,
+				});
+				this.pushInstruction({
+					op: "struct.set",
+					typeIndex: structInfo.typeIndex,
+					fieldIndex: 0,
+				});
+				setLastOp(0);
+				this.pushInstruction("end");
+
+				if (isStr) {
+					this.pushInstruction({ op: "local.get", index: resStrTmp });
+					this.releaseTemp(resStrTmp, "externref");
+				} else {
+					this.pushInstruction({ op: "local.get", index: resLineTmp });
+					this.releaseTemp(resLineTmp, sliceW);
+				}
+				this.pushInstruction({ op: "local.get", index: resErrTmp });
+
+				this.releaseTemp(resErrTmp, "anyref");
+				this.releaseTemp(matchTmp, "i32");
+				this.releaseTemp(capTmp, "i32");
+				this.releaseTemp(lenTmp, "i32");
+				this.releaseTemp(offTmp, "i32");
+				this.releaseTemp(arrTmp, arrW);
+				this.releaseTemp(bTmp, bufW);
+				return;
+			}
+			case "ReadFrom": {
+				const rTmp = this.acquireTemp("anyref");
+				this.emitExpr(args[0], "anyref");
+				this.pushInstruction({ op: "local.set", index: rTmp });
+
+				const chunkLen = 4096;
+				const chunkArrTmp = this.acquireTemp(arrW);
+				this.pushInstruction({ op: "i32.const", value: chunkLen });
+				this.pushInstruction({
+					op: "array.new_default",
+					typeIndex: arrInfo.typeIndex,
+				});
+				this.pushInstruction({ op: "local.set", index: chunkArrTmp });
+
+				const chunkSliceTmp = this.acquireTemp(sliceW);
+				this.pushInstruction({ op: "local.get", index: chunkArrTmp });
+				this.pushInstruction({ op: "i32.const", value: 0 });
+				this.pushInstruction({ op: "i32.const", value: chunkLen });
+				this.pushInstruction({ op: "i32.const", value: chunkLen });
+				this.pushInstruction({
+					op: "struct.new",
+					typeIndex: sliceInfo.typeIndex,
+				});
+				this.pushInstruction({ op: "local.set", index: chunkSliceTmp });
+
+				const totalTmp = this.acquireTemp("i64");
+				this.pushInstruction({ op: "i64.const", value: 0n });
+				this.pushInstruction({ op: "local.set", index: totalTmp });
+
+				const errTmp = this.acquireTemp("anyref");
+				this.pushInstruction({ op: "ref.null", heapType: "any" });
+				this.pushInstruction({ op: "local.set", index: errTmp });
+
+				const readErrTmp = this.acquireTemp("anyref");
+				const nrTmp = this.acquireTemp("i32");
+				const subsliceTmp = this.acquireTemp(sliceW);
+
+				const dispatchReadIdx = this.mod.resolveFuncIndex(
+					"__dispatch_io.Reader_Read",
+				);
+
+				this.pushInstruction({ op: "block", blockType: "void" });
+				this.pushInstruction({ op: "loop", blockType: "void" });
+
+				this.pushInstruction({ op: "local.get", index: rTmp });
+				this.pushInstruction({ op: "local.get", index: chunkSliceTmp });
+				if (dispatchReadIdx !== null) {
+					this.pushInstruction({ op: "call", funcIndex: dispatchReadIdx });
+				} else {
+					this.pushInstruction({ op: "i64.const", value: 0n });
+					this.pushInstruction({ op: "ref.null", heapType: "any" });
+				}
+				this.pushInstruction({ op: "local.set", index: readErrTmp });
+				this.pushInstruction("i32.wrap_i64");
+				this.pushInstruction({ op: "local.set", index: nrTmp });
+
+				this.pushInstruction({ op: "local.get", index: nrTmp });
+				this.pushInstruction({ op: "i32.const", value: 0 });
+				this.pushInstruction("i32.gt_s");
+				this.pushInstruction({ op: "if", blockType: "void" });
+
+				this.pushInstruction({ op: "local.get", index: chunkArrTmp });
+				this.pushInstruction({ op: "i32.const", value: 0 });
+				this.pushInstruction({ op: "local.get", index: nrTmp });
+				this.pushInstruction({ op: "local.get", index: nrTmp });
+				this.pushInstruction({
+					op: "struct.new",
+					typeIndex: sliceInfo.typeIndex,
+				});
+				this.pushInstruction({ op: "local.set", index: subsliceTmp });
+
+				this._emitBufferWriteCore(bTmp, subsliceTmp);
+				this.pushInstruction("drop");
+				this.pushInstruction("drop");
+
+				this.pushInstruction({ op: "local.get", index: totalTmp });
+				this.pushInstruction({ op: "local.get", index: nrTmp });
+				this.pushInstruction("i64.extend_i32_u");
+				this.pushInstruction("i64.add");
+				this.pushInstruction({ op: "local.set", index: totalTmp });
+				this.pushInstruction("end");
+
+				this.pushInstruction({ op: "local.get", index: readErrTmp });
+				this.pushInstruction("ref.is_null");
+				this.pushInstruction("i32.eqz");
+				this.pushInstruction({ op: "if", blockType: "void" });
+				this.pushInstruction({ op: "local.get", index: readErrTmp });
+				this.emitIoConst("EOF", "anyref");
+				this.pushInstruction({
+					op: "call",
+					funcIndex: this.mod.resolveFuncIndex("__errors_is"),
+				});
+				this.pushInstruction({ op: "if", blockType: "void" });
+				this.pushInstruction({ op: "ref.null", heapType: "any" });
+				this.pushInstruction({ op: "local.set", index: errTmp });
+				this.pushInstruction("else");
+				this.pushInstruction({ op: "local.get", index: readErrTmp });
+				this.pushInstruction({ op: "local.set", index: errTmp });
+				this.pushInstruction("end");
+				this.pushInstruction({ op: "br", depth: 2 });
+				this.pushInstruction("end");
+
+				this.pushInstruction({ op: "br", depth: 0 });
+				this.pushInstruction("end");
+				this.pushInstruction("end");
+
+				setLastOp(0);
+
+				this.pushInstruction({ op: "local.get", index: totalTmp });
+				this.pushInstruction({ op: "local.get", index: errTmp });
+
+				this.releaseTemp(subsliceTmp, sliceW);
+				this.releaseTemp(nrTmp, "i32");
+				this.releaseTemp(readErrTmp, "anyref");
+				this.releaseTemp(errTmp, "anyref");
+				this.releaseTemp(totalTmp, "i64");
+				this.releaseTemp(chunkSliceTmp, sliceW);
+				this.releaseTemp(chunkArrTmp, arrW);
+				this.releaseTemp(rTmp, "anyref");
+				this.releaseTemp(bTmp, bufW);
+				return;
+			}
+			case "WriteTo": {
+				const wTmp = this.acquireTemp("anyref");
+				this.emitExpr(args[0], "anyref");
+				this.pushInstruction({ op: "local.set", index: wTmp });
+
+				const sTmp = getBufSlice();
+				const arrTmp = this.acquireTemp(arrW);
+				const offTmp = this.acquireTemp("i32");
+				const lenTmp = this.acquireTemp("i32");
+				const capTmp = this.acquireTemp("i32");
+				this._emitSliceUnpack(sTmp, sliceInfo, {
+					arr: arrTmp,
+					off: offTmp,
+					len: lenTmp,
+					cap: capTmp,
+				});
+
+				const resNTmp = this.acquireTemp("i64");
+				const resErrTmp = this.acquireTemp("anyref");
+
+				this.pushInstruction({ op: "local.get", index: lenTmp });
+				this.pushInstruction("i32.eqz");
+				this.pushInstruction({ op: "if", blockType: "void" });
+				this.pushInstruction({ op: "i64.const", value: 0n });
+				this.pushInstruction({ op: "local.set", index: resNTmp });
+				this.pushInstruction({ op: "ref.null", heapType: "any" });
+				this.pushInstruction({ op: "local.set", index: resErrTmp });
+				this.pushInstruction("else");
+
+				const dispatchWriteIdx = this.mod.resolveFuncIndex(
+					"__dispatch_io.Writer_Write",
+				);
+				this.pushInstruction({ op: "local.get", index: wTmp });
+				this.pushInstruction({ op: "local.get", index: sTmp });
+				if (dispatchWriteIdx !== null) {
+					this.pushInstruction({ op: "call", funcIndex: dispatchWriteIdx });
+				} else {
+					this.pushInstruction({ op: "i64.const", value: 0n });
+					this.pushInstruction({ op: "ref.null", heapType: "any" });
+				}
+				this.pushInstruction({ op: "local.set", index: resErrTmp });
+				this.pushInstruction({ op: "local.set", index: resNTmp });
+
+				const nwI32Tmp = this.acquireTemp("i32");
+				this.pushInstruction({ op: "local.get", index: resNTmp });
+				this.pushInstruction("i32.wrap_i64");
+				this.pushInstruction({ op: "local.set", index: nwI32Tmp });
+
+				this.pushInstruction({ op: "local.get", index: bTmp });
+				this.pushInstruction({ op: "local.get", index: arrTmp });
+				this.pushInstruction({ op: "local.get", index: offTmp });
+				this.pushInstruction({ op: "local.get", index: nwI32Tmp });
+				this.pushInstruction("i32.add");
+				this.pushInstruction({ op: "local.get", index: lenTmp });
+				this.pushInstruction({ op: "local.get", index: nwI32Tmp });
+				this.pushInstruction("i32.sub");
+				this.pushInstruction({ op: "local.get", index: capTmp });
+				this.pushInstruction({ op: "local.get", index: nwI32Tmp });
+				this.pushInstruction("i32.sub");
+				this.pushInstruction({
+					op: "struct.new",
+					typeIndex: sliceInfo.typeIndex,
+				});
+				this.pushInstruction({
+					op: "struct.set",
+					typeIndex: structInfo.typeIndex,
+					fieldIndex: 0,
+				});
+				setLastOp(0);
+				this.releaseTemp(nwI32Tmp, "i32");
+				this.pushInstruction("end");
+
+				this.releaseTemp(sTmp, sliceW);
+				this.releaseTemp(capTmp, "i32");
+				this.releaseTemp(lenTmp, "i32");
+				this.releaseTemp(offTmp, "i32");
+				this.releaseTemp(arrTmp, arrW);
+
+				this.pushInstruction({ op: "local.get", index: resNTmp });
+				this.pushInstruction({ op: "local.get", index: resErrTmp });
+
+				this.releaseTemp(resErrTmp, "anyref");
+				this.releaseTemp(resNTmp, "i64");
+				this.releaseTemp(wTmp, "anyref");
+				this.releaseTemp(bTmp, bufW);
+				return;
+			}
+			case "Next": {
+				const nTmp = this.acquireTemp("i32");
+				this._emitI32Arg(args[0]);
+				this.pushInstruction({ op: "local.set", index: nTmp });
+
+				const sTmp = getBufSlice();
+				const arrTmp = this.acquireTemp(arrW);
+				const offTmp = this.acquireTemp("i32");
+				const lenTmp = this.acquireTemp("i32");
+				const capTmp = this.acquireTemp("i32");
+				this._emitSliceUnpack(sTmp, sliceInfo, {
+					arr: arrTmp,
+					off: offTmp,
+					len: lenTmp,
+					cap: capTmp,
+				});
+				this.releaseTemp(sTmp, sliceW);
+
+				const cntTmp = this.acquireTemp("i32");
+				this.pushInstruction({ op: "local.get", index: nTmp });
+				this.pushInstruction({ op: "i32.const", value: 0 });
+				this.pushInstruction("i32.lt_s");
+				this.pushInstruction({ op: "if", blockType: "i32" });
+				this.pushInstruction({ op: "i32.const", value: 0 });
+				this.pushInstruction("else");
+				this.pushInstruction({ op: "local.get", index: nTmp });
+				this.pushInstruction({ op: "local.get", index: lenTmp });
+				this.pushInstruction("i32.gt_s");
+				this.pushInstruction({ op: "if", blockType: "i32" });
+				this.pushInstruction({ op: "local.get", index: lenTmp });
+				this.pushInstruction("else");
+				this.pushInstruction({ op: "local.get", index: nTmp });
+				this.pushInstruction("end");
+				this.pushInstruction("end");
+				this.pushInstruction({ op: "local.set", index: cntTmp });
+				this.releaseTemp(nTmp, "i32");
+
+				this.pushInstruction({ op: "local.get", index: arrTmp });
+				this.pushInstruction({ op: "local.get", index: offTmp });
+				this.pushInstruction({ op: "local.get", index: cntTmp });
+				this.pushInstruction({ op: "local.get", index: cntTmp });
+				this.pushInstruction({
+					op: "struct.new",
+					typeIndex: sliceInfo.typeIndex,
+				});
+
+				this.pushInstruction({ op: "local.get", index: bTmp });
+				this.pushInstruction({ op: "local.get", index: arrTmp });
+				this.pushInstruction({ op: "local.get", index: offTmp });
+				this.pushInstruction({ op: "local.get", index: cntTmp });
+				this.pushInstruction("i32.add");
+				this.pushInstruction({ op: "local.get", index: lenTmp });
+				this.pushInstruction({ op: "local.get", index: cntTmp });
+				this.pushInstruction("i32.sub");
+				this.pushInstruction({ op: "local.get", index: capTmp });
+				this.pushInstruction({ op: "local.get", index: cntTmp });
+				this.pushInstruction("i32.sub");
+				this.pushInstruction({
+					op: "struct.new",
+					typeIndex: sliceInfo.typeIndex,
+				});
+				this.pushInstruction({
+					op: "struct.set",
+					typeIndex: structInfo.typeIndex,
+					fieldIndex: 0,
+				});
+				setLastOp(0);
+
+				this.releaseTemp(cntTmp, "i32");
+				this.releaseTemp(capTmp, "i32");
+				this.releaseTemp(lenTmp, "i32");
+				this.releaseTemp(offTmp, "i32");
+				this.releaseTemp(arrTmp, arrW);
+				this.releaseTemp(bTmp, bufW);
+				return;
+			}
+			case "Truncate": {
+				const nTmp = this.acquireTemp("i32");
+				this._emitI32Arg(args[0]);
+				this.pushInstruction({ op: "local.set", index: nTmp });
+
+				const sTmp = getBufSlice();
+				const arrTmp = this.acquireTemp(arrW);
+				const offTmp = this.acquireTemp("i32");
+				const lenTmp = this.acquireTemp("i32");
+				const capTmp = this.acquireTemp("i32");
+				this._emitSliceUnpack(sTmp, sliceInfo, {
+					arr: arrTmp,
+					off: offTmp,
+					len: lenTmp,
+					cap: capTmp,
+				});
+				this.releaseTemp(sTmp, sliceW);
+
+				this.pushInstruction({ op: "local.get", index: nTmp });
+				this.pushInstruction({ op: "i32.const", value: 0 });
+				this.pushInstruction("i32.lt_s");
+				this.pushInstruction({ op: "local.get", index: nTmp });
+				this.pushInstruction({ op: "local.get", index: lenTmp });
+				this.pushInstruction("i32.gt_s");
+				this.pushInstruction("i32.or");
+				this.pushInstruction({ op: "if", blockType: "void" });
+				this.emitPanic("bytes.Buffer: truncation out of range");
+				this.pushInstruction("end");
+
+				this.pushInstruction({ op: "local.get", index: bTmp });
+				this.pushInstruction({ op: "local.get", index: arrTmp });
+				this.pushInstruction({ op: "local.get", index: offTmp });
+				this.pushInstruction({ op: "local.get", index: nTmp });
+				this.pushInstruction({ op: "local.get", index: capTmp });
+				this.pushInstruction({
+					op: "struct.new",
+					typeIndex: sliceInfo.typeIndex,
+				});
+				this.pushInstruction({
+					op: "struct.set",
+					typeIndex: structInfo.typeIndex,
+					fieldIndex: 0,
+				});
+				setLastOp(0);
+
+				this.releaseTemp(nTmp, "i32");
+				this.releaseTemp(capTmp, "i32");
+				this.releaseTemp(lenTmp, "i32");
+				this.releaseTemp(offTmp, "i32");
+				this.releaseTemp(arrTmp, arrW);
+				this.releaseTemp(bTmp, bufW);
+				return;
+			}
+			case "Available": {
+				const sTmp = getBufSlice();
+				const lenTmp = this.acquireTemp("i32");
+				const capTmp = this.acquireTemp("i32");
+				this.pushInstruction({ op: "local.get", index: sTmp });
+				this.pushInstruction({
+					op: "struct.get",
 					typeIndex: sliceInfo.typeIndex,
+					fieldIndex: 2,
 				});
+				this.pushInstruction({ op: "local.set", index: lenTmp });
+				this.pushInstruction({ op: "local.get", index: sTmp });
 				this.pushInstruction({
-					op: "struct.set",
-					typeIndex: structInfo.typeIndex,
-					fieldIndex: 0,
+					op: "struct.get",
+					typeIndex: sliceInfo.typeIndex,
+					fieldIndex: 3,
 				});
+				this.pushInstruction({ op: "local.set", index: capTmp });
+				this.releaseTemp(sTmp, sliceW);
 
-				this.pushInstruction({ op: "local.get", index: rLenTmp });
-				this.pushInstruction("i64.extend_i32_u");
-				this.pushInstruction({ op: "ref.null", heapType: "any" });
+				this.pushInstruction({ op: "local.get", index: capTmp });
+				this.pushInstruction({ op: "local.get", index: lenTmp });
+				this.pushInstruction("i32.sub");
+				if ((targetWasmType ?? "i64") === "i64") {
+					this.pushInstruction("i64.extend_i32_u");
+				}
+				this.releaseTemp(capTmp, "i32");
+				this.releaseTemp(lenTmp, "i32");
+				this.releaseTemp(bTmp, bufW);
+				return;
+			}
+			case "AvailableBuffer": {
+				const sTmp = getBufSlice();
+				const arrTmp = this.acquireTemp(arrW);
+				const offTmp = this.acquireTemp("i32");
+				const lenTmp = this.acquireTemp("i32");
+				const capTmp = this.acquireTemp("i32");
+				this._emitSliceUnpack(sTmp, sliceInfo, {
+					arr: arrTmp,
+					off: offTmp,
+					len: lenTmp,
+					cap: capTmp,
+				});
+				this.releaseTemp(sTmp, sliceW);
 
-				this.releaseTemp(newCapTmp, "i32");
-				this.releaseTemp(newOffTmp, "i32");
-				this.releaseTemp(newArrTmp, arrW);
-				this.releaseTemp(newLenTmp, "i32");
-				this.releaseTemp(oldCapTmp, "i32");
-				this.releaseTemp(oldLenTmp, "i32");
-				this.releaseTemp(oldOffTmp, "i32");
-				this.releaseTemp(oldArrTmp, arrW);
-				this.releaseTemp(rLenTmp, "i32");
-				this.releaseTemp(rTmp, "i32");
+				this.pushInstruction({ op: "local.get", index: arrTmp });
+				this.pushInstruction({ op: "local.get", index: offTmp });
+				this.pushInstruction({ op: "local.get", index: lenTmp });
+				this.pushInstruction("i32.add");
+				this.pushInstruction({ op: "i32.const", value: 0 });
+				this.pushInstruction({ op: "local.get", index: capTmp });
+				this.pushInstruction({ op: "local.get", index: lenTmp });
+				this.pushInstruction("i32.sub");
+				this.pushInstruction({
+					op: "struct.new",
+					typeIndex: sliceInfo.typeIndex,
+				});
+
+				this.releaseTemp(capTmp, "i32");
+				this.releaseTemp(lenTmp, "i32");
+				this.releaseTemp(offTmp, "i32");
+				this.releaseTemp(arrTmp, arrW);
 				this.releaseTemp(bTmp, bufW);
 				return;
 			}
-			case "Grow": {
+			case "Peek": {
 				const nTmp = this.acquireTemp("i32");
 				this._emitI32Arg(args[0]);
 				this.pushInstruction({ op: "local.set", index: nTmp });
 
-				this.pushInstruction({ op: "local.get", index: nTmp });
-				this.pushInstruction({ op: "i32.const", value: 0 });
-				this.pushInstruction("i32.lt_s");
-				this.pushInstruction({ op: "if", blockType: "void" });
-				this.emitPanic("bytes.Buffer.Grow: negative count");
-				this.pushInstruction("end");
-
-				this.pushInstruction({ op: "local.get", index: nTmp });
-				this.pushInstruction({ op: "i32.const", value: 0 });
-				this.pushInstruction("i32.gt_s");
-				this.pushInstruction({ op: "if", blockType: "void" });
-
 				const sTmp = getBufSlice();
-				const oldArrTmp = this.acquireTemp(arrW);
-				const oldOffTmp = this.acquireTemp("i32");
-				const oldLenTmp = this.acquireTemp("i32");
-				const oldCapTmp = this.acquireTemp("i32");
+				const arrTmp = this.acquireTemp(arrW);
+				const offTmp = this.acquireTemp("i32");
+				const lenTmp = this.acquireTemp("i32");
+				const capTmp = this.acquireTemp("i32");
 				this._emitSliceUnpack(sTmp, sliceInfo, {
-					arr: oldArrTmp,
-					off: oldOffTmp,
-					len: oldLenTmp,
-					cap: oldCapTmp,
+					arr: arrTmp,
+					off: offTmp,
+					len: lenTmp,
+					cap: capTmp,
 				});
 				this.releaseTemp(sTmp, sliceW);
 
-				const targetCapTmp = this.acquireTemp("i32");
-				this.pushInstruction({ op: "local.get", index: oldLenTmp });
 				this.pushInstruction({ op: "local.get", index: nTmp });
-				this.pushInstruction("i32.add");
-				this.pushInstruction({ op: "local.set", index: targetCapTmp });
-
-				this.pushInstruction({ op: "local.get", index: targetCapTmp });
-				this.pushInstruction({ op: "local.get", index: oldCapTmp });
-				this.pushInstruction("i32.gt_u");
+				this.pushInstruction({ op: "i32.const", value: 0 });
+				this.pushInstruction("i32.lt_s");
 				this.pushInstruction({ op: "if", blockType: "void" });
+				this.emitPanic("runtime error: slice bounds out of range");
+				this.pushInstruction("end");
 
-				const newArrTmp = this.acquireTemp(arrW);
-				const newOffTmp = this.acquireTemp("i32");
-				const newCapTmp = this.acquireTemp("i32");
-
-				this._emitGrowSlice({
-					arrInfo,
-					elemGoType: byteGo,
-					oldArrTmp,
-					oldOffTmp,
-					oldLenTmp,
-					oldCapTmp,
-					newArrTmp,
-					newOffTmp,
-					newLenTmp: targetCapTmp,
-					newCapTmp,
-				});
+				const resSliceTmp = this.acquireTemp(sliceW);
+				const resErrTmp = this.acquireTemp("anyref");
 
-				this.pushInstruction({ op: "local.get", index: bTmp });
-				this.pushInstruction({ op: "local.get", index: newArrTmp });
-				this.pushInstruction({ op: "local.get", index: newOffTmp });
-				this.pushInstruction({ op: "local.get", index: oldLenTmp });
-				this.pushInstruction({ op: "local.get", index: newCapTmp });
+				this.pushInstruction({ op: "local.get", index: nTmp });
+				this.pushInstruction({ op: "local.get", index: lenTmp });
+				this.pushInstruction("i32.gt_s");
+				this.pushInstruction({ op: "if", blockType: "void" });
+				this.pushInstruction({ op: "local.get", index: arrTmp });
+				this.pushInstruction({ op: "local.get", index: offTmp });
+				this.pushInstruction({ op: "local.get", index: lenTmp });
+				this.pushInstruction({ op: "local.get", index: lenTmp });
 				this.pushInstruction({
 					op: "struct.new",
 					typeIndex: sliceInfo.typeIndex,
 				});
+				this.pushInstruction({ op: "local.set", index: resSliceTmp });
+				this.emitIoConst("EOF", "anyref");
+				this.pushInstruction({ op: "local.set", index: resErrTmp });
+				this.pushInstruction("else");
+				this.pushInstruction({ op: "local.get", index: arrTmp });
+				this.pushInstruction({ op: "local.get", index: offTmp });
+				this.pushInstruction({ op: "local.get", index: nTmp });
+				this.pushInstruction({ op: "local.get", index: nTmp });
 				this.pushInstruction({
-					op: "struct.set",
-					typeIndex: structInfo.typeIndex,
-					fieldIndex: 0,
+					op: "struct.new",
+					typeIndex: sliceInfo.typeIndex,
 				});
-
-				this.releaseTemp(newCapTmp, "i32");
-				this.releaseTemp(newOffTmp, "i32");
-				this.releaseTemp(newArrTmp, arrW);
+				this.pushInstruction({ op: "local.set", index: resSliceTmp });
+				this.pushInstruction({ op: "ref.null", heapType: "any" });
+				this.pushInstruction({ op: "local.set", index: resErrTmp });
 				this.pushInstruction("end");
 
-				this.releaseTemp(targetCapTmp, "i32");
-				this.releaseTemp(oldCapTmp, "i32");
-				this.releaseTemp(oldLenTmp, "i32");
-				this.releaseTemp(oldOffTmp, "i32");
-				this.releaseTemp(oldArrTmp, arrW);
-				this.pushInstruction("end");
+				this.pushInstruction({ op: "local.get", index: resSliceTmp });
+				this.pushInstruction({ op: "local.get", index: resErrTmp });
 
+				this.releaseTemp(resErrTmp, "anyref");
+				this.releaseTemp(resSliceTmp, sliceW);
+				this.releaseTemp(capTmp, "i32");
+				this.releaseTemp(lenTmp, "i32");
+				this.releaseTemp(offTmp, "i32");
+				this.releaseTemp(arrTmp, arrW);
 				this.releaseTemp(nTmp, "i32");
 				this.releaseTemp(bTmp, bufW);
 				return;
@@ -808,6 +1862,8 @@ export class BytesEmitter {
 				return this.emitSlicesClone(args);
 			case "Join":
 				return this._emitBytesJoin(name, args, targetWasmType);
+			case "ToValidUTF8":
+				return this._emitBytesToValidUTF8(args, targetWasmType);
 			default:
 				throw new Error(`Unsupported bytes function: bytes.${name}`);
 		}
@@ -4013,6 +5069,174 @@ export class BytesEmitter {
 		this.releaseTemp(bArr, arrW);
 	}
 
+	_emitIsSpaceAt(arr, off, idx, len, outWidth, arrInfo) {
+		this.pushInstruction({ op: "i32.const", value: 0 });
+		this.pushInstruction({ op: "local.set", index: outWidth });
+
+		const cTmp = this.acquireTemp("i32");
+		this.pushInstruction({ op: "local.get", index: arr });
+		this.pushInstruction({ op: "local.get", index: off });
+		this.pushInstruction({ op: "local.get", index: idx });
+		this.pushInstruction("i32.add");
+		this.pushInstruction({ op: "array.get", typeIndex: arrInfo.typeIndex });
+		this.pushInstruction({ op: "local.set", index: cTmp });
+
+		// if c == 32 || (c >= 9 && c <= 13) -> 1
+		this.pushInstruction({ op: "local.get", index: cTmp });
+		this.pushInstruction({ op: "i32.const", value: 32 });
+		this.pushInstruction("i32.eq");
+		this.pushInstruction({ op: "local.get", index: cTmp });
+		this.pushInstruction({ op: "i32.const", value: 9 });
+		this.pushInstruction("i32.sub");
+		this.pushInstruction({ op: "i32.const", value: 4 });
+		this.pushInstruction("i32.le_u");
+		this.pushInstruction("i32.or");
+		this.pushInstruction({ op: "if", blockType: "void" });
+		this.pushInstruction({ op: "i32.const", value: 1 });
+		this.pushInstruction({ op: "local.set", index: outWidth });
+		this.pushInstruction({ op: "else" });
+
+		// if c == 0xC2 && idx + 1 < len
+		this.pushInstruction({ op: "local.get", index: cTmp });
+		this.pushInstruction({ op: "i32.const", value: 0xc2 });
+		this.pushInstruction("i32.eq");
+		this.pushInstruction({ op: "local.get", index: idx });
+		this.pushInstruction({ op: "i32.const", value: 1 });
+		this.pushInstruction("i32.add");
+		this.pushInstruction({ op: "local.get", index: len });
+		this.pushInstruction("i32.lt_s");
+		this.pushInstruction("i32.and");
+		this.pushInstruction({ op: "if", blockType: "void" });
+		// c1 = arr[off + idx + 1]
+		this.pushInstruction({ op: "local.get", index: arr });
+		this.pushInstruction({ op: "local.get", index: off });
+		this.pushInstruction({ op: "local.get", index: idx });
+		this.pushInstruction("i32.add");
+		this.pushInstruction({ op: "i32.const", value: 1 });
+		this.pushInstruction("i32.add");
+		this.pushInstruction({ op: "array.get", typeIndex: arrInfo.typeIndex });
+		this.pushInstruction({ op: "local.tee", index: cTmp });
+		this.pushInstruction({ op: "i32.const", value: 0x85 });
+		this.pushInstruction("i32.eq");
+		this.pushInstruction({ op: "local.get", index: cTmp });
+		this.pushInstruction({ op: "i32.const", value: 0xa0 });
+		this.pushInstruction("i32.eq");
+		this.pushInstruction("i32.or");
+		this.pushInstruction({ op: "if", blockType: "void" });
+		this.pushInstruction({ op: "i32.const", value: 2 });
+		this.pushInstruction({ op: "local.set", index: outWidth });
+		this.pushInstruction("end");
+		this.pushInstruction({ op: "else" });
+
+		// idx + 2 < len
+		this.pushInstruction({ op: "local.get", index: idx });
+		this.pushInstruction({ op: "i32.const", value: 2 });
+		this.pushInstruction("i32.add");
+		this.pushInstruction({ op: "local.get", index: len });
+		this.pushInstruction("i32.lt_s");
+		this.pushInstruction({ op: "if", blockType: "void" });
+		const c1Tmp = this.acquireTemp("i32");
+		const c2Tmp = this.acquireTemp("i32");
+		this.pushInstruction({ op: "local.get", index: arr });
+		this.pushInstruction({ op: "local.get", index: off });
+		this.pushInstruction({ op: "local.get", index: idx });
+		this.pushInstruction("i32.add");
+		this.pushInstruction({ op: "i32.const", value: 1 });
+		this.pushInstruction("i32.add");
+		this.pushInstruction({ op: "array.get", typeIndex: arrInfo.typeIndex });
+		this.pushInstruction({ op: "local.set", index: c1Tmp });
+
+		this.pushInstruction({ op: "local.get", index: arr });
+		this.pushInstruction({ op: "local.get", index: off });
+		this.pushInstruction({ op: "local.get", index: idx });
+		this.pushInstruction("i32.add");
+		this.pushInstruction({ op: "i32.const", value: 2 });
+		this.pushInstruction("i32.add");
+		this.pushInstruction({ op: "array.get", typeIndex: arrInfo.typeIndex });
+		this.pushInstruction({ op: "local.set", index: c2Tmp });
+
+		// if c == 0xE1 && c1 == 0x9A && c2 == 0x80 -> 3
+		this.pushInstruction({ op: "local.get", index: cTmp });
+		this.pushInstruction({ op: "i32.const", value: 0xe1 });
+		this.pushInstruction("i32.eq");
+		this.pushInstruction({ op: "local.get", index: c1Tmp });
+		this.pushInstruction({ op: "i32.const", value: 0x9a });
+		this.pushInstruction("i32.eq");
+		this.pushInstruction("i32.and");
+		this.pushInstruction({ op: "local.get", index: c2Tmp });
+		this.pushInstruction({ op: "i32.const", value: 0x80 });
+		this.pushInstruction("i32.eq");
+		this.pushInstruction("i32.and");
+		this.pushInstruction({ op: "if", blockType: "void" });
+		this.pushInstruction({ op: "i32.const", value: 3 });
+		this.pushInstruction({ op: "local.set", index: outWidth });
+		this.pushInstruction("end");
+
+		// if c == 0xE2:
+		this.pushInstruction({ op: "local.get", index: cTmp });
+		this.pushInstruction({ op: "i32.const", value: 0xe2 });
+		this.pushInstruction("i32.eq");
+		this.pushInstruction({ op: "if", blockType: "void" });
+		// condition 1: (c1 == 0x80 && (c2 <= 0x8A || c2 == 0xA8 || c2 == 0xA9 || c2 == 0xAF))
+		this.pushInstruction({ op: "local.get", index: c1Tmp });
+		this.pushInstruction({ op: "i32.const", value: 0x80 });
+		this.pushInstruction("i32.eq");
+		this.pushInstruction({ op: "local.get", index: c2Tmp });
+		this.pushInstruction({ op: "i32.const", value: 0x8a });
+		this.pushInstruction("i32.le_u");
+		this.pushInstruction({ op: "local.get", index: c2Tmp });
+		this.pushInstruction({ op: "i32.const", value: 0xa8 });
+		this.pushInstruction("i32.eq");
+		this.pushInstruction("i32.or");
+		this.pushInstruction({ op: "local.get", index: c2Tmp });
+		this.pushInstruction({ op: "i32.const", value: 0xa9 });
+		this.pushInstruction("i32.eq");
+		this.pushInstruction("i32.or");
+		this.pushInstruction({ op: "local.get", index: c2Tmp });
+		this.pushInstruction({ op: "i32.const", value: 0xaf });
+		this.pushInstruction("i32.eq");
+		this.pushInstruction("i32.or");
+		this.pushInstruction("i32.and");
+		// condition 2: (c1 == 0x81 && c2 == 0x9F)
+		this.pushInstruction({ op: "local.get", index: c1Tmp });
+		this.pushInstruction({ op: "i32.const", value: 0x81 });
+		this.pushInstruction("i32.eq");
+		this.pushInstruction({ op: "local.get", index: c2Tmp });
+		this.pushInstruction({ op: "i32.const", value: 0x9f });
+		this.pushInstruction("i32.eq");
+		this.pushInstruction("i32.and");
+		this.pushInstruction("i32.or");
+		this.pushInstruction({ op: "if", blockType: "void" });
+		this.pushInstruction({ op: "i32.const", value: 3 });
+		this.pushInstruction({ op: "local.set", index: outWidth });
+		this.pushInstruction("end");
+		this.pushInstruction("end");
+
+		// if c == 0xE3 && c1 == 0x80 && c2 == 0x80 -> 3
+		this.pushInstruction({ op: "local.get", index: cTmp });
+		this.pushInstruction({ op: "i32.const", value: 0xe3 });
+		this.pushInstruction("i32.eq");
+		this.pushInstruction({ op: "local.get", index: c1Tmp });
+		this.pushInstruction({ op: "i32.const", value: 0x80 });
+		this.pushInstruction("i32.eq");
+		this.pushInstruction("i32.and");
+		this.pushInstruction({ op: "local.get", index: c2Tmp });
+		this.pushInstruction({ op: "i32.const", value: 0x80 });
+		this.pushInstruction("i32.eq");
+		this.pushInstruction("i32.and");
+		this.pushInstruction({ op: "if", blockType: "void" });
+		this.pushInstruction({ op: "i32.const", value: 3 });
+		this.pushInstruction({ op: "local.set", index: outWidth });
+		this.pushInstruction("end");
+
+		this.releaseTemp(c2Tmp, "i32");
+		this.releaseTemp(c1Tmp, "i32");
+		this.pushInstruction("end"); // idx + 2 < len
+		this.pushInstruction("end"); // c == 0xC2 else
+		this.pushInstruction("end"); // c == 32 else
+		this.releaseTemp(cTmp, "i32");
+	}
+
 	_emitInternalBytesFields(bTmp) {
 		const byteGo = { kind: "basic", name: "byte" };
 		const sliceInfo = this.mod.getSliceType(byteGo);
@@ -4062,31 +5286,17 @@ export class BytesEmitter {
 		this.pushInstruction("i32.ge_s");
 		this.pushInstruction({ op: "br_if", depth: 1 });
 
-		const cTmp = this.acquireTemp("i32");
-		this.pushInstruction({ op: "local.get", index: bArr });
-		this.pushInstruction({ op: "local.get", index: bOff });
-		this.pushInstruction({ op: "local.get", index: iTmp });
-		this.pushInstruction("i32.add");
-		this.pushInstruction({ op: "array.get", typeIndex: arrInfo.typeIndex });
-		this.pushInstruction({ op: "local.set", index: cTmp });
-
-		// isSp: c == 32 || (c >= 9 && c <= 13)
 		const isSpTmp = this.acquireTemp("i32");
-		this.pushInstruction({ op: "local.get", index: cTmp });
-		this.pushInstruction({ op: "i32.const", value: 32 });
-		this.pushInstruction("i32.eq");
-		this.pushInstruction({ op: "local.get", index: cTmp });
-		this.pushInstruction({ op: "i32.const", value: 9 });
-		this.pushInstruction("i32.sub");
-		this.pushInstruction({ op: "i32.const", value: 4 });
-		this.pushInstruction("i32.le_u");
-		this.pushInstruction("i32.or");
-		this.pushInstruction({ op: "local.set", index: isSpTmp });
+		this._emitIsSpaceAt(bArr, bOff, iTmp, bLen, isSpTmp, arrInfo);
 
 		this.pushInstruction({ op: "local.get", index: isSpTmp });
 		this.pushInstruction({ op: "if", blockType: "void" });
 		this.pushInstruction({ op: "i32.const", value: 0 });
 		this.pushInstruction({ op: "local.set", index: inWordTmp });
+		this.pushInstruction({ op: "local.get", index: iTmp });
+		this.pushInstruction({ op: "local.get", index: isSpTmp });
+		this.pushInstruction("i32.add");
+		this.pushInstruction({ op: "local.set", index: iTmp });
 		this.pushInstruction("else");
 		this.pushInstruction({ op: "local.get", index: inWordTmp });
 		this.pushInstruction("i32.eqz");
@@ -4098,15 +5308,14 @@ export class BytesEmitter {
 		this.pushInstruction({ op: "i32.const", value: 1 });
 		this.pushInstruction({ op: "local.set", index: inWordTmp });
 		this.pushInstruction("end");
-		this.pushInstruction("end");
-
-		this.releaseTemp(isSpTmp, "i32");
-		this.releaseTemp(cTmp, "i32");
-
 		this.pushInstruction({ op: "local.get", index: iTmp });
 		this.pushInstruction({ op: "i32.const", value: 1 });
 		this.pushInstruction("i32.add");
 		this.pushInstruction({ op: "local.set", index: iTmp });
+		this.pushInstruction("end");
+
+		this.releaseTemp(isSpTmp, "i32");
+
 		this.pushInstruction({ op: "br", depth: 0 });
 		this.pushInstruction("end");
 		this.pushInstruction("end");
@@ -4152,25 +5361,8 @@ export class BytesEmitter {
 		this.pushInstruction("i32.ge_s");
 		this.pushInstruction({ op: "br_if", depth: 1 });
 
-		const c2Tmp = this.acquireTemp("i32");
-		this.pushInstruction({ op: "local.get", index: bArr });
-		this.pushInstruction({ op: "local.get", index: bOff });
-		this.pushInstruction({ op: "local.get", index: kTmp });
-		this.pushInstruction("i32.add");
-		this.pushInstruction({ op: "array.get", typeIndex: arrInfo.typeIndex });
-		this.pushInstruction({ op: "local.set", index: c2Tmp });
-
 		const isSp2Tmp = this.acquireTemp("i32");
-		this.pushInstruction({ op: "local.get", index: c2Tmp });
-		this.pushInstruction({ op: "i32.const", value: 32 });
-		this.pushInstruction("i32.eq");
-		this.pushInstruction({ op: "local.get", index: c2Tmp });
-		this.pushInstruction({ op: "i32.const", value: 9 });
-		this.pushInstruction("i32.sub");
-		this.pushInstruction({ op: "i32.const", value: 4 });
-		this.pushInstruction("i32.le_u");
-		this.pushInstruction("i32.or");
-		this.pushInstruction({ op: "local.set", index: isSp2Tmp });
+		this._emitIsSpaceAt(bArr, bOff, kTmp, bLen, isSp2Tmp, arrInfo);
 
 		this.pushInstruction({ op: "local.get", index: isSp2Tmp });
 		this.pushInstruction({ op: "if", blockType: "void" });
@@ -4204,6 +5396,10 @@ export class BytesEmitter {
 		this.pushInstruction({ op: "i32.const", value: 0 });
 		this.pushInstruction({ op: "local.set", index: inWordTmp });
 		this.pushInstruction("end");
+		this.pushInstruction({ op: "local.get", index: kTmp });
+		this.pushInstruction({ op: "local.get", index: isSp2Tmp });
+		this.pushInstruction("i32.add");
+		this.pushInstruction({ op: "local.set", index: kTmp });
 		this.pushInstruction("else");
 		this.pushInstruction({ op: "local.get", index: inWordTmp });
 		this.pushInstruction("i32.eqz");
@@ -4213,15 +5409,14 @@ export class BytesEmitter {
 		this.pushInstruction({ op: "i32.const", value: 1 });
 		this.pushInstruction({ op: "local.set", index: inWordTmp });
 		this.pushInstruction("end");
-		this.pushInstruction("end");
-
-		this.releaseTemp(isSp2Tmp, "i32");
-		this.releaseTemp(c2Tmp, "i32");
-
 		this.pushInstruction({ op: "local.get", index: kTmp });
 		this.pushInstruction({ op: "i32.const", value: 1 });
 		this.pushInstruction("i32.add");
 		this.pushInstruction({ op: "local.set", index: kTmp });
+		this.pushInstruction("end");
+
+		this.releaseTemp(isSp2Tmp, "i32");
+
 		this.pushInstruction({ op: "br", depth: 0 });
 		this.pushInstruction("end");
 		this.pushInstruction("end");
@@ -5036,4 +6231,486 @@ export class BytesEmitter {
 		this.pushInstruction("end");
 		this.releaseTemp(b0Tmp, "i32");
 	}
+
+	_emitBytesToValidUTF8(args, _targetWasmType) {
+		const byteGo = { kind: "basic", name: "byte" };
+		const sliceInfo = this.mod.getSliceType(byteGo);
+		const arrInfo = sliceInfo.arrInfo;
+		const sliceW = {
+			kind: "ref",
+			nullable: true,
+			typeIndex: sliceInfo.typeIndex,
+		};
+		const arrW = { kind: "ref", nullable: true, typeIndex: arrInfo.typeIndex };
+
+		const bTmp = this.acquireTemp(sliceW);
+		const replTmp = this.acquireTemp(sliceW);
+		this.emitExpr(args[0], sliceW);
+		this.pushInstruction({ op: "local.set", index: bTmp });
+		this.emitExpr(args[1], sliceW);
+		this.pushInstruction({ op: "local.set", index: replTmp });
+
+		const bArr = this.acquireTemp(arrW),
+			bOff = this.acquireTemp("i32"),
+			bLen = this.acquireTemp("i32");
+		const replArr = this.acquireTemp(arrW),
+			replOff = this.acquireTemp("i32"),
+			replLen = this.acquireTemp("i32");
+
+		this._emitSliceUnpack(bTmp, sliceInfo, {
+			arr: bArr,
+			off: bOff,
+			len: bLen,
+		});
+		this._emitSliceUnpack(replTmp, sliceInfo, {
+			arr: replArr,
+			off: replOff,
+			len: replLen,
+		});
+
+		// Pass 1: compute outLen
+		const outLenTmp = this.acquireTemp("i32");
+		const inInvalidTmp = this.acquireTemp("i32");
+		const iTmp = this.acquireTemp("i32");
+		const b0Tmp = this.acquireTemp("i32");
+		const szTmp = this.acquireTemp("i32");
+		const validTmp = this.acquireTemp("i32");
+		const b1Tmp = this.acquireTemp("i32");
+		const b2Tmp = this.acquireTemp("i32");
+		const b3Tmp = this.acquireTemp("i32");
+		const rTmp = this.acquireTemp("i32");
+
+		this.pushInstruction({ op: "i32.const", value: 0 });
+		this.pushInstruction({ op: "local.set", index: outLenTmp });
+		this.pushInstruction({ op: "i32.const", value: 0 });
+		this.pushInstruction({ op: "local.set", index: inInvalidTmp });
+		this.pushInstruction({ op: "i32.const", value: 0 });
+		this.pushInstruction({ op: "local.set", index: iTmp });
+
+		const emitValidateStep = () => {
+			this.pushInstruction({ op: "i32.const", value: 0 });
+			this.pushInstruction({ op: "local.set", index: szTmp });
+			this.pushInstruction({ op: "i32.const", value: 0 });
+			this.pushInstruction({ op: "local.set", index: validTmp });
+
+			this.pushInstruction({ op: "local.get", index: bArr });
+			this.pushInstruction({ op: "local.get", index: bOff });
+			this.pushInstruction({ op: "local.get", index: iTmp });
+			this.pushInstruction("i32.add");
+			this.pushInstruction({ op: "array.get", typeIndex: arrInfo.typeIndex });
+			this.pushInstruction({ op: "local.set", index: b0Tmp });
+
+			this.pushInstruction({ op: "local.get", index: b0Tmp });
+			this.pushInstruction({ op: "i32.const", value: 0x80 });
+			this.pushInstruction("i32.lt_u");
+			this.pushInstruction({ op: "if", blockType: "void" });
+			this.pushInstruction({ op: "i32.const", value: 1 });
+			this.pushInstruction({ op: "local.set", index: szTmp });
+			this.pushInstruction({ op: "i32.const", value: 1 });
+			this.pushInstruction({ op: "local.set", index: validTmp });
+			this.pushInstruction("else");
+
+			this.pushInstruction({ op: "local.get", index: b0Tmp });
+			this.pushInstruction({ op: "i32.const", value: 0xc2 });
+			this.pushInstruction("i32.ge_u");
+			this.pushInstruction({ op: "local.get", index: b0Tmp });
+			this.pushInstruction({ op: "i32.const", value: 0xdf });
+			this.pushInstruction("i32.le_u");
+			this.pushInstruction("i32.and");
+			this.pushInstruction({ op: "if", blockType: "void" });
+			this.pushInstruction({ op: "local.get", index: iTmp });
+			this.pushInstruction({ op: "i32.const", value: 1 });
+			this.pushInstruction("i32.add");
+			this.pushInstruction({ op: "local.get", index: bLen });
+			this.pushInstruction("i32.lt_s");
+			this.pushInstruction({ op: "if", blockType: "void" });
+			this.pushInstruction({ op: "local.get", index: bArr });
+			this.pushInstruction({ op: "local.get", index: bOff });
+			this.pushInstruction({ op: "local.get", index: iTmp });
+			this.pushInstruction("i32.add");
+			this.pushInstruction({ op: "i32.const", value: 1 });
+			this.pushInstruction("i32.add");
+			this.pushInstruction({ op: "array.get", typeIndex: arrInfo.typeIndex });
+			this.pushInstruction({ op: "i32.const", value: 0xc0 });
+			this.pushInstruction("i32.and");
+			this.pushInstruction({ op: "i32.const", value: 0x80 });
+			this.pushInstruction("i32.eq");
+			this.pushInstruction({ op: "if", blockType: "void" });
+			this.pushInstruction({ op: "i32.const", value: 2 });
+			this.pushInstruction({ op: "local.set", index: szTmp });
+			this.pushInstruction({ op: "i32.const", value: 1 });
+			this.pushInstruction({ op: "local.set", index: validTmp });
+			this.pushInstruction("end");
+			this.pushInstruction("end");
+			this.pushInstruction("else");
+
+			this.pushInstruction({ op: "local.get", index: b0Tmp });
+			this.pushInstruction({ op: "i32.const", value: 0xe0 });
+			this.pushInstruction("i32.ge_u");
+			this.pushInstruction({ op: "local.get", index: b0Tmp });
+			this.pushInstruction({ op: "i32.const", value: 0xef });
+			this.pushInstruction("i32.le_u");
+			this.pushInstruction("i32.and");
+			this.pushInstruction({ op: "if", blockType: "void" });
+			this.pushInstruction({ op: "local.get", index: iTmp });
+			this.pushInstruction({ op: "i32.const", value: 2 });
+			this.pushInstruction("i32.add");
+			this.pushInstruction({ op: "local.get", index: bLen });
+			this.pushInstruction("i32.lt_s");
+			this.pushInstruction({ op: "if", blockType: "void" });
+			this.pushInstruction({ op: "local.get", index: bArr });
+			this.pushInstruction({ op: "local.get", index: bOff });
+			this.pushInstruction({ op: "local.get", index: iTmp });
+			this.pushInstruction("i32.add");
+			this.pushInstruction({ op: "i32.const", value: 1 });
+			this.pushInstruction("i32.add");
+			this.pushInstruction({ op: "array.get", typeIndex: arrInfo.typeIndex });
+			this.pushInstruction({ op: "local.set", index: b1Tmp });
+
+			this.pushInstruction({ op: "local.get", index: bArr });
+			this.pushInstruction({ op: "local.get", index: bOff });
+			this.pushInstruction({ op: "local.get", index: iTmp });
+			this.pushInstruction("i32.add");
+			this.pushInstruction({ op: "i32.const", value: 2 });
+			this.pushInstruction("i32.add");
+			this.pushInstruction({ op: "array.get", typeIndex: arrInfo.typeIndex });
+			this.pushInstruction({ op: "local.set", index: b2Tmp });
+
+			this.pushInstruction({ op: "local.get", index: b1Tmp });
+			this.pushInstruction({ op: "i32.const", value: 0xc0 });
+			this.pushInstruction("i32.and");
+			this.pushInstruction({ op: "i32.const", value: 0x80 });
+			this.pushInstruction("i32.eq");
+			this.pushInstruction({ op: "local.get", index: b2Tmp });
+			this.pushInstruction({ op: "i32.const", value: 0xc0 });
+			this.pushInstruction("i32.and");
+			this.pushInstruction({ op: "i32.const", value: 0x80 });
+			this.pushInstruction("i32.eq");
+			this.pushInstruction("i32.and");
+			this.pushInstruction({ op: "if", blockType: "void" });
+			this.pushInstruction({ op: "local.get", index: b0Tmp });
+			this.pushInstruction({ op: "i32.const", value: 0x0f });
+			this.pushInstruction("i32.and");
+			this.pushInstruction({ op: "i32.const", value: 12 });
+			this.pushInstruction("i32.shl");
+			this.pushInstruction({ op: "local.get", index: b1Tmp });
+			this.pushInstruction({ op: "i32.const", value: 0x3f });
+			this.pushInstruction("i32.and");
+			this.pushInstruction({ op: "i32.const", value: 6 });
+			this.pushInstruction("i32.shl");
+			this.pushInstruction("i32.or");
+			this.pushInstruction({ op: "local.get", index: b2Tmp });
+			this.pushInstruction({ op: "i32.const", value: 0x3f });
+			this.pushInstruction("i32.and");
+			this.pushInstruction("i32.or");
+			this.pushInstruction({ op: "local.set", index: rTmp });
+
+			this.pushInstruction({ op: "local.get", index: rTmp });
+			this.pushInstruction({ op: "i32.const", value: 0x800 });
+			this.pushInstruction("i32.ge_u");
+			this.pushInstruction({ op: "local.get", index: rTmp });
+			this.pushInstruction({ op: "i32.const", value: 0xd800 });
+			this.pushInstruction("i32.lt_u");
+			this.pushInstruction({ op: "local.get", index: rTmp });
+			this.pushInstruction({ op: "i32.const", value: 0xdfff });
+			this.pushInstruction("i32.gt_u");
+			this.pushInstruction("i32.or");
+			this.pushInstruction("i32.and");
+			this.pushInstruction({ op: "if", blockType: "void" });
+			this.pushInstruction({ op: "i32.const", value: 3 });
+			this.pushInstruction({ op: "local.set", index: szTmp });
+			this.pushInstruction({ op: "i32.const", value: 1 });
+			this.pushInstruction({ op: "local.set", index: validTmp });
+			this.pushInstruction("end");
+			this.pushInstruction("end");
+			this.pushInstruction("end");
+			this.pushInstruction("else");
+
+			this.pushInstruction({ op: "local.get", index: b0Tmp });
+			this.pushInstruction({ op: "i32.const", value: 0xf0 });
+			this.pushInstruction("i32.ge_u");
+			this.pushInstruction({ op: "local.get", index: b0Tmp });
+			this.pushInstruction({ op: "i32.const", value: 0xf4 });
+			this.pushInstruction("i32.le_u");
+			this.pushInstruction("i32.and");
+			this.pushInstruction({ op: "if", blockType: "void" });
+			this.pushInstruction({ op: "local.get", index: iTmp });
+			this.pushInstruction({ op: "i32.const", value: 3 });
+			this.pushInstruction("i32.add");
+			this.pushInstruction({ op: "local.get", index: bLen });
+			this.pushInstruction("i32.lt_s");
+			this.pushInstruction({ op: "if", blockType: "void" });
+			this.pushInstruction({ op: "local.get", index: bArr });
+			this.pushInstruction({ op: "local.get", index: bOff });
+			this.pushInstruction({ op: "local.get", index: iTmp });
+			this.pushInstruction("i32.add");
+			this.pushInstruction({ op: "i32.const", value: 1 });
+			this.pushInstruction("i32.add");
+			this.pushInstruction({ op: "array.get", typeIndex: arrInfo.typeIndex });
+			this.pushInstruction({ op: "local.set", index: b1Tmp });
+
+			this.pushInstruction({ op: "local.get", index: bArr });
+			this.pushInstruction({ op: "local.get", index: bOff });
+			this.pushInstruction({ op: "local.get", index: iTmp });
+			this.pushInstruction("i32.add");
+			this.pushInstruction({ op: "i32.const", value: 2 });
+			this.pushInstruction("i32.add");
+			this.pushInstruction({ op: "array.get", typeIndex: arrInfo.typeIndex });
+			this.pushInstruction({ op: "local.set", index: b2Tmp });
+
+			this.pushInstruction({ op: "local.get", index: bArr });
+			this.pushInstruction({ op: "local.get", index: bOff });
+			this.pushInstruction({ op: "local.get", index: iTmp });
+			this.pushInstruction("i32.add");
+			this.pushInstruction({ op: "i32.const", value: 3 });
+			this.pushInstruction("i32.add");
+			this.pushInstruction({ op: "array.get", typeIndex: arrInfo.typeIndex });
+			this.pushInstruction({ op: "local.set", index: b3Tmp });
+
+			this.pushInstruction({ op: "local.get", index: b1Tmp });
+			this.pushInstruction({ op: "i32.const", value: 0xc0 });
+			this.pushInstruction("i32.and");
+			this.pushInstruction({ op: "i32.const", value: 0x80 });
+			this.pushInstruction("i32.eq");
+			this.pushInstruction({ op: "local.get", index: b2Tmp });
+			this.pushInstruction({ op: "i32.const", value: 0xc0 });
+			this.pushInstruction("i32.and");
+			this.pushInstruction({ op: "i32.const", value: 0x80 });
+			this.pushInstruction("i32.eq");
+			this.pushInstruction("i32.and");
+			this.pushInstruction({ op: "local.get", index: b3Tmp });
+			this.pushInstruction({ op: "i32.const", value: 0xc0 });
+			this.pushInstruction("i32.and");
+			this.pushInstruction({ op: "i32.const", value: 0x80 });
+			this.pushInstruction("i32.eq");
+			this.pushInstruction("i32.and");
+			this.pushInstruction({ op: "if", blockType: "void" });
+			this.pushInstruction({ op: "local.get", index: b0Tmp });
+			this.pushInstruction({ op: "i32.const", value: 0x07 });
+			this.pushInstruction("i32.and");
+			this.pushInstruction({ op: "i32.const", value: 18 });
+			this.pushInstruction("i32.shl");
+			this.pushInstruction({ op: "local.get", index: b1Tmp });
+			this.pushInstruction({ op: "i32.const", value: 0x3f });
+			this.pushInstruction("i32.and");
+			this.pushInstruction({ op: "i32.const", value: 12 });
+			this.pushInstruction("i32.shl");
+			this.pushInstruction("i32.or");
+			this.pushInstruction({ op: "local.get", index: b2Tmp });
+			this.pushInstruction({ op: "i32.const", value: 0x3f });
+			this.pushInstruction("i32.and");
+			this.pushInstruction({ op: "i32.const", value: 6 });
+			this.pushInstruction("i32.shl");
+			this.pushInstruction("i32.or");
+			this.pushInstruction({ op: "local.get", index: b3Tmp });
+			this.pushInstruction({ op: "i32.const", value: 0x3f });
+			this.pushInstruction("i32.and");
+			this.pushInstruction("i32.or");
+			this.pushInstruction({ op: "local.set", index: rTmp });
+
+			this.pushInstruction({ op: "local.get", index: rTmp });
+			this.pushInstruction({ op: "i32.const", value: 0x10000 });
+			this.pushInstruction("i32.ge_u");
+			this.pushInstruction({ op: "local.get", index: rTmp });
+			this.pushInstruction({ op: "i32.const", value: 0x10ffff });
+			this.pushInstruction("i32.le_u");
+			this.pushInstruction("i32.and");
+			this.pushInstruction({ op: "if", blockType: "void" });
+			this.pushInstruction({ op: "i32.const", value: 4 });
+			this.pushInstruction({ op: "local.set", index: szTmp });
+			this.pushInstruction({ op: "i32.const", value: 1 });
+			this.pushInstruction({ op: "local.set", index: validTmp });
+			this.pushInstruction("end");
+			this.pushInstruction("end");
+			this.pushInstruction("end");
+			this.pushInstruction("end");
+			this.pushInstruction("end");
+			this.pushInstruction("end");
+			this.pushInstruction("end");
+		};
+
+		this.pushInstruction({ op: "block", blockType: "void" });
+		this.pushInstruction({ op: "loop", blockType: "void" });
+		this.pushInstruction({ op: "local.get", index: iTmp });
+		this.pushInstruction({ op: "local.get", index: bLen });
+		this.pushInstruction("i32.ge_s");
+		this.pushInstruction({ op: "br_if", depth: 1 });
+
+		emitValidateStep();
+
+		this.pushInstruction({ op: "local.get", index: validTmp });
+		this.pushInstruction({ op: "if", blockType: "void" });
+
+		this.pushInstruction({ op: "local.get", index: inInvalidTmp });
+		this.pushInstruction({ op: "if", blockType: "void" });
+		this.pushInstruction({ op: "local.get", index: outLenTmp });
+		this.pushInstruction({ op: "local.get", index: replLen });
+		this.pushInstruction("i32.add");
+		this.pushInstruction({ op: "local.set", index: outLenTmp });
+		this.pushInstruction({ op: "i32.const", value: 0 });
+		this.pushInstruction({ op: "local.set", index: inInvalidTmp });
+		this.pushInstruction("end");
+
+		this.pushInstruction({ op: "local.get", index: outLenTmp });
+		this.pushInstruction({ op: "local.get", index: szTmp });
+		this.pushInstruction("i32.add");
+		this.pushInstruction({ op: "local.set", index: outLenTmp });
+
+		this.pushInstruction({ op: "local.get", index: iTmp });
+		this.pushInstruction({ op: "local.get", index: szTmp });
+		this.pushInstruction("i32.add");
+		this.pushInstruction({ op: "local.set", index: iTmp });
+
+		this.pushInstruction("else");
+
+		this.pushInstruction({ op: "i32.const", value: 1 });
+		this.pushInstruction({ op: "local.set", index: inInvalidTmp });
+		this.pushInstruction({ op: "local.get", index: iTmp });
+		this.pushInstruction({ op: "i32.const", value: 1 });
+		this.pushInstruction("i32.add");
+		this.pushInstruction({ op: "local.set", index: iTmp });
+
+		this.pushInstruction("end");
+
+		this.pushInstruction({ op: "br", depth: 0 });
+		this.pushInstruction("end");
+		this.pushInstruction("end");
+
+		this.pushInstruction({ op: "local.get", index: inInvalidTmp });
+		this.pushInstruction({ op: "if", blockType: "void" });
+		this.pushInstruction({ op: "local.get", index: outLenTmp });
+		this.pushInstruction({ op: "local.get", index: replLen });
+		this.pushInstruction("i32.add");
+		this.pushInstruction({ op: "local.set", index: outLenTmp });
+		this.pushInstruction("end");
+
+		const resArrTmp = this.acquireTemp(arrW);
+		this.pushInstruction({ op: "local.get", index: outLenTmp });
+		this.pushInstruction({
+			op: "array.new_default",
+			typeIndex: arrInfo.typeIndex,
+		});
+		this.pushInstruction({ op: "local.set", index: resArrTmp });
+
+		const dstTmp = this.acquireTemp("i32");
+		this.pushInstruction({ op: "i32.const", value: 0 });
+		this.pushInstruction({ op: "local.set", index: dstTmp });
+		this.pushInstruction({ op: "i32.const", value: 0 });
+		this.pushInstruction({ op: "local.set", index: inInvalidTmp });
+		this.pushInstruction({ op: "i32.const", value: 0 });
+		this.pushInstruction({ op: "local.set", index: iTmp });
+
+		this.pushInstruction({ op: "block", blockType: "void" });
+		this.pushInstruction({ op: "loop", blockType: "void" });
+		this.pushInstruction({ op: "local.get", index: iTmp });
+		this.pushInstruction({ op: "local.get", index: bLen });
+		this.pushInstruction("i32.ge_s");
+		this.pushInstruction({ op: "br_if", depth: 1 });
+
+		emitValidateStep();
+
+		this.pushInstruction({ op: "local.get", index: validTmp });
+		this.pushInstruction({ op: "if", blockType: "void" });
+
+		this.pushInstruction({ op: "local.get", index: inInvalidTmp });
+		this.pushInstruction({ op: "if", blockType: "void" });
+		this.pushInstruction({ op: "local.get", index: replLen });
+		this.pushInstruction({ op: "i32.const", value: 0 });
+		this.pushInstruction("i32.gt_s");
+		this.pushInstruction({ op: "if", blockType: "void" });
+		this.pushInstruction({ op: "local.get", index: resArrTmp });
+		this.pushInstruction({ op: "local.get", index: dstTmp });
+		this.pushInstruction({ op: "local.get", index: replArr });
+		this.pushInstruction({ op: "local.get", index: replOff });
+		this.pushInstruction({ op: "local.get", index: replLen });
+		this._emitArrayCopy(arrInfo, byteGo);
+		this.pushInstruction("end");
+		this.pushInstruction({ op: "local.get", index: dstTmp });
+		this.pushInstruction({ op: "local.get", index: replLen });
+		this.pushInstruction("i32.add");
+		this.pushInstruction({ op: "local.set", index: dstTmp });
+		this.pushInstruction({ op: "i32.const", value: 0 });
+		this.pushInstruction({ op: "local.set", index: inInvalidTmp });
+		this.pushInstruction("end");
+
+		this.pushInstruction({ op: "local.get", index: resArrTmp });
+		this.pushInstruction({ op: "local.get", index: dstTmp });
+		this.pushInstruction({ op: "local.get", index: bArr });
+		this.pushInstruction({ op: "local.get", index: bOff });
+		this.pushInstruction({ op: "local.get", index: iTmp });
+		this.pushInstruction("i32.add");
+		this.pushInstruction({ op: "local.get", index: szTmp });
+		this._emitArrayCopy(arrInfo, byteGo);
+
+		this.pushInstruction({ op: "local.get", index: dstTmp });
+		this.pushInstruction({ op: "local.get", index: szTmp });
+		this.pushInstruction("i32.add");
+		this.pushInstruction({ op: "local.set", index: dstTmp });
+
+		this.pushInstruction({ op: "local.get", index: iTmp });
+		this.pushInstruction({ op: "local.get", index: szTmp });
+		this.pushInstruction("i32.add");
+		this.pushInstruction({ op: "local.set", index: iTmp });
+
+		this.pushInstruction("else");
+
+		this.pushInstruction({ op: "i32.const", value: 1 });
+		this.pushInstruction({ op: "local.set", index: inInvalidTmp });
+		this.pushInstruction({ op: "local.get", index: iTmp });
+		this.pushInstruction({ op: "i32.const", value: 1 });
+		this.pushInstruction("i32.add");
+		this.pushInstruction({ op: "local.set", index: iTmp });
+
+		this.pushInstruction("end");
+
+		this.pushInstruction({ op: "br", depth: 0 });
+		this.pushInstruction("end");
+		this.pushInstruction("end");
+
+		this.pushInstruction({ op: "local.get", index: inInvalidTmp });
+		this.pushInstruction({ op: "if", blockType: "void" });
+		this.pushInstruction({ op: "local.get", index: replLen });
+		this.pushInstruction({ op: "i32.const", value: 0 });
+		this.pushInstruction("i32.gt_s");
+		this.pushInstruction({ op: "if", blockType: "void" });
+		this.pushInstruction({ op: "local.get", index: resArrTmp });
+		this.pushInstruction({ op: "local.get", index: dstTmp });
+		this.pushInstruction({ op: "local.get", index: replArr });
+		this.pushInstruction({ op: "local.get", index: replOff });
+		this.pushInstruction({ op: "local.get", index: replLen });
+		this._emitArrayCopy(arrInfo, byteGo);
+		this.pushInstruction("end");
+		this.pushInstruction("end");
+
+		this.pushInstruction({ op: "local.get", index: resArrTmp });
+		this.pushInstruction({ op: "i32.const", value: 0 });
+		this.pushInstruction({ op: "local.get", index: outLenTmp });
+		this.pushInstruction({ op: "local.get", index: outLenTmp });
+		this.pushInstruction({
+			op: "struct.new",
+			typeIndex: sliceInfo.typeIndex,
+		});
+
+		this.releaseTemp(dstTmp, "i32");
+		this.releaseTemp(resArrTmp, arrW);
+		this.releaseTemp(rTmp, "i32");
+		this.releaseTemp(b3Tmp, "i32");
+		this.releaseTemp(b2Tmp, "i32");
+		this.releaseTemp(b1Tmp, "i32");
+		this.releaseTemp(validTmp, "i32");
+		this.releaseTemp(szTmp, "i32");
+		this.releaseTemp(b0Tmp, "i32");
+		this.releaseTemp(iTmp, "i32");
+		this.releaseTemp(inInvalidTmp, "i32");
+		this.releaseTemp(outLenTmp, "i32");
+
+		this.releaseTemp(replLen, "i32");
+		this.releaseTemp(replOff, "i32");
+		this.releaseTemp(replArr, arrW);
+		this.releaseTemp(bLen, "i32");
+		this.releaseTemp(bOff, "i32");
+		this.releaseTemp(bArr, arrW);
+		this.releaseTemp(replTmp, sliceW);
+		this.releaseTemp(bTmp, sliceW);
+	}
 }