@box-kite/react 2.0.1 → 2.1.0

package/interop.mjs

@@ -0,0 +1,454 @@
+import { t as e } from "./specDefs.mjs";
+import { t } from "./specData.mjs";
+//#region src/utils/interop/toolInterop.ts
+var n;
+(function(e) {
+	let t = {
+		"input-streaming": "pending",
+		"input-available": "running",
+		"output-available": "success",
+		"output-error": "error",
+		"approval-requested": "approval",
+		"approval-responded": "approval"
+	}, n = {
+		inProgress: "pending",
+		executing: "running",
+		complete: "success"
+	}, r = {
+		running: "running",
+		complete: "success",
+		incomplete: "error",
+		"requires-action": "pending"
+	};
+	function i(e) {
+		return typeof e == "object" && e && !Array.isArray(e) ? e : null;
+	}
+	function a(e) {
+		return typeof e == "string" && e !== "" ? e : void 0;
+	}
+	function o(e) {
+		return e.input ?? e.args ?? e.argsText;
+	}
+	function s(e) {
+		return e.output ?? e.result;
+	}
+	function c(e) {
+		let c = i(e);
+		if (c === null) return null;
+		let l = o(c), u = s(c), d = a(c.state);
+		if (d !== void 0 && d in t) {
+			let e = t[d];
+			if (e !== "approval") return {
+				kind: "call",
+				status: e,
+				decision: null,
+				input: l,
+				output: u,
+				error: a(c.errorText)
+			};
+			let n = i(c.approval)?.approved;
+			return {
+				kind: "approval",
+				status: "pending",
+				decision: typeof n == "boolean" ? n ? "approved" : "rejected" : null,
+				input: l
+			};
+		}
+		let f = c.status, p = i(f);
+		if (p !== null) {
+			let e = a(p.type) ?? "";
+			return {
+				kind: e === "requires-action" ? "approval" : "call",
+				status: r[e] ?? "pending",
+				decision: null,
+				input: l,
+				output: u,
+				error: a(i(p.error)?.message) ?? a(p.error)
+			};
+		}
+		let m = a(f);
+		if (m !== void 0 && m in n) {
+			let e = typeof c.respond == "function" && m === "executing";
+			return {
+				kind: e ? "approval" : "call",
+				status: e ? "pending" : n[m],
+				decision: null,
+				input: l,
+				output: u
+			};
+		}
+		return null;
+	}
+	e.toolPart = c;
+	function l(e, t) {
+		let n = i(t), r = a(n?.toolCallId);
+		if (n === null || r === void 0) return e;
+		let o = a(n.type), s = e[r] ?? {
+			kind: "call",
+			status: "pending",
+			decision: null
+		};
+		return o === "TOOL_CALL_START" ? {
+			...e,
+			[r]: {
+				...s,
+				kind: "call",
+				status: "pending"
+			}
+		} : o === "TOOL_CALL_ARGS" ? {
+			...e,
+			[r]: {
+				...s,
+				status: "pending"
+			}
+		} : o === "TOOL_CALL_END" ? {
+			...e,
+			[r]: {
+				...s,
+				status: "running"
+			}
+		} : o === "TOOL_CALL_RESULT" ? {
+			...e,
+			[r]: {
+				...s,
+				status: "success",
+				output: n.content ?? n.result
+			}
+		} : o === "INTERRUPT" || o === "RUN_INTERRUPT" ? {
+			...e,
+			[r]: {
+				...s,
+				kind: "approval",
+				status: "pending"
+			}
+		} : o === "RUN_ERROR" ? {
+			...e,
+			[r]: {
+				...s,
+				status: "error",
+				error: a(n.message)
+			}
+		} : e;
+	}
+	e.applyEvent = l;
+})(n ||= {});
+var r = n, i;
+(function(t) {
+	let n = t.ROOT_ID = "root", r = t.DEFAULT_SURFACE = "main";
+	t.EMPTY = {
+		surfaces: {},
+		order: []
+	};
+	function i(e) {
+		return typeof e == "object" && e && !Array.isArray(e) ? e : null;
+	}
+	function a(e) {
+		return typeof e == "string" && e !== "" ? e : void 0;
+	}
+	function o(e) {
+		return {
+			id: e,
+			components: {},
+			data: {}
+		};
+	}
+	function s(e, t, n) {
+		return {
+			surfaces: {
+				...e.surfaces,
+				[t]: n
+			},
+			order: e.order.includes(t) ? e.order : [...e.order, t]
+		};
+	}
+	function c(e) {
+		let t = i(e), n = a(t?.id);
+		if (t === null || n === void 0) return null;
+		let r = t.component;
+		if (typeof r == "string") {
+			let { id: e, component: i, ...a } = t;
+			return {
+				id: n,
+				component: r,
+				...a
+			};
+		}
+		let o = i(r), [s] = o ? Object.keys(o) : [];
+		return o === null || s === void 0 ? null : {
+			id: n,
+			component: s,
+			...i(o[s]) ?? {}
+		};
+	}
+	function l(e) {
+		return e.replace(/~1/g, "/").replace(/~0/g, "~");
+	}
+	function u(e) {
+		return e === void 0 || e === "" || e === "/" ? [] : (e.startsWith("/") ? e.slice(1) : e).split("/").map(l);
+	}
+	function d(e, t) {
+		return t.reduce((e, t) => i(e)?.[t], e);
+	}
+	function f(e, t, n) {
+		if (t.length === 0) return n;
+		let [r, ...a] = t, o = i(e) ?? {};
+		if (a.length > 0) return {
+			...o,
+			[r]: f(o[r], a, n)
+		};
+		if (n !== void 0) return {
+			...o,
+			[r]: n
+		};
+		let { [r]: s, ...c } = o;
+		return c;
+	}
+	function p(e) {
+		if (!Array.isArray(e)) return {};
+		let t = {};
+		for (let n of e) {
+			let e = i(n), r = a(e?.key);
+			e !== null && r !== void 0 && ("valueString" in e ? t[r] = e.valueString : "valueNumber" in e ? t[r] = e.valueNumber : "valueBoolean" in e ? t[r] = e.valueBoolean : "valueMap" in e && (t[r] = p(e.valueMap)));
+		}
+		return t;
+	}
+	function m(e, t) {
+		let n = i(t);
+		if (n === null) return e;
+		let l = i(n.createSurface) ?? i(n.beginRendering);
+		if (l !== null) {
+			let t = a(l.surfaceId) ?? r, n = e.surfaces[t] ?? o(t);
+			return s(e, t, {
+				...n,
+				catalogId: a(l.catalogId) ?? n.catalogId,
+				root: a(l.root) ?? n.root,
+				theme: i(l.theme) ?? i(l.styles) ?? n.theme
+			});
+		}
+		let m = i(n.updateComponents) ?? i(n.surfaceUpdate);
+		if (m !== null) {
+			let t = a(m.surfaceId) ?? r, n = e.surfaces[t] ?? o(t), i = { ...n.components }, l = !1;
+			for (let e of Array.isArray(m.components) ? m.components : []) {
+				let t = c(e);
+				t !== null && (i[t.id] = t, l = !0);
+			}
+			return l || !e.surfaces[t] ? s(e, t, {
+				...n,
+				components: i
+			}) : e;
+		}
+		let h = i(n.updateDataModel) ?? i(n.dataModelUpdate);
+		if (h !== null) {
+			let t = a(h.surfaceId) ?? r, n = e.surfaces[t] ?? o(t), c = u(a(h.path)), l = "contents" in h ? {
+				...i(d(n.data, c)) ?? {},
+				...p(h.contents)
+			} : void 0, m = f(n.data, c, l ?? h.value);
+			return s(e, t, {
+				...n,
+				data: i(m) ?? {}
+			});
+		}
+		let g = i(n.deleteSurface);
+		if (g !== null) {
+			let t = a(g.surfaceId) ?? r;
+			if (!e.surfaces[t]) return e;
+			let { [t]: n, ...i } = e.surfaces;
+			return {
+				surfaces: i,
+				order: e.order.filter((e) => e !== t)
+			};
+		}
+		return e;
+	}
+	t.apply = m;
+	function h(e, t) {
+		return t.reduce(m, e);
+	}
+	t.applyAll = h;
+	function g(e, t) {
+		return t === void 0 ? e.surfaces[e.order[0]] ?? null : e.surfaces[t] ?? null;
+	}
+	t.surface = g;
+	function _(e) {
+		let t = i(e);
+		return t === null ? e : "literalString" in t ? t.literalString : "literalNumber" in t ? t.literalNumber : "literalBoolean" in t ? t.literalBoolean : typeof t.path == "string" ? { $data: t.path } : e;
+	}
+	function v(e) {
+		let t = i(e);
+		return t === null ? a(e) : a(i(t.event)?.name) ?? a(t.name);
+	}
+	function y(e) {
+		let t = a(e.child);
+		if (t !== void 0) return { ids: [t] };
+		let n = e.children;
+		if (Array.isArray(n)) return { ids: n.filter((e) => typeof e == "string") };
+		let r = i(n);
+		if (r === null) return { ids: [] };
+		if (Array.isArray(r.explicitList)) return { ids: r.explicitList.filter((e) => typeof e == "string") };
+		let o = i(r.template) ?? r, s = a(o.componentId), c = a(o.path) ?? a(o.dataBinding);
+		return s !== void 0 && c !== void 0 ? {
+			ids: [],
+			template: {
+				componentId: s,
+				path: c
+			}
+		} : { ids: [] };
+	}
+	let b = /* @__PURE__ */ new Set([
+		"id",
+		"component",
+		"child",
+		"children",
+		"action"
+	]);
+	function x(e, t, n, r, i) {
+		let a = e.components[t];
+		if (a === void 0 || i > 32 || r.has(t)) return null;
+		let o = new Set(n.catalog?.components[a.component]?.events ?? []), s = {}, c = {};
+		for (let [e, t] of Object.entries(a)) {
+			if (b.has(e)) continue;
+			if (!o.has(e)) {
+				s[e] = _(t);
+				continue;
+			}
+			let n = v(t);
+			n !== void 0 && (c[e] = n);
+		}
+		let l = v(a.action);
+		l !== void 0 && (c.action = l);
+		let { ids: u, template: d } = y(a), f = /* @__PURE__ */ new Set([...r, t]), p = [];
+		for (let t of u) {
+			let r = x(e, t, n, f, i + 1);
+			r !== null && p.push(r);
+		}
+		if (d !== void 0) {
+			let t = x(e, d.componentId, n, f, i + 1);
+			t !== null && p.push({
+				...t,
+				repeat: { $data: d.path }
+			});
+		}
+		return {
+			type: a.component,
+			key: t,
+			...Object.keys(s).length ? { props: s } : {},
+			...p.length ? { children: p } : {},
+			...Object.keys(c).length ? { on: c } : {}
+		};
+	}
+	function S(e, t = {}) {
+		return e === null ? null : x(e, t.root ?? e.root ?? n, t, /* @__PURE__ */ new Set(), 0);
+	}
+	t.toSpec = S;
+	let C = {
+		type: "array",
+		items: { type: "string" },
+		description: "The ids of this component’s children, each a component of its own in the same surface."
+	}, w = {
+		type: "string",
+		description: "The name of an action the host handles."
+	};
+	function T(e, t) {
+		let n = i(i(e.components)?.[t]);
+		if (n === null) return null;
+		let r = i(e.$defs);
+		return r === null ? n : {
+			...n,
+			$defs: r
+		};
+	}
+	t.componentSchema = T;
+	function E(t, n = {}) {
+		let r = n.catalogId ?? `urn:box-kite:catalog:${t.version}`, i = {}, a = {};
+		for (let [n, r] of Object.entries(t.components)) {
+			let t = e.hoist(r.props, i);
+			a[n] = {
+				type: "object",
+				description: r.description,
+				properties: {
+					id: {
+						type: "string",
+						description: "This component’s id, unique within the surface."
+					},
+					component: {
+						type: "string",
+						enum: [n]
+					},
+					...t.properties ?? {},
+					...Object.fromEntries(r.events.map((e) => [e, w])),
+					...r.slots.length ? { children: C } : {}
+				},
+				required: [
+					"id",
+					"component",
+					...t.required ?? []
+				],
+				additionalProperties: !1
+			};
+		}
+		return {
+			$schema: "https://json-schema.org/draft/2020-12/schema",
+			$id: r,
+			catalogId: r,
+			title: n.title ?? `${t.library} catalog`,
+			description: n.description ?? t.rules.join(" "),
+			...Object.keys(i).length ? { $defs: i } : {},
+			components: a
+		};
+	}
+	t.catalogDocument = E;
+})(i ||= {});
+var a = i, o;
+(function(e) {
+	function n(e, t) {
+		if (typeof e == "string") return e;
+		if (t > 32 || typeof e != "object" || !e || typeof e.component != "string") return null;
+		let r = (e.children ?? []).map((e) => n(e, t + 1)).filter((e) => e !== null);
+		return {
+			type: e.component,
+			...e.key === void 0 ? {} : { key: e.key },
+			...e.props ? { props: e.props } : {},
+			...r.length ? { children: r } : {}
+		};
+	}
+	function r(e) {
+		return e == null ? [] : (Array.isArray(e.root) ? e.root : [e.root]).map((e) => n(e, 0)).filter((e) => typeof e == "object" && !!e);
+	}
+	e.toSpec = r;
+	function i(e, n, r, a) {
+		if (e == null) return null;
+		if (typeof e == "string") return e;
+		if (typeof e == "number" || typeof e == "boolean") return String(e);
+		if (t.isRef(e)) return r.push({
+			code: "data-binding",
+			path: n
+		}), null;
+		if (a > 32 || typeof e.type != "string") return null;
+		let o = e;
+		if (o.repeat && r.push({
+			code: "repeat",
+			path: n
+		}), o.on) for (let e of Object.keys(o.on)) r.push({
+			code: "event",
+			path: `${n}.on.${e}`
+		});
+		let s = (o.children === void 0 ? [] : Array.isArray(o.children) ? o.children : [o.children]).map((e, t) => i(e, `${n}.children.${t}`, r, a + 1)).filter((e) => e !== null);
+		return {
+			component: o.type,
+			...o.key === void 0 ? {} : { key: o.key },
+			...o.props ? { props: o.props } : {},
+			...s.length ? { children: s } : {}
+		};
+	}
+	function a(e) {
+		let t = [];
+		return {
+			spec: { root: (Array.isArray(e) ? e : [e]).map((e, n) => i(e, `root.${n}`, t, 0)).filter((e) => e !== null) },
+			losses: t
+		};
+	}
+	e.fromSpec = a;
+})(o ||= {});
+var s = o, c = r.toolPart, l = r.applyEvent, u = a.apply, d = a.applyAll, f = a.surface, p = a.toSpec, m = a.catalogDocument, h = a.componentSchema, g = a.EMPTY, _ = s.toSpec, v = s.fromSpec;
+//#endregion
+export { a as A2uiInterop, s as AssistantUiInterop, r as ToolInterop, u as a2uiApply, d as a2uiApplyAll, m as a2uiCatalog, h as a2uiComponentSchema, g as a2uiEmpty, f as a2uiSurface, p as a2uiToSpec, l as applyToolEvent, _ as fromGenerativeUi, v as toGenerativeUi, c as toolPart };

