@wasm-fmt/gofmt 0.5.0 → 0.5.1

package/README.md

@@ -48,12 +48,9 @@ import init, { format } from "@wasm-fmt/gofmt/vite";
 # 3. clone this repo
 git clone https://github.com/wasm-fmt/gofmt.git
 
-# 4. install dependencies inside the repo
-npm install
+# 4. build
+pnpm build
 
-# 5. build
-npm run build
-
-# 6. test
-npm run /^test:/
+# 5. test
+pnpm run /^test:/
 ```

package/gofmt.d.wasm.ts

@@ -0,0 +1,7 @@
+export declare const memory: WebAssembly.Memory;
+export declare function _initialize(): void;
+export declare function alloc(size: number): number;
+export declare function dispose(): void;
+export declare function format(): 0 | 1 | 2;
+export declare function output_ptr(): number;
+export declare function output_len(): number;

package/gofmt.js

@@ -1,435 +1,49 @@
-/* @ts-self-types="./gofmt.d.ts" */
-// Copyright 2018 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-//
-// This file has been modified for use by the TinyGo compiler.
-
-// End of polyfills for common API.
-
-	const encoder = new TextEncoder("utf-8");
-	const decoder = new TextDecoder("utf-8");
-	let reinterpretBuf = new DataView(new ArrayBuffer(8));
-	var logLine = [];
-	const wasmExit = {}; // thrown to exit via proc_exit (not an error)
-
-	class Go {
-		constructor() {
-			this._callbackTimeouts = new Map();
-			this._nextCallbackTimeoutID = 1;
-
-			const mem = () => {
-				// The buffer may change when requesting more memory.
-				return new DataView(this._inst.exports.memory.buffer);
-			}
-
-			const unboxValue = (v_ref) => {
-				reinterpretBuf.setBigInt64(0, v_ref, true);
-				const f = reinterpretBuf.getFloat64(0, true);
-				if (f === 0) {
-					return undefined;
-				}
-				if (!isNaN(f)) {
-					return f;
-				}
-
-				const id = v_ref & 0xffffffffn;
-				return this._values[id];
-			}
-
-
-			const loadValue = (addr) => {
-				let v_ref = mem().getBigUint64(addr, true);
-				return unboxValue(v_ref);
-			}
-
-			const boxValue = (v) => {
-				const nanHead = 0x7FF80000n;
-
-				if (typeof v === "number") {
-					if (isNaN(v)) {
-						return nanHead << 32n;
-					}
-					if (v === 0) {
-						return (nanHead << 32n) | 1n;
-					}
-					reinterpretBuf.setFloat64(0, v, true);
-					return reinterpretBuf.getBigInt64(0, true);
-				}
-
-				switch (v) {
-					case undefined:
-						return 0n;
-					case null:
-						return (nanHead << 32n) | 2n;
-					case true:
-						return (nanHead << 32n) | 3n;
-					case false:
-						return (nanHead << 32n) | 4n;
-				}
-
-				let id = this._ids.get(v);
-				if (id === undefined) {
-					id = this._idPool.pop();
-					if (id === undefined) {
-						id = BigInt(this._values.length);
-					}
-					this._values[id] = v;
-					this._goRefCounts[id] = 0;
-					this._ids.set(v, id);
-				}
-				this._goRefCounts[id]++;
-				let typeFlag = 1n;
-				switch (typeof v) {
-					case "string":
-						typeFlag = 2n;
-						break;
-					case "symbol":
-						typeFlag = 3n;
-						break;
-					case "function":
-						typeFlag = 4n;
-						break;
-				}
-				return id | ((nanHead | typeFlag) << 32n);
-			}
-
-			const storeValue = (addr, v) => {
-				let v_ref = boxValue(v);
-				mem().setBigUint64(addr, v_ref, true);
-			}
-
-			const loadSlice = (array, len, cap) => {
-				return new Uint8Array(this._inst.exports.memory.buffer, array, len);
-			}
-
-			const loadSliceOfValues = (array, len, cap) => {
-				const a = new Array(len);
-				for (let i = 0; i < len; i++) {
-					a[i] = loadValue(array + i * 8);
-				}
-				return a;
-			}
-
-			const loadString = (ptr, len) => {
-				return decoder.decode(new DataView(this._inst.exports.memory.buffer, ptr, len));
-			}
-
-			const timeOrigin = Date.now() - performance.now();
-			this.importObject = {
-				wasi_snapshot_preview1: {
-					// https://github.com/WebAssembly/WASI/blob/main/phases/snapshot/docs.md#fd_write
-					fd_write: function(fd, iovs_ptr, iovs_len, nwritten_ptr) {
-						let nwritten = 0;
-						if (fd == 1) {
-							for (let iovs_i=0; iovs_i<iovs_len;iovs_i++) {
-								let iov_ptr = iovs_ptr+iovs_i*8; // assuming wasm32
-								let ptr = mem().getUint32(iov_ptr + 0, true);
-								let len = mem().getUint32(iov_ptr + 4, true);
-								nwritten += len;
-								for (let i=0; i<len; i++) {
-									let c = mem().getUint8(ptr+i);
-									if (c == 13) { // CR
-										// ignore
-									} else if (c == 10) { // LF
-										// write line
-										let line = decoder.decode(new Uint8Array(logLine));
-										logLine = [];
-										console.log(line);
-									} else {
-										logLine.push(c);
-									}
-								}
-							}
-						} else {
-							console.error('invalid file descriptor:', fd);
-						}
-						mem().setUint32(nwritten_ptr, nwritten, true);
-						return 0;
-					},
-					/* removed fd_close */      // dummy
-					/* removed fd_fdstat_get */ // dummy
-					/* removed fd_seek */       // dummy
-					proc_exit: (code) => {
-						this.exited = true;
-						this.exitCode = code;
-						this._resolveExitPromise();
-						throw wasmExit;
-					},
-					random_get: (bufPtr, bufLen) => {
-						crypto.getRandomValues(loadSlice(bufPtr, bufLen));
-						return 0;
-					},
-				},
-				gojs: {
-					// func ticks() int64
-					"runtime.ticks": () => {
-						return BigInt((timeOrigin + performance.now()) * 1e6);
-					},
-
-					// func sleepTicks(timeout int64)
-					/* removed runtime.sleepTicks */
-
-					// func finalizeRef(v ref)
-					"syscall/js.finalizeRef": (v_ref) => {
-						// Note: TinyGo does not support finalizers so this is only called
-						// for one specific case, by js.go:jsString. and can/might leak memory.
-						const id = v_ref & 0xffffffffn;
-						if (this._goRefCounts?.[id] !== undefined) {
-							this._goRefCounts[id]--;
-							if (this._goRefCounts[id] === 0) {
-								const v = this._values[id];
-								this._values[id] = null;
-								this._ids.delete(v);
-								this._idPool.push(id);
-							}
-						} else {
-							console.error("syscall/js.finalizeRef: unknown id", id);
-						}
-					},
-
-					// func stringVal(value string) ref
-					"syscall/js.stringVal": (value_ptr, value_len) => {
-						value_ptr >>>= 0;
-						const s = loadString(value_ptr, value_len);
-						return boxValue(s);
-					},
-
-					// func valueGet(v ref, p string) ref
-					"syscall/js.valueGet": (v_ref, p_ptr, p_len) => {
-						let prop = loadString(p_ptr, p_len);
-						let v = unboxValue(v_ref);
-						let result = Reflect.get(v, prop);
-						return boxValue(result);
-					},
-
-					// func valueSet(v ref, p string, x ref)
-					"syscall/js.valueSet": (v_ref, p_ptr, p_len, x_ref) => {
-						const v = unboxValue(v_ref);
-						const p = loadString(p_ptr, p_len);
-						const x = unboxValue(x_ref);
-						Reflect.set(v, p, x);
-					},
-
-					// func valueDelete(v ref, p string)
-					/* removed syscall/js.valueDelete */
-
-					// func valueIndex(v ref, i int) ref
-					"syscall/js.valueIndex": (v_ref, i) => {
-						return boxValue(Reflect.get(unboxValue(v_ref), i));
-					},
-
-					// valueSetIndex(v ref, i int, x ref)
-					"syscall/js.valueSetIndex": (v_ref, i, x_ref) => {
-						Reflect.set(unboxValue(v_ref), i, unboxValue(x_ref));
-					},
-
-					// func valueCall(v ref, m string, args []ref) (ref, bool)
-					"syscall/js.valueCall": (ret_addr, v_ref, m_ptr, m_len, args_ptr, args_len, args_cap) => {
-						const v = unboxValue(v_ref);
-						const name = loadString(m_ptr, m_len);
-						const args = loadSliceOfValues(args_ptr, args_len, args_cap);
-						try {
-							const m = Reflect.get(v, name);
-							storeValue(ret_addr, Reflect.apply(m, v, args));
-							mem().setUint8(ret_addr + 8, 1);
-						} catch (err) {
-							storeValue(ret_addr, err);
-							mem().setUint8(ret_addr + 8, 0);
-						}
-					},
-
-					// func valueInvoke(v ref, args []ref) (ref, bool)
-					/* removed syscall/js.valueInvoke */
-
-					// func valueNew(v ref, args []ref) (ref, bool)
-					"syscall/js.valueNew": (ret_addr, v_ref, args_ptr, args_len, args_cap) => {
-						const v = unboxValue(v_ref);
-						const args = loadSliceOfValues(args_ptr, args_len, args_cap);
-						try {
-							storeValue(ret_addr, Reflect.construct(v, args));
-							mem().setUint8(ret_addr + 8, 1);
-						} catch (err) {
-							storeValue(ret_addr, err);
-							mem().setUint8(ret_addr+ 8, 0);
-						}
-					},
-
-					// func valueLength(v ref) int
-					"syscall/js.valueLength": (v_ref) => {
-						return unboxValue(v_ref).length;
-					},
-
-					// valuePrepareString(v ref) (ref, int)
-					"syscall/js.valuePrepareString": (ret_addr, v_ref) => {
-						const s = String(unboxValue(v_ref));
-						const str = encoder.encode(s);
-						storeValue(ret_addr, str);
-						mem().setInt32(ret_addr + 8, str.length, true);
-					},
-
-					// valueLoadString(v ref, b []byte)
-					"syscall/js.valueLoadString": (v_ref, slice_ptr, slice_len, slice_cap) => {
-						const str = unboxValue(v_ref);
-						loadSlice(slice_ptr, slice_len, slice_cap).set(str);
-					},
-
-					// func valueInstanceOf(v ref, t ref) bool
-					/* removed syscall/js.valueInstanceOf */
-
-					// func copyBytesToGo(dst []byte, src ref) (int, bool)
-					/* removed syscall/js.copyBytesToGo */
-
-					// copyBytesToJS(dst ref, src []byte) (int, bool)
-					// Originally copied from upstream Go project, then modified:
-					//   https://github.com/golang/go/blob/3f995c3f3b43033013013e6c7ccc93a9b1411ca9/misc/wasm/wasm_exec.js#L404-L416
-					/* removed syscall/js.copyBytesToJS */
-				}
-			};
+/**
+ * @import * as WASM from "./gofmt.wasm"
+ */
 
-			// Go 1.20 uses 'env'. Go 1.21 uses 'gojs'.
-			// For compatibility, we use both as long as Go 1.20 is supported.
-			this.importObject.env = this.importObject.gojs;
+/**
+ * @param {WASM} wasm
+ * @param {string} source
+ * @return {string}
+ */
+export function format(wasm, source) {
+	try {
+		writeStringToWasmMemory(wasm, source);
+		const result = wasm.format();
+		if (result === 0) {
+			return source;
 		}
 
-		async run(instance) {
-			this._inst = instance;
-			this._values = [ // JS values that Go currently has references to, indexed by reference id
-				NaN,
-				0,
-				null,
-				true,
-				false,
-				/* fake global */ { set format(fn) { instance.format = fn }, Array, Object},
-				this,
-			];
-			this._goRefCounts = []; // number of references that Go has to a JS value, indexed by reference id
-			this._ids = new Map();  // mapping from JS values to reference ids
-			this._idPool = [];      // unused ids that have been garbage collected
-			this.exited = false;    // whether the Go program has exited
-			this.exitCode = 0;
-
-			if (this._inst.exports._start) {
-				let exitPromise = new Promise((resolve, reject) => {
-					this._resolveExitPromise = resolve;
-				});
+		const ptr = wasm.output_ptr();
+		const length = wasm.output_len();
+		const text = readStringFromWasmMemory(wasm, ptr, length);
 
-				// Run program, but catch the wasmExit exception that's thrown
-				// to return back here.
-				try {
-					this._inst.exports._start();
-				} catch (e) {
-					if (e !== wasmExit) throw e;
-				}
-
-				await exitPromise;
-				return this.exitCode;
-			} else {
-				this._inst.exports._initialize();
-			}
-		}
-
-		_resume() {
-			if (this.exited) {
-				throw new Error("Go program has already exited");
-			}
-			try {
-				this._inst.exports.resume();
-			} catch (e) {
-				if (e !== wasmExit) throw e;
-			}
-			if (this.exited) {
-				this._resolveExitPromise();
-			}
+		if (result === 1) {
+			return text;
 		}
 
-		_makeFuncWrapper(id) {
-			const go = this;
-			return function () {
-				const event = { id: id, this: this, args: arguments };
-				go._pendingEvent = event;
-				go._resume();
-				return event.result;
-			};
-		}
+		throw new Error(text);
+	} finally {
+		wasm.dispose();
 	}
+}
+
 /**
- * ================== End of wasm_exec.js ==================
+ * @param {WASM} wasm
+ * @param {string} str
  */
-let wasm;
-async function __load(module, imports) {
-	if (typeof Response === "function" && module instanceof Response) {
-		if (typeof WebAssembly.instantiateStreaming === "function") {
-			try {
-				return await WebAssembly.instantiateStreaming(module, imports);
-			} catch (e) {
-				if (module.headers.get("Content-Type") != "application/wasm") {
-					console.warn(
-						"`WebAssembly.instantiateStreaming` failed because your server does not serve wasm with `application/wasm` MIME type. Falling back to `WebAssembly.instantiate` which is slower. Original error:\n",
-						e,
-					);
-				} else {
-					throw e;
-				}
-			}
-		}
-		const bytes = await module.arrayBuffer();
-		return await WebAssembly.instantiate(bytes, imports);
-	} else {
-		const instance = await WebAssembly.instantiate(module, imports);
-		if (instance instanceof WebAssembly.Instance)
-			return { instance, module };
-		else return instance;
-	}
-}
-function __finalize_init(instance) {
-	return (wasm = instance);
+function writeStringToWasmMemory(wasm, str) {
+	const bytes = encoder.encode(str);
+	const ptr = wasm.alloc(bytes.length);
+	const memory = new Uint8Array(wasm.memory.buffer, ptr, bytes.length);
+	memory.set(bytes);
 }
-function __init_memory(imports, maybe_memory) {}
-export function initSync(module) {
-	if (wasm !== undefined) return wasm;
-
-	const go = new Go();
-	const imports = go.importObject;
-
-	__init_memory(imports);
 
-	if (!(module instanceof WebAssembly.Module))
-		module = new WebAssembly.Module(module);
-
-	const instance = new WebAssembly.Instance(module, imports);
-
-	go.run(instance);
-	return __finalize_init(instance, module);
+function readStringFromWasmMemory(wasm, ptr, length) {
+	const memory = new Uint8Array(wasm.memory.buffer, ptr, length);
+	return decoder.decode(memory);
 }
-export default async function initAsync(input) {
-	if (wasm !== undefined) return wasm;
-
-	if (typeof input === "undefined")
-		input = new URL("gofmt.wasm", import.meta.url);
-
-	const go = new Go();
-	const imports = go.importObject;
 
-	if (
-		typeof input === "string" ||
-		(typeof Request === "function" && input instanceof Request) ||
-		(typeof URL === "function" && input instanceof URL)
-	) {
-		input = fetch(input);
-	}
-
-	__init_memory(imports);
-
-	const { instance, module } = await __load(await input, imports);
-
-	go.run(instance);
-	return __finalize_init(instance, module);
-}
-export function format(input) {
-	const [err, result] = wasm.format(input);
-	if (err) {
-		throw new Error(result);
-	}
-	return result;
-}
+const encoder = new TextEncoder();
+const decoder = new TextDecoder();

package/gofmt_bundle.js

@@ -0,0 +1,16 @@
+import wasm from "./gofmt.wasm";
+import { format as _format } from "./gofmt.js";
+
+wasm._initialize();
+
+export function initSync() {
+	return wasm;
+}
+
+export default async function initAsync() {
+	return wasm;
+}
+
+export function format(source) {
+	return _format(wasm, source);
+}

package/gofmt_entry.d.ts

@@ -0,0 +1,14 @@
+export type InitInput =
+	| RequestInfo
+	| URL
+	| Response
+	| BufferSource
+	| WebAssembly.Module;
+export type SyncInitInput = BufferSource | WebAssembly.Module;
+import type * as InitOutput from "./gofmt.d.wasm.ts";
+
+export default function initAsync(
+	init_input?: InitInput | Promise<InitInput>,
+): Promise<InitOutput>;
+export declare function initSync(buffer_or_module: SyncInitInput): InitOutput;
+export declare function format(input: string): string;

package/gofmt_esm.js

@@ -0,0 +1,25 @@
+import source wasmModule from "./gofmt.wasm";
+import { format as _format } from "./gofmt.js";
+/**
+ * @import * as WASM from "./gofmt.wasm"
+ */
+
+const instance = new WebAssembly.Instance(wasmModule);
+
+/**
+ * @type {WASM}
+ */
+let wasm = instance.exports;
+wasm._initialize();
+
+export function initSync() {
+	return wasm;
+}
+
+export default async function initAsync() {
+	return wasm;
+}
+
+export function format(source) {
+	return _format(wasm, source);
+}

package/gofmt_node.js

@@ -1,10 +1,102 @@
-import fs from "node:fs/promises";
-import initAsync from "./gofmt.js";
+/* @ts-self-types="./gofmt_entry.d.ts" */
+import { format as _format } from "./gofmt.js";
 
-const wasm = new URL("./gofmt.wasm", import.meta.url);
+let wasm, wasmModule;
 
-export default function (init = fs.readFile(wasm)) {
-	return initAsync(init);
+export function initSync(buffer_or_module) {
+	if (wasm !== void 0) return wasm;
+
+	if (!(buffer_or_module instanceof WebAssembly.Module)) {
+		buffer_or_module = new WebAssembly.Module(buffer_or_module);
+	}
+
+	return finalize_init(
+		new WebAssembly.Instance(buffer_or_module),
+		buffer_or_module,
+	);
+}
+
+export default async function initAsync(init_input) {
+	if (wasm !== void 0) return wasm;
+
+	if (init_input === void 0) {
+		init_input = new URL("gofmt.wasm", import.meta.url);
+	}
+
+	if (typeof init_input === "string") {
+		init_input = new URL(init_input);
+	}
+
+	if (init_input instanceof URL && init_input.protocol === "file:") {
+		const [{ readFile }, { fileURLToPath }] = await Promise.all([
+			import("fs/promises"),
+			import("url"),
+		]);
+		init_input = readFile(fileURLToPath(init_input));
+	} else if (
+		(typeof Request === "function" && init_input instanceof Request) ||
+		init_input instanceof URL
+	) {
+		init_input = fetch(init_input);
+	}
+
+	const { instance, module } = await load(await init_input);
+
+	return finalize_init(instance, module);
 }
 
-export * from "./gofmt.js";
+async function load(module, imports) {
+	if (typeof Response === "function" && module instanceof Response) {
+		if (typeof WebAssembly.instantiateStreaming === "function") {
+			try {
+				return await WebAssembly.instantiateStreaming(module, imports);
+			} catch (e) {
+				const validResponse =
+					module.ok && expectedResponseType(module.type);
+
+				if (
+					validResponse &&
+					module.headers.get("Content-Type") !== "application/wasm"
+				) {
+					console.warn(
+						"`WebAssembly.instantiateStreaming` failed because your server does not serve Wasm with `application/wasm` MIME type. Falling back to `WebAssembly.instantiate` which is slower. Original error:\n",
+						e,
+					);
+				} else {
+					throw e;
+				}
+			}
+		}
+
+		const bytes = await module.arrayBuffer();
+		return await WebAssembly.instantiate(bytes, imports);
+	} else {
+		const instance = await WebAssembly.instantiate(module, imports);
+
+		if (instance instanceof WebAssembly.Instance) {
+			return { instance, module };
+		} else {
+			return instance;
+		}
+	}
+
+	function expectedResponseType(type) {
+		switch (type) {
+			case "basic":
+			case "cors":
+			case "default":
+				return true;
+		}
+		return false;
+	}
+}
+
+function finalize_init(instance, module) {
+	wasm = instance.exports, wasmModule = module;
+	wasm._initialize();
+	return wasm;
+}
+
+export function format(source) {
+	return _format(wasm, source);
+}

package/gofmt_vite.js

@@ -1,8 +1,9 @@
-import initAsync from "./gofmt.js";
+/* @ts-self-types="./gofmt_entry.d.ts" */
+import initAsync from "./gofmt_web.js";
 import wasm_url from "./gofmt.wasm?url";
 
 export default function (input = wasm_url) {
 	return initAsync(input);
 }
 
-export * from "./gofmt.js";
+export * from "./gofmt_web.js";

package/gofmt_web.js

@@ -0,0 +1,89 @@
+/* @ts-self-types="./gofmt_entry.d.ts" */
+import { format as _format } from "./gofmt.js";
+let wasm, wasmModule;
+
+async function load(module, imports) {
+	if (typeof Response === "function" && module instanceof Response) {
+		if (typeof WebAssembly.instantiateStreaming === "function") {
+			try {
+				return await WebAssembly.instantiateStreaming(module, imports);
+			} catch (e) {
+				const validResponse =
+					module.ok && expectedResponseType(module.type);
+
+				if (
+					validResponse &&
+					module.headers.get("Content-Type") !== "application/wasm"
+				) {
+					console.warn(
+						"`WebAssembly.instantiateStreaming` failed because your server does not serve Wasm with `application/wasm` MIME type. Falling back to `WebAssembly.instantiate` which is slower. Original error:\n",
+						e,
+					);
+				} else {
+					throw e;
+				}
+			}
+		}
+
+		const bytes = await module.arrayBuffer();
+		return await WebAssembly.instantiate(bytes, imports);
+	} else {
+		const instance = await WebAssembly.instantiate(module, imports);
+
+		if (instance instanceof WebAssembly.Instance) {
+			return { instance, module };
+		} else {
+			return instance;
+		}
+	}
+
+	function expectedResponseType(type) {
+		switch (type) {
+			case "basic":
+			case "cors":
+			case "default":
+				return true;
+		}
+		return false;
+	}
+}
+
+function finalize_init(instance, module) {
+	wasm = instance.exports, wasmModule = module;
+	wasm._initialize();
+	return wasm;
+}
+
+export function initSync(module) {
+	if (wasm !== void 0) return wasm;
+
+	if (!(module instanceof WebAssembly.Module)) {
+		module = new WebAssembly.Module(module);
+	}
+	const instance = new WebAssembly.Instance(module);
+	return finalize_init(instance, module);
+}
+
+export default async function initAsync(module_or_path) {
+	if (wasm !== void 0) return wasm;
+
+	if (module_or_path === void 0) {
+		module_or_path = new URL("gofmt.wasm", import.meta.url);
+	}
+
+	if (
+		typeof module_or_path === "string" ||
+		(typeof Request === "function" && module_or_path instanceof Request) ||
+		(typeof URL === "function" && module_or_path instanceof URL)
+	) {
+		module_or_path = fetch(module_or_path);
+	}
+
+	const { instance, module } = await load(await module_or_path);
+
+	return finalize_init(instance, module);
+}
+
+export function format(source) {
+	return _format(wasm, source);
+}

package/package.json

@@ -2,7 +2,7 @@
 	"name": "@wasm-fmt/gofmt",
 	"description": "A wasm based golang formatter",
 	"author": "magic-akari <akari.ccino@gamil.com>",
-	"version": "0.5.0",
+	"version": "0.5.1",
 	"license": "MIT",
 	"keywords": [
 		"wasm",
@@ -18,17 +18,14 @@
 		"url": "https://github.com/wasm-fmt/gofmt/issues"
 	},
 	"type": "module",
-	"main": "gofmt.js",
-	"module": "gofmt.js",
-	"types": "gofmt.d.ts",
 	"exports": {
 		".": {
-			"types": "./gofmt.d.ts",
+			"types": "./gofmt_entry.d.ts",
 			"node": "./gofmt_node.js",
-			"default": "./gofmt.js"
+			"default": "./gofmt_web.js"
 		},
 		"./vite": {
-			"types": "./gofmt.d.ts",
+			"types": "./gofmt_entry.d.ts",
 			"default": "./gofmt_vite.js"
 		},
 		"./package.json": "./package.json",
@@ -36,6 +33,7 @@
 	},
 	"scripts": {
 		"build": "./scripts/build.sh",
+		"test:go": "go test ./src -v",
 		"test:node": "node --test test_node/node.test.js",
 		"test:deno": "deno test test_deno --allow-read",
 		"test:bun": "bun test test_bun"
@@ -45,8 +43,5 @@
 	},
 	"publishConfig": {
 		"access": "public"
-	},
-	"devDependencies": {
-		"@ast-grep/napi": "0.40.0"
 	}
 }

package/gofmt.d.ts

@@ -1,10 +0,0 @@
-export type InitInput =
-	| RequestInfo
-	| URL
-	| Response
-	| BufferSource
-	| WebAssembly.Module;
-
-export default function initAsync(wasm_url?: InitInput): Promise<void>;
-export declare function initSync(module: BufferSource | WebAssembly.Module): void;
-export declare function format(input: string): string;