@n6k.io/serve 0.1.1 → 0.2.2

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
@@ -0,0 +1,227 @@
1
+ import path from "node:path";
2
+ import os from "node:os";
3
+ import { mkdtempSync, rmSync, writeFileSync } from "node:fs";
4
+ import { afterEach, expect, test } from "bun:test";
5
+
6
+ const CLI = path.join(import.meta.dir, "cli.ts");
7
+
8
+ type Reply = {
9
+ id: number;
10
+ result?: {
11
+ content?: { text: string }[];
12
+ isError?: boolean;
13
+ tools?: { name: string }[];
14
+ instructions?: string;
15
+ };
16
+ };
17
+
18
+ function spawnMcp(args: string[] = []) {
19
+ const proc = Bun.spawn(["bun", CLI, "--mcp", "--port", "0", ...args], {
20
+ stdin: "pipe",
21
+ stdout: "pipe",
22
+ stderr: "pipe",
23
+ });
24
+ const lines: string[] = [];
25
+ const waiting = new Map<number, (reply: Reply) => void>();
26
+ let nextId = 1;
27
+
28
+ void (async () => {
29
+ const decoder = new TextDecoder();
30
+ let buf = "";
31
+ for await (const chunk of proc.stdout) {
32
+ buf += decoder.decode(chunk);
33
+ let nl: number;
34
+ while ((nl = buf.indexOf("\n")) !== -1) {
35
+ const line = buf.slice(0, nl);
36
+ buf = buf.slice(nl + 1);
37
+ lines.push(line);
38
+ const msg = JSON.parse(line) as Reply;
39
+ waiting.get(msg.id)?.(msg);
40
+ }
41
+ }
42
+ })();
43
+
44
+ const send = (msg: object) => {
45
+ void proc.stdin.write(JSON.stringify({ jsonrpc: "2.0", ...msg }) + "\n");
46
+ void proc.stdin.flush();
47
+ };
48
+
49
+ const request = (method: string, params: object): Promise<Reply> => {
50
+ const id = nextId++;
51
+ const reply = new Promise<Reply>((resolve) => waiting.set(id, resolve));
52
+ send({ id, method, params });
53
+ return reply;
54
+ };
55
+
56
+ const call = async (name: string, args: object = {}) => {
57
+ const reply = await request("tools/call", { name, arguments: args });
58
+ return {
59
+ text: reply.result?.content?.[0]?.text ?? "",
60
+ isError: reply.result?.isError === true,
61
+ };
62
+ };
63
+
64
+ const init = async () => {
65
+ const reply = await request("initialize", {
66
+ protocolVersion: "2025-06-18",
67
+ capabilities: {},
68
+ clientInfo: { name: "test", version: "0" },
69
+ });
70
+ send({ method: "notifications/initialized" });
71
+ return reply;
72
+ };
73
+
74
+ return { proc, lines, request, call, init };
75
+ }
76
+
77
+ let cleanup: (() => void)[] = [];
78
+ afterEach(() => {
79
+ for (const fn of cleanup) fn();
80
+ cleanup = [];
81
+ });
82
+
83
+ function tempDir(): string {
84
+ const dir = mkdtempSync(path.join(os.tmpdir(), "n6k-serve-test-"));
85
+ cleanup.push(() => rmSync(dir, { recursive: true, force: true }));
86
+ return dir;
87
+ }
88
+
89
+ async function status(url: string | URL): Promise<number> {
90
+ const res = await fetch(url);
91
+ return res.status;
92
+ }
93
+
94
+ async function body(url: string | URL): Promise<string> {
95
+ const res = await fetch(url);
96
+ return res.text();
97
+ }
98
+
99
+ test("mcp serves inline and path pages", async () => {
100
+ const mcp = spawnMcp();
101
+ cleanup.push(() => mcp.proc.kill());
102
+ await mcp.init();
103
+ const failed = async (name: string, args: object) => {
104
+ const reply = await mcp.call(name, args);
105
+ return reply.isError;
106
+ };
107
+
108
+ const tools = await mcp.request("tools/list", {});
109
+ expect(tools.result?.tools?.map((t) => t.name).toSorted()).toEqual([
110
+ "describe_component",
111
+ "list_pages",
112
+ "remove_data",
113
+ "remove_page",
114
+ "search_components",
115
+ "set_data",
116
+ "set_page",
117
+ ]);
118
+
119
+ const set = await mcp.call("set_page", { page: "p", mdx: "# one" });
120
+ expect(set.isError).toBe(false);
121
+ const url = set.text;
122
+ expect(url).toMatch(/^http:\/\/.*\/p\/$/);
123
+ expect(await status(url)).toBe(200);
124
+ const js = new URL("index.js", url);
125
+ expect(await body(js)).toContain("one");
126
+
127
+ await mcp.call("set_page", { page: "p", mdx: "# two" });
128
+ expect(await body(js)).toContain("two");
129
+
130
+ const broken = await mcp.call("set_page", { page: "bad", mdx: "<Nope" });
131
+ expect(broken.isError).toBe(true);
132
+ expect(broken.text).not.toBe("");
133
+
134
+ expect(
135
+ await failed("set_page", { page: "x", mdx: "# x", path: "/x.mdx" }),
136
+ ).toBe(true);
137
+ expect(await failed("set_page", { page: "x", path: "rel.mdx" })).toBe(true);
138
+ expect(await failed("set_page", { page: "a/b", mdx: "# x" })).toBe(true);
139
+
140
+ const file = path.join(tempDir(), "f.mdx");
141
+ writeFileSync(file, "# from file");
142
+ expect(await mcp.call("set_page", { page: "f", path: file })).toEqual({
143
+ text: url.replace(/p\/$/, "f/"),
144
+ isError: false,
145
+ });
146
+
147
+ const listed = await mcp.call("list_pages");
148
+ const pages = JSON.parse(listed.text) as { page: string }[];
149
+ expect(pages.map((p) => p.page).toSorted()).toEqual(["bad", "f", "p"]);
150
+
151
+ expect(await body(js)).not.toContain("tok-secret");
152
+ expect(
153
+ await failed("set_data", { alias: "1x", url: "ws://x", token: "t" }),
154
+ ).toBe(true);
155
+ expect(
156
+ await failed("set_data", { alias: "db", url: "http://x", token: "t" }),
157
+ ).toBe(true);
158
+ expect(
159
+ await failed("set_data", {
160
+ alias: "db",
161
+ url: "ws://127.0.0.1:1/ws",
162
+ token: "tok-secret",
163
+ }),
164
+ ).toBe(false);
165
+ expect(await body(js)).toContain("tok-secret");
166
+ expect(await body(js)).toContain("ws://127.0.0.1:1/ws");
167
+ expect(await failed("remove_data", { alias: "db" })).toBe(false);
168
+ expect(await body(js)).not.toContain("tok-secret");
169
+ expect(await body(js)).not.toContain("ws://127.0.0.1:1/ws");
170
+ expect(await failed("remove_data", { alias: "db" })).toBe(true);
171
+
172
+ expect(await failed("remove_page", { page: "p" })).toBe(false);
173
+ expect(await status(url)).toBe(404);
174
+ expect(await failed("remove_page", { page: "p" })).toBe(true);
175
+
176
+ for (const line of mcp.lines) expect(() => JSON.parse(line)).not.toThrow();
177
+
178
+ mcp.proc.stdin.end();
179
+ expect(await mcp.proc.exited).toBe(0);
180
+ }, 60_000);
181
+
182
+ test("mcp documents components and renders controls", async () => {
183
+ const mcp = spawnMcp();
184
+ cleanup.push(() => mcp.proc.kill());
185
+ const init = await mcp.init();
186
+ expect(init.result?.instructions).toContain("::Slider");
187
+
188
+ const search = async (query?: string) => {
189
+ const reply = await mcp.call("search_components", { query });
190
+ return JSON.parse(reply.text) as { name: string; kind: string }[];
191
+ };
192
+ expect(await search()).toHaveLength(52);
193
+ const charts = await search("chart");
194
+ expect(charts.map((c) => c.name)).toContain("BarChart");
195
+
196
+ const slider = await mcp.call("describe_component", { name: "Slider" });
197
+ const doc = JSON.parse(slider.text) as {
198
+ kind: string;
199
+ props: Record<string, unknown>;
200
+ };
201
+ expect(doc.kind).toBe("control");
202
+ expect(Object.keys(doc.props)).toEqual(
203
+ expect.arrayContaining(["min", "max"]),
204
+ );
205
+ const unknown = await mcp.call("describe_component", { name: "Bar" });
206
+ expect(unknown.isError).toBe(true);
207
+ expect(unknown.text).toContain("BarChart");
208
+
209
+ const leaf = await mcp.call("set_page", {
210
+ page: "leaf",
211
+ mdx: '::Slider[n]{label="N" min=1 max=10 default=5}\n\nValue {n}\n',
212
+ });
213
+ expect(leaf.isError).toBe(false);
214
+ expect(await body(new URL("index.js", leaf.text))).toContain("Controls");
215
+
216
+ const container = await mcp.call("set_page", {
217
+ page: "container",
218
+ mdx: [
219
+ ':::Select[month]{default="a"}',
220
+ "<SelectTrigger><SelectValue /></SelectTrigger>",
221
+ '<SelectContent><SelectItem value="a">A</SelectItem></SelectContent>',
222
+ ":::",
223
+ "",
224
+ ].join("\n"),
225
+ });
226
+ expect(container.isError).toBe(false);
227
+ }, 60_000);
package/src/mcp.ts ADDED
@@ -0,0 +1,268 @@
1
+ import os from "node:os";
2
+ import path from "node:path";
3
+ import { existsSync, mkdtempSync, rmSync } from "node:fs";
4
+ import { McpServer } from "@modelcontextprotocol/server";
5
+ import { StdioServerTransport } from "@modelcontextprotocol/server/stdio";
6
+ import { z } from "zod";
7
+ import { bundlePage } from "./bundle";
8
+ import { buildCss } from "./css";
9
+ import { describeComponent, searchComponents } from "./component-docs";
10
+ import { ALIAS, type DataSource } from "./data-args";
11
+ import { INSTRUCTIONS } from "./mcp-instructions";
12
+ import { PagesError, name } from "./pages";
13
+ import type { PageState, ServedPage, Server, Site } from "./server";
14
+ import { watchFile } from "./watch";
15
+
16
+ type Entry = {
17
+ file: string;
18
+ served: ServedPage;
19
+ cached?: Promise<PageState>;
20
+ unwatch: () => void;
21
+ };
22
+
23
+ function listing(pages: string[]): string {
24
+ const items = pages.map(
25
+ (page) => `<li><a href="/${page}/">${Bun.escapeHTML(page)}</a></li>`,
26
+ );
27
+ return `<!doctype html>
28
+ <html lang="en">
29
+ <head><meta charset="utf-8" /><title>n6k-serve</title></head>
30
+ <body><ul>${items.join("")}</ul></body>
31
+ </html>`;
32
+ }
33
+
34
+ export class McpSite implements Site {
35
+ private readonly entries = new Map<string, Entry>();
36
+ private readonly data = new Map<string, DataSource>();
37
+
38
+ constructor(private readonly onChange: (key: string) => void) {}
39
+
40
+ resolve: Site["resolve"] = (pathname) => {
41
+ if (pathname === "/")
42
+ return { kind: "html", body: listing([...this.entries.keys()]) };
43
+ const [, page, ...rest] = pathname.split("/");
44
+ const entry = this.entries.get(page);
45
+ if (!entry) return;
46
+ if (rest.length === 0) return { kind: "redirect", to: `${pathname}/` };
47
+ return { kind: "page", page: entry.served, rest: `/${rest.join("/")}` };
48
+ };
49
+
50
+ page: Site["page"] = (key) => this.entries.get(key)?.served;
51
+
52
+ setData(alias: string, source: DataSource): void {
53
+ this.data.set(alias, source);
54
+ this.rebuildAll();
55
+ }
56
+
57
+ removeData(alias: string): void {
58
+ if (!this.data.delete(alias)) throw new PagesError(`no data ${alias}`);
59
+ this.rebuildAll();
60
+ }
61
+
62
+ private rebuildAll(): void {
63
+ for (const [page, entry] of this.entries) {
64
+ entry.cached = undefined;
65
+ this.onChange(page);
66
+ }
67
+ }
68
+
69
+ list(): { page: string; file: string }[] {
70
+ return [...this.entries].map(([page, { file }]) => ({ page, file }));
71
+ }
72
+
73
+ set(page: string, file: string): ServedPage {
74
+ const existing = this.entries.get(page);
75
+ if (existing?.file === file) {
76
+ existing.cached = undefined;
77
+ this.onChange(page);
78
+ return existing.served;
79
+ }
80
+ existing?.unwatch();
81
+ const entry: Entry = {
82
+ file,
83
+ served: {
84
+ title: path.basename(file),
85
+ key: page,
86
+ state: () => {
87
+ if (entry.cached) return entry.cached;
88
+ const built = this.build(file);
89
+ entry.cached = built;
90
+ built.catch(() => {
91
+ if (entry.cached === built) entry.cached = undefined;
92
+ });
93
+ return built;
94
+ },
95
+ },
96
+ unwatch: watchFile(file, () => {
97
+ entry.cached = undefined;
98
+ this.onChange(page);
99
+ console.error(`changed ${page}`);
100
+ }),
101
+ };
102
+ this.entries.set(page, entry);
103
+ if (existing) this.onChange(page);
104
+ return entry.served;
105
+ }
106
+
107
+ remove(page: string): void {
108
+ const entry = this.entries.get(page);
109
+ if (!entry) throw new PagesError(`no page ${page}`);
110
+ entry.unwatch();
111
+ this.entries.delete(page);
112
+ }
113
+
114
+ private async build(file: string): Promise<PageState> {
115
+ const [bundle, css] = await Promise.all([
116
+ bundlePage(file, {
117
+ data: Object.fromEntries(
118
+ [...this.data].map(([alias, { url }]) => [alias, url]),
119
+ ),
120
+ tokens: Object.fromEntries(
121
+ [...this.data].map(([alias, { token }]) => [alias, token]),
122
+ ),
123
+ }),
124
+ buildCss(file),
125
+ ]);
126
+ return { bundle, css };
127
+ }
128
+ }
129
+
130
+ function text(value: unknown) {
131
+ return {
132
+ content: [
133
+ {
134
+ type: "text" as const,
135
+ text: typeof value === "string" ? value : JSON.stringify(value),
136
+ },
137
+ ],
138
+ };
139
+ }
140
+
141
+ export function startMcp(
142
+ site: McpSite,
143
+ server: Server,
144
+ version: string,
145
+ onClose: () => void,
146
+ ): void {
147
+ const inlineDir = mkdtempSync(path.join(os.tmpdir(), "n6k-serve-"));
148
+ const urlOf = (page: string) => new URL(`${page}/`, server.url).href;
149
+ const mcp = new McpServer(
150
+ { name: "n6k-serve", version },
151
+ { capabilities: { tools: {} }, instructions: INSTRUCTIONS },
152
+ );
153
+
154
+ mcp.registerTool(
155
+ "search_components",
156
+ {
157
+ description:
158
+ "Search components and controls by name or description; omit query to list all.",
159
+ inputSchema: z.object({ query: z.string().optional() }),
160
+ },
161
+ ({ query }) => text(searchComponents(query)),
162
+ );
163
+
164
+ mcp.registerTool(
165
+ "describe_component",
166
+ {
167
+ description: "Props and description of one component or control.",
168
+ inputSchema: z.object({ name: z.string() }),
169
+ },
170
+ ({ name: component }) => text(describeComponent(component)),
171
+ );
172
+
173
+ mcp.registerTool(
174
+ "list_pages",
175
+ { description: "List served pages with their URLs." },
176
+ () => text(site.list().map((p) => ({ ...p, url: urlOf(p.page) }))),
177
+ );
178
+
179
+ mcp.registerTool(
180
+ "set_page",
181
+ {
182
+ description:
183
+ "Serve a page from an absolute .mdx path or inline mdx content (exactly one), build it, and return its URL or the build error.",
184
+ inputSchema: z.object({
185
+ page: z.string(),
186
+ path: z.string().optional(),
187
+ mdx: z.string().optional(),
188
+ }),
189
+ },
190
+ async ({ page, path: file, mdx }) => {
191
+ name(page, "page");
192
+ if ((file === undefined) === (mdx === undefined))
193
+ throw new PagesError("pass exactly one of path or mdx");
194
+ let abs: string;
195
+ if (mdx === undefined) {
196
+ abs = file ?? "";
197
+ if (!path.isAbsolute(abs))
198
+ throw new PagesError(`${abs}: path must be absolute`);
199
+ if (!abs.endsWith(".mdx"))
200
+ throw new PagesError(`${abs}: not an .mdx file`);
201
+ if (!existsSync(abs)) throw new PagesError(`${abs}: no such file`);
202
+ } else {
203
+ abs = path.join(inlineDir, `${page}.mdx`);
204
+ await Bun.write(abs, mdx);
205
+ }
206
+ await site.set(page, abs).state();
207
+ return text(urlOf(page));
208
+ },
209
+ );
210
+
211
+ mcp.registerTool(
212
+ "set_data",
213
+ {
214
+ description:
215
+ "Attach a data source as `alias` (also the server catalog name). Rebuilds and reloads every page.",
216
+ inputSchema: z.object({
217
+ alias: z.string(),
218
+ url: z.string(),
219
+ token: z.string(),
220
+ }),
221
+ },
222
+ ({ alias, url, token }) => {
223
+ if (!ALIAS.test(alias))
224
+ throw new PagesError(
225
+ `alias ${JSON.stringify(alias)} must match ${ALIAS.source}`,
226
+ );
227
+ if (!URL.canParse(url) || !/^wss?:$/.test(new URL(url).protocol))
228
+ throw new PagesError(
229
+ `${JSON.stringify(url)} is not a ws:// or wss:// URL`,
230
+ );
231
+ site.setData(alias, { url, token });
232
+ return text(`set data ${alias}`);
233
+ },
234
+ );
235
+
236
+ mcp.registerTool(
237
+ "remove_data",
238
+ {
239
+ description: "Detach a data source. Rebuilds and reloads every page.",
240
+ inputSchema: z.object({ alias: z.string() }),
241
+ },
242
+ ({ alias }) => {
243
+ site.removeData(alias);
244
+ return text(`removed data ${alias}`);
245
+ },
246
+ );
247
+
248
+ mcp.registerTool(
249
+ "remove_page",
250
+ {
251
+ description: "Stop serving a page.",
252
+ inputSchema: z.object({ page: z.string() }),
253
+ },
254
+ ({ page }) => {
255
+ site.remove(page);
256
+ return text(`removed ${page}`);
257
+ },
258
+ );
259
+
260
+ const transport = new StdioServerTransport();
261
+ // eslint-disable-next-line unicorn/prefer-add-event-listener -- Transport has no addEventListener
262
+ transport.onclose = () => {
263
+ void server.stop(true);
264
+ rmSync(inlineDir, { recursive: true, force: true });
265
+ onClose();
266
+ };
267
+ void mcp.connect(transport);
268
+ }
@@ -1,15 +1,24 @@
1
1
  import type { ComponentProps } from "react";
