@wasm-fmt/shfmt 0.0.0 → 0.1.0

package/package.json

@@ -2,7 +2,7 @@
 	"name": "@wasm-fmt/shfmt",
 	"description": "A wasm based shell script formatter",
 	"author": "magic-akari <akari.ccino@gmail.com>",
-	"version": "0.0.0",
+	"version": "0.1.0",
 	"license": "MIT",
 	"keywords": [
 		"wasm",
@@ -20,17 +20,14 @@
 		"url": "https://github.com/wasm-fmt/shfmt/issues"
 	},
 	"type": "module",
-	"main": "shfmt.js",
-	"module": "shfmt.js",
-	"types": "shfmt.d.ts",
 	"exports": {
 		".": {
-			"types": "./shfmt.d.ts",
+			"types": "./shfmt_entry.d.ts",
 			"node": "./shfmt_node.js",
-			"default": "./shfmt.js"
+			"default": "./shfmt_web.js"
 		},
 		"./vite": {
-			"types": "./shfmt.d.ts",
+			"types": "./shfmt_entry.d.ts",
 			"default": "./shfmt_vite.js"
 		},
 		"./package.json": "./package.json",
@@ -48,8 +45,5 @@
 	},
 	"publishConfig": {
 		"access": "public"
-	},
-	"devDependencies": {
-		"@ast-grep/napi": "0.40.3"
 	}
 }

package/shfmt.d.wasm.ts

@@ -0,0 +1,9 @@
+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;
+export declare function set_options(): void;
+export declare function set_path(): void;

package/shfmt.js

@@ -1,434 +1,61 @@
-/* @ts-self-types="./shfmt.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 "./shfmt.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
+ * @param {string} [path]
+ * @param {object} [options]
+ * @return {string}
+ */
+export function format(wasm, source, path, options) {
+	try {
+		if (options) {
+			writeStringToWasmMemory(wasm, JSON.stringify(options));
+			wasm.set_options();
 		}
 
-		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) { _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;
-				});
-
-				// 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();
-			}
+		if (path) {
+			writeStringToWasmMemory(wasm, path);
+			wasm.set_path();
 		}
 
-		_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();
-			}
+		writeStringToWasmMemory(wasm, source);
+		const result = wasm.format();
+		if (result === 0) {
+			return source;
 		}
 
-		_makeFuncWrapper(id) {
-			const go = this;
-			return function () {
-				const event = { id: id, this: this, args: arguments };
-				go._pendingEvent = event;
-				go._resume();
-				return event.result;
-			};
+		const ptr = wasm.output_ptr();
+		const length = wasm.output_len();
+		const text = readStringFromWasmMemory(wasm, ptr, length);
+
+		if (result === 1) {
+			return text;
 		}
+
+		throw new Error(text);
+	} finally {
+		wasm.dispose();
 	}
+}
+
 /**
- * ================== End of wasm_exec.js ==================
+ * @param {WASM} wasm
+ * @param {string} str
  */
-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) {
-				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 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 __finalize_init(instance, module) {
-	(wasm = instance.exports), (wasmModule = module);
-	return wasm;
-}
-
-export function initSync(module) {
-	if (wasm !== void 0) return wasm;
 
-	const go = new Go();
-	const imports = go.importObject;
-
-	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 !== void 0) return wasm;
-
-	if (input === void 0) input = new URL("shfmt.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);
-	}
-
-	const { instance, module } = await __load(await input, imports);
-
-	go.run(instance);
-	return __finalize_init(instance, module);
-}
-var _format = function () {
-	throw new Error("wasm not initialized.");
-};
-export function format(input, path, options) {
-	const [result, err] = _format(input, path, options);
-	if (err) {
-		throw new Error(result);
-	}
-	return result;
-}
+const encoder = new TextEncoder();
+const decoder = new TextDecoder();

package/shfmt_bundle.js

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

package/shfmt_entry.d.ts

