bestax-mcp 0.0.0

package/dist/helper-props.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"helper-props.d.ts","sourceRoot":"","sources":["../src/helper-props.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAEH;;;;;GAKG;AACH,wBAAgB,YAAY,CAAC,EAAE,EAAE,MAAM,GAAG,MAAM,CA6B/C;AAED,MAAM,WAAW,WAAW;IAC1B,qEAAqE;IACrE,QAAQ,EAAE,MAAM,EAAE,CAAC;IACnB,yEAAyE;IACzE,KAAK,EAAE,MAAM,EAAE,CAAC;IAChB,2EAA2E;IAC3E,OAAO,EAAE,MAAM,EAAE,CAAC;CACnB;AAED;;;GAGG;AACH,eAAO,MAAM,aAAa,EAAE,MAAM,CAAC,MAAM,EAAE,WAAW,CAqGrD,CAAC;AAEF,eAAO,MAAM,WAAW,UAA6B,CAAC;AAEtD,8EAA8E;AAC9E,wBAAgB,YAAY,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAezD;AAKD,uFAAuF;AACvF,wBAAgB,SAAS,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,MAAM,EAAE,GAAG,MAAM,CAe/D;AAMD;;;;;;;GAOG;AACH,wBAAgB,mBAAmB,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CASvD;AAED,6EAA6E;AAC7E,wBAAgB,iBAAiB,CAAC,GAAG,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,CAgBnE"}

package/dist/helper-props.js

