@trylimbo/sdk-verifier-wasm 0.1.0-canary.100

package/gen/wasm/comlink.js

@@ -0,0 +1,270 @@
+//#region ../../../../node_modules/comlink/dist/esm/comlink.mjs
+/**
+* @license
+* Copyright 2019 Google LLC
+* SPDX-License-Identifier: Apache-2.0
+*/
+const proxyMarker = Symbol("Comlink.proxy");
+const createEndpoint = Symbol("Comlink.endpoint");
+const releaseProxy = Symbol("Comlink.releaseProxy");
+const finalizer = Symbol("Comlink.finalizer");
+const throwMarker = Symbol("Comlink.thrown");
+const isObject = (val) => typeof val === "object" && val !== null || typeof val === "function";
+/**
+* Allows customizing the serialization of certain values.
+*/
+const transferHandlers = /* @__PURE__ */ new Map([["proxy", {
+	canHandle: (val) => isObject(val) && val[proxyMarker],
+	serialize(obj) {
+		const { port1, port2 } = new MessageChannel();
+		expose(obj, port1);
+		return [port2, [port2]];
+	},
+	deserialize(port) {
+		port.start();
+		return wrap(port);
+	}
+}], ["throw", {
+	canHandle: (value) => isObject(value) && throwMarker in value,
+	serialize({ value }) {
+		let serialized;
+		if (value instanceof Error) serialized = {
+			isError: true,
+			value: {
+				message: value.message,
+				name: value.name,
+				stack: value.stack
+			}
+		};
+		else serialized = {
+			isError: false,
+			value
+		};
+		return [serialized, []];
+	},
+	deserialize(serialized) {
+		if (serialized.isError) throw Object.assign(new Error(serialized.value.message), serialized.value);
+		throw serialized.value;
+	}
+}]]);
+function isAllowedOrigin(allowedOrigins, origin) {
+	for (const allowedOrigin of allowedOrigins) {
+		if (origin === allowedOrigin || allowedOrigin === "*") return true;
+		if (allowedOrigin instanceof RegExp && allowedOrigin.test(origin)) return true;
+	}
+	return false;
+}
+function expose(obj, ep = globalThis, allowedOrigins = ["*"]) {
+	ep.addEventListener("message", function callback(ev) {
+		if (!ev || !ev.data) return;
+		if (!isAllowedOrigin(allowedOrigins, ev.origin)) {
+			console.warn(`Invalid origin '${ev.origin}' for comlink proxy`);
+			return;
+		}
+		const { id, type, path } = Object.assign({ path: [] }, ev.data);
+		const argumentList = (ev.data.argumentList || []).map(fromWireValue);
+		let returnValue;
+		try {
+			const parent = path.slice(0, -1).reduce((obj, prop) => obj[prop], obj);
+			const rawValue = path.reduce((obj, prop) => obj[prop], obj);
+			switch (type) {
+				case "GET":
+					returnValue = rawValue;
+					break;
+				case "SET":
+					parent[path.slice(-1)[0]] = fromWireValue(ev.data.value);
+					returnValue = true;
+					break;
+				case "APPLY":
+					returnValue = rawValue.apply(parent, argumentList);
+					break;
+				case "CONSTRUCT":
+					returnValue = proxy(new rawValue(...argumentList));
+					break;
+				case "ENDPOINT":
+					{
+						const { port1, port2 } = new MessageChannel();
+						expose(obj, port2);
+						returnValue = transfer(port1, [port1]);
+					}
+					break;
+				case "RELEASE":
+					returnValue = void 0;
+					break;
+				default: return;
+			}
+		} catch (value) {
+			returnValue = {
+				value,
+				[throwMarker]: 0
+			};
+		}
+		Promise.resolve(returnValue).catch((value) => {
+			return {
+				value,
+				[throwMarker]: 0
+			};
+		}).then((returnValue) => {
+			const [wireValue, transferables] = toWireValue(returnValue);
+			ep.postMessage(Object.assign(Object.assign({}, wireValue), { id }), transferables);
+			if (type === "RELEASE") {
+				ep.removeEventListener("message", callback);
+				closeEndPoint(ep);
+				if (finalizer in obj && typeof obj[finalizer] === "function") obj[finalizer]();
+			}
+		}).catch((error) => {
+			const [wireValue, transferables] = toWireValue({
+				value: /* @__PURE__ */ new TypeError("Unserializable return value"),
+				[throwMarker]: 0
+			});
+			ep.postMessage(Object.assign(Object.assign({}, wireValue), { id }), transferables);
+		});
+	});
+	if (ep.start) ep.start();
+}
+function isMessagePort(endpoint) {
+	return endpoint.constructor.name === "MessagePort";
+}
+function closeEndPoint(endpoint) {
+	if (isMessagePort(endpoint)) endpoint.close();
+}
+function wrap(ep, target) {
+	const pendingListeners = /* @__PURE__ */ new Map();
+	ep.addEventListener("message", function handleMessage(ev) {
+		const { data } = ev;
+		if (!data || !data.id) return;
+		const resolver = pendingListeners.get(data.id);
+		if (!resolver) return;
+		try {
+			resolver(data);
+		} finally {
+			pendingListeners.delete(data.id);
+		}
+	});
+	return createProxy(ep, pendingListeners, [], target);
+}
+function throwIfProxyReleased(isReleased) {
+	if (isReleased) throw new Error("Proxy has been released and is not useable");
+}
+function releaseEndpoint(ep) {
+	return requestResponseMessage(ep, /* @__PURE__ */ new Map(), { type: "RELEASE" }).then(() => {
+		closeEndPoint(ep);
+	});
+}
+const proxyCounter = /* @__PURE__ */ new WeakMap();
+const proxyFinalizers = "FinalizationRegistry" in globalThis && new FinalizationRegistry((ep) => {
+	const newCount = (proxyCounter.get(ep) || 0) - 1;
+	proxyCounter.set(ep, newCount);
+	if (newCount === 0) releaseEndpoint(ep);
+});
+function registerProxy(proxy, ep) {
+	const newCount = (proxyCounter.get(ep) || 0) + 1;
+	proxyCounter.set(ep, newCount);
+	if (proxyFinalizers) proxyFinalizers.register(proxy, ep, proxy);
+}
+function unregisterProxy(proxy) {
+	if (proxyFinalizers) proxyFinalizers.unregister(proxy);
+}
+function createProxy(ep, pendingListeners, path = [], target = function() {}) {
+	let isProxyReleased = false;
+	const proxy = new Proxy(target, {
+		get(_target, prop) {
+			throwIfProxyReleased(isProxyReleased);
+			if (prop === releaseProxy) return () => {
+				unregisterProxy(proxy);
+				releaseEndpoint(ep);
+				pendingListeners.clear();
+				isProxyReleased = true;
+			};
+			if (prop === "then") {
+				if (path.length === 0) return { then: () => proxy };
+				const r = requestResponseMessage(ep, pendingListeners, {
+					type: "GET",
+					path: path.map((p) => p.toString())
+				}).then(fromWireValue);
+				return r.then.bind(r);
+			}
+			return createProxy(ep, pendingListeners, [...path, prop]);
+		},
+		set(_target, prop, rawValue) {
+			throwIfProxyReleased(isProxyReleased);
+			const [value, transferables] = toWireValue(rawValue);
+			return requestResponseMessage(ep, pendingListeners, {
+				type: "SET",
+				path: [...path, prop].map((p) => p.toString()),
+				value
+			}, transferables).then(fromWireValue);
+		},
+		apply(_target, _thisArg, rawArgumentList) {
+			throwIfProxyReleased(isProxyReleased);
+			const last = path[path.length - 1];
+			if (last === createEndpoint) return requestResponseMessage(ep, pendingListeners, { type: "ENDPOINT" }).then(fromWireValue);
+			if (last === "bind") return createProxy(ep, pendingListeners, path.slice(0, -1));
+			const [argumentList, transferables] = processArguments(rawArgumentList);
+			return requestResponseMessage(ep, pendingListeners, {
+				type: "APPLY",
+				path: path.map((p) => p.toString()),
+				argumentList
+			}, transferables).then(fromWireValue);
+		},
+		construct(_target, rawArgumentList) {
+			throwIfProxyReleased(isProxyReleased);
+			const [argumentList, transferables] = processArguments(rawArgumentList);
+			return requestResponseMessage(ep, pendingListeners, {
+				type: "CONSTRUCT",
+				path: path.map((p) => p.toString()),
+				argumentList
+			}, transferables).then(fromWireValue);
+		}
+	});
+	registerProxy(proxy, ep);
+	return proxy;
+}
+function myFlat(arr) {
+	return Array.prototype.concat.apply([], arr);
+}
+function processArguments(argumentList) {
+	const processed = argumentList.map(toWireValue);
+	return [processed.map((v) => v[0]), myFlat(processed.map((v) => v[1]))];
+}
+const transferCache = /* @__PURE__ */ new WeakMap();
+function transfer(obj, transfers) {
+	transferCache.set(obj, transfers);
+	return obj;
+}
+function proxy(obj) {
+	return Object.assign(obj, { [proxyMarker]: true });
+}
+function toWireValue(value) {
+	for (const [name, handler] of transferHandlers) if (handler.canHandle(value)) {
+		const [serializedValue, transferables] = handler.serialize(value);
+		return [{
+			type: "HANDLER",
+			name,
+			value: serializedValue
+		}, transferables];
+	}
+	return [{
+		type: "RAW",
+		value
+	}, transferCache.get(value) || []];
+}
+function fromWireValue(value) {
+	switch (value.type) {
+		case "HANDLER": return transferHandlers.get(value.name).deserialize(value.value);
+		case "RAW": return value.value;
+	}
+}
+function requestResponseMessage(ep, pendingListeners, msg, transfers) {
+	return new Promise((resolve) => {
+		const id = generateUUID();
+		pendingListeners.set(id, resolve);
+		if (ep.start) ep.start();
+		ep.postMessage(Object.assign({ id }, msg), transfers);
+	});
+}
+function generateUUID() {
+	return new Array(4).fill(0).map(() => Math.floor(Math.random() * Number.MAX_SAFE_INTEGER).toString(16)).join("-");
+}
+//#endregion
+export { wrap as i, finalizer as n, proxy as r, expose as t };