@wasm-oj/server 0.2.0

package/dist/java-stage.mjs

@@ -0,0 +1,111 @@
+import { C as JAVA_COMPILE_CLASSLIB_ASSET_PATH, E as JAVA_RUNTIME_CLASSLIB_SHA256, S as JAVA_COMPILER_PACKAGE_SHA256, T as JAVA_RUNTIME_CLASSLIB_ASSET_PATH, b as JAVA_COMPILER_COMPRESSED_PACKAGE_SHA256, w as JAVA_COMPILE_CLASSLIB_SHA256, y as JAVA_COMPILER_ASSET_PATH } from "./chunks/toolchains-C6KuA1yM.js";
+import { n as javaMainClass, r as parseJavaDiagnostics, t as JAVA_COMPILE_TIMEOUT_MS } from "./chunks/java-toolchain-DajoRCHu.js";
+import { writeFileSync } from "node:fs";
+import { readFile } from "node:fs/promises";
+import { createHash } from "node:crypto";
+import path from "node:path";
+import { gunzipSync } from "node:zlib";
+import { Directory, Runtime, Wasmer, init } from "@wasmer/sdk/node";
+//#region src/server/java-stage.mjs
+var runtime;
+var packageHandle;
+var project;
+var toolchain;
+var exitCode = 0;
+try {
+	const encoded = JSON.parse(await readStdin());
+	if (encoded.request?.entry === void 0) throw new Error("The Java compiler stage received no entry file.");
+	await init({ log: "error" });
+	runtime = new Runtime({ registry: null });
+	const compilerBytes = await loadCompiler(requiredToolchainAsset(encoded, JAVA_COMPILER_ASSET_PATH), encoded.verifiedToolchain === true);
+	packageHandle = await Wasmer.fromFile(compilerBytes, runtime);
+	const command = packageHandle.commands["java-compiler"];
+	if (!command) throw new Error("The pinned Java compiler package does not expose java-compiler.");
+	project = new Directory(Object.fromEntries(encoded.request.files.map((file) => [`/${file.path}`, file.content])));
+	await project.createDir("/build");
+	toolchain = new Directory({
+		"/compile-classlib-teavm.bin": await loadRaw(requiredToolchainAsset(encoded, JAVA_COMPILE_CLASSLIB_ASSET_PATH), JAVA_COMPILE_CLASSLIB_SHA256, encoded.verifiedToolchain === true),
+		"/runtime-classlib-teavm.bin": await loadRaw(requiredToolchainAsset(encoded, JAVA_RUNTIME_CLASSLIB_ASSET_PATH), JAVA_RUNTIME_CLASSLIB_SHA256, encoded.verifiedToolchain === true)
+	});
+	const entrySource = encoded.request.files.find((file) => file.path === encoded.request.entry);
+	if (!entrySource) throw new Error(`Java entry '${encoded.request.entry}' does not exist.`);
+	const output = await withTimeout((await command.run({
+		args: [
+			"/toolchain/compile-classlib-teavm.bin",
+			"/toolchain/runtime-classlib-teavm.bin",
+			javaMainClass(encoded.request.entry, entrySource.content),
+			"/project/build/app.wasm",
+			...encoded.request.files.filter((file) => file.path.endsWith(".java")).map((file) => `/project/${file.path}`)
+		],
+		mount: {
+			"/project": project,
+			"/toolchain": toolchain
+		}
+	})).wait(), JAVA_COMPILE_TIMEOUT_MS);
+	const diagnostics = parseJavaDiagnostics(`${output.stderr}\n${output.stdout}`, encoded.request.entry);
+	let wasmBase64;
+	if (output.ok) {
+		const wasm = await project.readFile("/build/app.wasm");
+		await WebAssembly.compile(wasm);
+		wasmBase64 = Buffer.from(wasm).toString("base64");
+	}
+	writeResult({
+		success: output.ok && typeof wasmBase64 === "string",
+		wasmBase64,
+		stdout: output.stdout,
+		stderr: output.stderr,
+		diagnostics
+	});
+} catch (error) {
+	writeResult(void 0, error instanceof Error ? error.message : String(error));
+	exitCode = 1;
+} finally {
+	toolchain?.free();
+	project?.free();
+	packageHandle?.free();
+	runtime?.free();
+	setTimeout(() => process.exit(exitCode), 10);
+}
+async function loadCompiler(file, verified) {
+	const compressed = await readFile(file);
+	if (!verified) verifyDigest(file, compressed, JAVA_COMPILER_COMPRESSED_PACKAGE_SHA256);
+	const bytes = new Uint8Array(gunzipSync(compressed));
+	if (!verified) verifyDigest(file, bytes, JAVA_COMPILER_PACKAGE_SHA256);
+	return bytes;
+}
+async function loadRaw(file, expected, verified) {
+	const bytes = new Uint8Array(await readFile(file));
+	if (!verified) verifyDigest(file, bytes, expected);
+	return bytes;
+}
+function requiredToolchainAsset(encoded, assetPath) {
+	const file = encoded?.toolchainAssets?.[assetPath];
+	if (typeof file !== "string" || !path.isAbsolute(file)) throw new Error(`The Java compiler stage did not receive absolute asset '${assetPath}'.`);
+	return file;
+}
+function verifyDigest(label, bytes, expected) {
+	const actual = createHash("sha256").update(bytes).digest("hex");
+	if (actual !== expected) throw new Error(`Pinned Java asset '${label}' has digest ${actual}; expected ${expected}.`);
+}
+function withTimeout(promise, timeoutMs) {
+	let timer;
+	return Promise.race([promise, new Promise((_, reject) => {
+		timer = setTimeout(() => reject(/* @__PURE__ */ new Error(`Java compilation exceeded ${timeoutMs} ms.`)), timeoutMs);
+	})]).finally(() => clearTimeout(timer));
+}
+function writeResult(result, error) {
+	writeFileSync(3, JSON.stringify(result ? {
+		ok: true,
+		result
+	} : {
+		ok: false,
+		error
+	}));
+}
+async function readStdin() {
+	const chunks = [];
+	for await (const chunk of process.stdin) chunks.push(chunk);
+	return Buffer.concat(chunks).toString("utf8");
+}
+//#endregion
+export {};