package/mcp/src/data.d.ts

@@ -0,0 +1,88 @@
+import { RegistryItem } from '../../pages/site/registry';
+/**
+ * The corpora, all of them generated somewhere else in this repository: the prop reference F3
+ * measures off the engine, the component reference G4 extracts from the sources, the rules file AI3
+ * installs as a skill, and F4's registry items. Nothing here is written down a second time — a
+ * transcribed fact is the one an agent trusts over its priors and the one that goes stale.
+ */
+export interface PropExample {
+    value: unknown;
+    css: string;
+}
+export interface PropRecord {
+    name: string;
+    description: string;
+    /** The CSS properties it writes. More than one when the prop composes (`shadow`, the filters). */
+    properties: string[];
+    example: PropExample;
+    /** Whether a number is accepted, and whether values outside the listed set are. */
+    numeric: boolean;
+    open: boolean;
+    /** The listed values, or a count alone where the reference cut a long list short. Numeric scales list numbers. */
+    values?: (string | number)[];
+    valueCount?: number;
+}
+export interface ComponentProp {
+    name: string;
+    type: string;
+    required: boolean;
+    default: string | null;
+    description: string;
+}
+export interface ComponentPart {
+    name: string;
+    description: string;
+    props: ComponentProp[];
+}
+export interface ComponentKey {
+    mode: string | null;
+    keys: string;
+    action: string;
+}
+export interface ComponentRecord {
+    name: string;
+    route: string;
+    import: string;
+    description: string;
+    pattern?: string;
+    props: ComponentProp[];
+    parts?: ComponentPart[];
+    keyboard?: ComponentKey[];
+    a11y?: string[];
+    styleTree?: string[];
+}
+export interface RuleRecord {
+    number: number;
+    /** The bolded lead sentence — what the rule is about, without its 300 words of detail. */
+    heading: string;
+    body: string;
+}
+export declare const packageName: string;
+export declare const packageVersion: string;
+export declare const siteUrl = "https://www.box-kite.dev";
+export declare const props: readonly PropRecord[];
+export declare const prop: (name: string) => PropRecord | undefined;
+export declare const components: readonly ComponentRecord[];
+/** Case-insensitive, because a model asks for `datagrid` as readily as `DataGrid`. */
+export declare const component: (name: string) => ComponentRecord | undefined;
+export declare const rules: readonly RuleRecord[];
+/**
+ * Those bullets, verbatim — the server's `instructions`, which a client puts in front of the model
+ * before it calls anything. `scripts/agentSources.mjs` reads the same block for `llms.txt` and the
+ * skill; `data.test.ts` pins this reader to that one, because two parsers of one file is how a fact
+ * comes to be stated two ways.
+ */
+export declare const priorFacts: readonly string[];
+export declare const blocks: readonly RegistryItem[];
+export declare const blockInstall: (name: string) => string;
+/**
+ * A fresh engine with readable class names and no DOM: what `check_styles` judges a value with. One
+ * per call rather than one for the process, so a caller's `vars` or `css` cannot leak into the next
+ * answer through the rule registry.
+ */
+export declare const styleEngine: () => import('../../src/core').StyleEngine;
+/**
+ * Every style prop's accepted values, live off the registry rather than out of `props.json`, which
+ * cuts a list over 40 short — and a colour prop's 295 tokens are exactly the list worth having.
+ */
+export declare function acceptedValues(name: string): string[];

