@wasm-fmt/shfmt 0.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 wasm-fmt
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,65 @@
+[![Test](https://github.com/wasm-fmt/shfmt/actions/workflows/test.yml/badge.svg)](https://github.com/wasm-fmt/shfmt/actions/workflows/test.yml)
+
+# Install
+
+[![npm](https://img.shields.io/npm/v/@wasm-fmt/shfmt)](https://www.npmjs.com/package/@wasm-fmt/shfmt)
+
+```bash
+npm install @wasm-fmt/shfmt
+```
+
+[![jsr.io](https://jsr.io/badges/@fmt/shfmt)](https://jsr.io/@fmt/shfmt)
+
+```bash
+npx jsr add @fmt/shfmt
+```
+
+# Usage
+
+```JavaScript
+import init, { format } from "@wasm-fmt/shfmt";
+
+await init();
+
+const source = `#!/bin/bash
+echo "hello world"
+`;
+
+const formatted = format(source);
+console.log(formatted);
+```
+
+With options:
+
+```JavaScript
+const formatted = format(source, "script.sh", {
+  indent: 2,
+  binaryNextLine: true,
+  switchCaseIndent: false,
+  spaceRedirects: true,
+  keepPadding: false,
+  funcNextLine: false,
+  minify: false,
+  simplify: true
+});
+```
+
+# Build from source
+
+```bash
+# 1. install Go https://go.dev/doc/install
+
+# 2. install TinyGo https://tinygo.org/getting-started/install/
+
+# 3. clone this repo
+git clone https://github.com/wasm-fmt/shfmt.git
+
+# 4. install dependencies inside the repo
+npm
+
+# 5. build
+npm run build
+
+# 6. test
+npm run test:node
+```

package/package.json

@@ -0,0 +1,55 @@
+{
+	"name": "@wasm-fmt/shfmt",
+	"description": "A wasm based shell script formatter",
+	"author": "magic-akari <akari.ccino@gmail.com>",
+	"version": "0.0.0",
+	"license": "MIT",
+	"keywords": [
+		"wasm",
+		"shell",
+		"formatter",
+		"shfmt",
+		"bash"
+	],
+	"repository": {
+		"type": "git",
+		"url": "https://github.com/wasm-fmt/shfmt"
+	},
+	"homepage": "https://github.com/wasm-fmt/shfmt",
+	"bugs": {
+		"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",
+			"node": "./shfmt_node.js",
+			"default": "./shfmt.js"
+		},
+		"./vite": {
+			"types": "./shfmt.d.ts",
+			"default": "./shfmt_vite.js"
+		},
+		"./package.json": "./package.json",
+		"./*": "./*"
+	},
+	"scripts": {
+		"build": "./scripts/build.sh",
+		"test:go": "go test -C src -v",
+		"test:node": "node --test test_node/shfmt.test.js",
+		"test:deno": "deno test test_deno --allow-read",
+		"test:bun": "bun test test_bun"
+	},
+	"engines": {
+		"node": ">=16.17.0"
+	},
+	"publishConfig": {
+		"access": "public"
+	},
+	"devDependencies": {
+		"@ast-grep/napi": "0.40.3"
+	}
+}

package/shfmt.d.ts

@@ -0,0 +1,56 @@
+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;
+};

package/shfmt.js

@@ -0,0 +1,434 @@
+/* @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 */
+				}
+			};
+
+			// 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;
+		}
+
+		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();
+			}
+		}
+
+		_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();
+			}
+		}
+
+		_makeFuncWrapper(id) {
+			const go = this;
+			return function () {
+				const event = { id: id, this: this, args: arguments };
+				go._pendingEvent = event;
+				go._resume();
+				return event.result;
+			};
+		}
+	}
+/**
+ * ================== End of wasm_exec.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) {
+				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, 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);
+}
+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;
+}

package/shfmt_node.js

@@ -0,0 +1,10 @@
+import fs from "node:fs/promises";
+import initAsync from "./shfmt.js";
+
+const wasm = new URL("./shfmt.wasm", import.meta.url);
+
+export default function (init = fs.readFile(wasm)) {
+	return initAsync(init);
+}
+
+export * from "./shfmt.js";

package/shfmt_vite.js

@@ -0,0 +1,8 @@
+import initAsync from "./shfmt.js";
+import wasm_url from "./shfmt.wasm?url";
+
+export default function (input = wasm_url) {
+	return initAsync(input);
+}
+
+export * from "./shfmt.js";