@marimo-team/marimo-export 0.0.0 → 0.0.2

package/dist/loader/anywidget.mjs

@@ -0,0 +1,1561 @@
+import { t as defineBlobAssetLoader } from "../loader-CDfnJ5Yb.mjs";
+//#region ../loader-anywidget/src/runtime/value-types.ts
+function isPrimitiveWithPrototype(value, prototype) {
+	const boxed = Object(value);
+	return boxed !== value && Object.getPrototypeOf(boxed) === prototype;
+}
+function isStringValue(value) {
+	return isPrimitiveWithPrototype(value, String.prototype);
+}
+function isNumberValue(value) {
+	return isPrimitiveWithPrototype(value, Number.prototype);
+}
+function isBooleanValue(value) {
+	return isPrimitiveWithPrototype(value, Boolean.prototype);
+}
+function isRecordValue(value) {
+	return value !== null && !Array.isArray(value) && Object.prototype.toString.call(value) === "[object Object]";
+}
+function isPropertyOwner(value) {
+	return value !== null && Object(value) === value;
+}
+function isCallableValue(value) {
+	try {
+		Function.prototype.toString.call(value);
+		return true;
+	} catch {
+		return false;
+	}
+}
+//#endregion
+//#region ../loader-anywidget/src/payload.ts
+const ANYWIDGET_SCHEMA = "marimo-export.anywidget.v1";
+function embeddedFileKey(url) {
+	return url.startsWith("./@file/") ? url.slice(1) : url;
+}
+const UNSAFE_PATH_KEYS = /* @__PURE__ */ new Set([
+	"__proto__",
+	"constructor",
+	"prototype"
+]);
+const MAX_DIAGNOSTIC_LENGTH = 2048;
+const MAX_UNEXPECTED_FIELDS = 8;
+const MAX_DATA_URL_MEDIA_TYPE_BYTES = 1024;
+const MAX_EXTERNAL_ESM_URL_BYTES = 8192;
+function parseAnyWidgetPayload(value) {
+	const payload = record(parseSnapshotValue(value), "AnyWidget payload");
+	exactKeys(payload, [
+		"schema",
+		"rootModelId",
+		"files",
+		"modelNotifications"
+	], "payload");
+	if (payload.schema !== "marimo-export.anywidget.v1") throw new TypeError(`AnyWidget payload schema must be ${JSON.stringify(ANYWIDGET_SCHEMA)}.`);
+	const rootModelId = nonEmptyString(payload.rootModelId, "rootModelId");
+	if (rootModelId !== "model-0") throw new TypeError("AnyWidget payload rootModelId must be \"model-0\".");
+	const files = parseFiles(payload.files);
+	const notifications = array(payload.modelNotifications, "modelNotifications");
+	const models = /* @__PURE__ */ new Map();
+	for (const [index, value] of notifications.entries()) {
+		const notification = record(value, `modelNotifications[${index}]`);
+		exactKeys(notification, [
+			"op",
+			"model_id",
+			"message"
+		], `modelNotifications[${index}]`);
+		if (notification.op !== "model-lifecycle") throw new TypeError(`modelNotifications[${index}].op must be "model-lifecycle".`);
+		const id = nonEmptyString(notification.model_id, `modelNotifications[${index}].model_id`);
+		const expectedId = `model-${index}`;
+		if (id !== expectedId) throw new TypeError(`modelNotifications[${index}].model_id must be ${JSON.stringify(expectedId)}.`);
+		const message = record(notification.message, `modelNotifications[${index}].message`);
+		exactKeys(message, [
+			"method",
+			"state",
+			"buffer_paths",
+			"buffers",
+			"esm_spec"
+		], `modelNotifications[${index}].message`);
+		if (message.method !== "open") throw new TypeError(`AnyWidget model ${JSON.stringify(id)} must contain an open message.`);
+		const state = cloneJsonObject(record(message.state, `AnyWidget model ${JSON.stringify(id)} state`));
+		const bufferPaths = parseBufferPaths(message.buffer_paths, id);
+		const buffers = parseBuffers(message.buffers, id);
+		if (bufferPaths.length !== buffers.length) throw new TypeError(`AnyWidget model ${JSON.stringify(id)} has ${bufferPaths.length} buffer paths and ${buffers.length} buffers.`);
+		for (const [bufferIndex, path] of bufferPaths.entries()) setBuffer(state, path, buffers[bufferIndex], id);
+		const esmSpec = parseEsmSpec(message.esm_spec, files, id);
+		models.set(id, Object.freeze({
+			id,
+			state,
+			esmSpec
+		}));
+	}
+	const root = models.get(rootModelId);
+	if (root === void 0) throw new TypeError(`AnyWidget root model ${JSON.stringify(rootModelId)} is missing.`);
+	if (root.esmSpec === void 0) throw new TypeError(`AnyWidget root model ${JSON.stringify(rootModelId)} has no ESM spec.`);
+	const reachable = collectReachableModels(rootModelId, models);
+	if (reachable.size !== models.size) {
+		const unrelated = [];
+		let unrelatedCount = 0;
+		for (const id of models.keys()) {
+			if (reachable.has(id)) continue;
+			unrelatedCount += 1;
+			if (unrelated.length < MAX_UNEXPECTED_FIELDS) unrelated.push(id);
+		}
+		throw new TypeError(truncateDiagnostic(`AnyWidget payload contains models outside the root closure: ${renderUnexpectedFields(unrelated, unrelatedCount)}.`));
+	}
+	return Object.freeze({
+		rootModelId,
+		files,
+		models
+	});
+}
+function cloneModelState(state) {
+	return structuredClone(state);
+}
+function readonlyModelState(state) {
+	return deepFreeze(cloneModelState(state));
+}
+function parseDataUrl(value, path) {
+	const comma = value.indexOf(",");
+	if (comma === -1) throw new TypeError(`${path} is a malformed data URL.`);
+	const mediaTypeEnd = dataUrlMediaTypeEnd(value, comma, path);
+	return {
+		body: value.slice(comma + 1),
+		isBase64: hasBase64Parameter(value, mediaTypeEnd + 1, comma),
+		mediaType: value.slice(5, mediaTypeEnd) || "text/plain"
+	};
+}
+function parseFiles(value) {
+	const input = record(value, "files");
+	const files = Object.create(null);
+	for (const [path, dataUrl] of Object.entries(input)) {
+		if (path.length === 0) throw new TypeError("AnyWidget file paths must be non-empty strings.");
+		const fileLabel = `AnyWidget file ${quoteField(path)}`;
+		if (!isStringValue(dataUrl) || !dataUrl.startsWith("data:")) throw new TypeError(`${fileLabel} must contain a data URL.`);
+		validateDataUrl(dataUrl, fileLabel);
+		files[path] = dataUrl;
+	}
+	return Object.freeze(files);
+}
+function parseEsmSpec(value, files, modelId) {
+	if (value === null) return void 0;
+	const spec = record(value, `AnyWidget model ${JSON.stringify(modelId)} ESM spec`);
+	exactKeys(spec, ["url", "hash"], `AnyWidget model ${JSON.stringify(modelId)} ESM spec`);
+	const url = nonEmptyString(spec.url, `AnyWidget model ${JSON.stringify(modelId)} ESM URL`);
+	const hash = nonEmptyString(spec.hash, `AnyWidget model ${JSON.stringify(modelId)} ESM hash`);
+	if (!Object.hasOwn(files, embeddedFileKey(url))) {
+		if (hasDataUrlPrefix(url)) {
+			validateDataUrl(url, `AnyWidget model ${JSON.stringify(modelId)} ESM URL`);
+			return Object.freeze({
+				url,
+				hash
+			});
+		}
+		if (!hasUtf8ByteLengthAtMost(url, MAX_EXTERNAL_ESM_URL_BYTES)) throw new TypeError(`AnyWidget model ${JSON.stringify(modelId)} contains an invalid ESM URL ${quoteField(url)}.`);
+		let parsed;
+		try {
+			parsed = new URL(url);
+		} catch (error) {
+			throw new TypeError(`AnyWidget model ${JSON.stringify(modelId)} references missing virtual file ${quoteField(url)}.`, { cause: error });
+		}
+		if (parsed.protocol !== "http:" && parsed.protocol !== "https:") throw new TypeError(`AnyWidget model ${JSON.stringify(modelId)} uses incompatible ESM URL protocol ${quoteField(parsed.protocol)}.`);
+	}
+	return Object.freeze({
+		url,
+		hash
+	});
+}
+function parseBufferPaths(value, modelId) {
+	const input = array(value, `AnyWidget model ${JSON.stringify(modelId)} buffer_paths`);
+	const seen = /* @__PURE__ */ new Set();
+	return Object.freeze(input.map((value, index) => {
+		const path = array(value, `AnyWidget model ${JSON.stringify(modelId)} buffer path ${index}`);
+		if (path.length === 0) throw new TypeError(`AnyWidget model ${JSON.stringify(modelId)} has an empty buffer path.`);
+		const parsed = path.map((token) => {
+			if (isNumberValue(token) && Number.isSafeInteger(token) && token >= 0) return token;
+			if (isStringValue(token) && !UNSAFE_PATH_KEYS.has(token)) return token;
+			throw new TypeError(`AnyWidget model ${JSON.stringify(modelId)} has an invalid buffer path token.`);
+		});
+		const identity = JSON.stringify(parsed);
+		if (seen.has(identity)) throw new TypeError(`AnyWidget model ${JSON.stringify(modelId)} repeats buffer path ${quoteField(identity)}.`);
+		seen.add(identity);
+		return Object.freeze(parsed);
+	}));
+}
+function parseBuffers(value, modelId) {
+	return Object.freeze(array(value, `AnyWidget model ${JSON.stringify(modelId)} buffers`).map((buffer, index) => {
+		if (!isStringValue(buffer) || !isCanonicalBase64(buffer)) throw new TypeError(`AnyWidget model ${JSON.stringify(modelId)} buffer ${index} is not canonical base64.`);
+		return base64ToDataView(buffer);
+	}));
+}
+function base64ToDataView(value) {
+	const binary = atob(value);
+	const bytes = new Uint8Array(binary.length);
+	for (let index = 0; index < binary.length; index += 1) bytes[index] = binary.charCodeAt(index);
+	return new DataView(bytes.buffer);
+}
+function validateDataUrl(value, path) {
+	const { body, isBase64 } = parseDataUrl(value, path);
+	if (isBase64) {
+		if (!isCanonicalBase64(body)) throw new TypeError(`${path} contains malformed base64 data.`);
+		return;
+	}
+	if (!isValidPercentData(body)) throw new TypeError(`${path} contains malformed percent-encoded data.`);
+}
+function dataUrlMediaTypeEnd(value, comma, path) {
+	let byteLength = 0;
+	for (let index = 5; index < comma; index += 1) {
+		const codePoint = value.codePointAt(index);
+		if (codePoint === 59) return index;
+		byteLength += utf8CodePointBytes(codePoint);
+		if (byteLength > MAX_DATA_URL_MEDIA_TYPE_BYTES) throw new TypeError(`${path} data URL media type exceeds ${MAX_DATA_URL_MEDIA_TYPE_BYTES} UTF-8 bytes.`);
+		if (codePoint > 65535) index += 1;
+	}
+	return comma;
+}
+function hasBase64Parameter(value, start, end) {
+	let segmentStart = start;
+	for (let index = start; index <= end; index += 1) {
+		if (index < end && value.charCodeAt(index) !== 59) continue;
+		if (isBase64Parameter(value, segmentStart, index)) return true;
+		segmentStart = index + 1;
+	}
+	return false;
+}
+function isBase64Parameter(value, start, end) {
+	return end - start === 6 && (value.charCodeAt(start) | 32) === 98 && (value.charCodeAt(start + 1) | 32) === 97 && (value.charCodeAt(start + 2) | 32) === 115 && (value.charCodeAt(start + 3) | 32) === 101 && value.charCodeAt(start + 4) === 54 && value.charCodeAt(start + 5) === 52;
+}
+function isCanonicalBase64(value) {
+	if (value.length % 4 !== 0) return false;
+	let contentEnd = value.length;
+	if (contentEnd > 0 && value.charCodeAt(contentEnd - 1) === 61) {
+		contentEnd -= 1;
+		if (contentEnd > 0 && value.charCodeAt(contentEnd - 1) === 61) contentEnd -= 1;
+	}
+	for (let index = 0; index < contentEnd; index += 1) {
+		const codeUnit = value.charCodeAt(index);
+		if ((codeUnit < 65 || codeUnit > 90) && (codeUnit < 97 || codeUnit > 122) && (codeUnit < 48 || codeUnit > 57) && codeUnit !== 43 && codeUnit !== 47) return false;
+	}
+	const padding = value.length - contentEnd;
+	if (padding > 0) {
+		if ((base64Value(value.charCodeAt(contentEnd - 1)) & (padding === 2 ? 15 : 3)) !== 0) return false;
+	}
+	return true;
+}
+function base64Value(codeUnit) {
+	if (codeUnit >= 65 && codeUnit <= 90) return codeUnit - 65;
+	if (codeUnit >= 97 && codeUnit <= 122) return codeUnit - 97 + 26;
+	if (codeUnit >= 48 && codeUnit <= 57) return codeUnit - 48 + 52;
+	return codeUnit === 43 ? 62 : 63;
+}
+function isValidPercentData(value) {
+	if (value.indexOf("%") === -1) return true;
+	let index = 0;
+	let remaining = 0;
+	let continuationMin = 128;
+	let continuationMax = 191;
+	while (index < value.length) {
+		const codePoint = value.codePointAt(index);
+		if (codePoint > 127) {
+			if (remaining > 0) return false;
+			index += codePoint > 65535 ? 2 : 1;
+			continue;
+		}
+		let byte;
+		if (codePoint === 37) {
+			if (index + 2 >= value.length) return false;
+			const high = hexValue(value.charCodeAt(index + 1));
+			const low = hexValue(value.charCodeAt(index + 2));
+			if (high < 0 || low < 0) return false;
+			byte = high * 16 + low;
+			index += 3;
+		} else {
+			byte = codePoint;
+			index += 1;
+		}
+		if (remaining > 0) {
+			if (byte < continuationMin || byte > continuationMax) return false;
+			remaining -= 1;
+			continuationMin = 128;
+			continuationMax = 191;
+			continue;
+		}
+		if (byte <= 127) continue;
+		if (byte >= 194 && byte <= 223) remaining = 1;
+		else if (byte === 224) {
+			remaining = 2;
+			continuationMin = 160;
+		} else if (byte >= 225 && byte <= 236 || byte >= 238 && byte <= 239) remaining = 2;
+		else if (byte === 237) {
+			remaining = 2;
+			continuationMax = 159;
+		} else if (byte === 240) {
+			remaining = 3;
+			continuationMin = 144;
+		} else if (byte >= 241 && byte <= 243) remaining = 3;
+		else if (byte === 244) {
+			remaining = 3;
+			continuationMax = 143;
+		} else return false;
+	}
+	return remaining === 0;
+}
+function hexValue(codeUnit) {
+	if (codeUnit >= 48 && codeUnit <= 57) return codeUnit - 48;
+	if (codeUnit >= 65 && codeUnit <= 70) return codeUnit - 55;
+	if (codeUnit >= 97 && codeUnit <= 102) return codeUnit - 87;
+	return -1;
+}
+function hasDataUrlPrefix(value) {
+	return value.length >= 5 && (value.charCodeAt(0) | 32) === 100 && (value.charCodeAt(1) | 32) === 97 && (value.charCodeAt(2) | 32) === 116 && (value.charCodeAt(3) | 32) === 97 && value.charCodeAt(4) === 58;
+}
+function hasUtf8ByteLengthAtMost(value, maximum) {
+	let byteLength = 0;
+	for (let index = 0; index < value.length; index += 1) {
+		const codePoint = value.codePointAt(index);
+		byteLength += utf8CodePointBytes(codePoint);
+		if (byteLength > maximum) return false;
+		if (codePoint > 65535) index += 1;
+	}
+	return true;
+}
+function utf8CodePointBytes(codePoint) {
+	if (codePoint <= 127) return 1;
+	if (codePoint <= 2047) return 2;
+	if (codePoint <= 65535) return 3;
+	return 4;
+}
+function setBuffer(state, path, buffer, modelId) {
+	let target = state;
+	for (const token of path.slice(0, -1)) target = ownChild(target, token, modelId, path);
+	const finalToken = path.at(-1);
+	if (isNumberValue(finalToken)) {
+		if (!Array.isArray(target) || finalToken >= target.length || !Object.hasOwn(target, finalToken)) invalidBufferPath(modelId, path);
+		defineBuffer(target, finalToken, buffer);
+		return;
+	}
+	if (!isModelState(target)) invalidBufferPath(modelId, path);
+	defineBuffer(target, finalToken, buffer);
+}
+function defineBuffer(target, token, buffer) {
+	Object.defineProperty(target, token, {
+		value: buffer,
+		configurable: true,
+		enumerable: true,
+		writable: true
+	});
+}
+function ownChild(target, token, modelId, path) {
+	if (isNumberValue(token)) {
+		if (!Array.isArray(target) || token >= target.length || !Object.hasOwn(target, token)) invalidBufferPath(modelId, path);
+		const child = target[token];
+		if (child === void 0) invalidBufferPath(modelId, path);
+		return child;
+	}
+	if (!isModelState(target) || !Object.hasOwn(target, token)) invalidBufferPath(modelId, path);
+	const child = target[token];
+	if (child === void 0) invalidBufferPath(modelId, path);
+	return child;
+}
+function invalidBufferPath(modelId, _path) {
+	throw new TypeError(`AnyWidget model ${JSON.stringify(modelId)} has a buffer path that does not target existing state.`);
+}
+function collectReachableModels(rootModelId, models) {
+	const reachable = /* @__PURE__ */ new Set();
+	const pending = [rootModelId];
+	while (pending.length > 0) {
+		const id = pending.pop();
+		if (reachable.has(id)) continue;
+		const model = models.get(id);
+		if (model === void 0) throw new TypeError(`AnyWidget model reference ${quoteField(id)} is unresolved.`);
+		reachable.add(id);
+		for (const reference of findWidgetReferences(model.state)) pending.push(reference);
+	}
+	return reachable;
+}
+function findWidgetReferences(value) {
+	const references = [];
+	const visit = (value) => {
+		if (isModelString(value)) {
+			for (const prefix of ["anywidget:", "IPY_MODEL_"]) {
+				if (!value.startsWith(prefix)) continue;
+				const id = value.slice(prefix.length);
+				if (id.length === 0) throw new TypeError("AnyWidget state contains an empty model reference.");
+				references.push(id);
+				return;
+			}
+			return;
+		}
+		if (Array.isArray(value)) {
+			for (const child of value) visit(child);
+			return;
+		}
+		if (isModelState(value) && !(value instanceof DataView)) for (const child of Object.values(value)) visit(child);
+	};
+	visit(value);
+	return references;
+}
+function cloneJsonObject(value) {
+	return structuredClone(value);
+}
+function deepFreeze(value) {
+	if (ArrayBuffer.isView(value)) return value;
+	if (Array.isArray(value)) {
+		for (const child of value) deepFreeze(child);
+		return Object.freeze(value);
+	}
+	if (isModelState(value)) {
+		for (const child of Object.values(value)) deepFreeze(child);
+		return Object.freeze(value);
+	}
+	return value;
+}
+function exactKeys(value, expected, path) {
+	const allowed = new Set(expected);
+	const unexpected = [];
+	let unexpectedCount = 0;
+	for (const key of Object.keys(value)) {
+		if (allowed.has(key)) continue;
+		unexpectedCount += 1;
+		if (unexpected.length < MAX_UNEXPECTED_FIELDS) unexpected.push(key);
+	}
+	const missing = expected.filter((key) => !Object.hasOwn(value, key));
+	if (unexpectedCount > 0 || missing.length > 0) {
+		const missingText = missing.length === 0 ? "none" : missing.map(quoteField).join(", ");
+		const unexpectedText = renderUnexpectedFields(unexpected, unexpectedCount);
+		throw new TypeError(truncateDiagnostic(`${path} fields are invalid. Missing: ${missingText}. Unexpected: ${unexpectedText}.`));
+	}
+}
+function renderUnexpectedFields(fields, total) {
+	if (total === 0) return "none";
+	const rendered = fields.map(quoteField).join(", ");
+	const omitted = total - fields.length;
+	return omitted === 0 ? rendered : `${rendered}, ... (+${omitted} more)`;
+}
+function quoteField(value) {
+	let body = "";
+	const bodyLimit = 123;
+	let truncated = false;
+	for (let index = 0; index < value.length; index += 1) {
+		const codeUnit = value.charCodeAt(index);
+		let token;
+		if (codeUnit === 34 || codeUnit === 92) token = `\\${value[index]}`;
+		else if (codeUnit <= 31 || codeUnit >= 127 && codeUnit <= 159 || codeUnit >= 55296 && codeUnit <= 57343) {
+			if (codeUnit >= 55296 && codeUnit <= 56319 && index + 1 < value.length && value.charCodeAt(index + 1) >= 56320 && value.charCodeAt(index + 1) <= 57343) {
+				token = value.slice(index, index + 2);
+				index += 1;
+			} else token = `\\u${codeUnit.toString(16).padStart(4, "0")}`;
+		} else token = value[index];
+		if (body.length + token.length > bodyLimit) {
+			truncated = true;
+			break;
+		}
+		body += token;
+	}
+	return `"${body}${truncated ? "..." : ""}"`;
+}
+function truncateDiagnostic(value) {
+	if (value.length <= MAX_DIAGNOSTIC_LENGTH) return value;
+	return `${value.slice(0, 2045)}...`;
+}
+function nonEmptyString(value, path) {
+	if (!isStringValue(value) || value.length === 0) throw new TypeError(`${path} must be a non-empty string.`);
+	return value;
+}
+function array(value, path) {
+	if (!Array.isArray(value)) throw new TypeError(`${path} must be an array.`);
+	return value;
+}
+function record(value, path) {
+	if (!isModelState(value)) throw new TypeError(`${path} must be an object.`);
+	return value;
+}
+function isModelState(value) {
+	return isRecordValue(value) && !(value instanceof DataView);
+}
+function isModelString(value) {
+	return isStringValue(value);
+}
+function parseSnapshotValue(value) {
+	if (value === null) return null;
+	if (isBooleanValue(value) || isNumberValue(value) || isStringValue(value)) return value;
+	if (Array.isArray(value)) return value.map(parseSnapshotValue);
+	if (!isRecordValue(value)) throw new TypeError("AnyWidget payload must contain JSON values.");
+	const parsed = {};
+	for (const [key, child] of Object.entries(value)) parsed[key] = parseSnapshotValue(child);
+	return parsed;
+}
+//#endregion
+//#region ../loader-anywidget/src/runtime/abort.ts
+function combineAbortSignals(signals) {
+	const sources = [...new Set(signals)];
+	const candidate = Object.getOwnPropertyDescriptor(AbortSignal, "any")?.value;
+	if (isCallableValue(candidate)) return candidate(sources);
+	const controller = new AbortController();
+	const listeners = /* @__PURE__ */ new Map();
+	const settle = (signal) => {
+		for (const [source, listener] of listeners) source.removeEventListener("abort", listener);
+		listeners.clear();
+		controller.abort(signal.reason);
+	};
+	for (const signal of sources) {
+		if (signal.aborted) {
+			settle(signal);
+			break;
+		}
+		const listener = () => settle(signal);
+		listeners.set(signal, listener);
+		signal.addEventListener("abort", listener, { once: true });
+	}
+	return controller.signal;
+}
+async function raceAbort(task, signal, message) {
+	if (signal.aborted) throw abortReason(signal, message);
+	let onAbort;
+	const aborted = new Promise((_resolve, reject) => {
+		onAbort = () => reject(abortReason(signal, message));
+		signal.addEventListener("abort", onAbort, { once: true });
+	});
+	try {
+		return await Promise.race([task, aborted]);
+	} finally {
+		if (onAbort !== void 0) signal.removeEventListener("abort", onAbort);
+	}
+}
+function abortError(message) {
+	return Object.assign(new Error(message), { name: "AbortError" });
+}
+function abortReason(signal, message) {
+	return signal.reason instanceof Error ? signal.reason : abortError(message);
+}
+function throwIfAborted(signal, message) {
+	if (signal.aborted) throw abortReason(signal, message);
+}
+//#endregion
+//#region ../loader-anywidget/src/runtime/model-proxy.ts
+function modelProxy(model, signal) {
+	const events = modelEvents(model);
+	const listeners = /* @__PURE__ */ new Set();
+	return {
+		get(key) {
+			return model.get(key);
+		},
+		set(key, value) {
+			model.set(key, value);
+		},
+		save_changes() {
+			model.save_changes();
+		},
+		send: model.send.bind(model),
+		on(name, callback) {
+			if (signal.aborted) return;
+			let registration;
+			const onAbort = () => {
+				listeners.delete(registration);
+				events.off(name, callback);
+			};
+			registration = {
+				name,
+				callback,
+				onAbort
+			};
+			listeners.add(registration);
+			signal.addEventListener("abort", onAbort, { once: true });
+			try {
+				events.on(name, callback);
+			} catch (error) {
+				signal.removeEventListener("abort", onAbort);
+				listeners.delete(registration);
+				throw error;
+			}
+		},
+		off(name, callback) {
+			const normalizedName = name ?? null;
+			const normalizedCallback = callback ?? null;
+			try {
+				events.off(normalizedName, normalizedCallback);
+			} finally {
+				for (const listener of listeners) {
+					const matchesName = normalizedName === null || listener.name === normalizedName;
+					const matchesCallback = normalizedCallback === null || listener.callback === normalizedCallback;
+					if (!matchesName || !matchesCallback) continue;
+					signal.removeEventListener("abort", listener.onAbort);
+					listeners.delete(listener);
+				}
+			}
+		},
+		widget_manager: { async get_model(modelId) {
+			return modelProxy(await model.widget_manager.get_model(modelId), signal);
+		} }
+	};
+}
+function modelEvents(model) {
+	return model;
+}
+//#endregion
+//#region ../loader-anywidget/src/runtime/binding.ts
+const experimental = { async invoke() {
+	throw new Error("Exported AnyWidgets cannot invoke Python.");
+} };
+function resolveAnyWidgetModule(module, moduleUrl) {
+	if (!isPropertyOwner(module) || !("default" in module)) throw invalidModule(moduleUrl);
+	if (isAnyWidget(module.default)) return module.default;
+	if (module.default !== void 0) throw invalidModule(moduleUrl);
+	const render = callableMember(module, "render");
+	const initialize = callableMember(module, "initialize");
+	if (render === void 0 && initialize === void 0) throw invalidModule(moduleUrl);
+	return widgetDefinition({
+		render,
+		initialize
+	});
+}
+var WidgetBinding = class WidgetBinding {
+	#controller;
+	#widget;
+	#model;
+	#createHost;
+	#exports;
+	#cleanupTasks = /* @__PURE__ */ new Set();
+	#cleanupErrors = [];
+	#viewTasks = /* @__PURE__ */ new Set();
+	#destroyPromise;
+	#destroyed = false;
+	constructor(options) {
+		this.#controller = options.controller;
+		this.#widget = options.widget;
+		this.#model = options.model;
+		this.#createHost = options.createHost;
+		this.#exports = options.exports;
+	}
+	static async create(options) {
+		const { controller, model, createHost } = options;
+		const signal = controller.signal;
+		const widget = await raceAbort(Promise.resolve(isWidgetFactory(options.widget) ? options.widget() : options.widget), signal, "AnyWidget binding was disposed.");
+		let lateInitializeCleanup;
+		const settleLateInitializeCleanup = (cleanup) => {
+			lateInitializeCleanup ??= settleCleanup(cleanup);
+			return lateInitializeCleanup;
+		};
+		const initializeTask = Promise.resolve(widget.initialize?.({
+			model: modelProxy(model, signal),
+			experimental,
+			signal
+		}));
+		initializeTask.then(async (result) => {
+			if (signal.aborted && isCleanup(result)) await settleLateInitializeCleanup(result);
+		}).catch((cause) => {
+			if (signal.aborted) reportLateFailure("initialize", cause);
+		});
+		const initializeResult = await raceAbort(initializeTask, signal, "AnyWidget binding was disposed.");
+		if (signal.aborted) {
+			if (isCleanup(initializeResult)) await settleLateInitializeCleanup(initializeResult);
+			throw abortReason(signal, "AnyWidget binding was disposed.");
+		}
+		let exports;
+		let initializeCleanup;
+		if (isCleanup(initializeResult)) initializeCleanup = initializeResult;
+		else if (isPropertyOwner(initializeResult)) exports = initializeResult;
+		const binding = new WidgetBinding({
+			controller,
+			widget,
+			model,
+			createHost,
+			exports
+		});
+		if (initializeCleanup !== void 0) signal.addEventListener("abort", () => binding.#trackCleanup(initializeCleanup, "initialize"), { once: true });
+		return binding;
+	}
+	get exports() {
+		return this.#exports;
+	}
+	async createView(element, signal) {
+		const task = this.#createView(element, signal);
+		this.#viewTasks.add(task);
+		try {
+			await task;
+		} finally {
+			this.#viewTasks.delete(task);
+		}
+	}
+	destroy() {
+		this.#destroyPromise ??= this.#destroy();
+		return this.#destroyPromise;
+	}
+	async #createView(element, signal) {
+		const renderSignal = combineAbortSignals([signal, this.#controller.signal]);
+		if (renderSignal.aborted) throw abortReason(renderSignal, "AnyWidget view was disposed.");
+		element.replaceChildren();
+		let renderCleanupTask;
+		const settleRenderCleanup = (cleanup) => {
+			renderCleanupTask ??= this.#trackCleanup(cleanup, "render");
+			return renderCleanupTask;
+		};
+		const renderTask = Promise.resolve().then(() => this.#widget.render?.({
+			model: modelProxy(this.#model, renderSignal),
+			el: element,
+			experimental,
+			signal: renderSignal,
+			host: this.#createHost(renderSignal)
+		}));
+		renderTask.then((cleanup) => {
+			if (renderSignal.aborted && isCleanup(cleanup)) return settleRenderCleanup(cleanup);
+		}).catch((cause) => {
+			if (renderSignal.aborted) reportLateFailure("render", cause);
+		});
+		let cleanup;
+		try {
+			cleanup = await raceAbort(renderTask, renderSignal, "AnyWidget view was disposed.");
+		} catch (error) {
+			element.replaceChildren();
+			throw error;
+		}
+		const clear = () => element.replaceChildren();
+		if (!isCleanup(cleanup)) {
+			if (renderSignal.aborted) clear();
+			else renderSignal.addEventListener("abort", clear, { once: true });
+			return;
+		}
+		const release = () => {
+			settleRenderCleanup(cleanup).finally(clear);
+		};
+		if (renderSignal.aborted) {
+			release();
+			return;
+		}
+		renderSignal.addEventListener("abort", release, { once: true });
+	}
+	#trackCleanup(cleanup, phase) {
+		const task = settleCleanup(cleanup).catch((error) => {
+			const failure = new Error(`AnyWidget ${phase} cleanup failed.`, { cause: error });
+			if (this.#destroyed) reportLateFailure(phase, failure);
+			else this.#cleanupErrors.push(failure);
+		});
+		this.#cleanupTasks.add(task);
+		task.finally(() => this.#cleanupTasks.delete(task));
+		return task;
+	}
+	async #destroy() {
+		this.#controller.abort();
+		await Promise.allSettled(this.#viewTasks);
+		while (this.#cleanupTasks.size > 0) await Promise.all(this.#cleanupTasks);
+		this.#destroyed = true;
+		if (this.#cleanupErrors.length > 0) throw new AggregateError(this.#cleanupErrors, "AnyWidget cleanup failed.");
+	}
+};
+function reportLateFailure(phase, cause) {
+	console.error(`AnyWidget ${phase} settled after its mount was disposed.`, cause);
+}
+function isAnyWidget(value) {
+	return isCallableValue(value) || isPropertyOwner(value) && (callableMember(value, "render") !== void 0 || callableMember(value, "initialize") !== void 0);
+}
+function invalidModule(url) {
+	return /* @__PURE__ */ new Error(`AnyWidget module ${quoteDiagnostic(url)} must default-export a factory or an object with render or initialize.`);
+}
+function quoteDiagnostic(value) {
+	let body = "";
+	for (let index = 0; index < value.length; index += 1) {
+		const codeUnit = value.charCodeAt(index);
+		let token;
+		if (codeUnit === 34 || codeUnit === 92) token = `\\${value[index]}`;
+		else if (codeUnit <= 31 || codeUnit >= 127 && codeUnit <= 159 || codeUnit >= 55296 && codeUnit <= 57343) {
+			if (codeUnit >= 55296 && codeUnit <= 56319 && index + 1 < value.length && value.charCodeAt(index + 1) >= 56320 && value.charCodeAt(index + 1) <= 57343) {
+				token = value.slice(index, index + 2);
+				index += 1;
+			} else token = `\\u${codeUnit.toString(16).padStart(4, "0")}`;
+		} else token = value[index];
+		if (body.length + token.length > 123) return `"${body}..."`;
+		body += token;
+	}
+	return `"${body}"`;
+}
+function isCleanup(value) {
+	return isCallableValue(value);
+}
+async function settleCleanup(cleanup) {
+	await cleanup();
+}
+function callableMember(value, name) {
+	const member = Object.getOwnPropertyDescriptor(value, name)?.value;
+	return isCallableValue(member) ? member : void 0;
+}
+function isWidgetFactory(value) {
+	return isCallableValue(value);
+}
+function widgetDefinition(value) {
+	return value;
+}
+//#endregion
+//#region ../loader-anywidget/src/runtime/widget-ref.ts
+function parseWidgetRef(value) {
+	if (isStringValue(value) && value.startsWith("anywidget:")) {
+		const modelId = value.slice(10);
+		if (modelId.length > 0) return modelId;
+	}
+	throw new Error(`Invalid AnyWidget model reference: ${JSON.stringify(value)}.`);
+}
+//#endregion
+//#region ../loader-anywidget/src/runtime/host.ts
+function createHost(resolver, parentSignal) {
+	return {
+		async getModel(ref) {
+			throwIfAborted(parentSignal, "AnyWidget parent view was disposed.");
+			const model = await resolver.getModel(parseWidgetRef(ref));
+			throwIfAborted(parentSignal, "AnyWidget parent view was disposed.");
+			return modelProxy(model, parentSignal);
+		},
+		async getWidget(ref) {
+			throwIfAborted(parentSignal, "AnyWidget parent view was disposed.");
+			const widget = await resolver.getWidget(parseWidgetRef(ref));
+			throwIfAborted(parentSignal, "AnyWidget parent view was disposed.");
+			return {
+				exports: widget.exports,
+				async render({ el, signal }) {
+					const renderSignal = signal === void 0 || signal === parentSignal ? parentSignal : combineAbortSignals([parentSignal, signal]);
+					throwIfAborted(renderSignal, "AnyWidget parent view was disposed.");
+					await widget.render({
+						el,
+						signal: renderSignal
+					});
+				}
+			};
+		}
+	};
+}
+//#endregion
+//#region ../loader-anywidget/src/runtime/model.ts
+var StaticModel = class {
+	#resolver;
+	#dirtyFields = /* @__PURE__ */ new Map();
+	#data;
+	#listeners = /* @__PURE__ */ new Map();
+	#changeQueued = false;
+	constructor(data, resolver, signal) {
+		this.#data = data;
+		this.#resolver = resolver;
+		signal.addEventListener("abort", () => {
+			this.#listeners.clear();
+			this.#dirtyFields.clear();
+		}, { once: true });
+	}
+	get(key) {
+		if (Object.hasOwn(this.#data, key)) return this.#data[key];
+	}
+	set(key, value) {
+		this.#data = {
+			...this.#data,
+			[key]: value
+		};
+		this.#dirtyFields.set(key, value);
+		this.#emit(`change:${String(key)}`, value);
+		this.#queueAnyChange();
+	}
+	save_changes() {
+		this.#dirtyFields.clear();
+	}
+	send = (_content, callbacks) => {
+		if (isCallableValue(callbacks)) queueMicrotask(callbacks);
+	};
+	widget_manager = { get_model: async (modelId) => {
+		return await this.#resolver.getModel(widgetManagerModelId(modelId));
+	} };
+	on(eventName, callback, options) {
+		if (options?.signal?.aborted === true) return;
+		const listeners = this.#listeners.get(eventName) ?? /* @__PURE__ */ new Set();
+		listeners.add(callback);
+		this.#listeners.set(eventName, listeners);
+		options?.signal?.addEventListener("abort", () => this.off(eventName, callback), { once: true });
+	}
+	off(eventName, callback) {
+		if (!eventName) {
+			this.#listeners.clear();
+			return;
+		}
+		if (!callback) {
+			this.#listeners.delete(eventName);
+			return;
+		}
+		this.#listeners.get(eventName)?.delete(callback);
+	}
+	#emit(eventName, ...args) {
+		const listeners = this.#listeners.get(eventName);
+		if (listeners === void 0) return;
+		for (const listener of [...listeners]) try {
+			listener(...args);
+		} catch (error) {
+			console.error(`AnyWidget model listener for ${JSON.stringify(eventName)} failed.`, error);
+		}
+	}
+	#queueAnyChange() {
+		if (this.#changeQueued) return;
+		this.#changeQueued = true;
+		queueMicrotask(() => {
+			this.#changeQueued = false;
+			this.#emit("change");
+		});
+	}
+};
+function widgetManagerModelId(value) {
+	for (const prefix of ["IPY_MODEL_", "anywidget:"]) if (value.startsWith(prefix) && value.length > prefix.length) return value.slice(prefix.length);
+	return value;
+}
+//#endregion
+//#region ../loader-anywidget/src/runtime/module-cache.ts
+const MAX_PAGE_MODULES = 1024;
+const PAGE_MODULE_CACHE_SYMBOL = Symbol.for("@marimo-team/marimo-export:anywidget-module-cache:v1");
+const PAGE_MODULE_CACHE_VERSION = 1;
+const encoder = new TextEncoder();
+async function loadPageAnyWidget(spec, files) {
+	const source = await moduleSource(spec, files);
+	const modules = pageModuleCache().modules;
+	const existing = modules.get(source.cacheKey);
+	if (existing !== void 0) return existing;
+	if (modules.size >= 1024) throw new Error(`AnyWidget page module cache exceeds ${MAX_PAGE_MODULES} unique modules.`);
+	let promise;
+	promise = startImport(source, spec.url).catch((cause) => {
+		if (modules.get(source.cacheKey) === promise) modules.delete(source.cacheKey);
+		throw cause;
+	});
+	modules.set(source.cacheKey, promise);
+	return promise;
+}
+async function moduleSource(spec, files) {
+	const key = embeddedFileKey(spec.url);
+	const embedded = files[key];
+	if (embedded !== void 0) return {
+		cacheKey: await digestIdentity([
+			spec.hash,
+			"embedded",
+			key,
+			embedded
+		]),
+		importUrl: spec.url,
+		embedded
+	};
+	const importUrl = new URL(spec.url).href;
+	const kind = importUrl.startsWith("data:") ? "data" : "url";
+	return {
+		cacheKey: await digestIdentity([
+			spec.hash,
+			kind,
+			importUrl
+		]),
+		importUrl,
+		embedded: void 0
+	};
+}
+function startImport(source, diagnosticUrl) {
+	if (source.embedded === void 0) return resolveImportedWidget(importModule(source.importUrl), diagnosticUrl);
+	return importEmbeddedWidget(URL.createObjectURL(dataUrlToBlob(source.embedded)), diagnosticUrl);
+}
+async function importEmbeddedWidget(objectUrl, diagnosticUrl) {
+	try {
+		return resolveAnyWidgetModule(await importModule(objectUrl), diagnosticUrl);
+	} finally {
+		URL.revokeObjectURL(objectUrl);
+	}
+}
+async function resolveImportedWidget(task, diagnosticUrl) {
+	return resolveAnyWidgetModule(await task, diagnosticUrl);
+}
+function importModule(url) {
+	return import(
+		/* @vite-ignore */
+		/* webpackIgnore: true */
+		/* turbopackIgnore: true */
+		url
+);
+}
+function dataUrlToBlob(dataUrl) {
+	const { body, isBase64, mediaType } = parseDataUrl(dataUrl, "AnyWidget ESM data URL");
+	const bytes = isBase64 ? base64Bytes(body) : new TextEncoder().encode(decodeURIComponent(body));
+	return new Blob([bytes], { type: mediaType });
+}
+function base64Bytes(value) {
+	const binary = atob(value);
+	const bytes = new Uint8Array(binary.length);
+	for (let index = 0; index < binary.length; index += 1) bytes[index] = binary.charCodeAt(index);
+	return bytes;
+}
+async function digestIdentity(parts) {
+	const bytes = encoder.encode(JSON.stringify(parts));
+	const digest = await crypto.subtle.digest("SHA-256", new Uint8Array(bytes));
+	return [...new Uint8Array(digest)].map((byte) => byte.toString(16).padStart(2, "0")).join("");
+}
+function pageModuleCache() {
+	const existing = Object.getOwnPropertyDescriptor(globalThis, PAGE_MODULE_CACHE_SYMBOL)?.value;
+	if (existing !== void 0) {
+		if (isPageModuleCache(existing)) return existing;
+		throw new Error("AnyWidget page module cache has an incompatible value.");
+	}
+	const created = Object.freeze({
+		version: PAGE_MODULE_CACHE_VERSION,
+		modules: /* @__PURE__ */ new Map()
+	});
+	Object.defineProperty(globalThis, PAGE_MODULE_CACHE_SYMBOL, {
+		configurable: false,
+		enumerable: false,
+		value: created,
+		writable: false
+	});
+	return created;
+}
+function isPageModuleCache(value) {
+	if (!isPropertyOwner(value) || !("version" in value) || !("modules" in value)) return false;
+	return value.version === PAGE_MODULE_CACHE_VERSION && value.modules instanceof Map;
+}
+//#endregion
+//#region ../loader-anywidget/src/runtime/registry.ts
+const ACTIVE_MOUNTS = /* @__PURE__ */ new WeakSet();
+async function mountSnapshot(snapshot, element, options = {}) {
+	assertBrowserElement(element);
+	options.signal?.throwIfAborted();
+	if (ACTIVE_MOUNTS.has(element)) throw new Error("Dispose the existing AnyWidget mount before reusing its element.");
+	const registry = new StaticRegistry(snapshot);
+	ACTIVE_MOUNTS.add(element);
+	let disposePromise;
+	const dispose = () => {
+		disposePromise ??= registry.dispose().finally(() => ACTIVE_MOUNTS.delete(element));
+		return disposePromise;
+	};
+	const onAbort = () => {
+		dispose().catch(() => void 0);
+	};
+	options.signal?.addEventListener("abort", onAbort, { once: true });
+	try {
+		const binding = await registry.getBinding(snapshot.rootModelId);
+		await registry.createView(snapshot.rootModelId, element, registry.signal);
+		if (registry.signal.aborted) throw abortError("AnyWidget mount was disposed.");
+		options.signal?.throwIfAborted();
+		const model = await registry.getModel(snapshot.rootModelId);
+		if (registry.signal.aborted) throw abortError("AnyWidget mount was disposed.");
+		options.signal?.throwIfAborted();
+		return Object.freeze({
+			model,
+			exports: binding.exports,
+			async dispose() {
+				options.signal?.removeEventListener("abort", onAbort);
+				await dispose();
+			}
+		});
+	} catch (error) {
+		options.signal?.removeEventListener("abort", onAbort);
+		try {
+			await dispose();
+		} catch (cleanupError) {
+			throw new AggregateError([error, cleanupError], "AnyWidget mount and cleanup failed.");
+		}
+		throw error;
+	}
+}
+var StaticRegistry = class {
+	#snapshot;
+	#controller = new AbortController();
+	#runtimes = /* @__PURE__ */ new Map();
+	#bindings = /* @__PURE__ */ new Map();
+	#bindingOrder = [];
+	#disposePromise;
+	#disposing = false;
+	constructor(snapshot) {
+		this.#snapshot = snapshot;
+		for (const model of snapshot.models.values()) {
+			const state = cloneModelState(model.state);
+			const runtime = {
+				model: new StaticModel(state, this, this.#controller.signal),
+				esmSpec: model.esmSpec,
+				styleMounts: /* @__PURE__ */ new Map(),
+				css: isStringValue(state._css) ? state._css : ""
+			};
+			runtime.model.on("change:_css", () => {
+				const css = runtime.model.get("_css");
+				runtime.css = isStringValue(css) ? css : "";
+				for (const mount of runtime.styleMounts.values()) mount.update(runtime.css);
+			}, { signal: this.#controller.signal });
+			this.#runtimes.set(model.id, runtime);
+		}
+	}
+	get signal() {
+		return this.#controller.signal;
+	}
+	async getModel(modelId) {
+		return this.#runtime(modelId).model;
+	}
+	async getWidget(modelId) {
+		return {
+			exports: (await this.getBinding(modelId)).exports,
+			render: async ({ el, signal }) => {
+				await this.createView(modelId, el, signal ?? this.#controller.signal);
+			}
+		};
+	}
+	getBinding(modelId) {
+		if (this.#disposing) return Promise.reject(abortError("AnyWidget registry was disposed."));
+		const existing = this.#bindings.get(modelId);
+		if (existing !== void 0) return existing.promise;
+		const runtime = this.#runtime(modelId);
+		if (runtime.esmSpec === void 0) return Promise.reject(/* @__PURE__ */ new Error(`AnyWidget model ${JSON.stringify(modelId)} has no ESM spec.`));
+		const controller = new AbortController();
+		const onDispose = () => controller.abort(this.#controller.signal.reason);
+		if (this.#controller.signal.aborted) onDispose();
+		else this.#controller.signal.addEventListener("abort", onDispose, { once: true });
+		const state = {};
+		const promise = raceAbort(this.#loadWidget(runtime.esmSpec), controller.signal, "AnyWidget binding was disposed.").then((widget) => WidgetBinding.create({
+			widget,
+			model: runtime.model,
+			createHost: (signal) => createHost(this, signal),
+			controller
+		})).then((binding) => {
+			state.binding = binding;
+			this.#bindingOrder.push(binding);
+			return binding;
+		}).catch((cause) => {
+			controller.abort();
+			this.#bindings.delete(modelId);
+			throw cause;
+		}).finally(() => this.#controller.signal.removeEventListener("abort", onDispose));
+		this.#bindings.set(modelId, {
+			controller,
+			promise,
+			state
+		});
+		return promise;
+	}
+	async createView(modelId, element, signal) {
+		if (signal.aborted || this.#controller.signal.aborted) throw abortError("AnyWidget view was disposed.");
+		const runtime = this.#runtime(modelId);
+		const controller = new AbortController();
+		const viewSignal = combineAbortSignals([
+			signal,
+			this.#controller.signal,
+			controller.signal
+		]);
+		try {
+			this.#mountStyle(runtime, element, viewSignal);
+			await (await this.getBinding(modelId)).createView(element, viewSignal);
+		} catch (error) {
+			controller.abort(error);
+			throw error;
+		}
+	}
+	dispose() {
+		if (this.#disposePromise === void 0) {
+			this.#disposing = true;
+			const entries = [...this.#bindings.values()];
+			for (const entry of entries) if (entry.state.binding === void 0) entry.controller.abort();
+			this.#disposePromise = this.#dispose(entries);
+		}
+		return this.#disposePromise;
+	}
+	async #loadWidget(spec) {
+		if (this.#disposing) throw abortError("AnyWidget registry was disposed.");
+		return loadPageAnyWidget(spec, this.#snapshot.files);
+	}
+	#runtime(modelId) {
+		const runtime = this.#runtimes.get(modelId);
+		if (runtime === void 0) throw new Error(`AnyWidget model ${JSON.stringify(modelId)} is missing from this mount.`);
+		return runtime;
+	}
+	#mountStyle(runtime, element, signal) {
+		const root = element.getRootNode();
+		if (!isDocument(root) && !isShadowRoot(root)) return;
+		let mount = runtime.styleMounts.get(root);
+		if (mount === void 0) {
+			mount = createStyleMount(root, runtime.css);
+			runtime.styleMounts.set(root, mount);
+		}
+		mount.references += 1;
+		let released = false;
+		signal.addEventListener("abort", () => {
+			if (released) return;
+			released = true;
+			const current = runtime.styleMounts.get(root);
+			if (current === void 0) return;
+			current.references -= 1;
+			if (current.references === 0) {
+				current.dispose();
+				runtime.styleMounts.delete(root);
+			}
+		}, { once: true });
+	}
+	async #dispose(entries) {
+		const errors = [];
+		await Promise.allSettled(entries.map((entry) => entry.promise));
+		for (const binding of [...this.#bindingOrder].reverse()) try {
+			await binding.destroy();
+		} catch (error) {
+			errors.push(error);
+		}
+		this.#controller.abort();
+		for (const runtime of this.#runtimes.values()) {
+			for (const mount of runtime.styleMounts.values()) mount.dispose();
+			runtime.styleMounts.clear();
+		}
+		if (errors.length > 0) throw new AggregateError(errors, "AnyWidget cleanup failed.");
+	}
+};
+function createStyleMount(root, css) {
+	const style = (isDocument(root) ? root : root.ownerDocument).createElement("style");
+	style.textContent = css;
+	if (isDocument(root)) root.head.append(style);
+	else root.append(style);
+	return {
+		references: 0,
+		update(nextCss) {
+			style.textContent = nextCss;
+		},
+		dispose() {
+			style.remove();
+		}
+	};
+}
+function isDocument(node) {
+	return node.nodeType === 9 && "head" in node;
+}
+function isShadowRoot(node) {
+	return node.nodeType === 11 && "host" in node;
+}
+function assertBrowserElement(element) {
+	if (globalThis.document === void 0 || globalThis.window === void 0 || !isPropertyOwner(element) || element.nodeType !== 1 || !("replaceChildren" in element)) throw new TypeError("AnyWidget mount requires a browser element.");
+}
+//#endregion
+//#region ../loader-anywidget/src/runtime/prepared-graph.ts
+var PreparedWidgetGraphReplacementError = class extends Error {
+	remount = true;
+	constructor(cause) {
+		super("Prepared AnyWidget graph replacement requires a full remount", { cause });
+		this.name = "PreparedWidgetGraphReplacementError";
+	}
+};
+const emptyGraph = () => ({
+	files: Object.freeze({}),
+	records: /* @__PURE__ */ new Map()
+});
+const graphFailure = (cause) => cause instanceof Error ? cause : new Error(String(cause));
+const sameFiles = (left, right) => {
+	const leftNames = Object.keys(left);
+	const rightNames = Object.keys(right);
+	return leftNames.length === rightNames.length && leftNames.every((name) => Object.hasOwn(right, name) && left[name] === right[name]);
+};
+const snapshotCopy = (snapshot, port) => {
+	const records = /* @__PURE__ */ new Map();
+	snapshot.records.forEach((record, key) => {
+		const id = port.id(record);
+		if (id !== key) throw new Error(`Prepared AnyWidget graph record ${JSON.stringify(key)} has identity ${JSON.stringify(id)}`);
+		records.set(id, record);
+	});
+	return Object.freeze({
+		files: Object.freeze({ ...snapshot.files }),
+		records
+	});
+};
+const changesFor = (previous, next, port) => {
+	const additions = [];
+	const stableUpdates = [];
+	const replacements = [];
+	next.records.forEach((record, id) => {
+		if (!port.active(record)) return;
+		const current = previous.records.get(id);
+		if (current === void 0 || !port.active(current)) {
+			additions.push(record);
+			return;
+		}
+		if (port.same(current, record)) return;
+		if (port.changesModule(current, record)) replacements.push(record);
+		else stableUpdates.push(record);
+	});
+	return {
+		additions,
+		stableUpdates,
+		replacements,
+		removals: []
+	};
+};
+const currentRecordActive = (next, id, port) => {
+	const record = next.records.get(id);
+	return record !== void 0 && port.active(record);
+};
+const plannedChanges = (previous, next, port) => {
+	return {
+		...changesFor(previous, next, port),
+		removals: [...previous.records.entries()].filter(([id, record]) => port.active(record) && !currentRecordActive(next, id, port)).map(([, record]) => record)
+	};
+};
+const captureStates = (changes, port) => {
+	const capture = (records) => new Map(records.map((record) => [port.id(record), port.capture(port.id(record))]));
+	return {
+		stable: capture(changes.stableUpdates),
+		replacements: capture(changes.replacements),
+		removals: capture(changes.removals)
+	};
+};
+const attempt = async (errors, action) => {
+	try {
+		await action();
+	} catch (error) {
+		errors.push(graphFailure(error));
+	}
+};
+const eachSequential = async (values, action) => {
+	for (const value of values) await action(value);
+};
+const throwCleanup = (errors, message) => {
+	if (errors.length === 1) throw errors[0];
+	if (errors.length > 1) throw new AggregateError(errors, message);
+};
+const settledReplacement = (mutated, remount, settle) => {
+	let committed = false;
+	let commitFailure;
+	let commitTask;
+	let rollbackTask;
+	return Object.freeze({
+		mutated,
+		remount,
+		commit() {
+			if (rollbackTask !== void 0) return rollbackTask.then(() => void 0);
+			commitTask ??= Promise.resolve().then(() => settle(true)).then((result) => {
+				committed = true;
+				return result;
+			}).catch((cause) => {
+				commitFailure = graphFailure(cause);
+				throw cause;
+			});
+			return commitTask;
+		},
+		rollback() {
+			rollbackTask ??= (commitTask ?? Promise.resolve()).catch(() => {}).then(async () => {
+				if (committed) return;
+				try {
+					await settle(false);
+				} catch (error) {
+					throw new PreparedWidgetGraphReplacementError(commitFailure === void 0 ? graphFailure(error) : new AggregateError([commitFailure, graphFailure(error)], "Prepared AnyWidget graph commit and rollback failed"));
+				}
+			});
+			return rollbackTask;
+		}
+	});
+};
+var PreparedWidgetGraph = class {
+	#checkpoints = /* @__PURE__ */ new WeakMap();
+	#port;
+	#current;
+	#active;
+	#operation;
+	#pending;
+	#disposed = false;
+	#disposal;
+	constructor(port, initial = emptyGraph()) {
+		this.#port = port;
+		this.#current = snapshotCopy(initial, port);
+		this.#port.setFiles(this.#current.files);
+	}
+	checkpoint() {
+		this.#requireIdle();
+		const records = new Map(this.#current.records);
+		this.#current.records.forEach((record, id) => {
+			if (this.#port.active(record)) records.set(id, this.#port.merge(record, this.#port.capture(id)));
+		});
+		const snapshot = snapshotCopy({
+			files: this.#current.files,
+			records
+		}, this.#port);
+		const checkpoint = Object.freeze({});
+		this.#checkpoints.set(checkpoint, {
+			snapshot,
+			source: this.#current
+		});
+		return checkpoint;
+	}
+	replace(target, signal) {
+		if (signal?.aborted) return Promise.reject(abortReason(signal, "Prepared AnyWidget graph replacement aborted"));
+		if (this.#disposed) return Promise.resolve(settledReplacement(false, false, () => void 0));
+		this.#requireIdle();
+		const controller = new AbortController();
+		const abort = () => {
+			if (signal !== void 0) controller.abort(abortReason(signal, "Prepared AnyWidget graph replacement aborted"));
+		};
+		signal?.addEventListener("abort", abort, { once: true });
+		if (signal?.aborted) abort();
+		this.#active = controller;
+		const operation = this.#replace(target, controller.signal);
+		this.#operation = operation;
+		return operation.finally(() => {
+			signal?.removeEventListener("abort", abort);
+			if (this.#active === controller) this.#active = void 0;
+			if (this.#operation === operation) this.#operation = void 0;
+		});
+	}
+	dispose() {
+		this.#disposal ??= this.#dispose();
+		return this.#disposal;
+	}
+	async #replace(target, signal) {
+		const checkpoint = this.#checkpoints.get(target);
+		const value = checkpoint === void 0 ? target : checkpoint.snapshot;
+		const next = snapshotCopy(value, this.#port);
+		const adopt = checkpoint?.source ?? next;
+		const previous = this.#current;
+		const changes = plannedChanges(previous, next, this.#port);
+		if (!(!sameFiles(previous.files, next.files) || changes.additions.length > 0 || changes.stableUpdates.length > 0 || changes.replacements.length > 0 || changes.removals.length > 0)) return this.#replacement(false, false, () => {
+			this.#current = adopt;
+			return adopt;
+		});
+		return this.#stage(previous, next, adopt, changes, signal);
+	}
+	async #stage(previous, next, adopt, changes, signal) {
+		this.#port.setFiles({
+			...previous.files,
+			...next.files
+		});
+		try {
+			await this.#preflight(changes, signal);
+		} catch (error) {
+			this.#port.setFiles(previous.files);
+			throw error;
+		}
+		let live;
+		try {
+			live = captureStates(changes, this.#port);
+		} catch (error) {
+			this.#port.setFiles(previous.files);
+			throw error;
+		}
+		const added = /* @__PURE__ */ new Set();
+		const replaced = /* @__PURE__ */ new Set();
+		const removed = /* @__PURE__ */ new Set();
+		const rollback = () => this.#rollback(previous, changes, live, added, replaced, removed);
+		let remount = false;
+		try {
+			await eachSequential(changes.additions, async (record) => {
+				signal.throwIfAborted();
+				added.add(this.#port.id(record));
+				await this.#port.replay(record, signal);
+			});
+			await eachSequential(changes.stableUpdates, async (record) => {
+				signal.throwIfAborted();
+				await this.#port.replay(record, signal);
+			});
+			await eachSequential(changes.replacements, async (record) => {
+				signal.throwIfAborted();
+				const id = this.#port.id(record);
+				const state = live.replacements.get(id);
+				replaced.add(id);
+				remount = true;
+				await this.#port.close(id);
+				await this.#port.replay(this.#port.merge(record, state), signal);
+			});
+			signal.throwIfAborted();
+		} catch (error) {
+			const failure = graphFailure(error);
+			try {
+				await rollback();
+			} catch (rollbackError) {
+				throw new PreparedWidgetGraphReplacementError(new AggregateError([failure, graphFailure(rollbackError)], "Prepared AnyWidget graph replacement and rollback failed"));
+			}
+			if (remount) throw new PreparedWidgetGraphReplacementError(failure);
+			throw failure;
+		}
+		return this.#replacement(true, changes.replacements.length > 0, async (commit) => {
+			if (!commit) {
+				await rollback();
+				return;
+			}
+			await eachSequential(changes.removals, async (record) => {
+				const id = this.#port.id(record);
+				removed.add(id);
+				await this.#port.close(id);
+			});
+			this.#port.setFiles(next.files);
+			this.#current = adopt;
+			return adopt;
+		});
+	}
+	async #preflight(changes, signal) {
+		await eachSequential([
+			...changes.additions,
+			...changes.stableUpdates,
+			...changes.replacements
+		], async (record) => {
+			signal.throwIfAborted();
+			await this.#port.validate?.(record, signal);
+		});
+		await eachSequential([...changes.additions, ...changes.replacements], async (record) => {
+			signal.throwIfAborted();
+			await this.#port.preflight?.(record, signal);
+		});
+		signal.throwIfAborted();
+	}
+	async #rollback(previous, changes, live, added, replaced, removed) {
+		this.#port.setFiles(previous.files);
+		const errors = [];
+		await eachSequential(added, (id) => attempt(errors, () => this.#port.close(id)));
+		await eachSequential(live.stable, ([id, state]) => attempt(errors, () => this.#port.restore(id, state)));
+		await this.#replayPrevious(errors, previous, live.replacements, replaced);
+		await this.#replayPrevious(errors, previous, live.removals, removed);
+		throwCleanup(errors, "Prepared AnyWidget graph rollback failed");
+	}
+	async #replayPrevious(errors, previous, states, ids) {
+		await eachSequential(ids, async (id) => {
+			const record = previous.records.get(id);
+			const state = states.get(id);
+			if (record === void 0 || state === void 0) return;
+			await attempt(errors, () => this.#port.close(id));
+			await attempt(errors, () => this.#port.replay(this.#port.merge(record, state)));
+		});
+	}
+	#replacement(mutated, remount, settle) {
+		const replacement = settledReplacement(mutated, remount, async (commit) => {
+			let settled = false;
+			try {
+				const result = await settle(commit);
+				settled = true;
+				return result;
+			} finally {
+				if (settled && this.#pending === replacement) this.#pending = void 0;
+			}
+		});
+		this.#pending = replacement;
+		return replacement;
+	}
+	#requireIdle() {
+		if (this.#disposed) throw new Error("Prepared AnyWidget graph is disposed");
+		if (this.#operation !== void 0 || this.#pending !== void 0) throw new Error("A prepared AnyWidget graph replacement is already active");
+	}
+	async #dispose() {
+		this.#disposed = true;
+		this.#active?.abort(new DOMException("Prepared AnyWidget graph disposed", "AbortError"));
+		const errors = [];
+		if (this.#operation !== void 0) await attempt(errors, () => this.#operation?.then(() => {}));
+		if (this.#pending !== void 0) await attempt(errors, () => this.#pending?.rollback());
+		await eachSequential(this.#current.records, ([id, record]) => this.#port.active(record) ? attempt(errors, () => this.#port.close(id)) : void 0);
+		await attempt(errors, () => this.#port.setFiles({}));
+		this.#current = emptyGraph();
+		throwCleanup(errors, "Prepared AnyWidget graph disposal failed");
+	}
+};
+//#endregion
+//#region ../loader-anywidget/src/index.ts
+/** Decode exported AnyWidget bytes and prepare them for browser mounting. */
+async function loadAnyWidget(data, signal) {
+	signal?.throwIfAborted();
+	const value = JSON.parse(new TextDecoder("utf-8", { fatal: true }).decode(data));
+	signal?.throwIfAborted();
+	const snapshot = parseAnyWidgetPayload(value);
+	const initialState = specializeState(readonlyModelState(snapshot.models.get(snapshot.rootModelId).state));
+	return Object.freeze({
+		initialState,
+		async mount(element, options = {}) {
+			return mountSnapshot(snapshot, element, options);
+		}
+	});
+}
+function specializeState(state) {
+	return state;
+}
+//#endregion
+//#region src/loader/anywidget.ts
+const MEDIA_TYPE = "application/vnd.marimo-export.anywidget.v1+json";
+/** Decode an exported AnyWidget value and prepare it for browser mounting. */
+const anyWidgetLoader = () => defineBlobAssetLoader({
+	mediaTypes: MEDIA_TYPE,
+	load: ({ payload, signal }) => loadAnyWidget(payload.data, signal)
+});
+//#endregion
+export { PreparedWidgetGraph, PreparedWidgetGraphReplacementError, anyWidgetLoader };