package/mcp/src/data.test.d.ts

@@ -0,0 +1 @@
+export {};

package/mcp/src/engine.d.ts

@@ -0,0 +1,23 @@
+/**
+ * What one prop writes, measured. Every answer this server gives about a value — the example, the
+ * scale, the verdict — comes through here rather than out of a table, so a changed divider changes
+ * the documentation in the same commit and a rejected value is reported as what it is: nothing.
+ */
+/**
+ * The sheet as a list of top-level rules. A brace counter rather than a split on `}`, because a
+ * `@media`, `@container` or `@scope` block carries rules of its own and a nested one must stay with
+ * its wrapper — and because the sink writes several rules to a line, so a line is not a rule.
+ */
+export declare function splitRules(css: string): string[];
+export interface Measured {
+    /** The rules this prop added, at-rules included — empty when the value was not accepted. */
+    css: string;
+    /** The class names it produced, without the base class every Box carries. */
+    classNames: string[];
+}
+/** One prop resolved on an engine of its own, so nothing it writes can hide behind another prop's class. */
+export declare function measure(name: string, value: unknown): Measured;
+/** Just the declarations, for a table where the selector is noise: `padding:1rem`. */
+export declare function declarations(name: string, value: unknown): string;
+/** How a value is written in JSX — a string in quotes, everything else in braces. */
+export declare const written: (name: string, value: unknown) => string;

