@daydreamui/tokens 0.0.0-stage → 0.4.0

package/dist/bridge.js

@@ -0,0 +1,973 @@
+var ENTITIES = {
+	""": "\"",
+	"'": "'",
+	"&lt;": "<",
+	"&gt;": ">",
+	"&amp;": "&"
+};
+var unescapeXml = (text) => text.replace(/&(?:quot|apos|lt|gt|amp);|&#(\d+);|&#x([0-9a-fA-F]+);/g, (match, dec, hex) => dec !== void 0 ? String.fromCodePoint(Number(dec)) : hex !== void 0 ? String.fromCodePoint(parseInt(hex, 16)) : ENTITIES[match] ?? match);
+var sizeOf = (value) => {
+	if (value === void 0) return null;
+	const n = Number(value);
+	return Number.isFinite(n) && n > 0 ? n : null;
+};
+function frameOf(xml) {
+	const root = /^\s*<([A-Za-z][\w-]*)\b([^>]*?)\/?>/.exec(xml);
+	if (root === null) return listedFrame(xml);
+	const attributes = new Map();
+	for (const match of root[2].matchAll(/(?:^|\s)([\w:-]+)\s*=\s*"([^"]*)"/g)) attributes.set(match[1], unescapeXml(match[2]));
+	const id = attributes.get("id");
+	const name = (attributes.get("name") ?? "").replace(/\p{Cc}+/gu, " ").trim().slice(0, 80).trimEnd();
+	return {
+		id: id === void 0 || id === "" ? null : id,
+		name: name === "" ? null : name,
+		width: sizeOf(attributes.get("width")),
+		height: sizeOf(attributes.get("height"))
+	};
+}
+var listedFrame = (text) => selectionOf(text)[0] ?? null;
+function selectionOf(text) {
+	if (!/^\s*Currently selected nodes\b/.test(text)) return [];
+	const frames = [];
+	for (const line of text.matchAll(/^\s*-\s+([\w:;-]+):[ \t]*(.*)$/gm)) {
+		const name = line[2].replace(/\p{Cc}+/gu, " ").trim().slice(0, 80).trimEnd();
+		frames.push({
+			id: line[1],
+			name: name === "" ? null : name,
+			width: null,
+			height: null
+		});
+	}
+	return frames;
+}
+var NODE_ID = /^\d+[:-]\d+$/;
+function nodeIdFromUrl(urlOrId) {
+	const given = urlOrId.trim();
+	if (NODE_ID.test(given)) return given.replace("-", ":");
+	let url;
+	try {
+		url = new URL(given);
+	} catch {
+		return null;
+	}
+	const id = url.searchParams.get("node-id");
+	return id !== null && NODE_ID.test(id) ? id.replace("-", ":") : null;
+}
+var NOT_REACHABLE = "Figma is not reachable: open Figma desktop and enable the Dev Mode MCP server in its preferences";
+var TimeoutError = class extends Error {
+	constructor(timeoutMs) {
+		super(`Figma did not answer within ${Math.round(timeoutMs / 1e3)} s`);
+		this.name = "TimeoutError";
+	}
+};
+var UnreachableError = class extends Error {
+	constructor(message, cause) {
+		super(message, { cause });
+		this.name = "UnreachableError";
+	}
+};
+var MAX_STREAM_BYTES = 33554432;
+var OversizeError = class extends Error {
+	constructor() {
+		super(`Figma streamed more than ${MAX_STREAM_BYTES / 1048576} MB without answering; the answer was dropped`);
+		this.name = "OversizeError";
+	}
+};
+async function post(options, message, wantId, unreachable) {
+	const headers = {
+		"content-type": "application/json",
+		accept: "application/json, text/event-stream"
+	};
+	if (options.session !== null) headers["mcp-session-id"] = options.session;
+	if (options.protocolVersion !== null) headers["MCP-Protocol-Version"] = options.protocolVersion;
+	const signal = AbortSignal.timeout(options.timeoutMs);
+	let response;
+	try {
+		response = await options.fetch(options.url, {
+			method: "POST",
+			headers,
+			body: JSON.stringify(message),
+			signal
+		});
+	} catch (error) {
+		throw signal.aborted ? new TimeoutError(options.timeoutMs) : new UnreachableError(unreachable, error);
+	}
+	const session = response.headers.get("mcp-session-id");
+	const type = response.headers.get("content-type") ?? "";
+	let messages = [];
+	try {
+		if (type.startsWith("text/event-stream") && response.body !== null) messages = await readEvents(response.body, wantId);
+		else if (response.status !== 202 && response.status !== 204) messages = parseMessages(await response.text());
+	} catch (error) {
+		if (signal.aborted) throw new TimeoutError(options.timeoutMs);
+		if (error instanceof OversizeError) throw error;
+		throw new UnreachableError(unreachable, error);
+	}
+	return {
+		status: response.status,
+		session,
+		messages
+	};
+}
+function parseMessages(text) {
+	let parsed;
+	try {
+		parsed = JSON.parse(text);
+	} catch {
+		return [];
+	}
+	return (Array.isArray(parsed) ? parsed : [parsed]).filter(isResponse);
+}
+var isResponse = (value) => typeof value === "object" && value !== null && value.jsonrpc === "2.0" && "id" in value && !("method" in value) && ("result" in value || "error" in value);
+function dataOf(event) {
+	const lines = event.split("\n").filter((line) => line.startsWith("data:")).map((line) => line.slice(5).replace(/^ /, ""));
+	return lines.length === 0 ? null : lines.join("\n");
+}
+async function readEvents(body, wantId) {
+	const reader = body.getReader();
+	const decoder = new TextDecoder();
+	const messages = [];
+	let buffered = "";
+	let searched = 0;
+	let received = 0;
+	let heldCr = false;
+	const take = (event) => {
+		const data = dataOf(event);
+		if (data === null) return false;
+		const read = parseMessages(data);
+		messages.push(...read);
+		return wantId !== null && read.some((m) => m.id === wantId);
+	};
+	try {
+		for (;;) {
+			const { value, done } = await reader.read();
+			received += value?.byteLength ?? 0;
+			if (received > 33554432) {
+				await reader.cancel().catch(() => {});
+				throw new OversizeError();
+			}
+			let text = (heldCr ? "\r" : "") + decoder.decode(value, { stream: !done });
+			heldCr = !done && text.endsWith("\r");
+			if (heldCr) text = text.slice(0, -1);
+			buffered += text.replace(/\r\n?/g, "\n");
+			let end;
+			while ((end = buffered.indexOf("\n\n", searched)) !== -1) {
+				const event = buffered.slice(0, end);
+				buffered = buffered.slice(end + 2);
+				searched = 0;
+				if (take(event)) {
+					await reader.cancel().catch(() => {});
+					return messages;
+				}
+			}
+			searched = Math.max(0, buffered.length - 1);
+			if (done) {
+				if (buffered.trim() !== "") take(buffered);
+				return messages;
+			}
+		}
+	} finally {
+		reader.releaseLock();
+	}
+}
+var PROTOCOL_VERSION = "2025-06-18";
+var DEFAULT_TIMEOUT_MS = 2e4;
+var DEFAULT_BUDGET_MS = 45e3;
+var isContentItem = (value) => typeof value === "object" && value !== null && typeof value.type === "string";
+var textsOf = (content) => content.flatMap((item) => item.type === "text" && typeof item.text === "string" ? [item.text] : []);
+var imageOf = (content) => {
+	for (const item of content) {
+		if (item.type !== "image") continue;
+		const { data, mimeType } = item;
+		if (typeof data === "string") return {
+			mimeType: typeof mimeType === "string" ? mimeType : "image/png",
+			base64: data
+		};
+	}
+	return null;
+};
+var textResult = (content) => {
+	const [text = "", ...notes] = textsOf(content);
+	return {
+		text,
+		notes
+	};
+};
+var xmlResult = (content) => {
+	const texts = textsOf(content);
+	const at = texts.findIndex((text) => /^\s*</.test(text));
+	if (at === -1) return textResult(content);
+	return {
+		text: texts[at],
+		notes: texts.filter((_, i) => i !== at)
+	};
+};
+var acknowledged = (status) => status >= 200 && status < 300;
+var failedRead = (error) => error instanceof TimeoutError ? { kind: "late" } : {
+	kind: "unreachable",
+	said: error instanceof Error ? error.message : String(error)
+};
+function connectFigma(options = {}) {
+	const settings = {
+		fetch: options.fetch ?? fetch,
+		url: options.url ?? "http://127.0.0.1:3845/mcp",
+		timeoutMs: options.timeoutMs ?? DEFAULT_TIMEOUT_MS,
+		budgetMs: options.budgetMs ?? DEFAULT_BUDGET_MS
+	};
+	const client = {
+		clientLanguages: options.clientLanguages ?? "html,css",
+		clientFrameworks: options.clientFrameworks ?? "unknown"
+	};
+	let nextId = 0;
+	let session = null;
+	const request = (method, params) => ({
+		jsonrpc: "2.0",
+		id: ++nextId,
+		method,
+		params
+	});
+	const statusError = (answer, method) => new Error(answer.messages.find((m) => m.error !== void 0)?.error?.message ?? `Figma's Dev Mode server answered ${method} with HTTP ${answer.status}`);
+	function resultOf(answer, id, method) {
+		const response = answer.messages.find((m) => m.id === id);
+		if (response?.error !== void 0) throw new Error(response.error.message);
+		if (response !== void 0 && answer.status === 200) return response.result;
+		throw statusError(answer, method);
+	}
+	const budget = (ms = settings.budgetMs) => ({
+		deadline: Date.now() + ms,
+		ms
+	});
+	function bound(budget) {
+		const left = budget.deadline - Date.now();
+		if (left <= 0) throw new TimeoutError(budget.ms);
+		return Math.min(settings.timeoutMs, left);
+	}
+	function within(pending, budget) {
+		const left = bound(budget);
+		let timer;
+		const late = new Promise((_resolve, reject) => {
+			timer = setTimeout(() => reject(new TimeoutError(budget.ms)), left);
+		});
+		return Promise.race([pending, late]).finally(() => clearTimeout(timer));
+	}
+	async function initialize(budget) {
+		const hello = request("initialize", {
+			protocolVersion: PROTOCOL_VERSION,
+			capabilities: {},
+			clientInfo: {
+				name: "daydream-figma",
+				version: "0.1.0"
+			}
+		});
+		const answer = await post({
+			...settings,
+			session: null,
+			protocolVersion: null,
+			timeoutMs: bound(budget)
+		}, hello, hello.id, NOT_REACHABLE);
+		const agreed = resultOf(answer, hello.id, "initialize")?.protocolVersion;
+		const opened = {
+			id: answer.session,
+			protocol: typeof agreed === "string" && agreed !== "" ? agreed : PROTOCOL_VERSION
+		};
+		const ready = await post({
+			...settings,
+			session: opened.id,
+			protocolVersion: opened.protocol,
+			timeoutMs: bound(budget)
+		}, {
+			jsonrpc: "2.0",
+			method: "notifications/initialized"
+		}, null, NOT_REACHABLE);
+		if (!acknowledged(ready.status)) throw statusError(ready, "notifications/initialized");
+		return opened;
+	}
+	function ensureSession(budget) {
+		if (session === null) {
+			const opening = initialize(budget);
+			session = opening;
+			opening.catch(() => {
+				if (session === opening) session = null;
+			});
+		}
+		return within(session, budget);
+	}
+	const currentSession = () => session;
+	async function call(method, params, budget, retried = false) {
+		const sessionPromise = ensureSession(budget);
+		const rode = currentSession();
+		const { id, protocol } = await sessionPromise;
+		const message = request(method, params);
+		const answer = await post({
+			...settings,
+			session: id,
+			protocolVersion: protocol,
+			timeoutMs: bound(budget)
+		}, message, message.id, NOT_REACHABLE);
+		if (answer.status === 404 && id !== null && !retried) {
+			if (session === rode) session = null;
+			return call(method, params, budget, true);
+		}
+		return resultOf(answer, message.id, method);
+	}
+	async function tool(name, args, under = budget()) {
+		const result = await call("tools/call", {
+			name,
+			arguments: args
+		}, under);
+		const content = Array.isArray(result?.content) ? result.content.filter(isContentItem) : [];
+		if (result?.isError === true) {
+			const said = textsOf(content).join(" ").trim();
+			throw new Error(said === "" ? `Figma could not answer ${name}` : said);
+		}
+		return content;
+	}
+	function nodeArgs(node) {
+		if (node === void 0 || node.trim() === "") return {};
+		const nodeId = nodeIdFromUrl(node);
+		if (nodeId === null) throw new Error(`not a Figma node id or link: ${node}`);
+		return { nodeId };
+	}
+	return {
+		async reachable() {
+			try {
+				const under = budget();
+				if (session === null) await ensureSession(under);
+				else await call("ping", {}, under);
+				return true;
+			} catch {
+				return false;
+			}
+		},
+		async variableDefs(node) {
+			return textResult(await tool("get_variable_defs", {
+				...nodeArgs(node),
+				...client
+			}));
+		},
+		async designContext(node, options = {}) {
+			const content = await tool("get_design_context", {
+				...nodeArgs(node),
+				...client,
+				...options.excludeScreenshot === void 0 ? {} : { excludeScreenshot: options.excludeScreenshot },
+				...options.forceCode === void 0 ? {} : { forceCode: options.forceCode }
+			});
+			return {
+				...textResult(content),
+				screenshot: imageOf(content)
+			};
+		},
+		async metadata(node) {
+			return xmlResult(await tool("get_metadata", {
+				...nodeArgs(node),
+				...client
+			}));
+		},
+		async frame(node, options = {}) {
+			try {
+				const frame = frameOf(xmlResult(await tool("get_metadata", {
+					...nodeArgs(node),
+					...client
+				}, budget(options.timeoutMs ?? 3e3))).text);
+				return frame === null ? { kind: "none" } : {
+					kind: "frame",
+					frame
+				};
+			} catch (error) {
+				return failedRead(error);
+			}
+		},
+		async selection(options = {}) {
+			try {
+				const listing = textsOf(await tool("get_metadata", { ...client }, budget(options.timeoutMs ?? 5e3))).find((text) => /^\s*Currently selected nodes\b/.test(text));
+				const frames = listing === void 0 ? [] : selectionOf(listing);
+				return frames.length === 0 ? { kind: "none" } : {
+					kind: "frames",
+					frames
+				};
+			} catch (error) {
+				return failedRead(error);
+			}
+		},
+		async screenshot(node, options = {}) {
+			const content = await tool("get_screenshot", {
+				...nodeArgs(node),
+				...options.contentsOnly === void 0 ? {} : { contentsOnly: options.contentsOnly }
+			});
+			const image = imageOf(content);
+			if (image === null) {
+				const said = textsOf(content).join(" ").trim();
+				throw new Error(said === "" ? "Figma answered no image" : said);
+			}
+			return image;
+		},
+		async close() {
+			const opened = session;
+			session = null;
+			if (opened === null) return;
+			let id;
+			try {
+				id = (await opened).id;
+			} catch {
+				return;
+			}
+			if (id === null) return;
+			try {
+				await settings.fetch(settings.url, {
+					method: "DELETE",
+					headers: { "mcp-session-id": id },
+					signal: AbortSignal.timeout(settings.timeoutMs)
+				});
+			} catch {}
+		}
+	};
+}
+var NODE_SHAPE = "Give a Figma link or a node id, or nothing for Figma's selection.";
+function nodeInput(input) {
+	if (input === void 0 || input === null) return void 0;
+	if (typeof input !== "object") throw new Error(NODE_SHAPE);
+	const node = input.node;
+	if (node === void 0 || node === null) return void 0;
+	if (typeof node !== "string" || node.length > 2048) throw new Error(NODE_SHAPE);
+	return node.trim() === "" ? void 0 : node;
+}
+function parseVariableDefs(text) {
+	const given = text.trim();
+	if (given === "") return [];
+	return fromJson(given) ?? fromPythonDict(given) ?? [];
+}
+function fromJson(text) {
+	let parsed;
+	try {
+		parsed = JSON.parse(text);
+	} catch {
+		return null;
+	}
+	if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) return null;
+	return Object.entries(parsed).map(([name, value]) => ({
+		name,
+		value: typeof value === "string" ? value : JSON.stringify(value)
+	}));
+}
+function fromPythonDict(text) {
+	if (!text.startsWith("{") || !text.endsWith("}")) return null;
+	const entry = /(?:'((?:[^'\\]|\\.)*)'|"((?:[^"\\]|\\.)*)")\s*:\s*(?:'((?:[^'\\]|\\.)*)'|"((?:[^"\\]|\\.)*)"|((?:[^,}]|,(?!\s*['"]))+))/g;
+	const defs = [];
+	for (const match of text.slice(1, -1).matchAll(entry)) {
+		const name = unescape(match[1] ?? match[2] ?? "");
+		const value = match[3] !== void 0 || match[4] !== void 0 ? unescape(match[3] ?? match[4] ?? "") : (match[5] ?? "").trim();
+		defs.push({
+			name,
+			value
+		});
+	}
+	return defs.length === 0 ? null : defs;
+}
+var unescape = (quoted) => quoted.replace(/\\(.)/g, "$1");
+var COLOR_KINDS = ["color"];
+var SIZE_KINDS = ["number", "dimension"];
+var FONT_KINDS = ["font"];
+var ROLES = [
+	[
+		"background",
+		[
+			"background",
+			"bg",
+			"canvas",
+			"page",
+			"surface-0"
+		],
+		COLOR_KINDS
+	],
+	[
+		"foreground",
+		[
+			"foreground",
+			"fg",
+			"text",
+			"text-primary",
+			"text-default",
+			"on-background",
+			"ink"
+		],
+		COLOR_KINDS
+	],
+	[
+		"card",
+		[
+			"card",
+			"surface",
+			"elevated",
+			"panel"
+		],
+		COLOR_KINDS
+	],
+	[
+		"muted",
+		[
+			"muted",
+			"subtle",
+			"secondary-surface"
+		],
+		COLOR_KINDS
+	],
+	[
+		"muted-foreground",
+		[
+			"muted-foreground",
+			"text-secondary",
+			"secondary",
+			"hint",
+			"placeholder"
+		],
+		COLOR_KINDS
+	],
+	[
+		"primary",
+		[
+			"primary",
+			"brand",
+			"accent",
+			"action",
+			"cta"
+		],
+		COLOR_KINDS
+	],
+	[
+		"primary-foreground",
+		[
+			"primary-foreground",
+			"on-primary",
+			"on-brand",
+			"on-accent"
+		],
+		COLOR_KINDS
+	],
+	[
+		"border",
+		[
+			"border",
+			"stroke",
+			"outline",
+			"divider"
+		],
+		COLOR_KINDS
+	],
+	[
+		"radius",
+		[
+			"radius",
+			"corner",
+			"rounded"
+		],
+		SIZE_KINDS
+	],
+	[
+		"spacing",
+		[
+			"spacing",
+			"space",
+			"gap",
+			"unit"
+		],
+		SIZE_KINDS
+	],
+	[
+		"font-sans",
+		[
+			"font-sans",
+			"font-family",
+			"sans",
+			"body-font",
+			"font-body"
+		],
+		FONT_KINDS
+	],
+	[
+		"font-heading",
+		[
+			"font-heading",
+			"heading-font",
+			"display"
+		],
+		FONT_KINDS
+	],
+	[
+		"heading-weight",
+		["heading-weight", "weight-bold"],
+		["number", "keyword"]
+	],
+	[
+		"heading-tracking",
+		[
+			"heading-tracking",
+			"tracking",
+			"letter-spacing"
+		],
+		SIZE_KINDS
+	]
+];
+var KINDS_OF_ROLE = new Map(ROLES.map(([role, , kinds]) => [role, kinds]));
+var fits = (role, kind) => kind !== null && (KINDS_OF_ROLE.get(role)?.includes(kind) ?? false);
+var SCALE_STEP = /^(\d+|xs|sm|md|lg|xl|\dxl|default|base|main|regular|normal)$/;
+var PREFERRED_STEP = /^(500|default|base|main|regular|normal|md)$/;
+function tokenName(figmaName) {
+	const slug = figmaName.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
+	return `--${slug === "" ? "token" : slug}`;
+}
+var segmentsOf = (name) => tokenName(name).slice(2).split("-");
+var COLOR = /^(#[0-9a-f]{3,8}|transparent|(rgba?|hsla?|hwb|lab|lch|oklab|oklch|color)\([^()]*\))$/i;
+var NUMBER = /^[-+]?(\d+\.?\d*|\.\d+)$/;
+var DIMENSION = /^[-+]?(\d+\.?\d*|\.\d+)(px|rem|em|%|vw|vh|pt|ch|ex|ms|s|deg)$/;
+var FONT_STACK = /^[A-Za-z0-9 ,'"._-]+$/;
+var UNITLESS = /(^|-)(opacity|weight|line-height|lineheight|ratio|z)(-|$)/;
+var FONT_NAME = /font|family|type/;
+var WEIGHT_KEYWORD = /^(normal|bold|bolder|lighter)$/i;
+function aliasOf(value) {
+	const braced = /^\{([^{}"']+)\}$/.exec(value);
+	return braced === null ? null : braced[1].trim();
+}
+function valueKind(name, raw) {
+	const value = raw.trim();
+	if (value === "" || value === "true" || value === "false") return null;
+	if (value.startsWith("{") || value.startsWith("[")) return null;
+	if (COLOR.test(value)) return {
+		kind: "color",
+		value
+	};
+	if (DIMENSION.test(value)) return {
+		kind: "dimension",
+		value
+	};
+	const slug = tokenName(name).slice(2);
+	if (NUMBER.test(value)) {
+		const number = value.replace(/^\+/, "");
+		return UNITLESS.test(slug) ? {
+			kind: "number",
+			value: number
+		} : {
+			kind: "dimension",
+			value: `${number}px`
+		};
+	}
+	if (WEIGHT_KEYWORD.test(value)) return {
+		kind: "keyword",
+		value
+	};
+	if (FONT_NAME.test(slug) && FONT_STACK.test(value)) return {
+		kind: "font",
+		value
+	};
+	return {
+		kind: "text",
+		value: quoted(value)
+	};
+}
+function readValue(name, raw, names) {
+	const value = raw.trim();
+	if (value === "" || value === "true" || value === "false") return { kind: "dropped" };
+	const alias = aliasOf(value);
+	if (alias !== null) return names.has(alias) ? {
+		kind: "alias",
+		to: alias
+	} : { kind: "dropped" };
+	const found = valueKind(name, value);
+	return found === null ? { kind: "dropped" } : {
+		kind: "value",
+		value: found.value,
+		of: found.kind
+	};
+}
+function quoted(text) {
+	return `"${text.replace(/[\r\n]+/g, " ").replace(/[\\"]/g, "\\$&")}"`;
+}
+function roleOf(name) {
+	const segments = segmentsOf(name);
+	let best = roleIn(segments.slice(-2), false);
+	let preferred = false;
+	while (segments.length > 1 && SCALE_STEP.test(segments.at(-1))) preferred = PREFERRED_STEP.test(segments.pop());
+	const stripped = roleIn(segments.slice(-2), preferred);
+	if (stripped !== null && (best === null || stripped.score > best.score)) best = stripped;
+	return best;
+}
+function roleIn(window, preferred) {
+	let best = null;
+	for (const [role, keywords] of ROLES) for (const keyword of keywords) {
+		const words = keyword.split("-");
+		let score = 0;
+		if (words.length === 1) {
+			if (window.at(-1) === words[0]) score = 3;
+			else if (window.length === 2 && window[0] === words[0]) score = 2;
+		} else if (window.length === 2 && window[0] === words[0] && window[1] === words[1]) score = 5;
+		if (score > 0 && (best === null || score > best.score)) best = {
+			role,
+			score,
+			preferred
+		};
+	}
+	return best;
+}
+function readVariables(variables) {
+	const names = new Set(variables.map((v) => v.name));
+	const read = new Map();
+	let dropped = 0;
+	for (const variable of variables) {
+		if (read.has(variable.name)) {
+			dropped += 1;
+			continue;
+		}
+		const reading = readValue(variable.name, variable.value, names);
+		if (reading.kind === "dropped") dropped += 1;
+		else read.set(variable.name, reading);
+	}
+	return {
+		read,
+		dropped
+	};
+}
+function resolveChains(read) {
+	const chains = new Map();
+	let dropped = 0;
+	for (const name of read.keys()) {
+		const chain = chainFrom(name, read);
+		if (chain === null) dropped += 1;
+		else chains.set(name, chain);
+	}
+	return {
+		chains,
+		dropped
+	};
+}
+function chainFrom(name, read) {
+	const names = [];
+	const seen = new Set();
+	for (let at = name;;) {
+		if (seen.has(at)) return null;
+		const reading = read.get(at);
+		if (reading === void 0) return null;
+		seen.add(at);
+		names.push(at);
+		if (reading.kind === "value") return {
+			names,
+			kind: reading.of
+		};
+		at = reading.to;
+	}
+}
+var ROLE_NAMES = new Set(ROLES.map(([role]) => `--${role}`));
+function nameTokens(chains) {
+	const property = new Map();
+	const taken = new Set();
+	for (const [name, chain] of chains) {
+		const base = tokenName(name);
+		let n = ROLE_NAMES.has(base) && !fits(base.slice(2), chain.kind) ? 2 : 1;
+		let candidate = n === 1 ? base : `${base}-${n}`;
+		while (taken.has(candidate)) candidate = `${base}-${++n}`;
+		taken.add(candidate);
+		property.set(name, candidate);
+	}
+	return property;
+}
+function rawTokens(read, property) {
+	const tokens = new Map();
+	for (const [name, token] of property) {
+		const reading = read.get(name);
+		tokens.set(name, {
+			name: token,
+			value: reading.kind === "alias" ? `var(${property.get(reading.to)})` : reading.value
+		});
+	}
+	return tokens;
+}
+function suggestRoles(chains, property, tokens) {
+	const judged = [];
+	for (const [name, chain] of chains) {
+		const token = tokens.get(name);
+		const best = ROLE_NAMES.has(token.name) ? {
+			role: token.name.slice(2),
+			score: 10,
+			preferred: true
+		} : roleOf(name);
+		if (best !== null && fits(best.role, chain.kind)) judged.push({
+			name,
+			token,
+			best
+		});
+	}
+	const claimed = new Set();
+	const roles = [];
+	for (const [role] of ROLES) {
+		const candidates = judged.filter((j) => j.best.role === role && !claimed.has(j.name));
+		const pick = candidates.find((j) => j.token.name === `--${role}`) ?? candidates.find((j) => j.best.preferred) ?? candidates[0];
+		if (pick === void 0) continue;
+		claimed.add(pick.name);
+		roles.push({
+			token: pick.token.name === `--${role}` ? pick.token : {
+				name: `--${role}`,
+				value: `var(${pick.token.name})`
+			},
+			via: pick.name
+		});
+	}
+	return roles;
+}
+function underCap(roles, chains, tokens) {
+	const chosenRoles = [];
+	const chosen = [];
+	const placed = new Set();
+	let cut = 0;
+	const linksOf = (via) => chains.get(via).names.map((name) => tokens.get(name));
+	const take = (links, role) => {
+		const chain = links.filter((link) => !placed.has(link.name));
+		if (placed.size + chain.length > 100) {
+			cut += 1;
+			return;
+		}
+		for (const link of chain) {
+			placed.add(link.name);
+			(link === role ? chosenRoles : chosen).push(link);
+		}
+	};
+	for (const { token, via } of roles) {
+		const links = linksOf(via);
+		take(links[0] === token ? links : [token, ...links], token);
+	}
+	for (const [name, token] of tokens) if (!placed.has(token.name)) take(linksOf(name), null);
+	return {
+		tokens: [...chosenRoles, ...chosen],
+		cut
+	};
+}
+function convertFigmaVariables(variables) {
+	const { read, dropped: unread } = readVariables(variables);
+	const { chains, dropped: dangling } = resolveChains(read);
+	const property = nameTokens(chains);
+	const tokens = rawTokens(read, property);
+	const kept = underCap(suggestRoles(chains, property, tokens), chains, tokens);
+	return {
+		tokens: kept.tokens,
+		omitted: unread + dangling + kept.cut
+	};
+}
+var NO_VARIABLES = "The Figma selection uses no variables.";
+var DEFAULT_ORIGIN = "From Figma";
+var NO_FRAME = "Select a frame in Figma first.";
+var TOO_SLOW = "Figma took too long to answer; try again.";
+var MAX_SELECTION = 12;
+var tooManySelected = (count) => `${count} frames are selected in Figma; From Figma takes at most 12 at once. Select fewer.`;
+var EXTRACT_BUDGET_MS = 4e4;
+var CLIENT = Symbol.for("daydream.figma-devmode.client");
+function processClient(holder = globalThis, connect = () => connectFigma()) {
+	return holder[CLIENT] ??= connect();
+}
+function tokensOf(variables, origin, omitted = 0) {
+	if (variables.length === 0) throw new Error(NO_VARIABLES);
+	const converted = convertFigmaVariables(variables);
+	if (converted.tokens.length === 0) throw new Error(NO_VARIABLES);
+	return {
+		...converted,
+		omitted: converted.omitted + omitted,
+		origin
+	};
+}
+var originOf = (name) => name === null ? DEFAULT_ORIGIN : `${name} from Figma`;
+function askable(frames) {
+	const kept = frames.filter((frame) => frame.id !== null && nodeIdFromUrl(frame.id) !== null);
+	return {
+		frames: kept,
+		leftOut: frames.length - kept.length
+	};
+}
+function by(pending, deadline) {
+	let timer;
+	const late = new Promise((resolve) => {
+		timer = setTimeout(() => resolve({ kind: "late" }), Math.max(0, deadline - Date.now()));
+	});
+	return Promise.race([pending.then((value) => ({
+		kind: "answered",
+		value
+	})), late]).finally(() => clearTimeout(timer));
+}
+var OLDER_CONNECTION = "Daydream's host loaded an older Figma connection than this plugin; quit and reopen Daydream, then try again.";
+var NEEDED = [
+	"reachable",
+	"frame",
+	"selection",
+	"variableDefs"
+];
+function olderConnection(client) {
+	return NEEDED.some((name) => typeof client?.[name] !== "function");
+}
+function createTokensPart(given = {}) {
+	const client = given.client ?? processClient(given.holder, given.connect);
+	const budgetMs = given.extractBudgetMs ?? 4e4;
+	if (olderConnection(client)) return {
+		reachable: () => typeof client.reachable === "function" ? client.reachable() : Promise.resolve(false),
+		async extract() {
+			throw new Error(OLDER_CONNECTION);
+		}
+	};
+	async function extractSeveral(frames, leftOut) {
+		const deadline = Date.now() + budgetMs;
+		const reads = await Promise.allSettled(frames.map((frame) => by(client.variableDefs(frame.id), deadline)));
+		const merged = new Map();
+		const answered = [];
+		let refused = null;
+		let omitted = leftOut;
+		for (const [i, read] of reads.entries()) {
+			if (read.status === "rejected") {
+				refused ??= read.reason;
+				omitted += 1;
+				continue;
+			}
+			if (read.value.kind === "late") {
+				omitted += 1;
+				continue;
+			}
+			for (const variable of parseVariableDefs(read.value.value.text)) if (!merged.has(variable.name)) merged.set(variable.name, variable);
+			answered.push(frames[i]);
+		}
+		if (answered.length === 0) throw refused ?? new Error("Figma took too long to answer; try again.");
+		const origin = answered.length === 1 ? originOf(answered[0].name) : `${answered.length} frames from Figma`;
+		return tokensOf([...merged.values()], origin, omitted);
+	}
+	async function extractSelection() {
+		const read = await client.selection();
+		switch (read.kind) {
+			case "none": throw new Error(NO_FRAME);
+			case "unreachable": throw new Error(read.said);
+			case "late": throw new Error(TOO_SLOW);
+			case "frames": {
+				const { frames, leftOut } = askable(read.frames);
+				if (frames.length > 12) throw new Error(tooManySelected(frames.length));
+				if (frames.length === 0) throw new Error(`${NO_FRAME} ${leftOut === 1 ? "1 layer inside an instance was left out; select its frame." : `${leftOut} layers inside instances were left out; select their frames.`}`);
+				if (frames.length === 1) {
+					const read = await by(client.variableDefs(frames[0].id), Date.now() + budgetMs);
+					if (read.kind === "late") throw new Error(TOO_SLOW);
+					return tokensOf(parseVariableDefs(read.value.text), originOf(frames[0].name), leftOut);
+				}
+				return extractSeveral(frames, leftOut);
+			}
+		}
+	}
+	return {
+		async reachable() {
+			try {
+				return await client.reachable();
+			} catch {
+				return false;
+			}
+		},
+		async extract(node) {
+			if (node === void 0) return extractSelection();
+			const [answer, frame] = await Promise.all([client.variableDefs(node), client.frame(node)]);
+			return tokensOf(parseVariableDefs(answer.text), originOf(frame.kind === "frame" ? frame.frame.name : null));
+		}
+	};
+}
+function activate(host) {
+	const part = createTokensPart();
+	host.browserPart.handle("figma-reachable", () => part.reachable());
+	host.browserPart.handle("figma-extract", (input) => part.extract(nodeInput(input)));
+}
+export { DEFAULT_ORIGIN, EXTRACT_BUDGET_MS, MAX_SELECTION, NO_FRAME, NO_VARIABLES, OLDER_CONNECTION, TOO_SLOW, createTokensPart, activate as default, olderConnection, processClient, tooManySelected };