package/dist/python-stage.mjs

@@ -0,0 +1,90 @@
+import { A as PYTHON_PACKAGE_ASSET_PATH, O as PYTHON_COMPRESSED_PACKAGE_SHA256, j as PYTHON_PACKAGE_SHA256, k as PYTHON_PACKAGE } from "./chunks/toolchains-C6KuA1yM.js";
+import { t as PYTHON_COMPILE_TIMEOUT_MS } from "./chunks/python-toolchain-Dx834o2A.js";
+import { writeFileSync } from "node:fs";
+import { readFile } from "node:fs/promises";
+import { createHash } from "node:crypto";
+import path from "node:path";
+import { gunzipSync } from "node:zlib";
+import { Directory, Runtime, Wasmer, init } from "@wasmer/sdk/node";
+//#region src/server/python-stage.mjs
+var runtime;
+var exitCode = 0;
+try {
+	const encoded = JSON.parse(await readStdin());
+	await init({ log: "warn" });
+	runtime = new Runtime({ registry: null });
+	const pythonFiles = encoded.request.files.filter((file) => file.path.endsWith(".py"));
+	const project = new Directory(Object.fromEntries(encoded.request.files.map((file) => [`/${file.path}`, file.content])));
+	await project.createDir("/build");
+	const packagePath = encoded?.toolchainAssets?.[PYTHON_PACKAGE_ASSET_PATH];
+	if (typeof packagePath !== "string" || !path.isAbsolute(packagePath)) throw new Error(`The Python compiler stage did not receive absolute asset '${PYTHON_PACKAGE_ASSET_PATH}'.`);
+	const compressed = await readFile(packagePath);
+	if (encoded.verifiedToolchain !== true) verifyDigest(packagePath, compressed, PYTHON_COMPRESSED_PACKAGE_SHA256);
+	const packageBytes = uint8View(gunzipSync(compressed));
+	if (encoded.verifiedToolchain !== true) verifyDigest(packagePath, packageBytes, PYTHON_PACKAGE_SHA256);
+	const command = (await Wasmer.fromFile(packageBytes, runtime)).commands.python;
+	if (!command) throw new Error(`Package '${PYTHON_PACKAGE}' does not expose python.`);
+	const instance = await command.run({
+		args: ["-c", compileScript(pythonFiles.map((file) => file.path))],
+		cwd: "/project",
+		env: {
+			PYTHONHOME: "/usr/local",
+			PYTHONHASHSEED: "0",
+			PYTHONDONTWRITEBYTECODE: "1"
+		},
+		mount: { "/project": project }
+	});
+	let timer;
+	const output = await Promise.race([instance.wait(), new Promise((_, reject) => {
+		timer = setTimeout(() => reject(/* @__PURE__ */ new Error(`Python compilation exceeded ${PYTHON_COMPILE_TIMEOUT_MS} ms.`)), PYTHON_COMPILE_TIMEOUT_MS);
+	})]);
+	clearTimeout(timer);
+	const bytecodeBase64 = {};
+	if (output.ok) for (const file of pythonFiles) {
+		const compiledPath = `build/${file.path.replace(/\.py$/, ".pyc")}`;
+		bytecodeBase64[compiledPath] = Buffer.from(await project.readFile(`/${compiledPath}`)).toString("base64");
+	}
+	writeFileSync(3, JSON.stringify({
+		ok: true,
+		result: {
+			success: output.ok,
+			bytecodeBase64,
+			stdout: output.stdout,
+			stderr: output.stderr,
+			diagnostics: []
+		}
+	}));
+} catch (error) {
+	writeFileSync(3, JSON.stringify({
+		ok: false,
+		error: error instanceof Error ? error.message : String(error)
+	}));
+	exitCode = 1;
+} finally {
+	runtime?.free();
+	setTimeout(() => process.exit(exitCode), 10);
+}
+function verifyDigest(filename, bytes, expected) {
+	const actual = createHash("sha256").update(bytes).digest("hex");
+	if (actual !== expected) throw new Error(`Pinned Python package '${filename}' has digest ${actual}; expected ${expected}.`);
+}
+function uint8View(bytes) {
+	return new Uint8Array(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+}
+function compileScript(files) {
+	return [
+		"import pathlib, py_compile",
+		`files = ${JSON.stringify(files)}`,
+		"for name in files:",
+		"    output = pathlib.Path('/project/build') / pathlib.Path(name).with_suffix('.pyc')",
+		"    output.parent.mkdir(parents=True, exist_ok=True)",
+		"    py_compile.compile('/project/' + name, cfile=str(output), doraise=True, invalidation_mode=py_compile.PycInvalidationMode.CHECKED_HASH)"
+	].join("\n");
+}
+async function readStdin() {
+	const chunks = [];
+	for await (const chunk of process.stdin) chunks.push(chunk);
+	return Buffer.concat(chunks).toString("utf8");
+}
+//#endregion
+export {};

package/dist/rustc-stage.mjs

@@ -0,0 +1,301 @@
+import { a as deterministicRustLinkerEnvironment, c as RUST_FINAL_OUTPUT_PATH, d as instantiateRustLinkerArguments, f as MountedOutputStabilityObserver, i as deterministicRustCompilerEnvironment, l as RUST_LINKER_COMMAND, n as RUST_TOOLCHAIN, o as rustcDependencyArguments, r as decodeRustToolchainManifest, s as rustcObjectArguments, t as RUST_COMPILE_TIMEOUT_MS, u as RUST_OBJECT_PATH } from "./chunks/rust-toolchain-CJ3sMxPE.js";
+import { writeFileSync } from "node:fs";
+import { readFile } from "node:fs/promises";
+import { createHash } from "node:crypto";
+import path from "node:path";
+import { gunzipSync } from "node:zlib";
+import { Directory, Runtime, Wasmer, init } from "@wasmer/sdk/node";
+//#region src/compiler/rust-allocator-bitcode.ts
+var ALLOCATOR_BITCODE_BASENAME = /^main\.[a-z0-9]+\.rcgu\.bc$/i;
+function selectRustAllocatorBitcodeName(names) {
+	const matches = names.filter((name) => ALLOCATOR_BITCODE_BASENAME.test(name)).sort();
+	if (matches.length > 1) throw new Error(`rustc emitted multiple allocator bitcode modules: ${matches.join(", ")}.`);
+	return matches[0];
+}
+function isLlvmBitcode(bytes) {
+	if (bytes.byteLength < 4) return false;
+	const rawBitcode = bytes[0] === 66 && bytes[1] === 67 && bytes[2] === 192 && bytes[3] === 222;
+	const bitcodeWrapper = bytes[0] === 222 && bytes[1] === 192 && bytes[2] === 23 && bytes[3] === 11;
+	return rawBitcode || bitcodeWrapper;
+}
+//#endregion
+//#region src/server/rustc-stage.mjs
+var OUTPUT_QUIET_PERIOD_MS = 50;
+var runtime;
+var pkg;
+var rustc;
+var linker;
+var work;
+var exitCode = 0;
+try {
+	const encoded = JSON.parse(await readStdin());
+	await init({ log: "warn" });
+	runtime = new Runtime({ registry: null });
+	const [packageBytes, manifest] = await Promise.all([loadRustPackage(requiredToolchainAsset(encoded, RUST_TOOLCHAIN.packageAsset), encoded.verifiedToolchain === true), loadRustManifest(requiredToolchainAsset(encoded, RUST_TOOLCHAIN.manifestAsset), encoded.verifiedToolchain === true)]);
+	pkg = await Wasmer.fromFile(packageBytes, runtime);
+	rustc = pkg.commands.rustc;
+	if (!rustc) throw new Error("The pinned Rust WebC does not expose its rustc command.");
+	linker = pkg.commands[RUST_LINKER_COMMAND];
+	if (!linker) throw new Error(`The pinned Rust WebC does not expose its ${RUST_LINKER_COMMAND} command.`);
+	work = new Directory(Object.fromEntries(encoded.request.files.map((file) => [`/${file.path}`, file.content])));
+	await work.createDir("/build");
+	await work.createDir("/build/deps");
+	let dependencyStdout = "";
+	let dependencyStderr = "";
+	let dependencyFailed = false;
+	for (const dependency of encoded.request.dependencies ?? []) {
+		const output = await runObservedStage({
+			command: rustc,
+			args: rustcDependencyArguments(dependency, encoded.request.optimization),
+			env: deterministicRustCompilerEnvironment(),
+			work,
+			outputPath: dependency.outputPath,
+			stage: `rustc dependency ${dependency.id}`,
+			hasTerminalError: (stderr) => parseRustDiagnostics(stderr, encoded.request.entry).some((diagnostic) => diagnostic.severity === "error"),
+			outputValidator: isRustArchive
+		});
+		dependencyStdout += output.stdout;
+		dependencyStderr += output.stderr;
+		if (!output.success) {
+			dependencyFailed = true;
+			break;
+		}
+	}
+	if (dependencyFailed) writeResult({
+		success: false,
+		stdout: dependencyStdout,
+		stderr: dependencyStderr,
+		diagnostics: parseRustDiagnostics(dependencyStderr, encoded.request.entry)
+	});
+	else {
+		const compiled = await runObservedStage({
+			command: rustc,
+			args: rustcObjectArguments(encoded.request.entry, encoded.request.optimization, encoded.request.rootExterns),
+			env: deterministicRustCompilerEnvironment(),
+			work,
+			outputPath: RUST_OBJECT_PATH,
+			stage: "rustc",
+			hasTerminalError: (stderr) => parseRustDiagnostics(stderr, encoded.request.entry).some((diagnostic) => diagnostic.severity === "error"),
+			requiresAllocatorBitcode: true
+		});
+		const diagnostics = parseRustDiagnostics(`${dependencyStderr}${compiled.stderr}`, encoded.request.entry);
+		if (!compiled.success) writeResult({
+			success: false,
+			stdout: `${dependencyStdout}${compiled.stdout}`,
+			stderr: `${dependencyStderr}${compiled.stderr}`,
+			diagnostics
+		});
+		else {
+			const linkerArguments = instantiateRustLinkerArguments(manifest.linkerArguments, encoded.request.optimization, requireAllocatorBitcodePath(compiled));
+			const objectIndex = linkerArguments.indexOf(RUST_OBJECT_PATH);
+			if (objectIndex < 0) throw new Error("Pinned Rust linker arguments omit the submission object.");
+			const libraries = [...encoded.request.dependencies ?? []].reverse().map((item) => item.outputPath);
+			if (libraries.length > 0) linkerArguments.splice(objectIndex + 1, 0, ...libraries);
+			const linked = await runObservedStage({
+				command: linker,
+				args: linkerArguments,
+				env: deterministicRustLinkerEnvironment(),
+				work,
+				outputPath: RUST_FINAL_OUTPUT_PATH,
+				stage: "wasm-ld",
+				hasTerminalError: (stderr) => /(?:wasm-ld|lld): error:/i.test(stderr)
+			});
+			writeResult({
+				success: linked.success && Boolean(linked.bytes),
+				wasmBase64: linked.bytes ? Buffer.from(linked.bytes).toString("base64") : void 0,
+				stdout: `${dependencyStdout}${compiled.stdout}${linked.stdout}`,
+				stderr: `${dependencyStderr}${compiled.stderr}${linked.stderr}`,
+				diagnostics
+			});
+		}
+	}
+} catch (error) {
+	writeFileSync(3, JSON.stringify({
+		ok: false,
+		error: error instanceof Error ? error.message : String(error)
+	}));
+	exitCode = 1;
+} finally {
+	work?.free();
+	rustc?.free();
+	linker?.free();
+	pkg?.free();
+	runtime?.free();
+	setTimeout(() => process.exit(exitCode), 10);
+}
+function writeResult(result) {
+	writeFileSync(3, JSON.stringify({
+		ok: true,
+		result
+	}));
+}
+async function runObservedStage({ command, args, env, work, outputPath, stage, hasTerminalError, requiresAllocatorBitcode = false, outputValidator = (bytes) => WebAssembly.validate(bytes) }) {
+	const instance = await command.run({
+		args,
+		env,
+		mount: { "/work": work },
+		cwd: "/work"
+	});
+	const stdout = captureReadable(instance.stdout);
+	const stderr = captureReadable(instance.stderr);
+	const outputStability = new MountedOutputStabilityObserver();
+	let allocatorStability = new MountedOutputStabilityObserver();
+	let allocatorCandidatePath;
+	const deadline = performance.now() + RUST_COMPILE_TIMEOUT_MS;
+	try {
+		while (performance.now() < deadline) {
+			const stderrText = stderr.text();
+			const quiet = stdout.quietFor(OUTPUT_QUIET_PERIOD_MS) && stderr.quietFor(OUTPUT_QUIET_PERIOD_MS);
+			const observedAt = performance.now();
+			const bytes = outputStability.observe(await readValidOutput(work, outputPath, outputValidator), observedAt);
+			const allocator = requiresAllocatorBitcode ? await readRustAllocatorBitcode(work) : void 0;
+			if (allocator?.path !== allocatorCandidatePath) {
+				allocatorCandidatePath = allocator?.path;
+				allocatorStability = new MountedOutputStabilityObserver();
+			}
+			const allocatorBytes = requiresAllocatorBitcode ? allocatorStability.observe(allocator?.bytes, observedAt) : void 0;
+			if (bytes && (!requiresAllocatorBitcode || Boolean(allocatorBytes && allocatorCandidatePath)) && quiet) {
+				await new Promise((resolve) => setTimeout(resolve, 0));
+				return {
+					success: true,
+					bytes,
+					allocatorBitcodePath: allocatorCandidatePath,
+					stdout: stdout.text(),
+					stderr: stderr.text()
+				};
+			}
+			if (quiet && hasTerminalError(stderrText)) return {
+				success: false,
+				stdout: stdout.text(),
+				stderr: stderrText
+			};
+			await new Promise((resolve) => setTimeout(resolve, 5));
+		}
+		throw new Error(`${stage} exceeded ${RUST_COMPILE_TIMEOUT_MS} ms.`);
+	} finally {
+		await Promise.all([stdout.cancel(), stderr.cancel()]);
+		instance.free();
+	}
+}
+function requireAllocatorBitcodePath(observation) {
+	if (!observation.allocatorBitcodePath) throw new Error("rustc completed without its allocator bitcode module.");
+	return observation.allocatorBitcodePath;
+}
+function captureReadable(stream) {
+	const reader = stream.getReader();
+	const chunks = [];
+	let lastUpdate = performance.now();
+	(async () => {
+		try {
+			while (true) {
+				const result = await reader.read();
+				if (result.done) return;
+				const bytes = result.value instanceof Uint8Array ? result.value : new Uint8Array(result.value);
+				chunks.push(bytes.slice());
+				lastUpdate = performance.now();
+			}
+		} catch {}
+	})();
+	return {
+		text: () => new TextDecoder().decode(concatenate(chunks)),
+		quietFor: (milliseconds) => performance.now() - lastUpdate >= milliseconds,
+		cancel: async () => {
+			try {
+				await reader.cancel();
+			} catch {}
+		}
+	};
+}
+function concatenate(chunks) {
+	const output = new Uint8Array(chunks.reduce((total, chunk) => total + chunk.byteLength, 0));
+	let offset = 0;
+	for (const chunk of chunks) {
+		output.set(chunk, offset);
+		offset += chunk.byteLength;
+	}
+	return output;
+}
+async function readValidOutput(work, guestPath, validator) {
+	const mountRelativePath = guestPath.startsWith("/work/") ? guestPath.slice(5) : guestPath;
+	try {
+		const bytes = (await work.readFile(mountRelativePath)).slice();
+		return bytes.byteLength > 8 && validator(bytes) ? bytes : void 0;
+	} catch {
+		return;
+	}
+}
+function isRustArchive(bytes) {
+	return bytes.byteLength > 8 && new TextDecoder().decode(bytes.subarray(0, 8)) === "!<arch>\n";
+}
+async function readRustAllocatorBitcode(work) {
+	try {
+		const name = selectRustAllocatorBitcodeName((await work.readDir("/build")).map((entry) => entry.name));
+		if (!name) return void 0;
+		const bytes = (await work.readFile(`/build/${name}`)).slice();
+		return isLlvmBitcode(bytes) ? {
+			path: `/work/build/${name}`,
+			bytes
+		} : void 0;
+	} catch (error) {
+		if (error instanceof Error && error.message.startsWith("rustc emitted multiple")) throw error;
+		return;
+	}
+}
+async function loadRustPackage(file, verifiedToolchain) {
+	const compressed = await readFile(file);
+	if (!verifiedToolchain) verifyDigest(file, compressed, RUST_TOOLCHAIN.packageCompressedSha256);
+	const bytes = uint8View(gunzipSync(compressed));
+	if (!verifiedToolchain) verifyDigest("decompressed Rust WebC", bytes, RUST_TOOLCHAIN.packageSha256);
+	return bytes;
+}
+async function loadRustManifest(file, verifiedToolchain) {
+	const bytes = new Uint8Array(await readFile(file));
+	if (!verifiedToolchain) verifyDigest(file, bytes, RUST_TOOLCHAIN.manifestSha256);
+	return decodeRustToolchainManifest(bytes);
+}
+function requiredToolchainAsset(encoded, assetPath) {
+	const file = encoded?.toolchainAssets?.[assetPath];
+	if (typeof file !== "string" || !path.isAbsolute(file)) throw new Error(`The Rust compiler stage did not receive absolute asset '${assetPath}'.`);
+	return file;
+}
+function verifyDigest(filename, bytes, expected) {
+	const actual = createHash("sha256").update(bytes).digest("hex");
+	if (actual !== expected) throw new Error(`Pinned Rust toolchain asset '${filename}' has digest ${actual}; expected ${expected}.`);
+}
+function uint8View(bytes) {
+	return new Uint8Array(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+}
+async function readStdin() {
+	const chunks = [];
+	for await (const chunk of process.stdin) chunks.push(chunk);
+	return Buffer.concat(chunks).toString("utf8");
+}
+function parseRustDiagnostics(output, entry) {
+	const diagnostics = [];
+	for (const line of output.split(/\r?\n/)) {
+		if (!line.startsWith("{")) continue;
+		let value;
+		try {
+			value = JSON.parse(line);
+		} catch {
+			continue;
+		}
+		if (value?.$message_type !== "diagnostic" || typeof value.message !== "string") continue;
+		const spans = Array.isArray(value.spans) ? value.spans : [];
+		const location = spans.find((span) => span?.is_primary) ?? spans[0];
+		diagnostics.push({
+			severity: value.level === "warning" ? "warning" : value.level === "note" ? "info" : "error",
+			message: value.message,
+			file: String(location?.file_name ?? entry).replace(/^\/work\//, ""),
+			line: Number(location?.line_start ?? 1),
+			column: Number(location?.column_start ?? 1),
+			endLine: location?.line_end,
+			endColumn: location?.column_end,
+			source: "rustc",
+			code: value.code?.code
+		});
+	}
+	return diagnostics;
+}
+//#endregion
+export {};