package/mcp/src/index.d.ts

@@ -0,0 +1 @@
+export {};

package/mcp/src/search.d.ts

@@ -0,0 +1,26 @@
+/**
+ * One entry point over the four corpora, because an agent mid-task knows what it wants the UI to do
+ * and not which of them holds the answer. Ranked rather than filtered: a query with no exact hit
+ * should still come back with the three things most worth reading, since an empty result sends the
+ * model back to its priors — which is the failure this whole package exists to prevent.
+ */
+export type HitKind = 'prop' | 'component' | 'nesting' | 'rule';
+export interface Hit {
+    kind: HitKind;
+    /** What to pass to `get_props`, `get_component` or `get_rules` for the whole record. */
+    name: string;
+    summary: string;
+    score: number;
+}
+/** The four corpora, ranked together. `kind` narrows it when the caller already knows which it wants. */
+export declare function search(query: string, options?: {
+    kind?: HitKind;
+    limit?: number;
+}): Hit[];
+/**
+ * The components whose own props a name belongs to — what a search for `onValueChange` should answer
+ * with, since the same prop name lives on six widgets and none of them is in the prop registry.
+ */
+export declare function componentsWithProp(name: string): string[];
+/** Case-insensitive component lookup that also answers for a part (`Tabs.Tab` → `Tabs`). */
+export declare function resolveComponent(name: string): import('./data').ComponentRecord | undefined;

