@hongdown/wasm 0.2.0-dev.0

package/dist/index.cjs

@@ -0,0 +1,508 @@
+let _wasm_loader = require("#wasm-loader");
+
+//#region pkg/hongdown.js
+let wasm;
+function addToExternrefTable0(obj) {
+	const idx = wasm.__externref_table_alloc();
+	wasm.__wbindgen_externrefs.set(idx, obj);
+	return idx;
+}
+function debugString(val) {
+	const type = typeof val;
+	if (type == "number" || type == "boolean" || val == null) return `${val}`;
+	if (type == "string") return `"${val}"`;
+	if (type == "symbol") {
+		const description = val.description;
+		if (description == null) return "Symbol";
+		else return `Symbol(${description})`;
+	}
+	if (type == "function") {
+		const name = val.name;
+		if (typeof name == "string" && name.length > 0) return `Function(${name})`;
+		else return "Function";
+	}
+	if (Array.isArray(val)) {
+		const length = val.length;
+		let debug = "[";
+		if (length > 0) debug += debugString(val[0]);
+		for (let i = 1; i < length; i++) debug += ", " + debugString(val[i]);
+		debug += "]";
+		return debug;
+	}
+	const builtInMatches = /\[object ([^\]]+)\]/.exec(toString.call(val));
+	let className;
+	if (builtInMatches && builtInMatches.length > 1) className = builtInMatches[1];
+	else return toString.call(val);
+	if (className == "Object") try {
+		return "Object(" + JSON.stringify(val) + ")";
+	} catch (_) {
+		return "Object";
+	}
+	if (val instanceof Error) return `${val.name}: ${val.message}\n${val.stack}`;
+	return className;
+}
+function getArrayU8FromWasm0(ptr, len) {
+	ptr = ptr >>> 0;
+	return getUint8ArrayMemory0().subarray(ptr / 1, ptr / 1 + len);
+}
+let cachedDataViewMemory0 = null;
+function getDataViewMemory0() {
+	if (cachedDataViewMemory0 === null || cachedDataViewMemory0.buffer.detached === true || cachedDataViewMemory0.buffer.detached === void 0 && cachedDataViewMemory0.buffer !== wasm.memory.buffer) cachedDataViewMemory0 = new DataView(wasm.memory.buffer);
+	return cachedDataViewMemory0;
+}
+function getStringFromWasm0(ptr, len) {
+	ptr = ptr >>> 0;
+	return decodeText(ptr, len);
+}
+let cachedUint8ArrayMemory0 = null;
+function getUint8ArrayMemory0() {
+	if (cachedUint8ArrayMemory0 === null || cachedUint8ArrayMemory0.byteLength === 0) cachedUint8ArrayMemory0 = new Uint8Array(wasm.memory.buffer);
+	return cachedUint8ArrayMemory0;
+}
+function handleError(f, args) {
+	try {
+		return f.apply(this, args);
+	} catch (e) {
+		const idx = addToExternrefTable0(e);
+		wasm.__wbindgen_exn_store(idx);
+	}
+}
+function isLikeNone(x) {
+	return x === void 0 || x === null;
+}
+function passStringToWasm0(arg, malloc, realloc) {
+	if (realloc === void 0) {
+		const buf = cachedTextEncoder.encode(arg);
+		const ptr$1 = malloc(buf.length, 1) >>> 0;
+		getUint8ArrayMemory0().subarray(ptr$1, ptr$1 + buf.length).set(buf);
+		WASM_VECTOR_LEN = buf.length;
+		return ptr$1;
+	}
+	let len = arg.length;
+	let ptr = malloc(len, 1) >>> 0;
+	const mem = getUint8ArrayMemory0();
+	let offset = 0;
+	for (; offset < len; offset++) {
+		const code = arg.charCodeAt(offset);
+		if (code > 127) break;
+		mem[ptr + offset] = code;
+	}
+	if (offset !== len) {
+		if (offset !== 0) arg = arg.slice(offset);
+		ptr = realloc(ptr, len, len = offset + arg.length * 3, 1) >>> 0;
+		const view = getUint8ArrayMemory0().subarray(ptr + offset, ptr + len);
+		const ret = cachedTextEncoder.encodeInto(arg, view);
+		offset += ret.written;
+		ptr = realloc(ptr, len, offset, 1) >>> 0;
+	}
+	WASM_VECTOR_LEN = offset;
+	return ptr;
+}
+function takeFromExternrefTable0(idx) {
+	const value = wasm.__wbindgen_externrefs.get(idx);
+	wasm.__externref_table_dealloc(idx);
+	return value;
+}
+let cachedTextDecoder = new TextDecoder("utf-8", {
+	ignoreBOM: true,
+	fatal: true
+});
+cachedTextDecoder.decode();
+const MAX_SAFARI_DECODE_BYTES = 2146435072;
+let numBytesDecoded = 0;
+function decodeText(ptr, len) {
+	numBytesDecoded += len;
+	if (numBytesDecoded >= MAX_SAFARI_DECODE_BYTES) {
+		cachedTextDecoder = new TextDecoder("utf-8", {
+			ignoreBOM: true,
+			fatal: true
+		});
+		cachedTextDecoder.decode();
+		numBytesDecoded = len;
+	}
+	return cachedTextDecoder.decode(getUint8ArrayMemory0().subarray(ptr, ptr + len));
+}
+const cachedTextEncoder = new TextEncoder();
+if (!("encodeInto" in cachedTextEncoder)) cachedTextEncoder.encodeInto = function(arg, view) {
+	const buf = cachedTextEncoder.encode(arg);
+	view.set(buf);
+	return {
+		read: arg.length,
+		written: buf.length
+	};
+};
+let WASM_VECTOR_LEN = 0;
+/**
+* Format Markdown according to Hong Minhee's style conventions.
+*
+* # Arguments
+*
+* * `input` - Markdown source to format
+* * `options` - Optional formatting options as a JavaScript object
+*
+* # Returns
+*
+* The formatted Markdown string.
+* @param {string} input
+* @param {any} options
+* @returns {string}
+*/
+function format$1(input, options) {
+	let deferred3_0;
+	let deferred3_1;
+	try {
+		const ptr0 = passStringToWasm0(input, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+		const len0 = WASM_VECTOR_LEN;
+		const ret = wasm.format(ptr0, len0, options);
+		var ptr2 = ret[0];
+		var len2 = ret[1];
+		if (ret[3]) {
+			ptr2 = 0;
+			len2 = 0;
+			throw takeFromExternrefTable0(ret[2]);
+		}
+		deferred3_0 = ptr2;
+		deferred3_1 = len2;
+		return getStringFromWasm0(ptr2, len2);
+	} finally {
+		wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
+	}
+}
+/**
+* Format Markdown and return both output and warnings.
+*
+* # Arguments
+*
+* * `input` - Markdown source to format
+* * `options` - Optional formatting options as a JavaScript object
+*
+* # Returns
+*
+* An object with `output` (formatted string) and `warnings` (array of warning objects).
+* @param {string} input
+* @param {any} options
+* @returns {any}
+*/
+function formatWithWarnings$1(input, options) {
+	const ptr0 = passStringToWasm0(input, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+	const len0 = WASM_VECTOR_LEN;
+	const ret = wasm.formatWithWarnings(ptr0, len0, options);
+	if (ret[2]) throw takeFromExternrefTable0(ret[1]);
+	return takeFromExternrefTable0(ret[0]);
+}
+const EXPECTED_RESPONSE_TYPES = new Set([
+	"basic",
+	"cors",
+	"default"
+]);
+async function __wbg_load(module$1, imports) {
+	if (typeof Response === "function" && module$1 instanceof Response) {
+		if (typeof WebAssembly.instantiateStreaming === "function") try {
+			return await WebAssembly.instantiateStreaming(module$1, imports);
+		} catch (e) {
+			if (module$1.ok && EXPECTED_RESPONSE_TYPES.has(module$1.type) && module$1.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$1.arrayBuffer();
+		return await WebAssembly.instantiate(bytes, imports);
+	} else {
+		const instance = await WebAssembly.instantiate(module$1, imports);
+		if (instance instanceof WebAssembly.Instance) return {
+			instance,
+			module: module$1
+		};
+		else return instance;
+	}
+}
+function __wbg_get_imports() {
+	const imports = {};
+	imports.wbg = {};
+	imports.wbg.__wbg_Error_52673b7de5a0ca89 = function(arg0, arg1) {
+		return Error(getStringFromWasm0(arg0, arg1));
+	};
+	imports.wbg.__wbg_Number_2d1dcfcf4ec51736 = function(arg0) {
+		return Number(arg0);
+	};
+	imports.wbg.__wbg_String_8f0eb39a4a4c2f66 = function(arg0, arg1) {
+		const ptr1 = passStringToWasm0(String(arg1), wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+		const len1 = WASM_VECTOR_LEN;
+		getDataViewMemory0().setInt32(arg0 + 4, len1, true);
+		getDataViewMemory0().setInt32(arg0 + 0, ptr1, true);
+	};
+	imports.wbg.__wbg___wbindgen_bigint_get_as_i64_6e32f5e6aff02e1d = function(arg0, arg1) {
+		const v = arg1;
+		const ret = typeof v === "bigint" ? v : void 0;
+		getDataViewMemory0().setBigInt64(arg0 + 8, isLikeNone(ret) ? BigInt(0) : ret, true);
+		getDataViewMemory0().setInt32(arg0 + 0, !isLikeNone(ret), true);
+	};
+	imports.wbg.__wbg___wbindgen_boolean_get_dea25b33882b895b = function(arg0) {
+		const v = arg0;
+		const ret = typeof v === "boolean" ? v : void 0;
+		return isLikeNone(ret) ? 16777215 : ret ? 1 : 0;
+	};
+	imports.wbg.__wbg___wbindgen_debug_string_adfb662ae34724b6 = function(arg0, arg1) {
+		const ptr1 = passStringToWasm0(debugString(arg1), wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+		const len1 = WASM_VECTOR_LEN;
+		getDataViewMemory0().setInt32(arg0 + 4, len1, true);
+		getDataViewMemory0().setInt32(arg0 + 0, ptr1, true);
+	};
+	imports.wbg.__wbg___wbindgen_in_0d3e1e8f0c669317 = function(arg0, arg1) {
+		return arg0 in arg1;
+	};
+	imports.wbg.__wbg___wbindgen_is_bigint_0e1a2e3f55cfae27 = function(arg0) {
+		return typeof arg0 === "bigint";
+	};
+	imports.wbg.__wbg___wbindgen_is_function_8d400b8b1af978cd = function(arg0) {
+		return typeof arg0 === "function";
+	};
+	imports.wbg.__wbg___wbindgen_is_null_dfda7d66506c95b5 = function(arg0) {
+		return arg0 === null;
+	};
+	imports.wbg.__wbg___wbindgen_is_object_ce774f3490692386 = function(arg0) {
+		const val = arg0;
+		return typeof val === "object" && val !== null;
+	};
+	imports.wbg.__wbg___wbindgen_is_undefined_f6b95eab589e0269 = function(arg0) {
+		return arg0 === void 0;
+	};
+	imports.wbg.__wbg___wbindgen_jsval_eq_b6101cc9cef1fe36 = function(arg0, arg1) {
+		return arg0 === arg1;
+	};
+	imports.wbg.__wbg___wbindgen_jsval_loose_eq_766057600fdd1b0d = function(arg0, arg1) {
+		return arg0 == arg1;
+	};
+	imports.wbg.__wbg___wbindgen_number_get_9619185a74197f95 = function(arg0, arg1) {
+		const obj = arg1;
+		const ret = typeof obj === "number" ? obj : void 0;
+		getDataViewMemory0().setFloat64(arg0 + 8, isLikeNone(ret) ? 0 : ret, true);
+		getDataViewMemory0().setInt32(arg0 + 0, !isLikeNone(ret), true);
+	};
+	imports.wbg.__wbg___wbindgen_string_get_a2a31e16edf96e42 = function(arg0, arg1) {
+		const obj = arg1;
+		const ret = typeof obj === "string" ? obj : void 0;
+		var ptr1 = isLikeNone(ret) ? 0 : passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+		var len1 = WASM_VECTOR_LEN;
+		getDataViewMemory0().setInt32(arg0 + 4, len1, true);
+		getDataViewMemory0().setInt32(arg0 + 0, ptr1, true);
+	};
+	imports.wbg.__wbg___wbindgen_throw_dd24417ed36fc46e = function(arg0, arg1) {
+		throw new Error(getStringFromWasm0(arg0, arg1));
+	};
+	imports.wbg.__wbg_call_abb4ff46ce38be40 = function() {
+		return handleError(function(arg0, arg1) {
+			return arg0.call(arg1);
+		}, arguments);
+	};
+	imports.wbg.__wbg_done_62ea16af4ce34b24 = function(arg0) {
+		return arg0.done;
+	};
+	imports.wbg.__wbg_entries_83c79938054e065f = function(arg0) {
+		return Object.entries(arg0);
+	};
+	imports.wbg.__wbg_get_6b7bd52aca3f9671 = function(arg0, arg1) {
+		return arg0[arg1 >>> 0];
+	};
+	imports.wbg.__wbg_get_af9dab7e9603ea93 = function() {
+		return handleError(function(arg0, arg1) {
+			return Reflect.get(arg0, arg1);
+		}, arguments);
+	};
+	imports.wbg.__wbg_get_with_ref_key_1dc361bd10053bfe = function(arg0, arg1) {
+		return arg0[arg1];
+	};
+	imports.wbg.__wbg_instanceof_ArrayBuffer_f3320d2419cd0355 = function(arg0) {
+		let result;
+		try {
+			result = arg0 instanceof ArrayBuffer;
+		} catch (_) {
+			result = false;
+		}
+		return result;
+	};
+	imports.wbg.__wbg_instanceof_Map_084be8da74364158 = function(arg0) {
+		let result;
+		try {
+			result = arg0 instanceof Map;
+		} catch (_) {
+			result = false;
+		}
+		return result;
+	};
+	imports.wbg.__wbg_instanceof_Uint8Array_da54ccc9d3e09434 = function(arg0) {
+		let result;
+		try {
+			result = arg0 instanceof Uint8Array;
+		} catch (_) {
+			result = false;
+		}
+		return result;
+	};
+	imports.wbg.__wbg_isArray_51fd9e6422c0a395 = function(arg0) {
+		return Array.isArray(arg0);
+	};
+	imports.wbg.__wbg_isSafeInteger_ae7d3f054d55fa16 = function(arg0) {
+		return Number.isSafeInteger(arg0);
+	};
+	imports.wbg.__wbg_iterator_27b7c8b35ab3e86b = function() {
+		return Symbol.iterator;
+	};
+	imports.wbg.__wbg_length_22ac23eaec9d8053 = function(arg0) {
+		return arg0.length;
+	};
+	imports.wbg.__wbg_length_d45040a40c570362 = function(arg0) {
+		return arg0.length;
+	};
+	imports.wbg.__wbg_new_1ba21ce319a06297 = function() {
+		return /* @__PURE__ */ new Object();
+	};
+	imports.wbg.__wbg_new_25f239778d6112b9 = function() {
+		return new Array();
+	};
+	imports.wbg.__wbg_new_6421f6084cc5bc5a = function(arg0) {
+		return new Uint8Array(arg0);
+	};
+	imports.wbg.__wbg_next_138a17bbf04e926c = function(arg0) {
+		return arg0.next;
+	};
+	imports.wbg.__wbg_next_3cfe5c0fe2a4cc53 = function() {
+		return handleError(function(arg0) {
+			return arg0.next();
+		}, arguments);
+	};
+	imports.wbg.__wbg_prototypesetcall_dfe9b766cdc1f1fd = function(arg0, arg1, arg2) {
+		Uint8Array.prototype.set.call(getArrayU8FromWasm0(arg0, arg1), arg2);
+	};
+	imports.wbg.__wbg_set_3f1d0b984ed272ed = function(arg0, arg1, arg2) {
+		arg0[arg1] = arg2;
+	};
+	imports.wbg.__wbg_set_7df433eea03a5c14 = function(arg0, arg1, arg2) {
+		arg0[arg1 >>> 0] = arg2;
+	};
+	imports.wbg.__wbg_value_57b7b035e117f7ee = function(arg0) {
+		return arg0.value;
+	};
+	imports.wbg.__wbindgen_cast_2241b6af4c4b2941 = function(arg0, arg1) {
+		return getStringFromWasm0(arg0, arg1);
+	};
+	imports.wbg.__wbindgen_cast_4625c577ab2ec9ee = function(arg0) {
+		return BigInt.asUintN(64, arg0);
+	};
+	imports.wbg.__wbindgen_cast_9ae0607507abb057 = function(arg0) {
+		return arg0;
+	};
+	imports.wbg.__wbindgen_cast_d6cd19b81560fd6e = function(arg0) {
+		return arg0;
+	};
+	imports.wbg.__wbindgen_init_externref_table = function() {
+		const table = wasm.__wbindgen_externrefs;
+		const offset = table.grow(4);
+		table.set(0, void 0);
+		table.set(offset + 0, void 0);
+		table.set(offset + 1, null);
+		table.set(offset + 2, true);
+		table.set(offset + 3, false);
+	};
+	return imports;
+}
+function __wbg_finalize_init(instance, module$1) {
+	wasm = instance.exports;
+	__wbg_init.__wbindgen_wasm_module = module$1;
+	cachedDataViewMemory0 = null;
+	cachedUint8ArrayMemory0 = null;
+	wasm.__wbindgen_start();
+	return wasm;
+}
+async function __wbg_init(module_or_path) {
+	if (wasm !== void 0) return wasm;
+	if (typeof module_or_path !== "undefined") if (Object.getPrototypeOf(module_or_path) === Object.prototype) ({module_or_path} = module_or_path);
+	else console.warn("using deprecated parameters for the initialization function; pass a single object instead");
+	if (typeof module_or_path === "undefined") module_or_path = new URL("hongdown_bg.wasm", require("url").pathToFileURL(__filename).href);
+	const imports = __wbg_get_imports();
+	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: module$1 } = await __wbg_load(await module_or_path, imports);
+	return __wbg_finalize_init(instance, module$1);
+}
+var hongdown_default = __wbg_init;
+
+//#endregion
+//#region src/index.ts
+let initialized = false;
+let initPromise = null;
+/**
+* Ensure the WASM module is initialized.
+* @internal
+*/
+async function ensureInitialized() {
+	if (initialized) return;
+	if (!initPromise) initPromise = (async () => {
+		await hongdown_default({ module_or_path: await (0, _wasm_loader.loadWasmBuffer)() });
+		initialized = true;
+	})();
+	await initPromise;
+}
+/**
+* Format Markdown according to Hong Minhee's style conventions.
+*
+* This function supports formatting directives embedded in HTML comments:
+*
+* - `<!-- hongdown-disable-file -->` - Disable formatting for the entire file.
+* - `<!-- hongdown-disable-next-line -->` - Disable formatting for the next block.
+* - `<!-- hongdown-disable-next-section -->` - Disable formatting until the next
+*   section heading.
+* - `<!-- hongdown-disable -->` - Disable formatting from this point.
+* - `<!-- hongdown-enable -->` - Re-enable formatting.
+*
+* @param input - Markdown source to format
+* @param options - Formatting options (all optional)
+* @returns The formatted Markdown string
+*
+* @example
+* ```typescript
+* import { format } from "@hongdown/wasm";
+*
+* // Basic usage
+* const result = await format("# Hello\nWorld");
+*
+* // With options
+* const result = await format(markdown, {
+*   lineWidth: 100,
+*   setextH1: false,
+*   fenceChar: "`",
+* });
+* ```
+*/
+async function format(input, options = {}) {
+	await ensureInitialized();
+	return format$1(input, options);
+}
+/**
+* Format Markdown and return both output and warnings.
+*
+* This is similar to {@link format}, but also returns any warnings generated
+* during formatting (e.g., inconsistent table column counts).
+*
+* @param input - Markdown source to format
+* @param options - Formatting options (all optional)
+* @returns Object with formatted output and any warnings
+*
+* @example
+* ```typescript
+* import { formatWithWarnings } from "@hongdown/wasm";
+*
+* const { output, warnings } = await formatWithWarnings(markdown);
+*
+* if (warnings.length > 0) {
+*   for (const warning of warnings) {
+*     console.warn(`Line ${warning.line}: ${warning.message}`);
+*   }
+* }
+* ```
+*/
+async function formatWithWarnings(input, options = {}) {
+	await ensureInitialized();
+	return formatWithWarnings$1(input, options);
+}
+
+//#endregion
+exports.format = format;
+exports.formatWithWarnings = formatWithWarnings;