@@ -0,0 +1,28 @@
+export type InitInput =
+	| RequestInfo
+	| URL
+	| Response
+	| BufferSource
+	| WebAssembly.Module;
+export type SyncInitInput = BufferSource | WebAssembly.Module;
+import type * as InitOutput from "./shfmt.d.wasm.ts";
+
+export default function initAsync(
+	init_input?: InitInput | Promise<InitInput>,
+): Promise<InitOutput>;
+export declare function initSync(buffer_or_module: SyncInitInput): InitOutput;
+export interface FormatOptions {
+	indent?: number;
+	binaryNextLine?: boolean;
+	switchCaseIndent?: boolean;
+	spaceRedirects?: boolean;
+	funcNextLine?: boolean;
+	minify?: boolean;
+	singleLine?: boolean;
+	simplify?: boolean;
+}
+export declare function format(
+	input: string,
+	path?: string,
+	options?: FormatOptions,
+): string;

package/shfmt_esm.js

@@ -0,0 +1,25 @@
+import source wasmModule from "./shfmt.wasm";
+import { format as _format } from "./shfmt.js";
+/**
+ * @import * as WASM from "./shfmt.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, path, options) {
+	return _format(wasm, source, path, options);
+}

package/shfmt_node.js

@@ -1,10 +1,101 @@
-import fs from "node:fs/promises";
-import initAsync from "./shfmt.js";
+/* @ts-self-types="./shfmt_entry.d.ts" */
+import { format as _format } from "./shfmt.js";
+let wasm, wasmModule;
 
-const wasm = new URL("./shfmt.wasm", import.meta.url);
+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);
 
-export default function (init = fs.readFile(wasm)) {
-	return initAsync(init);
+				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(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 * from "./shfmt.js";
+export default async function initAsync(init_input) {
+	if (wasm !== void 0) return wasm;
+
+	if (init_input === void 0) {
+		init_input = new URL("shfmt.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 function format(source, path, options) {
+	return _format(wasm, source, path, options);
+}

package/shfmt_vite.js

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

package/shfmt_web.js

@@ -0,0 +1,89 @@
+/* @ts-self-types="./shfmt_entry.d.ts" */
+import { format as _format } from "./shfmt.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("shfmt.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, path, options) {
+	return _format(wasm, source, path, options);
+}

package/shfmt.d.ts

@@ -1,56 +0,0 @@
-export type InitInput =
-	| RequestInfo
-	| URL
-	| Response
-	| BufferSource
-	| WebAssembly.Module;
-
-/**
- * Initializes the WASM module asynchronously.
- * @param wasm_url - Optional URL/path to the WASM file, or any valid InitInput
- */
-export default function initAsync(wasm_url?: InitInput): Promise<void>;
-/**
- * Initializes the WASM module synchronously.
- * @param module - The WASM module or buffer source
- */
-export declare function initSync(
-	module: BufferSource | WebAssembly.Module,
-): void;
-
-/**
- * Formats a shell script source code.
- * @param source - The shell script source code to format
- * @param path - Optional file path for language detection (e.g., ".bash", ".sh")
- * @param options - Formatting options
- * @returns The formatted shell script
- */
-export declare function format(
-	source: string,
-	path?: string,
-	options?: FormatOptions,
-): string;
-
-/**
- * Options for formatting shell scripts.
- * These options correspond to shfmt's command-line flags.
- * @see https://pkg.go.dev/mvdan.cc/sh/v3/syntax#PrinterOption
- */
-export type FormatOptions = {
-	/** Indent sets the number of spaces used for indentation. If set to 0, tabs will be used instead. */
-	indent?: number;
-	/** BinaryNextLine will make binary operators appear on the next line when a binary command, such as a pipe, spans multiple lines. A backslash will be used. */
-	binaryNextLine?: boolean;
-	/** SwitchCaseIndent will make switch cases be indented. As such, switch case bodies will be two levels deeper than the switch itself. */
-	switchCaseIndent?: boolean;
-	/** SpaceRedirects will put a space after most redirection operators. The exceptions are '>&', '<&', '>(', and '<('. */
-	spaceRedirects?: boolean;
-	/** FunctionNextLine will place a function's opening braces on the next line. */
-	funcNextLine?: boolean;
-	/** Minify will print programs in a way to save the most bytes possible. For example, indentation and comments are skipped, and extra whitespace is avoided when possible. */
-	minify?: boolean;
-	/** SingleLine will attempt to print programs in one line. For example, lists of commands or nested blocks do not use newlines in this mode. Note that some newlines must still appear, such as those following comments or around here-documents. */
-	singleLine?: boolean;
-	/** Simplify will perform a series of simplifications on the AST, to prepare it for printing. */
-	simplify?: boolean;
-};