package/mcp/src/search.test.d.ts

@@ -0,0 +1 @@
+export {};

package/mcp/src/server.d.ts

@@ -0,0 +1,18 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+/**
+ * `@box-kite/mcp` — the retrieval channel for an agent mid-task.
+ *
+ * Deliberately six tools at *capability* level rather than one per document: what may I write, what
+ * does this component take, and — the one no docs mirror can answer — does this value actually work.
+ * The package is built from this repository, so every answer is the reference the same commit
+ * generated: `api/props.json` measured off the engine, `api/components/*.json` extracted from the
+ * sources, the rules file the skill installs, and the engine itself for `check_styles`.
+ */
+/**
+ * What a client puts in front of the model before it calls anything. The facts are `AGENTS.md`'s own
+ * lead block — the four a model's memory of a library with these prop names gets wrong — because an
+ * agent that never calls a tool should still be told the dividers differ.
+ */
+export declare const instructions: string;
+/** The server, transport-free so a test can drive it over an in-memory pair. */
+export declare function createServer(): McpServer;

package/mcp/src/server.test.d.ts

@@ -0,0 +1 @@
+export {};

package/mcp/src/styles.d.ts

@@ -0,0 +1,27 @@
+/**
+ * `check_styles`: the answer an agent cannot get from prose. A value this library does not accept
+ * produces **no rule and no class name** — silently, by design — so the only honest way to say
+ * whether `bgColor="blue-550"` works is to hand it to the engine and look at what came back.
+ *
+ * Each prop is measured on its own, because one bag would let a rejected value hide behind an
+ * accepted one in the same class list.
+ */
+export type Verdict = 'ok' | 'rejected-value' | 'unknown-prop' | 'html-attribute' | 'reserved';
+export interface PropCheck {
+    name: string;
+    verdict: Verdict;
+    /** The rules this prop wrote, at-rules included. Empty unless `ok`. */
+    css: string;
+    /** What to do about it, when the verdict is not `ok`. */
+    note?: string;
+    /** Prop names worth trying instead, closest first. */
+    suggestions?: string[];
+}
+export interface StyleCheck {
+    checks: PropCheck[];
+    /** The class attribute the whole bag resolves to — what `<Box {...props}>` would render. */
+    className: string;
+    ok: boolean;
+}
+/** Judge a whole prop bag: one verdict per prop, plus the class attribute the bag as a whole resolves to. */
+export declare function checkStyles(bag: Record<string, unknown>): StyleCheck;