2
2
  import type { MDXComponents } from "mdx/types";
3
3
  import * as n6k from "@n6k.io/ui/components";
4
+ import {
5
+ SelectContent,
6
+ SelectItem,
7
+ SelectTrigger,
8
+ SelectValue,
9
+ } from "@n6k.io/ui/components/ui/select";
4
10
 
5
- // MDX component scope. The build auto-discovers this file, so every name
6
- // returned here is usable as a bare tag in any `.mdx` page — no import needed.
7
- // Spread the n6k component set, then add your own components or restyle the
8
- // markdown elements. A tag that isn't registered here (or imported in the page)
9
- // fails when the page is rendered.
11
+ // Passed to the build as `mdxComponents`. A tag that is neither
12
+ // here nor imported by the page still builds and fails at render.
13
+ // `Controls` is the name @n6k.io/build's remark-controls emits for `::X[…]`.
10
14
  export function useMDXComponents(components: MDXComponents): MDXComponents {
11
15
  return {
12
16
  ...n6k,
17
+ Controls: n6k.controls,
18
+ SelectContent,
19
+ SelectItem,
20
+ SelectTrigger,
21
+ SelectValue,
13
22
  h1: (props: ComponentProps<"h1">) => (
14
23
  <h1 className="pb-4 text-4xl font-black tracking-tight" {...props} />
15
24
  ),
@@ -0,0 +1,113 @@
1
+ import path from "node:path";
2
+ import { bundlePage } from "./bundle";
3
+ import { buildCss } from "./css";
4
+ import { diffPages, type PagesConfig, type PageRef } from "./pages";
5
+ import type { PageState, ServedPage, Site } from "./server";
6
+ import { watchFile } from "./watch";
7
+
8
+ type Entry = {
9
+ served: ServedPage;
10
+ unwatch: () => void;
11
+ cached?: Promise<PageState>;
12
+ };
13
+
14
+ function keyOf({ app, page }: PageRef): string {
15
+ return `${app}/${page}`;
16
+ }
17
+
18
+ function listing(config: PagesConfig): string {
19
+ const items = Object.entries(config).flatMap(([app, { pages }]) =>
20
+ Object.keys(pages).map((page) => {
21
+ const href = `/${app}/${page}/`;
22
+ return `<li><a href="${href}">${Bun.escapeHTML(`${app}/${page}`)}</a></li>`;
23
+ }),
24
+ );
25
+ return `<!doctype html>
26
+ <html lang="en">
27
+ <head><meta charset="utf-8" /><title>n6k-serve</title></head>
28
+ <body><ul>${items.join("")}</ul></body>
29
+ </html>`;
30
+ }
31
+
32
+ export class PagesSite implements Site {
33
+ private config: PagesConfig = {};
34
+ private readonly entries = new Map<string, Entry>();
35
+
36
+ constructor(private readonly onChange: (key: string) => void) {}
37
+
38
+ update(next: PagesConfig): void {
39
+ const prev = this.config;
40
+ this.config = next;
41
+ const diff = diffPages(prev, next);
42
+ for (const ref of [...diff.removed, ...diff.changed]) this.drop(ref);
43
+ for (const ref of [...diff.added, ...diff.changed]) this.add(ref);
44
+ for (const ref of diff.changed) this.onChange(keyOf(ref));
45
+ }
46
+
47
+ resolve: Site["resolve"] = (pathname) => {
48
+ if (pathname === "/") return { kind: "html", body: listing(this.config) };
49
+ const [, app, page, ...rest] = pathname.split("/");
50
+ const entry = this.entries.get(`${app}/${page}`);
51
+ if (!entry) return;
52
+ if (rest.length === 0) return { kind: "redirect", to: `${pathname}/` };
53
+ return { kind: "page", page: entry.served, rest: `/${rest.join("/")}` };
54
+ };
55
+
56
+ page: Site["page"] = (key) => this.entries.get(key)?.served;
57
+
58
+ private add(ref: PageRef): void {
59
+ const key = keyOf(ref);
60
+ const file = this.config[ref.app].pages[ref.page];
61
+ const { url, token, catalogs } = this.config[ref.app].gateway;
62
+ const entry: Entry = {
63
+ served: {
64
+ title: path.basename(file),
65
+ key,
66
+ state: () => {
67
+ if (entry.cached) return entry.cached;
68
+ const built = this.build(file, url, catalogs, token);
69
+ entry.cached = built;
70
+ built.catch(() => {
71
+ if (entry.cached === built) entry.cached = undefined;
72
+ });
73
+ return built;
74
+ },
75
+ },
76
+ unwatch: () => {},
77
+ };
78
+ try {
79
+ entry.unwatch = watchFile(file, () => {
80
+ entry.cached = undefined;
81
+ this.onChange(key);
82
+ console.error(`changed ${key}`);
83
+ });
84
+ } catch (err) {
85
+ console.error(
86
+ `${key}: cannot watch ${file}: ${err instanceof Error ? err.message : String(err)}`,
87
+ );
88
+ }
89
+ this.entries.set(key, entry);
90
+ }
91
+
92
+ private drop(ref: PageRef): void {
93
+ const key = keyOf(ref);
94
+ this.entries.get(key)?.unwatch();
95
+ this.entries.delete(key);
96
+ }
97
+
98
+ private async build(
99
+ file: string,
100
+ url: string,
101
+ catalogs: string[],
102
+ token: string,
103
+ ): Promise<PageState> {
104
+ const [bundle, css] = await Promise.all([
105
+ bundlePage(file, {
106
+ data: Object.fromEntries(catalogs.map((c) => [c, url])),
107
+ tokens: Object.fromEntries(catalogs.map((c) => [c, token])),
108
+ }),
109
+ buildCss(file),
110
+ ]);
111
+ return { bundle, css };
112
+ }
113
+ }