@ulearning/ai-generative-frame 0.0.0-stage → 1.0.0-next.0

package/dist/widget.js

@@ -0,0 +1,655 @@
+import { DEFAULT_LIGHT_TOKENS } from "./theme.js";
+import { buildBootstrapHtml, themeContext } from "./bootstrap.js";
+import { GENFRAME_PROTOCOL_VERSION, INIT_MESSAGE, METHODS } from "./protocol.js";
+import { RPC_ERROR, RpcError, createRpcPeer, isJsonRpcMessage } from "./rpc.js";
+import { VERSION } from "./version.js";
+import { SafeContentFrame } from "@ulearning/ai-safe-content-frame";
+// src/widget.ts
+const DEFAULT_PRODUCT = "generative-frame";
+/** The Safe Content Frame salt behind a widget id's stable origin. */
+const widgetStorageSalt = (id) => `genframe:v1:${id}`;
+/**
+* An opaque origin cannot be named as a `postMessage` target, so messages to
+* the frame use `"*"`. A sandboxed frame keeps its opaque origin and window
+* when it navigates, so after a navigated document loads, `origin` stops
+* matching and nothing is posted to the frame. Loads are counted from the
+* bootstrap's first ready message, so an extra initial `about:blank` load in
+* some browser cannot cut off the bootstrap itself. A navigated document can
+* still post before its own `load`; that grants it nothing the widget code
+* could not already do.
+*/
+const opaqueFrame = { async renderHtml(html, container) {
+	const iframe = container.ownerDocument.createElement("iframe");
+	iframe.setAttribute("sandbox", "allow-scripts");
+	iframe.style.cssText = "border:none;width:100%;height:100%";
+	iframe.srcdoc = html;
+	let ready = false;
+	let loads = 0;
+	const onMessage = (event) => {
+		if (event.source === iframe.contentWindow && event.data?.type === "genframe:ready") ready = true;
+	};
+	window.addEventListener("message", onMessage);
+	iframe.addEventListener("load", () => {
+		if (ready) loads++;
+	});
+	container.appendChild(iframe);
+	return {
+		iframe,
+		get origin() {
+			return loads > 1 ? "" : "null";
+		},
+		sendMessage: (data, transfer) => {
+			if (loads > 1) return;
+			iframe.contentWindow?.postMessage(data, "*", transfer);
+		},
+		fullyLoadedPromiseWithTimeout: async () => {},
+		dispose: () => {
+			window.removeEventListener("message", onMessage);
+			iframe.remove();
+		}
+	};
+} };
+const resolveFrame = (options) => {
+	if (options.opaqueOrigin) {
+		if (options.frame || options.id !== void 0 || options.unsafeShimDomain !== void 0) throw new TypeError("`opaqueOrigin` renders without Safe Content Frame, so it cannot be combined with `frame`, `id`, or `unsafeShimDomain`.");
+		return opaqueFrame;
+	}
+	if (options.frame && (options.id !== void 0 || options.unsafeShimDomain !== void 0)) throw new TypeError("`frame` cannot be combined with `id` or `unsafeShimDomain`; configure the `SafeContentFrame` instead, with `salt: widgetStorageSalt(id)` and `unsafeShimDomain` as needed.");
+	return options.frame ?? new SafeContentFrame(options.product ?? DEFAULT_PRODUCT, {
+		...options.id !== void 0 ? { salt: widgetStorageSalt(options.id) } : {},
+		...options.unsafeShimDomain !== void 0 ? { unsafeShimDomain: options.unsafeShimDomain } : {}
+	});
+};
+/** Lets `clearWidgetStorage` send a request no public method exposes. */
+const internalRequests = /* @__PURE__ */ new WeakMap();
+const DEFAULT_READY_TIMEOUT_MS = 15e3;
+const REQUEST_TIMEOUT_MS = 3e4;
+const SCRIPT_TAG = /<script[\s>]/i;
+const REVEAL_MS = 120;
+const prefersReducedMotion = () => window.matchMedia?.("(prefers-reduced-motion: reduce)").matches ?? false;
+const promptText = (params) => {
+	const content = params.content ?? [];
+	return Object.keys(content).filter((key) => {
+		const index = Number(key);
+		return Number.isInteger(index) && index >= 0 && index < content.length && String(index) === key;
+	}).map((key) => content[Number(key)]).filter((part) => typeof part === "object" && part !== null && part.type === "text" && typeof part.text === "string").map((part) => part.text).join("\n");
+};
+const VALID_DISPLAY_MODES = [
+	"inline",
+	"fullscreen",
+	"pip"
+];
+const isDisplayMode = (value) => VALID_DISPLAY_MODES.some((mode) => mode === value);
+const isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+/** How many characters a widget's state may take as JSON. A shared object counts once for each place it appears, as it does once serialized, so checking and saving a state stay bounded however the widget shares objects. */
+const MAX_STATE_LENGTH = 1e6;
+/** The length of `text` once JSON quotes and escapes it. */
+const jsonStringLength = (text) => {
+	let length = text.length + 2;
+	for (let index = 0; index < text.length; index++) {
+		const code = text.charCodeAt(index);
+		if (code === 34 || code === 92) length += 1;
+		else if (code < 32) length += code === 8 || code === 9 || code === 10 || code === 12 || code === 13 ? 1 : 5;
+		else if (code >= 55296 && code <= 56319) {
+			const next = text.charCodeAt(index + 1);
+			if (next >= 56320 && next <= 57343) index++;
+			else length += 5;
+		} else if (code >= 56320 && code <= 57343) length += 5;
+	}
+	return length;
+};
+const isPlainJson = (state) => {
+	let budget = MAX_STATE_LENGTH;
+	const spend = (length) => (budget -= length) >= 0;
+	const spendText = (text) => text.length + 2 <= budget && spend(jsonStringLength(text));
+	const ancestors = /* @__PURE__ */ new Set();
+	const check = (value) => {
+		if (value === null || typeof value === "boolean") return spend(5);
+		if (typeof value === "string") return spendText(value);
+		if (typeof value === "number") return Number.isFinite(value) && spend(String(value).length);
+		if (typeof value !== "object" || ancestors.has(value) || !spend(2)) return false;
+		const array = Array.isArray(value);
+		const prototype = Object.getPrototypeOf(value);
+		if (array ? prototype !== Array.prototype : prototype !== Object.prototype && prototype !== null) return false;
+		ancestors.add(value);
+		const keys = Reflect.ownKeys(value);
+		if (array && keys.length !== value.length + 1) return false;
+		if (array) for (let index = 0; index < value.length; index++) {
+			const property = Object.getOwnPropertyDescriptor(value, String(index));
+			if (!property || !("value" in property) || !spend(1) || !check(property.value)) return false;
+		}
+		else for (const key of keys) {
+			if (typeof key !== "string") return false;
+			const property = Object.getOwnPropertyDescriptor(value, key);
+			if (!property || !("value" in property) || !property.enumerable || !spendText(key) || !spend(2) || !check(property.value)) return false;
+		}
+		ancestors.delete(value);
+		return true;
+	};
+	return check(state);
+};
+const isAppInfo = (value) => isRecord(value) && typeof value["name"] === "string" && typeof value["version"] === "string";
+const getAppCapabilities = (value) => {
+	if (!isRecord(value)) return void 0;
+	const { availableDisplayModes, ...rest } = value;
+	return {
+		...rest,
+		...Array.isArray(availableDisplayModes) ? { availableDisplayModes: Object.values(availableDisplayModes).filter(isDisplayMode) } : {}
+	};
+};
+const getInitializeParams = (params) => {
+	if (!isRecord(params)) return {};
+	const appCapabilities = getAppCapabilities(params["appCapabilities"]);
+	return {
+		...isAppInfo(params["appInfo"]) ? { appInfo: params["appInfo"] } : {},
+		...appCapabilities ? { appCapabilities } : {},
+		...typeof params["protocolVersion"] === "string" ? { protocolVersion: params["protocolVersion"] } : {}
+	};
+};
+const defaultOpenLink = (url) => {
+	window.open(url, "_blank", "noopener,noreferrer");
+};
+/**
+* Mounts a widget frame in `container`. The frame loads a bootstrap document
+* once through Safe Content Frame; code then streams in over a private
+* `MessagePort`, so every chunk renders without reloading the frame.
+*/
+function createWidget(options) {
+	const { container } = options;
+	const frame = resolveFrame(options);
+	const minHeight = options.minHeight ?? 0;
+	const maxHeight = options.maxHeight ?? Number.POSITIVE_INFINITY;
+	const readyTimeoutMs = options.readyTimeoutMs ?? DEFAULT_READY_TIMEOUT_MS;
+	let tokens = options.tokens ?? DEFAULT_LIGHT_TOKENS;
+	let context = {
+		...themeContext(tokens),
+		platform: "web",
+		...Number.isFinite(maxHeight) ? { containerDimensions: { maxHeight } } : {},
+		...options.context
+	};
+	let code = "";
+	let widgetState = options.initialState ?? null;
+	let ended = false;
+	let disposed = false;
+	let lastToolInput;
+	let lastToolResult;
+	const listeners = /* @__PURE__ */ new Map();
+	const emit = (event, payload) => {
+		for (const listener of listeners.get(event) ?? []) try {
+			listener(payload);
+		} catch (error) {
+			console.error(error);
+		}
+	};
+	const reportError = (error) => {
+		options.onError?.(error);
+		emit("error", error);
+	};
+	const onRequest = async (method, params) => {
+		const p = params ?? {};
+		switch (method) {
+			case METHODS.initialize: return {
+				protocolVersion: typeof p["protocolVersion"] === "string" ? p["protocolVersion"] : GENFRAME_PROTOCOL_VERSION,
+				hostInfo: {
+					name: "generative-frame",
+					version: VERSION
+				},
+				hostCapabilities: {
+					openLinks: {},
+					...options.onCallTool ? { serverTools: {} } : {},
+					...options.onMessage || options.onPrompt ? { message: { text: {} } } : {},
+					...options.onUpdateModelContext ? { updateModelContext: {
+						text: {},
+						structuredContent: {}
+					} } : {},
+					logging: {}
+				},
+				hostContext: context
+			};
+			case METHODS.message:
+				if (options.onMessage) return options.onMessage(p);
+				if (options.onPrompt) {
+					await options.onPrompt(promptText(p));
+					return {};
+				}
+				throw new RpcError(RPC_ERROR.methodNotFound, "This host does not accept messages");
+			case METHODS.openLink: {
+				const url = p["url"];
+				let protocol = "";
+				try {
+					protocol = typeof url === "string" ? new URL(url).protocol : "";
+				} catch {}
+				if (protocol !== "http:" && protocol !== "https:") throw new RpcError(RPC_ERROR.invalidParams, "ui/open-link requires an http(s) URL");
+				await (options.onOpenLink ?? defaultOpenLink)(url);
+				return {};
+			}
+			case METHODS.callTool: {
+				if (!options.onCallTool) throw new RpcError(RPC_ERROR.methodNotFound, "This host does not expose tools");
+				if (typeof p["name"] !== "string") throw new RpcError(RPC_ERROR.invalidParams, "tools/call requires a string 'name'");
+				const args = p["arguments"];
+				if (args !== void 0 && (typeof args !== "object" || args === null || Array.isArray(args))) throw new RpcError(RPC_ERROR.invalidParams, "tools/call 'arguments' must be an object");
+				return options.onCallTool({
+					name: p["name"],
+					...args !== void 0 ? { arguments: args } : {}
+				});
+			}
+			case METHODS.requestDisplayMode: {
+				const mode = p["mode"];
+				if (!isDisplayMode(mode)) throw new RpcError(RPC_ERROR.invalidParams, "ui/request-display-mode requires a valid 'mode'");
+				if (!options.onRequestDisplayMode) return { mode: context.displayMode ?? "inline" };
+				return await options.onRequestDisplayMode({ mode }) ?? { mode };
+			}
+			case METHODS.copyText:
+				if (!options.onCopyText) throw new RpcError(RPC_ERROR.methodNotFound, "This host does not copy text");
+				if (typeof p["text"] !== "string") throw new RpcError(RPC_ERROR.invalidParams, "genframe/copy-text requires a string 'text'");
+				await options.onCopyText(p["text"]);
+				return {};
+			case METHODS.updateModelContext:
+				if (!options.onUpdateModelContext) throw new RpcError(RPC_ERROR.methodNotFound, "This host does not accept model context");
+				return options.onUpdateModelContext(params);
+			default: throw new RpcError(RPC_ERROR.methodNotFound, `Unknown method: ${method}`);
+		}
+	};
+	let activeSession;
+	let pendingSession;
+	let pendingWidgetState;
+	let hasPendingWidgetState = false;
+	let heldWidgetState;
+	let hasHeldWidgetState = false;
+	const applySize = (session, size) => {
+		const iframe = session.iframe();
+		if (iframe) {
+			const height = Math.min(Math.max(size.height, minHeight), maxHeight);
+			iframe.style.height = `${height}px`;
+			session.reveal();
+		}
+		if (session === activeSession) {
+			options.onResize?.(size);
+			emit("resize", size);
+		}
+	};
+	const createSession = (hidden) => {
+		const slot = container.ownerDocument.createElement("div");
+		slot.dataset["generativeFrame"] = "";
+		slot.style.cssText = hidden ? "display:block;height:0;overflow:hidden;visibility:hidden;pointer-events:none;opacity:0" : "display:block;opacity:0";
+		container.appendChild(slot);
+		let rendered;
+		let peer;
+		let initSent = false;
+		let initializeParams = {};
+		let pendingInitialized;
+		let sessionDisposed = false;
+		let revealed = false;
+		let resolveReady;
+		let rejectReady;
+		const ready = new Promise((resolve, reject) => {
+			resolveReady = resolve;
+			rejectReady = reject;
+		});
+		ready.catch(() => {});
+		const session = {
+			slot,
+			ready,
+			peer: () => {
+				if (!peer) throw new Error("Widget frame is not connected");
+				return peer;
+			},
+			iframe: () => rendered?.iframe,
+			reveal() {
+				if (revealed) return;
+				revealed = true;
+				if (!prefersReducedMotion()) slot.style.transition = `opacity ${REVEAL_MS}ms ease-out`;
+				slot.style.opacity = "1";
+			},
+			deliverInitialized() {
+				if (session !== activeSession || !pendingInitialized) return;
+				const params = pendingInitialized;
+				pendingInitialized = void 0;
+				try {
+					options.onInitialized?.(params);
+				} catch {}
+			},
+			dispose() {
+				if (sessionDisposed) return;
+				sessionDisposed = true;
+				clearTimeout(timer);
+				window.removeEventListener("message", onWindowMessage);
+				peer?.dispose();
+				rendered?.dispose();
+				slot.remove();
+				rejectReady(/* @__PURE__ */ new Error("Widget disposed"));
+			}
+		};
+		const fail = (message) => {
+			if (sessionDisposed) return;
+			rejectReady(new Error(message));
+			reportError({
+				kind: "error",
+				message
+			});
+		};
+		const timer = setTimeout(() => fail(`Widget frame did not connect within ${readyTimeoutMs}ms`), readyTimeoutMs);
+		const sendInit = () => {
+			if (initSent || !rendered) return;
+			initSent = true;
+			const channel = new MessageChannel();
+			peer = createRpcPeer(channel.port1, {
+				onRequest: (method, params) => {
+					if (method === METHODS.initialize) initializeParams = getInitializeParams(params);
+					return onRequest(method, params);
+				},
+				onNotification: (method, params) => {
+					const p = params ?? {};
+					switch (method) {
+						case METHODS.ready:
+							clearTimeout(timer);
+							resolveReady();
+							return;
+						case METHODS.initialized:
+							pendingInitialized = initializeParams;
+							session.deliverInitialized();
+							return;
+						case METHODS.sizeChanged:
+							if (typeof p["height"] === "number" && typeof p["width"] === "number") applySize(session, {
+								width: p["width"],
+								height: p["height"]
+							});
+							return;
+						case METHODS.error:
+							if (session === activeSession) reportError(p);
+							return;
+						case METHODS.log:
+							if (session === activeSession) {
+								options.onLog?.(p);
+								emit("log", p);
+							}
+							return;
+						case METHODS.widgetState:
+							if (session !== pendingSession && session !== activeSession) return;
+							try {
+								if (!isPlainJson(p["state"])) return;
+							} catch {
+								return;
+							}
+							if (session === pendingSession) {
+								pendingWidgetState = p["state"];
+								hasPendingWidgetState = true;
+								return;
+							}
+							if (pendingSession) {
+								heldWidgetState = p["state"];
+								hasHeldWidgetState = true;
+								return;
+							}
+							widgetState = p["state"];
+							options.onWidgetState?.(widgetState);
+							return;
+						default: return;
+					}
+				}
+			});
+			const init = {
+				type: INIT_MESSAGE,
+				context,
+				state: widgetState
+			};
+			rendered.sendMessage(init, [channel.port2]);
+		};
+		function onWindowMessage(event) {
+			if (!rendered) return;
+			if (event.source !== rendered.iframe.contentWindow || event.origin !== rendered.origin) return;
+			const data = event.data;
+			if (data?.type === "genframe:ready") {
+				sendInit();
+				return;
+			}
+			if (peer && isJsonRpcMessage(data)) {
+				const target = rendered;
+				peer.receive(data, (message) => target.sendMessage(message));
+			}
+		}
+		window.addEventListener("message", onWindowMessage);
+		const html = buildBootstrapHtml({
+			hostOrigin: window.location.origin,
+			tokens,
+			...options.csp !== void 0 ? { csp: options.csp } : {},
+			...options.animate !== void 0 ? { animate: options.animate } : {},
+			...options.css !== void 0 ? { css: options.css } : {}
+		});
+		frame.renderHtml(html, slot).then((result) => {
+			if (sessionDisposed) {
+				result.dispose();
+				return;
+			}
+			rendered = result;
+			const style = result.iframe.style;
+			style.display = "block";
+			style.height = `${minHeight}px`;
+			style.colorScheme = tokens.colorScheme;
+			result.iframe.setAttribute("title", "Generated widget");
+			result.fullyLoadedPromiseWithTimeout(readyTimeoutMs).catch((error) => fail(error instanceof Error ? error.message : String(error)));
+		}, (error) => fail(error instanceof Error ? error.message : String(error)));
+		return session;
+	};
+	activeSession = createSession(false);
+	let queue = [];
+	activeSession.ready.then(() => {
+		const ops = queue ?? [];
+		queue = void 0;
+		emit("ready", void 0);
+		for (const op of ops) if (op.kind === "write") activeSession?.peer().notify(METHODS.write, { chunk: op.chunk });
+		else op.run();
+	}, () => {});
+	const enqueue = (run) => {
+		if (queue) queue.push({
+			kind: "run",
+			run
+		});
+		else run();
+	};
+	const request = (method, params) => new Promise((resolve, reject) => {
+		const session = activeSession;
+		if (!session || disposed) {
+			reject(/* @__PURE__ */ new Error("Widget disposed"));
+			return;
+		}
+		session.ready.then(() => enqueue(() => {
+			session.peer().request(method, params, { timeoutMs: REQUEST_TIMEOUT_MS }).then((value) => resolve(value), reject);
+		}), reject);
+	});
+	const notify = (method, params) => {
+		const session = activeSession;
+		if (!session || disposed) return;
+		enqueue(() => {
+			try {
+				session.peer().notify(method, params);
+			} catch {}
+		});
+	};
+	const replayState = (session) => {
+		const peer = session.peer();
+		if (lastToolInput) peer.notify(lastToolInput.partial ? METHODS.toolInputPartial : METHODS.toolInput, { arguments: lastToolInput.args });
+		if (lastToolResult) peer.notify(METHODS.toolResult, lastToolResult.result);
+	};
+	const remount = async (next) => {
+		const previous = activeSession;
+		pendingSession?.dispose();
+		const session = createSession(true);
+		pendingSession = session;
+		hasPendingWidgetState = false;
+		let result;
+		try {
+			await session.ready;
+			if (disposed || pendingSession !== session) throw new Error("Widget replacement superseded");
+			replayState(session);
+			result = await session.peer().request(METHODS.replace, { code: next }, { timeoutMs: REQUEST_TIMEOUT_MS });
+			if (disposed || pendingSession !== session) throw new Error("Widget replacement superseded");
+		} catch (error) {
+			const superseded = !disposed && pendingSession !== session;
+			if (pendingSession === session) {
+				pendingSession = void 0;
+				hasPendingWidgetState = false;
+				if (hasHeldWidgetState && !disposed) {
+					hasHeldWidgetState = false;
+					widgetState = heldWidgetState;
+					try {
+						options.onWidgetState?.(widgetState);
+					} catch {}
+				}
+			}
+			session.dispose();
+			if (disposed) throw new Error("Widget disposed");
+			throw superseded ? /* @__PURE__ */ new Error("Widget replacement superseded") : error;
+		}
+		pendingSession = void 0;
+		hasHeldWidgetState = false;
+		activeSession = session;
+		if (hasPendingWidgetState) widgetState = pendingWidgetState;
+		session.slot.style.cssText = "display:block";
+		previous?.dispose();
+		if (hasPendingWidgetState) {
+			hasPendingWidgetState = false;
+			try {
+				options.onWidgetState?.(widgetState);
+			} catch {}
+		}
+		session.deliverInitialized();
+		applySize(session, result.size);
+		return result;
+	};
+	const handle = {
+		ready: activeSession.ready,
+		get code() {
+			return code;
+		},
+		get ended() {
+			return ended;
+		},
+		get iframe() {
+			return activeSession?.iframe();
+		},
+		write(chunk) {
+			if (disposed || !chunk) return;
+			if (ended) throw new Error("Cannot write after end(); use replace()");
+			code += chunk;
+			const last = queue?.[queue.length - 1];
+			if (queue) {
+				if (last?.kind === "write") last.chunk += chunk;
+				else queue.push({
+					kind: "write",
+					chunk
+				});
+				return;
+			}
+			activeSession?.peer().notify(METHODS.write, { chunk });
+		},
+		async end() {
+			ended = true;
+			const result = await request(METHODS.end);
+			emit("end", result);
+			return result;
+		},
+		async replace(next) {
+			const scriptsRan = pendingSession !== void 0 || ended && SCRIPT_TAG.test(code);
+			code = next;
+			ended = true;
+			const result = scriptsRan ? await remount(next) : await request(METHODS.replace, { code: next });
+			emit("end", result);
+			return result;
+		},
+		setTheme(next) {
+			tokens = next;
+			context = {
+				...context,
+				...themeContext(next)
+			};
+			notify(METHODS.hostContextChanged, themeContext(next));
+			const session = activeSession;
+			const followTheme = () => {
+				const iframe = session?.iframe();
+				if (iframe && tokens === next) iframe.style.colorScheme = next.colorScheme;
+			};
+			request(METHODS.inspect).then(followTheme, followTheme);
+		},
+		setContext(partial) {
+			context = {
+				...context,
+				...partial
+			};
+			notify(METHODS.hostContextChanged, partial);
+		},
+		notifyToolInput(args, notifyOptions) {
+			const partial = notifyOptions?.partial ?? false;
+			lastToolInput = {
+				args,
+				partial
+			};
+			notify(partial ? METHODS.toolInputPartial : METHODS.toolInput, { arguments: args });
+		},
+		notifyToolResult(result) {
+			lastToolResult = { result };
+			notify(METHODS.toolResult, result);
+		},
+		screenshot(screenshotOptions) {
+			return request(METHODS.screenshot, screenshotOptions ?? {});
+		},
+		async inspect() {
+			return {
+				...await request(METHODS.inspect),
+				code
+			};
+		},
+		on(event, listener) {
+			let set = listeners.get(event);
+			if (!set) {
+				set = /* @__PURE__ */ new Set();
+				listeners.set(event, set);
+			}
+			set.add(listener);
+			return () => set.delete(listener);
+		},
+		dispose() {
+			if (disposed) return;
+			disposed = true;
+			queue = void 0;
+			pendingSession?.dispose();
+			pendingSession = void 0;
+			activeSession?.dispose();
+			activeSession = void 0;
+			listeners.clear();
+		}
+	};
+	internalRequests.set(handle, request);
+	if (options.code !== void 0) {
+		handle.write(options.code);
+		handle.end().catch(() => {});
+	}
+	return handle;
+}
+/**
+* Clears what widgets with this `id` stored (localStorage, sessionStorage,
+* IndexedDB, Cache Storage, and cookies) by loading a hidden frame on the
+* same origin. Resolves with the storage kinds that were cleared.
+*/
+async function clearWidgetStorage(id, options = {}) {
+	const container = document.createElement("div");
+	container.setAttribute("aria-hidden", "true");
+	container.style.cssText = "position:fixed;left:0;top:0;width:1px;height:1px;overflow:hidden;opacity:0;pointer-events:none;";
+	document.body.appendChild(container);
+	let widget;
+	try {
+		widget = createWidget({
+			...options,
+			container,
+			id
+		});
+		await widget.ready;
+		return await internalRequests.get(widget)(METHODS.clearStorage);
+	} finally {
+		widget?.dispose();
+		container.remove();
+	}
+}
+export { clearWidgetStorage, createWidget, widgetStorageSalt };
+
+//# sourceMappingURL=widget.js.map