package/mcp/src/styles.test.d.ts

@@ -0,0 +1 @@
+export {};

package/mcp/src/tools.d.ts

@@ -0,0 +1,18 @@
+import { ComponentRecord } from './data';
+import { Hit } from './search';
+/** `search_docs` — the entry point when the caller knows the goal and not the name. */
+export declare function searchDocs(query: string, kind?: Hit['kind'], limit?: number): string;
+/** `get_props` — the record for named style props, with the scale measured rather than stated. */
+export declare function getProps(names: string[]): string;
+export type ComponentSection = 'props' | 'parts' | 'keyboard' | 'a11y' | 'styles';
+/** `get_component` — one component's whole contract: props, parts, the keyboard map and the ARIA. */
+export declare function getComponent(name: string, include?: ComponentSection[]): string;
+/** `check_styles` — the engine's own answer, which is the only one that counts. */
+export declare function checkStylesTool(bag: Record<string, unknown>): string;
+/** `get_rules` — the numbered rules, or the index of them. */
+export declare function getRules(numbers?: number[]): string;
+/** `get_blocks` — F4's registry: whole sections the shadcn CLI installs, wired and compiling. */
+export declare function getBlocks(name?: string): string;
+/** Every nesting key, for the tool description's "what else can I write" — small enough to state whole. */
+export declare const nestingSummary: () => string;
+export type { ComponentRecord };