typst-wasm 0.0.1-alpha

package/dist/index.js

@@ -0,0 +1,746 @@
+import { loadWasmModule, toWasmCompileOptions } from "./wasm.js";
+import { parseTarGzip } from "nanotar";
+
+export * from "@typst-wasm/fonts"
+
+//#region src/webassembly-jspi.ts
+const getJspiWebAssembly = () => WebAssembly;
+
+//#endregion
+//#region src/backend-support.ts
+const supportsWorkerBackend = () => typeof Worker !== "undefined" && typeof SharedArrayBuffer !== "undefined" && typeof Atomics !== "undefined" && typeof Atomics.wait === "function";
+const supportsJspiBackend = () => {
+	const wasm = getJspiWebAssembly();
+	return typeof wasm.Suspending === "function" && typeof wasm.promising === "function";
+};
+
+//#endregion
+//#region src/errors.ts
+var TypstError = class extends Error {
+	constructor(message, options) {
+		super(message, options);
+		this.name = new.target.name;
+	}
+};
+var CompileError = class extends TypstError {
+	diagnostics;
+	constructor(message, options = {}) {
+		super(message, { cause: options.cause });
+		this.diagnostics = options.diagnostics ?? [];
+	}
+};
+var CompilerNotInitializedError = class extends TypstError {};
+var CompilerDisposedError = class extends TypstError {};
+var FontLoadError = class extends TypstError {
+	fontName;
+	constructor(fontName, cause) {
+		super(`Failed to load font "${fontName}"`, { cause });
+		this.fontName = fontName;
+	}
+};
+var FetchError = class extends TypstError {
+	path;
+	constructor(path, cause) {
+		super(`Failed to fetch "${path}"`, { cause });
+		this.path = path;
+	}
+};
+var PackageParseError = class extends TypstError {
+	spec;
+	constructor(spec, message) {
+		super(message);
+		this.spec = spec;
+	}
+};
+var PackageFetchError = class extends TypstError {
+	url;
+	constructor(url, cause) {
+		super(`Failed to fetch package: ${url}`, { cause });
+		this.url = url;
+	}
+};
+var FileNotFoundError = class extends TypstError {
+	filePath;
+	constructor(filePath) {
+		super(`File not found: ${filePath}`);
+		this.filePath = filePath;
+	}
+};
+var WorkerError = class extends TypstError {};
+
+//#endregion
+//#region src/direct-service.ts
+const MAX_FETCH_ATTEMPTS = 3;
+const textDecoder = new TextDecoder();
+const retry = async (task, maxAttempts) => {
+	let lastError;
+	for (let attempt = 0; attempt < maxAttempts; attempt += 1) try {
+		return await task();
+	} catch (error) {
+		lastError = error;
+	}
+	throw lastError ?? /* @__PURE__ */ new Error("Unknown host fetch error");
+};
+var DirectService = class {
+	disposed = false;
+	initPromise = null;
+	compiler = null;
+	wasmExports = null;
+	compileAsync = null;
+	constructor(packageManager, fetchImpl = fetch) {
+		this.packageManager = packageManager;
+		this.fetchImpl = fetchImpl;
+	}
+	async init(moduleOrPath) {
+		this.assertNotDisposed();
+		this.initPromise ??= this.initDirect(moduleOrPath);
+		await this.initPromise;
+	}
+	async dispose() {
+		this.disposed = true;
+		if (this.compiler) this.compiler.free();
+		this.compiler = null;
+		this.wasmExports = null;
+		this.compileAsync = null;
+	}
+	async addFont(data) {
+		this.withCompiler((compiler) => void compiler.add_font(data), "add_font");
+	}
+	async addFile(path, data) {
+		this.withCompiler((compiler) => void compiler.add_file(path, data), "add_file");
+	}
+	async addSource(path, text) {
+		this.withCompiler((compiler) => void compiler.add_source(path, text), "add_source");
+	}
+	async removeFile(path) {
+		this.withCompiler((compiler) => void compiler.remove_file(path), "remove_file");
+	}
+	async clearFiles() {
+		this.withCompiler((compiler) => void compiler.clear_files(), "clear_files");
+	}
+	async listFiles() {
+		return this.withCompiler((compiler) => compiler.list_files(), "list_files");
+	}
+	async hasFile(path) {
+		return this.withCompiler((compiler) => compiler.has_file(path), "has_file");
+	}
+	async setMain(path) {
+		this.withCompiler((compiler) => void compiler.set_main(path), "set_main");
+	}
+	async compile(options) {
+		this.assertNotDisposed();
+		const compiler = this.compiler;
+		const wasmExports = this.wasmExports;
+		const compile = this.compileAsync;
+		if (!compiler || !wasmExports || !compile) throw new CompilerNotInitializedError("Compiler not initialized");
+		let ret;
+		try {
+			ret = await compile(compiler.__wbg_ptr, options);
+		} catch (cause) {
+			throw new WorkerError("Direct command failed: compile", { cause });
+		}
+		if (ret[2]) throw this.takeExternref(wasmExports, ret[1]);
+		return this.takeExternref(wasmExports, ret[0]);
+	}
+	async initDirect(moduleOrPath) {
+		if (!supportsJspiBackend()) throw new WorkerError("JSPI is unavailable in this runtime");
+		const wasmModule = await loadWasmModule();
+		const { Suspending, promising } = getJspiWebAssembly();
+		if (!Suspending || !promising) throw new WorkerError("JSPI is unavailable in this runtime");
+		const suspending = new Suspending(this.hostFetch);
+		const wasmExports = await wasmModule.default({
+			module_or_path: moduleOrPath,
+			imports: { bridge: { host_fetch: suspending } }
+		});
+		this.wasmExports = wasmExports;
+		this.compileAsync = promising(wasmExports.typstcompiler_compile);
+		this.compiler = new wasmModule.TypstCompiler();
+	}
+	hostFetch = async (pathPtr, pathLen, resultLenPtr) => {
+		const wasmExports = this.wasmExports;
+		if (!wasmExports) throw new Error("WASM exports not initialized");
+		const path = textDecoder.decode(new Uint8Array(wasmExports.memory.buffer, pathPtr, pathLen));
+		try {
+			const bytes = await retry(() => this.fetchBytes(path), MAX_FETCH_ATTEMPTS);
+			const resultPtr = wasmExports.__wbindgen_malloc(bytes.length, 1);
+			new Uint8Array(wasmExports.memory.buffer, resultPtr, bytes.length).set(bytes);
+			new DataView(wasmExports.memory.buffer).setUint32(resultLenPtr, bytes.length, true);
+			return resultPtr;
+		} catch {
+			new DataView(wasmExports.memory.buffer).setUint32(resultLenPtr, 0, true);
+			return 0;
+		}
+	};
+	async fetchBytes(path) {
+		if (path.startsWith("@")) return this.packageManager.getFile(path);
+		const response = await this.fetchImpl(path);
+		if (!response.ok) throw new Error(`Failed to fetch "${path}" with status ${response.status}`);
+		return new Uint8Array(await response.arrayBuffer());
+	}
+	withCompiler(run, name) {
+		this.assertNotDisposed();
+		if (!this.compiler) throw new CompilerNotInitializedError("Compiler not initialized");
+		try {
+			return run(this.compiler);
+		} catch (cause) {
+			throw new WorkerError(`Direct command failed: ${name}`, { cause });
+		}
+	}
+	assertNotDisposed() {
+		if (this.disposed) throw new CompilerDisposedError("Compiler has been disposed");
+	}
+	takeExternref(wasmExports, idx) {
+		const value = wasmExports.__wbindgen_externrefs.get(idx);
+		wasmExports.__externref_table_dealloc(idx);
+		return value;
+	}
+};
+
+//#endregion
+//#region src/worker.ts?worker
+function WorkerWrapper(options) {
+	return new Worker(new URL("worker.js", import.meta.url), {
+		type: "module",
+		name: options?.name
+	});
+}
+
+//#endregion
+//#region src/messages.ts
+const isRecord$1 = (value) => typeof value === "object" && value !== null;
+const isRpcResponseMessage = (value) => {
+	if (!isRecord$1(value)) return false;
+	if (typeof value.requestId !== "number") return false;
+	return "result" in value !== "error" in value;
+};
+const isWorkerEventMessage = (value) => {
+	if (!isRecord$1(value)) return false;
+	if (typeof value.kind !== "string") return false;
+	if (value.kind === "web_fetch") {
+		if (!("payload" in value) || !isRecord$1(value.payload)) return false;
+		return typeof value.payload.path === "string";
+	}
+	return false;
+};
+const isWorkerToMainMessage = (value) => isRpcResponseMessage(value) || isWorkerEventMessage(value);
+
+//#endregion
+//#region src/rpc.ts
+const isRecord = (value) => typeof value === "object" && value !== null;
+const extractRpcErrorMessage = (error) => {
+	if (typeof error === "string") return error;
+	if (isRecord(error) && typeof error.message === "string") return error.message;
+	try {
+		return JSON.stringify(error);
+	} catch {
+		return String(error);
+	}
+};
+const makeRpcClient = (sender) => {
+	let requestIdCounter = 0;
+	const pending = /* @__PURE__ */ new Map();
+	const call = (kind, ...args) => {
+		const requestId = requestIdCounter;
+		requestIdCounter += 1;
+		return new Promise((resolve, reject) => {
+			pending.set(requestId, {
+				resolve,
+				reject,
+				kind
+			});
+			const payload = args[0];
+			try {
+				sender(payload === void 0 ? {
+					kind,
+					requestId
+				} : {
+					kind,
+					requestId,
+					payload
+				});
+			} catch (cause) {
+				pending.delete(requestId);
+				reject(new WorkerError(`Failed to send worker command "${String(kind)}"`, { cause }));
+			}
+		});
+	};
+	const receive = (response) => {
+		if (!isRpcResponseMessage(response)) return;
+		const req = pending.get(response.requestId);
+		if (!req) return;
+		pending.delete(response.requestId);
+		if ("result" in response) req.resolve(response.result);
+		else req.reject(new WorkerError(`Worker command failed: ${req.kind}`, { cause: response.error ?? extractRpcErrorMessage(response.error) }));
+	};
+	const rejectAll = (cause) => {
+		for (const [requestId, req] of pending) {
+			pending.delete(requestId);
+			req.reject(new WorkerError(`Worker command failed: ${req.kind}`, { cause }));
+		}
+	};
+	return {
+		call,
+		notify: sender,
+		receive,
+		rejectAll
+	};
+};
+
+//#endregion
+//#region src/protocol.ts
+const INITIAL_SAB_SIZE = 1024 * 1024;
+const MAX_SAB_SIZE = 4 * 1024 * 1024 * 1024;
+const DEFAULT_FETCH_TIMEOUT = 3e4;
+const SharedMemoryCommunicationStatus = {
+	None: 0,
+	Pending: 1,
+	Error: 2,
+	Success: 3
+};
+var SharedMemoryCommunication = class SharedMemoryCommunication {
+	dataBuf;
+	statusBuf;
+	sizeBuf;
+	constructor() {
+		this.dataBuf = new SharedArrayBuffer(INITIAL_SAB_SIZE, { maxByteLength: MAX_SAB_SIZE });
+		this.statusBuf = new SharedArrayBuffer(4);
+		this.sizeBuf = new SharedArrayBuffer(4);
+	}
+	getStatus() {
+		return Atomics.load(new Int32Array(this.statusBuf), 0);
+	}
+	setStatus(status) {
+		const statusView = new Int32Array(this.statusBuf);
+		Atomics.store(statusView, 0, status);
+		Atomics.notify(statusView, 0, 1);
+	}
+	setBuffer(buf) {
+		const needed = buf.byteLength;
+		if (needed > MAX_SAB_SIZE) throw new Error(`File too large: ${needed} bytes. Maximum allowed: ${MAX_SAB_SIZE} bytes.`);
+		if (needed > this.dataBuf.byteLength) this.dataBuf.grow(needed);
+		new Uint8Array(this.dataBuf).set(buf);
+		Atomics.store(new Int32Array(this.sizeBuf), 0, needed);
+	}
+	getBuffer() {
+		const size = Atomics.load(new Int32Array(this.sizeBuf), 0);
+		return new Uint8Array(this.dataBuf, 0, size);
+	}
+	waitForStatusChange(expectedStatus, timeoutMs = DEFAULT_FETCH_TIMEOUT) {
+		return Atomics.wait(new Int32Array(this.statusBuf), 0, expectedStatus, timeoutMs) === "ok";
+	}
+	static hydrateObj(obj) {
+		const instantiation = new SharedMemoryCommunication();
+		instantiation.dataBuf = obj.dataBuf;
+		instantiation.statusBuf = obj.statusBuf;
+		instantiation.sizeBuf = obj.sizeBuf;
+		return instantiation;
+	}
+};
+
+//#endregion
+//#region src/fetch-bridge.ts
+const makeFetchBridge = (packageLoader, isDisposed, fetchImpl = fetch) => {
+	const sharedMemoryCommunication = new SharedMemoryCommunication();
+	const handleFetchRequest = async (path) => {
+		if (isDisposed()) return;
+		try {
+			const bytes = path.startsWith("@") ? await packageLoader.getFile(path) : await fetchPath(path, fetchImpl);
+			if (isDisposed()) return;
+			sharedMemoryCommunication.setBuffer(bytes);
+			sharedMemoryCommunication.setStatus(SharedMemoryCommunicationStatus.Success);
+		} catch {
+			if (!isDisposed()) sharedMemoryCommunication.setStatus(SharedMemoryCommunicationStatus.Error);
+		}
+	};
+	return {
+		sharedMemoryCommunication,
+		handleFetchRequest
+	};
+};
+const fetchPath = async (path, fetchImpl) => {
+	try {
+		const response = await fetchImpl(path);
+		if (!response.ok) throw new Error(`Status ${response.status}`);
+		return new Uint8Array(await response.arrayBuffer());
+	} catch (cause) {
+		throw new FetchError(path, cause);
+	}
+};
+
+//#endregion
+//#region src/worker-transport.ts
+const makeWorkerTransport = (worker, onMessage, onError) => {
+	worker.onmessage = (event) => {
+		if (isWorkerToMainMessage(event.data)) onMessage(event.data);
+	};
+	if ("onerror" in worker) worker.onerror = (event) => {
+		onError(event.error ?? event.message);
+	};
+	return {
+		post: (message) => {
+			worker.postMessage(message);
+		},
+		close: () => {
+			worker.onmessage = null;
+			if ("onerror" in worker) worker.onerror = null;
+		}
+	};
+};
+
+//#endregion
+//#region src/worker-service.ts
+var WorkerService = class {
+	disposed = false;
+	initPromise = null;
+	worker;
+	rpcClient;
+	transport;
+	constructor(packageManager, fetchImpl = fetch) {
+		this.worker = new WorkerWrapper();
+		const fetchBridge = makeFetchBridge(packageManager, () => this.disposed, fetchImpl);
+		this.rpcClient = makeRpcClient((msg) => {
+			this.transport.post(msg);
+		});
+		this.transport = makeWorkerTransport(this.worker, (msg) => {
+			this.handleMessage(msg, fetchBridge.handleFetchRequest);
+		}, (cause) => {
+			this.rpcClient.rejectAll(cause);
+		});
+		this.initWorker = async (moduleOrPath) => {
+			await this.rpcClient.call("init", {
+				sharedMemoryCommunication: fetchBridge.sharedMemoryCommunication,
+				moduleOrPath
+			});
+		};
+	}
+	initWorker;
+	async init(moduleOrPath) {
+		this.assertNotDisposed();
+		this.initPromise ??= this.initWorker(moduleOrPath);
+		try {
+			await this.initPromise;
+		} catch (error) {
+			this.initPromise = null;
+			throw error;
+		}
+	}
+	async dispose() {
+		if (this.disposed) return;
+		this.disposed = true;
+		this.rpcClient.rejectAll(new CompilerDisposedError("Compiler has been disposed"));
+		this.transport.close();
+		this.worker.terminate();
+	}
+	addFont(data) {
+		return this.rpcClient.call("add_font", { data });
+	}
+	addFile(path, data) {
+		return this.rpcClient.call("add_file", {
+			path,
+			data
+		});
+	}
+	addSource(path, text) {
+		return this.rpcClient.call("add_source", {
+			path,
+			text
+		});
+	}
+	removeFile(path) {
+		return this.rpcClient.call("remove_file", { path });
+	}
+	clearFiles() {
+		return this.rpcClient.call("clear_files");
+	}
+	listFiles() {
+		return this.rpcClient.call("list_files");
+	}
+	hasFile(path) {
+		return this.rpcClient.call("has_file", { path });
+	}
+	setMain(path) {
+		return this.rpcClient.call("set_main", { path });
+	}
+	compile(options) {
+		return this.rpcClient.call("compile", { options });
+	}
+	async handleMessage(msg, handleFetchRequest) {
+		if (isRpcResponseMessage(msg)) {
+			this.rpcClient.receive(msg);
+			return;
+		}
+		switch (msg.kind) {
+			case "web_fetch":
+				await handleFetchRequest(msg.payload.path);
+				return;
+		}
+	}
+	assertNotDisposed() {
+		if (this.disposed) throw new CompilerDisposedError("Compiler has been disposed");
+	}
+};
+
+//#endregion
+//#region src/compiler-backend.ts
+const selectAutomaticBackendKind = () => {
+	if (supportsWorkerBackend()) return "worker";
+	if (supportsJspiBackend()) return "jspi";
+	return "none";
+};
+const createCompilerBackend = (backend, options) => {
+	switch (backend === "auto" ? selectAutomaticBackendKind() : backend) {
+		case "worker": return new WorkerService(options.packageManager, options.fetch);
+		case "jspi": return new DirectService(options.packageManager, options.fetch);
+		case "none": throw new Error("No compatible typst-wasm backend available. Requires Worker+SharedArrayBuffer+Atomics.wait or JSPI.");
+	}
+};
+
+//#endregion
+//#region src/cache-abstraction.ts
+const makeBrowserCacheStorage = () => {
+	let cachePromise = null;
+	const openCache = async () => {
+		cachePromise ??= caches.open("typst-packages").catch(() => null);
+		return cachePromise;
+	};
+	return {
+		async get(key) {
+			const cache = await openCache();
+			if (!cache) return null;
+			try {
+				const response = await cache.match(key);
+				if (!response) return null;
+				return new Uint8Array(await response.arrayBuffer());
+			} catch {
+				return null;
+			}
+		},
+		async set(key, value) {
+			const cache = await openCache();
+			if (!cache) return;
+			try {
+				const response = new Response(value.slice(), { headers: { "Content-Type": "application/octet-stream" } });
+				await cache.put(key, response);
+			} catch {}
+		}
+	};
+};
+const makeMemoryCacheStorage = (capacity) => {
+	const storage = /* @__PURE__ */ new Map();
+	return {
+		async get(key) {
+			const value = storage.get(key);
+			if (!value) return null;
+			storage.delete(key);
+			storage.set(key, value);
+			return value;
+		},
+		async set(key, value) {
+			if (storage.has(key)) storage.delete(key);
+			storage.set(key, value);
+			while (storage.size > capacity) {
+				const oldest = storage.keys().next().value;
+				if (!oldest) break;
+				storage.delete(oldest);
+			}
+		}
+	};
+};
+const makeDefaultPackageCache = (capacity = 400) => typeof caches !== "undefined" ? makeBrowserCacheStorage() : makeMemoryCacheStorage(capacity);
+
+//#endregion
+//#region src/package-manager.ts
+const parseSpec = (spec) => {
+	const match = spec.match(/^@([a-z0-9-]+)\/([a-z0-9_-]+):([0-9]+\.[0-9]+\.[0-9]+(?:-[a-zA-Z0-9.-]+)?)\/(.+)$/);
+	if (!match) throw new PackageParseError(spec, "Expected format: @namespace/name:version/path where namespace is lowercase alphanumeric with hyphens, name is lowercase alphanumeric with hyphens/underscores, version is semver, and path is the file path.");
+	const [, namespace, name, version, filePath] = match;
+	if (namespace.startsWith("-") || namespace.endsWith("-")) throw new PackageParseError(spec, `Invalid package namespace: "${namespace}" cannot start or end with hyphen`);
+	if (name.startsWith("_") || name.endsWith("_")) throw new PackageParseError(spec, `Invalid package name: "${name}" cannot start or end with underscore`);
+	return {
+		namespace,
+		name,
+		version,
+		filePath
+	};
+};
+const getFileCacheKey = (spec, filePath) => `@${spec.namespace}/${spec.name}:${spec.version}/${filePath}`;
+const getCacheKey = (spec) => getFileCacheKey(spec, spec.filePath);
+const getPackageKey = (spec) => `@${spec.namespace}/${spec.name}:${spec.version}`;
+var PackageManager = class {
+	fetchImpl;
+	packageBaseUrl;
+	cache;
+	loadedPackages = /* @__PURE__ */ new Set();
+	loadingPackages = /* @__PURE__ */ new Map();
+	constructor(options = {}) {
+		this.fetchImpl = options.fetch ?? fetch;
+		this.packageBaseUrl = options.packageBaseUrl ?? "https://packages.typst.org";
+		this.cache = options.cache ?? makeDefaultPackageCache(options.memoryPackageCacheCapacity);
+	}
+	async getFile(spec) {
+		const parsed = parseSpec(spec);
+		const cacheKey = getCacheKey(parsed);
+		const cached = await this.cache.get(cacheKey);
+		if (cached) return cached;
+		const packageKey = getPackageKey(parsed);
+		if (!this.loadedPackages.has(packageKey)) await this.loadPackageDeduped(parsed);
+		const file = await this.cache.get(cacheKey);
+		if (!file) throw new FileNotFoundError(parsed.filePath);
+		return file;
+	}
+	async loadPackageDeduped(spec) {
+		const packageKey = getPackageKey(spec);
+		const existing = this.loadingPackages.get(packageKey);
+		if (existing) {
+			await existing;
+			return;
+		}
+		const load = this.loadPackage(spec);
+		this.loadingPackages.set(packageKey, load);
+		try {
+			await load;
+			this.loadedPackages.add(packageKey);
+		} finally {
+			this.loadingPackages.delete(packageKey);
+		}
+	}
+	async loadPackage(spec) {
+		const url = `${this.packageBaseUrl}/${spec.namespace}/${spec.name}-${spec.version}.tar.gz`;
+		try {
+			const response = await this.fetchImpl(url);
+			if (!response.ok) throw new Error(`Status ${response.status}`);
+			const files = await parseTarGzip(new Uint8Array(await response.arrayBuffer()));
+			await Promise.all(files.map(async (file) => {
+				if (file.type === "file" && file.data) await this.cache.set(getFileCacheKey(spec, file.name), file.data);
+			}));
+		} catch (cause) {
+			throw new PackageFetchError(url, cause);
+		}
+	}
+};
+
+//#endregion
+//#region src/index.ts
+const hasErrorDiagnostics = (diagnostics) => diagnostics.some((diagnostic) => diagnostic.severity === "error");
+const extractErrorMessage = (error) => {
+	if (error instanceof Error) return error.message;
+	if (typeof error === "string") return error;
+	try {
+		return JSON.stringify(error);
+	} catch {
+		return String(error);
+	}
+};
+const normalizeCompileResult = (result) => {
+	const diagnostics = result.diagnostics;
+	const deps = result.deps ?? void 0;
+	const timings = result.timings;
+	switch (result.format) {
+		case "pdf": return {
+			format: "pdf",
+			output: result.output_bytes ?? new Uint8Array(),
+			diagnostics,
+			deps,
+			timings
+		};
+		case "png": return {
+			format: "png",
+			pages: result.pages.map((page) => ({
+				page: page.page,
+				output: page.output_bytes ?? new Uint8Array()
+			})),
+			diagnostics,
+			deps,
+			timings
+		};
+		case "svg": return {
+			format: "svg",
+			pages: result.pages.map((page) => ({
+				page: page.page,
+				output: page.output_text ?? ""
+			})),
+			diagnostics,
+			deps,
+			timings
+		};
+		case "html": return {
+			format: "html",
+			output: result.output_text ?? "",
+			diagnostics,
+			deps,
+			timings
+		};
+		case "bundle": return {
+			format: "bundle",
+			files: result.files.map((file) => ({
+				path: file.path,
+				data: file.data,
+				mediaType: file.media_type ?? void 0
+			})),
+			diagnostics,
+			deps,
+			timings
+		};
+	}
+};
+var PromiseTypstCompiler = class {
+	constructor(backend) {
+		this.backend = backend;
+	}
+	addFont(data) {
+		return this.backend.addFont(data);
+	}
+	addFile(path, data) {
+		return this.backend.addFile(path, data);
+	}
+	addSource(path, text) {
+		return this.backend.addSource(path, text);
+	}
+	removeFile(path) {
+		return this.backend.removeFile(path);
+	}
+	clearFiles() {
+		return this.backend.clearFiles();
+	}
+	listFiles() {
+		return this.backend.listFiles();
+	}
+	hasFile(path) {
+		return this.backend.hasFile(path);
+	}
+	setMain(path) {
+		return this.backend.setMain(path);
+	}
+	async compile(options = {}) {
+		if (options.main) await this.setMain(options.main);
+		let rawResult;
+		try {
+			rawResult = await this.backend.compile(toWasmCompileOptions(options));
+		} catch (cause) {
+			throw new CompileError(extractErrorMessage(cause), { cause });
+		}
+		if (hasErrorDiagnostics(rawResult.diagnostics) || !rawResult.success) throw new CompileError(rawResult.internal_error ?? "Compilation failed", { diagnostics: rawResult.diagnostics });
+		return normalizeCompileResult(rawResult);
+	}
+	dispose() {
+		return this.backend.dispose();
+	}
+};
+const createTypstCompiler = async (options) => {
+	const packageManager = new PackageManager({
+		fetch: options.fetch,
+		packageBaseUrl: options.packageBaseUrl,
+		cache: options.packageCache,
+		memoryPackageCacheCapacity: options.memoryPackageCacheCapacity
+	});
+	const backend = createCompilerBackend(options.backend ?? "auto", {
+		packageManager,
+		fetch: options.fetch
+	});
+	await backend.init(options.moduleOrPath);
+	return new PromiseTypstCompiler(backend);
+};
+
+//#endregion
+export { CompileError, CompilerDisposedError, CompilerNotInitializedError, FetchError, FileNotFoundError, FontLoadError, PackageFetchError, PackageManager, PackageParseError, SharedMemoryCommunication, TypstError, WorkerError, createTypstCompiler, makeBrowserCacheStorage, makeDefaultPackageCache, makeMemoryCacheStorage, selectAutomaticBackendKind, supportsJspiBackend, supportsWorkerBackend };
+//# sourceMappingURL=index.js.map