@@ -0,0 +1,249 @@
+/**
+ * Shaping the helper-prop reference so asking one question does not cost the whole page.
+ *
+ * `get_helper_props` was 54,886 characters — 49% of everything a cold-start builder read in
+ * a measured session, on the tool this server's own `instructions` tell every client to call
+ * before writing styling. Its `group` argument was supposed to prevent that and did not: the
+ * filter substring-matched whole section BODIES, and three sections (`Supported Props`,
+ * `Viewport-Specific Properties`, `Full TypeScript Definition`) name every helper keyword, so
+ * `group: "text"` matched 21 of 41 sections — 87% of the page.
+ *
+ * Matching headings instead is not the fix either; it is a regression. `spacing` and
+ * `typography` — two of the three groups the tool's own description advertises — match no
+ * heading at all and would answer nothing.
+ *
+ * So the groups are curated, and each one carries its own slice of the prop table. The
+ * governing rule is that **no call ever loses a prop name**: the default lists all 46 with
+ * their accepted values, because a builder has to be able to look up a valid value in one
+ * call. What moves behind `group` is the prose and the live examples, which are re-fetchable
+ * and which nothing breaks without.
+ */
+/**
+ * Markdown tables in the generated index are column-padded for human reading. That padding
+ * is 32% of this document — 16,352 characters, of which `Supported Props` alone contributes
+ * 12,455. Stripping it is free: no model reads alignment, and the cell contents are
+ * untouched.
+ */
+export function reflowTables(md) {
+    // Fenced code is left exactly as written. Today's document happens to contain no table
+    // inside a fence, so this changes nothing — but "pure whitespace, nothing lost" has to be
+    // a property of the function rather than of the content it currently gets handed, and a
+    // docs example that renders a markdown table is an ordinary thing to add.
+    let inFence = false;
+    return md
+        .split('\n')
+        .map(line => {
+        const t = line.trim();
+        if (t.startsWith('```') || t.startsWith('~~~')) {
+            inFence = !inFence;
+            return line;
+        }
+        if (inFence)
+            return line;
+        if (!t.startsWith('|') || !t.endsWith('|'))
+            return line;
+        // Split on unescaped pipes only. A `\|` inside a cell is markdown's escape for a
+        // literal pipe — the natural way to write a value union like `` `a` \| `b` `` — and
+        // splitting on it would invent a column, which is exactly the information loss this
+        // function promises not to cause. The index has no escaped pipes today; the guarantee
+        // has to hold for the document, not for today's contents.
+        const cells = t.slice(1, -1).split(/(?<!\\)\|/);
+        // A separator row (`| --- | --- |`) collapses to the shortest legal form.
+        if (cells.every(c => /^\s*:?-+:?\s*$/.test(c))) {
+            return `|${cells.map(c => (c.includes(':') ? c.trim() : '---')).join('|')}|`;
+        }
+        return `|${cells.map(c => ` ${c.trim()} `).join('|')}|`;
+    })
+        .join('\n');
+}
+/**
+ * Every prop in the table belongs to exactly one group — checked by a test, because a prop
+ * that falls through the map is a prop a `group` call can never surface.
+ */
+export const HELPER_GROUPS = {
+    spacing: {
+        headings: ['### Margin'],
+        props: [
+            'm',
+            'mt',
+            'mr',
+            'mb',
+            'ml',
+            'mx',
+            'my',
+            'p',
+            'pt',
+            'pr',
+            'pb',
+            'pl',
+            'px',
+            'py',
+        ],
+        aliases: ['margin', 'padding', 'gap', 'space'],
+    },
+    color: {
+        headings: [
+            '### Colors',
+            '### Background Color',
+            '### Color Shade',
+            '### Background Color Shade',
+        ],
+        props: ['color', 'backgroundColor', 'colorShade', 'backgroundColorShade'],
+        aliases: ['colour', 'background', 'bgcolor', 'textcolor', 'shade'],
+    },
+    typography: {
+        headings: [
+            '### Text Size',
+            '### Text Align',
+            '### Text Transform',
+            '### Text Weight',
+            '### Font Family',
+        ],
+        props: [
+            'textSize',
+            'textAlign',
+            'textTransform',
+            'textWeight',
+            'fontFamily',
+        ],
+        aliases: ['text', 'font', 'weight', 'align', 'size', 'uppercase', 'italic'],
+    },
+    flex: {
+        headings: ['### With Flexbox Helpers'],
+        props: [
+            'flexDirection',
+            'flexWrap',
+            'justifyContent',
+            'alignContent',
+            'alignItems',
+            'alignSelf',
+            'flexGrow',
+            'flexShrink',
+        ],
+        aliases: ['flexbox', 'justify', 'row', 'column'],
+    },
+    layout: {
+        headings: [
+            '### Visibility',
+            '### Overflow',
+            '### Clearfix',
+            '### Relative Position',
+        ],
+        props: [
+            'display',
+            'visibility',
+            'float',
+            'overflow',
+            'clearfix',
+            'relative',
+            'fullHeight',
+        ],
+        aliases: ['hidden', 'show', 'hide', 'block', 'inline', 'position'],
+    },
+    interaction: {
+        headings: [
+            '### Interaction',
+            '### Cursor',
+            '### Overlay',
+            '### Skeleton Examples',
+        ],
+        props: ['interaction', 'cursor', 'overlay', 'skeleton', 'radius', 'shadow'],
+        aliases: ['hover', 'click', 'loading', 'rounded'],
+    },
+    responsive: {
+        headings: [
+            '### Responsive Props',
+            '### Global Viewport Property (Legacy)',
+            '### Viewport-Specific Properties (Recommended)',
+            '### Properties That Support Viewport Modifiers',
+            '### Breakpoint Reference',
+        ],
+        props: ['responsive', 'viewport'],
+        aliases: ['mobile', 'tablet', 'desktop', 'breakpoint', 'widescreen'],
+    },
+};
+export const GROUP_NAMES = Object.keys(HELPER_GROUPS);
+/** A builder's word → a group name, or null when nothing sensible matches. */
+export function resolveGroup(input) {
+    const q = input.trim().toLowerCase();
+    if (!q)
+        return null;
+    if (HELPER_GROUPS[q])
+        return q;
+    for (const [name, g] of Object.entries(HELPER_GROUPS)) {
+        if (g.aliases.some(a => a === q))
+            return name;
+        // A prop name is the most precise thing a builder can ask for: `mt` → spacing.
+        if (g.props.some(p => p.toLowerCase() === q))
+            return name;
+    }
+    // Last resort, substring against names and aliases, so "colors" and "flexbox layout" land.
+    for (const [name, g] of Object.entries(HELPER_GROUPS)) {
+        if (name.includes(q) || q.includes(name))
+            return name;
+        if (g.aliases.some(a => q.includes(a)))
+            return name;
+    }
+    return null;
+}
+const sections = (doc) => doc.split(/\n(?=#{2,3} )/);
+const headingOf = (chunk) => chunk.split('\n')[0].trim();
+/** The `## Supported Props` table, reflowed, header rows plus the rows for `props`. */
+export function propTable(doc, props) {
+    const chunk = sections(doc).find(c => headingOf(c) === '## Supported Props');
+    if (!chunk)
+        return '';
+    const lines = reflowTables(chunk).split('\n');
+    const rows = lines.filter(l => l.trim().startsWith('|'));
+    if (rows.length < 3)
+        return '';
+    const [header, sep, ...body] = rows;
+    const wanted = props
+        ? body.filter(r => {
+            const m = r.match(/^\s*\|\s*`?([A-Za-z][A-Za-z0-9]*)`?\s*\|/);
+            return m ? props.includes(m[1]) : false;
+        })
+        : body;
+    if (!wanted.length)
+        return '';
+    return [header, sep, ...wanted].join('\n');
+}
+const GROUP_INDEX = `Narrow with \`get_helper_props({ group })\` — ` +
+    `${GROUP_NAMES.join(' · ')} — for the examples and the prose behind any row above.`;
+/**
+ * The no-argument answer: every prop and every accepted value, and nothing else.
+ *
+ * Deliberately excluded, and why each is safe to drop: `Full TypeScript Definition` (5,143)
+ * is a lossless restatement of the table above it; `Composable Mini-Hooks` (4,792) is
+ * material for writing a component, which is `bestax-custom-component`'s job; the twenty-odd
+ * live example blocks are reachable through `group`.
+ */
+export function renderHelperDefault(doc) {
+    const keep = ['## Overview', '## Import'];
+    const intro = sections(doc)
+        .filter(c => keep.includes(headingOf(c)))
+        .map(c => reflowTables(c).trim());
+    const table = propTable(doc);
+    return ['# Helper props', ...intro, '## Supported props', table, GROUP_INDEX]
+        .filter(Boolean)
+        .join('\n\n');
+}
+/** One group: its example sections, then just its rows of the prop table. */
+export function renderHelperGroup(doc, name) {
+    const group = HELPER_GROUPS[name];
+    if (!group)
+        return '';
+    const bodies = sections(doc)
+        .filter(c => group.headings.includes(headingOf(c)))
+        .map(c => reflowTables(c).trim());
+    const table = propTable(doc, group.props);
+    return [
+        `# Helper props — ${name}`,
+        table && `## Props\n\n${table}`,
+        ...bodies,
+        `Other groups: ${GROUP_NAMES.filter(g => g !== name).join(' · ')}. ` +
+            `Call \`get_helper_props\` with no argument for every prop at once.`,
+    ]
+        .filter(Boolean)
+        .join('\n\n');
+}

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export {};
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":""}

package/dist/index.js

@@ -0,0 +1,18 @@
+#!/usr/bin/env node
+/**
+ * stdio entry point.
+ *
+ * Nothing may be written to stdout except JSON-RPC frames — stdout IS the
+ * transport, and a stray console.log corrupts the stream in a way that
+ * surfaces to the user as an unexplained disconnect. Diagnostics go to stderr.
+ */
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { createServer } from './server.js';
+async function main() {
+    const server = await createServer();
+    await server.connect(new StdioServerTransport());
+}
+main().catch((err) => {
+    process.stderr.write(`bestax-mcp: ${err instanceof Error ? err.message : String(err)}\n`);
+    process.exit(1);
+});

package/dist/search.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Ranking for `search_bestax`, the entry point a model reaches for first.
+ *
+ * Deliberately a small scorer over the catalog rather than an index: the corpus
+ * is 87 components, ~1500 props and ~900 examples, all already in memory, and
+ * anything cleverer would need a build step this package does not have.
+ *
+ * What matters more than the algorithm is that every hit names the tool to call
+ * next. A search result a model cannot act on costs a round trip to rediscover
+ * what it just found.
+ */
+import type { Catalog, ComponentRecord, Skill } from './data.js';
+export type HitKind = 'component' | 'prop' | 'example' | 'css-var' | 'skill';
+export interface Hit {
+    kind: HitKind;
+    name: string;
+    detail: string;
+    /** The tool call that returns the full thing. */
+    next: string;
+    score: number;
+}
+export declare function searchAll(query: string, catalog: Catalog, components: ComponentRecord[], skills: Skill[], kinds: HitKind[]): Hit[];
+/**
+ * Near misses for a name that did not resolve.
+ *
+ * Real edit distance rather than a prefix heuristic, because the typos that
+ * actually happen are a dropped or transposed letter — and a first-letter
+ * heuristic answered "Buton" with "Badge, Block, Box", which is worse than
+ * saying nothing.
+ */
+export declare function suggest(input: string, names: string[], limit?: number): string[];
+//# sourceMappingURL=search.d.ts.map

package/dist/search.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"search.d.ts","sourceRoot":"","sources":["../src/search.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AACH,OAAO,KAAK,EAAE,OAAO,EAAE,eAAe,EAAE,KAAK,EAAE,MAAM,WAAW,CAAC;AAEjE,MAAM,MAAM,OAAO,GAAG,WAAW,GAAG,MAAM,GAAG,SAAS,GAAG,SAAS,GAAG,OAAO,CAAC;AAE7E,MAAM,WAAW,GAAG;IAClB,IAAI,EAAE,OAAO,CAAC;IACd,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,MAAM,CAAC;IACf,iDAAiD;IACjD,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,CAAC;CACf;AAyED,wBAAgB,SAAS,CACvB,KAAK,EAAE,MAAM,EACb,OAAO,EAAE,OAAO,EAChB,UAAU,EAAE,eAAe,EAAE,EAC7B,MAAM,EAAE,KAAK,EAAE,EACf,KAAK,EAAE,OAAO,EAAE,GACf,GAAG,EAAE,CAoGP;AAoBD;;;;;;;GAOG;AACH,wBAAgB,OAAO,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,EAAE,KAAK,SAAI,GAAG,MAAM,EAAE,CAY3E"}

package/dist/search.js

@@ -0,0 +1,194 @@
+const norm = (s) => s.toLowerCase();
+const escapeRe = (s) => s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+/**
+ * A prefix of a term that survives common English inflection.
+ *
+ * Exact substring matching is too brittle here, and the miss is not
+ * hypothetical: "theme" does not occur in `bestax-theming`, whose own
+ * description says "colors", "dark mode" and "tokens" but never "theme". A user
+ * asking how to theme their app got nothing. Trimming two characters catches
+ * theme/theming, color/colors, migrate/migration and icon/icons without
+ * needing a stemmer.
+ *
+ * The floor of 4 matters: shorter stems ("the") match everything.
+ */
+const stem = (t) => t.slice(0, Math.max(4, t.length - 2));
+/**
+ * Compiled word-initial matchers, memoised per stem.
+ *
+ * `termHit` runs once per term per haystack, and a search covers ~1,500 props and ~900
+ * examples — so compiling here meant thousands of identical `new RegExp` calls per query,
+ * which is where the measured 5.8 s at 3,000 terms went. The terms in one query are a tiny
+ * set; compiling each once turns that into a lookup.
+ *
+ * The cap exists because the cache outlives a request: a stdio session is long-lived, and
+ * every distinct query would otherwise pin a regex forever. Clearing wholesale rather than
+ * evicting LRU keeps this honest — the cache is an optimisation, not state anything depends
+ * on.
+ */
+const STEM_RE_CACHE = new Map();
+const STEM_RE_CACHE_MAX = 500;
+function wordInitialRe(stemmed) {
+    let re = STEM_RE_CACHE.get(stemmed);
+    if (!re) {
+        if (STEM_RE_CACHE.size >= STEM_RE_CACHE_MAX)
+            STEM_RE_CACHE.clear();
+        re = new RegExp(`\\b${escapeRe(stemmed)}`);
+        STEM_RE_CACHE.set(stemmed, re);
+    }
+    return re;
+}
+/** 2 for a substring hit, 1 for a word-initial stem hit, 0 for neither. */
+function termHit(hay, term) {
+    if (hay.includes(term))
+        return 2;
+    const s = stem(term);
+    // Word-initial, so "them" finds "theming" but not "anthem".
+    return s !== term && wordInitialRe(s).test(hay) ? 1 : 0;
+}
+/**
+ * Score a haystack against the query terms.
+ *
+ * Whole-phrase and exact-name matches dominate; term coverage breaks ties. A
+ * miss on any term is not fatal — "button icon" should still find Button —
+ * but scoring coverage means the thing matching both wins.
+ */
+function score(haystack, name, terms, query) {
+    const hay = norm(haystack);
+    const lowerName = norm(name);
+    let s = 0;
+    if (lowerName === query)
+        s += 100;
+    else if (lowerName.startsWith(query))
+        s += 60;
+    else if (lowerName.includes(query))
+        s += 40;
+    else if (termHit(lowerName, query))
+        s += 25;
+    if (hay.includes(query))
+        s += 20;
+    for (const t of terms)
+        s += termHit(hay, t) * 5;
+    return s;
+}
+export function searchAll(query, catalog, components, skills, kinds) {
+    const q = norm(query.trim());
+    const terms = q.split(/\s+/).filter(Boolean);
+    if (!terms.length)
+        return [];
+    const hits = [];
+    const want = (k) => kinds.includes(k);
+    if (want('component')) {
+        for (const c of catalog.components) {
+            const s = score(`${c.name} ${c.purpose} ${c.category}`, c.name, terms, q);
+            if (s > 0) {
+                hits.push({
+                    kind: 'component',
+                    name: c.name,
+                    detail: c.purpose,
+                    // A helper has no prop table, and `get_component` on one is itself only a
+                    // pointer at `get_helper_props` — so naming it here would make a search hit a
+                    // three-hop trip to the answer.
+                    next: c.kind === 'helper'
+                        ? 'get_helper_props()'
+                        : `get_component({ name: "${c.name}" })`,
+                    score: s,
+                });
+            }
+        }
+    }
+    for (const record of components) {
+        if (want('prop')) {
+            for (const part of record.parts) {
+                for (const p of part.props) {
+                    const s = score(`${p.name} ${p.description}`, p.name, terms, q);
+                    if (s > 20) {
+                        hits.push({
+                            kind: 'prop',
+                            name: `${part.path}.${p.name}`,
+                            detail: `${p.type}${p.description ? ` — ${p.description}` : ''}`,
+                            next: `get_props({ component: "${record.name}", path: "${part.path}" })`,
+                            score: s,
+                        });
+                    }
+                }
+            }
+        }
+        if (want('example')) {
+            for (const e of record.examples) {
+                const s = score(`${e.title} ${e.code}`, e.title, terms, q);
+                if (s > 20) {
+                    hits.push({
+                        kind: 'example',
+                        name: `${record.name}: ${e.title}`,
+                        detail: e.code.split('\n')[0].slice(0, 100),
+                        next: `get_examples({ component: "${record.name}", query: "${e.title}" })`,
+                        score: s,
+                    });
+                }
+            }
+        }
+    }
+    if (want('css-var')) {
+        for (const [cssVar, owner] of Object.entries(catalog.cssVarIndex)) {
+            const s = score(cssVar, cssVar, terms, q);
+            if (s > 0) {
+                hits.push({
+                    kind: 'css-var',
+                    name: cssVar,
+                    detail: `declared by ${owner}`,
+                    next: `get_css_variables({ component: "${owner}" })`,
+                    score: s,
+                });
+            }
+        }
+    }
+    if (want('skill')) {
+        for (const skill of skills) {
+            const s = score(`${skill.name} ${skill.description}`, skill.name, terms, q);
+            if (s > 0) {
+                hits.push({
+                    kind: 'skill',
+                    name: skill.name,
+                    detail: skill.description.slice(0, 160),
+                    next: `get_skill({ name: "${skill.name}" })`,
+                    score: s,
+                });
+            }
+        }
+    }
+    return hits.sort((a, b) => b.score - a.score || (a.name < b.name ? -1 : a.name > b.name ? 1 : 0));
+}
+/** Edit distance, capped — the names are short and the corpus is 87 entries. */
+function editDistance(a, b) {
+    if (a === b)
+        return 0;
+    let prev = Array.from({ length: b.length + 1 }, (_, i) => i);
+    for (let i = 1; i <= a.length; i++) {
+        const row = [i];
+        for (let j = 1; j <= b.length; j++) {
+            row[j] = Math.min(prev[j] + 1, row[j - 1] + 1, prev[j - 1] + (a[i - 1] === b[j - 1] ? 0 : 1));
+        }
+        prev = row;
+    }
+    return prev[b.length];
+}
+/**
+ * Near misses for a name that did not resolve.
+ *
+ * Real edit distance rather than a prefix heuristic, because the typos that
+ * actually happen are a dropped or transposed letter — and a first-letter
+ * heuristic answered "Buton" with "Badge, Block, Box", which is worse than
+ * saying nothing.
+ */
+export function suggest(input, names, limit = 3) {
+    const q = norm(input);
+    return (names
+        .map(n => ({ n, d: editDistance(q, norm(n)) }))
+        // Scale with length so short names don't swallow every query, and long
+        // ones still tolerate a typo or two.
+        .filter(x => x.d <= Math.max(1, Math.floor(x.n.length / 3)))
+        .sort((a, b) => a.d - b.d || (a.n < b.n ? -1 : 1))
+        .slice(0, limit)
+        .map(x => x.n));
+}

package/dist/server.d.ts

@@ -0,0 +1,28 @@
+/**
+ * The bestax MCP server.
+ *
+ * Nine tools, four resource templates, and one prompt per Agent Skill — all
+ * built from the generated index in `data/`, so nothing here carries a list
+ * that can drift from the library.
+ *
+ * Two things shape the surface:
+ *
+ * 1. PROGRESSIVE DISCLOSURE. `search_bestax` and `list_components` are cheap
+ *    and every result names the tool to call next; the expensive things (full
+ *    prop tables, 24 usage examples, a 23 KB skill reference) are separate
+ *    calls. A server that returns everything on the first call spends the
+ *    context the client needs for the actual task.
+ *
+ * 2. MORE THAN A PROP LOOKUP. bestax is a component library with opinions —
+ *    helper props instead of inline styles, `--bulma-*` overrides instead of
+ *    hand-written CSS, Field/Control composition instead of bare inputs. Those
+ *    live in the skills, so the skills ship as prompts and resources rather
+ *    than being left to a separate install step.
+ */
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+export interface CreateServerOptions {
+    /** Directory to resolve the consumer's installed library from. */
+    cwd?: string;
+}
+export declare function createServer(options?: CreateServerOptions): Promise<McpServer>;
+//# sourceMappingURL=server.d.ts.map

package/dist/server.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"server.d.ts","sourceRoot":"","sources":["../src/server.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,OAAO,EACL,SAAS,EAEV,MAAM,yCAAyC,CAAC;AA6FjD,MAAM,WAAW,mBAAmB;IAClC,kEAAkE;IAClE,GAAG,CAAC,EAAE,MAAM,CAAC;CACd;AAED,wBAAsB,YAAY,CAChC,OAAO,GAAE,mBAAwB,GAChC,OAAO,CAAC,SAAS,CAAC,CAurBpB"}