@skhema/cli 0.3.1

package/dist/commands/contribute.js

@@ -0,0 +1,318 @@
+import fs from 'node:fs';
+import ora from 'ora';
+import { isApprovedContributor } from '../lib/auth/entitlements.js';
+import { getStoredCredentials } from '../lib/auth/token-store.js';
+import { resolveComponentAuthor, resolveElementAuthor, } from '../lib/contribute/author-resolver.js';
+import { generateComponentEmbed, generateEmbed, } from '../lib/contribute/embed-generator.js';
+import { generateSaveComponentLink, generateSaveElementLink, publishAndGenerateComponentShareLink, publishAndGenerateElementShareLink, } from '../lib/contribute/link-generator.js';
+import { getGlobalOptions, log, outputError, outputSuccess, } from '../lib/output.js';
+function parseElementArgs(elementArgs) {
+    return elementArgs.map((arg) => {
+        const colonIndex = arg.indexOf(':');
+        if (colonIndex === -1) {
+            throw new Error(`Invalid element format "${arg}". Expected "element_type:content text"`);
+        }
+        return {
+            elementType: arg.substring(0, colonIndex),
+            content: arg.substring(colonIndex + 1),
+        };
+    });
+}
+function loadElementsFromFile(filePath) {
+    const raw = fs.readFileSync(filePath, 'utf-8');
+    const parsed = JSON.parse(raw);
+    if (!Array.isArray(parsed)) {
+        throw new Error('--from-file must contain a JSON array');
+    }
+    for (const item of parsed) {
+        if (typeof item.elementType !== 'string' ||
+            typeof item.content !== 'string') {
+            throw new Error('Each element in --from-file must have "elementType" and "content" string fields');
+        }
+    }
+    return parsed;
+}
+async function requireContributor() {
+    const approved = await isApprovedContributor();
+    if (!approved) {
+        const credentials = await getStoredCredentials();
+        if (!credentials?.access_token) {
+            outputError('Authentication required. Run "skhema auth login" first.', 'contribute');
+        }
+        else {
+            outputError('Contributor access required. Apply at https://skhema.com/contribute', 'contribute');
+        }
+        process.exit(1);
+    }
+}
+export function registerContributeCommands(program) {
+    const contribute = program
+        .command('contribute')
+        .description('Contributor tools — requires approved contributor status')
+        .hook('preAction', requireContributor);
+    const generate = contribute
+        .command('generate')
+        .description('Generate embed snippets and shareable links');
+    generate
+        .command('embed')
+        .description('Generate an HTML embed snippet for an element or component')
+        .option('--element-type <type>', 'Element type (e.g. key_challenge)')
+        .option('--content <text>', 'Element content text')
+        .option('--component-type <type>', 'Component type (e.g. diagnosis)')
+        .option('--element <elements...>', 'Elements as type:content')
+        .option('--from-file <path>', 'Path to JSON file with elements array')
+        .option('--title <title>', 'Component title')
+        .option('--contributor-id <id>', 'Your contributor ID')
+        .option('--element-id <id>', 'Published sysauth element ID — resolves author from sysauthElementAuthor')
+        .option('--component-id <id>', 'Published sysauth component ID — resolves component-level author from view')
+        .option('--theme <theme>', 'Theme: light, dark, or auto', 'auto')
+        .option('--no-track-analytics', 'Disable analytics tracking')
+        .option('--source-url <url>', 'Source URL for attribution')
+        .action(async (options) => {
+        try {
+            if (options.elementType && options.componentType) {
+                outputError('--element-type and --component-type are mutually exclusive. Use one or the other.', 'contribute generate embed');
+                process.exit(1);
+            }
+            if (!options.contributorId) {
+                outputError('--contributor-id is required', 'contribute generate embed');
+                process.exit(1);
+            }
+            let authorName;
+            let authorSlug;
+            const credentials = await getStoredCredentials();
+            if (credentials?.access_token) {
+                if (options.elementId) {
+                    const resolved = await resolveElementAuthor(options.elementId, credentials.access_token);
+                    if (resolved) {
+                        authorName = resolved.authorName;
+                        authorSlug = resolved.authorSlug;
+                    }
+                }
+                else if (options.componentId) {
+                    const resolved = await resolveComponentAuthor(options.componentId, credentials.access_token);
+                    if (resolved) {
+                        authorName = resolved.authorName;
+                        authorSlug = resolved.authorSlug;
+                    }
+                }
+            }
+            if (options.componentType) {
+                // Component mode
+                let elements;
+                if (options.fromFile) {
+                    elements = loadElementsFromFile(options.fromFile);
+                }
+                else if (options.element) {
+                    elements = parseElementArgs(options.element);
+                }
+                else {
+                    outputError('Component mode requires --element or --from-file', 'contribute generate embed');
+                    process.exit(1);
+                }
+                const result = generateComponentEmbed({
+                    componentType: options.componentType,
+                    contributorId: options.contributorId,
+                    authorName,
+                    authorSlug,
+                    elements,
+                    title: options.title,
+                    theme: options.theme,
+                    trackAnalytics: options.trackAnalytics,
+                    sourceUrl: options.sourceUrl,
+                });
+                if (getGlobalOptions().json) {
+                    outputSuccess(result, 'contribute generate embed');
+                }
+                else {
+                    log(result.snippet);
+                }
+            }
+            else {
+                // Element mode
+                if (!options.elementType) {
+                    outputError('--element-type is required for element mode', 'contribute generate embed');
+                    process.exit(1);
+                }
+                if (!options.content) {
+                    outputError('--content is required for element mode', 'contribute generate embed');
+                    process.exit(1);
+                }
+                const result = generateEmbed({
+                    elementType: options.elementType,
+                    contributorId: options.contributorId,
+                    authorName,
+                    authorSlug,
+                    content: options.content,
+                    theme: options.theme,
+                    trackAnalytics: options.trackAnalytics,
+                    sourceUrl: options.sourceUrl,
+                });
+                if (getGlobalOptions().json) {
+                    outputSuccess(result, 'contribute generate embed');
+                }
+                else {
+                    log(result.snippet);
+                }
+            }
+        }
+        catch (error) {
+            outputError(error instanceof Error ? error.message : 'Failed to generate embed', 'contribute generate embed');
+            process.exit(1);
+        }
+    });
+    generate
+        .command('link')
+        .description('Generate a shareable link for an element or component')
+        .option('--element-type <type>', 'Element type (e.g. key_challenge)')
+        .option('--content <text>', 'Element content text')
+        .option('--component-type <type>', 'Component type (e.g. diagnosis)')
+        .option('--element <elements...>', 'Elements as type:content')
+        .option('--from-file <path>', 'Path to JSON file with elements array')
+        .option('--title <title>', 'Component title')
+        .option('--contributor-id <id>', 'Your contributor ID')
+        .option('--source-url <url>', 'Source URL for attribution')
+        .option('--utm-source <source>', 'UTM source parameter')
+        .option('--utm-medium <medium>', 'UTM medium parameter')
+        .option('--utm-campaign <campaign>', 'UTM campaign parameter')
+        .option('--save-only', 'Only generate the save link (skip share link, works offline)')
+        .action(async (options) => {
+        try {
+            if (options.elementType && options.componentType) {
+                outputError('--element-type and --component-type are mutually exclusive. Use one or the other.', 'contribute generate link');
+                process.exit(1);
+            }
+            if (!options.contributorId) {
+                outputError('--contributor-id is required', 'contribute generate link');
+                process.exit(1);
+            }
+            if (options.componentType) {
+                // Component mode
+                let elements;
+                if (options.fromFile) {
+                    elements = loadElementsFromFile(options.fromFile);
+                }
+                else if (options.element) {
+                    elements = parseElementArgs(options.element);
+                }
+                else {
+                    outputError('Component mode requires --element or --from-file', 'contribute generate link');
+                    process.exit(1);
+                }
+                const saveResult = generateSaveComponentLink({
+                    componentType: options.componentType,
+                    contributorId: options.contributorId,
+                    elements,
+                    title: options.title,
+                    sourceUrl: options.sourceUrl,
+                    utmSource: options.utmSource,
+                    utmMedium: options.utmMedium,
+                    utmCampaign: options.utmCampaign,
+                });
+                let shareResult = null;
+                if (!options.saveOnly) {
+                    const credentials = await getStoredCredentials();
+                    if (!credentials?.access_token) {
+                        outputError('Authentication required for share link. Run "sk auth login" first, or use --save-only.', 'contribute generate link');
+                        process.exit(1);
+                    }
+                    const spinner = ora('Publishing component for share link...').start();
+                    try {
+                        shareResult = await publishAndGenerateComponentShareLink({
+                            contributorId: options.contributorId,
+                            componentType: options.componentType,
+                            title: options.title,
+                            elements,
+                            accessToken: credentials.access_token,
+                        });
+                        spinner.succeed('Published');
+                    }
+                    catch (err) {
+                        spinner.fail('Failed to publish');
+                        outputError(err instanceof Error
+                            ? err.message
+                            : 'Failed to generate share link', 'contribute generate link');
+                        process.exit(1);
+                    }
+                }
+                if (getGlobalOptions().json) {
+                    outputSuccess({
+                        saveLink: saveResult.url,
+                        shareLink: shareResult?.shareUrl || null,
+                        componentHash: saveResult.componentHash,
+                        componentId: shareResult?.componentId || null,
+                    }, 'contribute generate link');
+                }
+                else {
+                    log(`Save link:  ${saveResult.url}`);
+                    if (shareResult) {
+                        log(`Share link: ${shareResult.shareUrl}`);
+                    }
+                }
+            }
+            else {
+                // Element mode
+                if (!options.elementType) {
+                    outputError('--element-type is required for element mode', 'contribute generate link');
+                    process.exit(1);
+                }
+                if (!options.content) {
+                    outputError('--content is required for element mode', 'contribute generate link');
+                    process.exit(1);
+                }
+                const saveResult = generateSaveElementLink({
+                    elementType: options.elementType,
+                    contributorId: options.contributorId,
+                    content: options.content,
+                    sourceUrl: options.sourceUrl,
+                    utmSource: options.utmSource,
+                    utmMedium: options.utmMedium,
+                    utmCampaign: options.utmCampaign,
+                });
+                let shareResult = null;
+                if (!options.saveOnly) {
+                    const credentials = await getStoredCredentials();
+                    if (!credentials?.access_token) {
+                        outputError('Authentication required for share link. Run "sk auth login" first, or use --save-only.', 'contribute generate link');
+                        process.exit(1);
+                    }
+                    const spinner = ora('Publishing element for share link...').start();
+                    try {
+                        shareResult = await publishAndGenerateElementShareLink({
+                            contributorId: options.contributorId,
+                            elementType: options.elementType,
+                            content: options.content,
+                            accessToken: credentials.access_token,
+                        });
+                        spinner.succeed('Published');
+                    }
+                    catch (err) {
+                        spinner.fail('Failed to publish');
+                        outputError(err instanceof Error
+                            ? err.message
+                            : 'Failed to generate share link', 'contribute generate link');
+                        process.exit(1);
+                    }
+                }
+                if (getGlobalOptions().json) {
+                    outputSuccess({
+                        saveLink: saveResult.url,
+                        shareLink: shareResult?.shareUrl || null,
+                        contentHash: saveResult.contentHash,
+                        elementId: shareResult?.elementId || null,
+                    }, 'contribute generate link');
+                }
+                else {
+                    log(`Save link:  ${saveResult.url}`);
+                    if (shareResult) {
+                        log(`Share link: ${shareResult.shareUrl}`);
+                    }
+                }
+            }
+        }
+        catch (error) {
+            outputError(error instanceof Error ? error.message : 'Failed to generate link', 'contribute generate link');
+            process.exit(1);
+        }
+    });
+}

package/dist/commands/element.d.ts

@@ -0,0 +1,7 @@
+import { Command } from 'commander';
+/**
+ * Element commands — the strategic building blocks in a workspace. All are
+ * workspace-scoped via `--workspace` (falling back to the default workspace).
+ */
+export declare function registerElementCommands(program: Command): void;
+//# sourceMappingURL=element.d.ts.map

package/dist/commands/element.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"element.d.ts","sourceRoot":"","sources":["../../src/commands/element.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAA;AAkBnC;;;GAGG;AACH,wBAAgB,uBAAuB,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI,CA+P9D"}

package/dist/commands/element.js

@@ -0,0 +1,167 @@
+import chalk from 'chalk';
+import { resolveClient } from '../lib/api/client.js';
+import { asRecord, buildBody, coerceList, readPayloadFile, resolveWorkspaceId, } from '../lib/api/command-helpers.js';
+import { runCommand, UsageError } from '../lib/api/run-command.js';
+import { getGlobalOptions, log, logHeader, logTable } from '../lib/output.js';
+/** Truncate free-text element content for table display. */
+function summarize(content) {
+    const text = typeof content === 'string' ? content : '';
+    return text.length > 48 ? `${text.slice(0, 47)}…` : text || '—';
+}
+/**
+ * Element commands — the strategic building blocks in a workspace. All are
+ * workspace-scoped via `--workspace` (falling back to the default workspace).
+ */
+export function registerElementCommands(program) {
+    const element = program.command('element').description('Element commands');
+    const withWorkspace = (cmd) => cmd.option('--workspace <id>', 'Workspace id (defaults to `skhema workspace use`)');
+    withWorkspace(element.command('list').description('List elements')).action(async (options) => {
+        await runCommand('element list', async () => {
+            const workspaceId = resolveWorkspaceId(options.workspace);
+            const { client } = await resolveClient();
+            const data = await client.elements.list(workspaceId);
+            const rows = coerceList(data, 'elements');
+            if (!getGlobalOptions().json) {
+                logHeader(`Elements (${rows.length})`);
+                if (rows.length === 0)
+                    log(chalk.dim('  No elements.'));
+                else
+                    logTable(['Id', 'Component', 'Type', 'Content'], rows.map((r) => {
+                        const e = asRecord(r);
+                        return [
+                            String(e.id ?? '—'),
+                            String(e.componentType ?? '—'),
+                            String(e.elementType ?? '—'),
+                            summarize(e.content),
+                        ];
+                    }));
+            }
+            return data;
+        });
+    });
+    // No `GET /v1/.../elements/:id` route exists on the gateway, so `element get`
+    // fetches the workspace's element list and filters it client-side by id.
+    withWorkspace(element.command('get <element-id>').description('Get an element by id')).action(async (elementId, options) => {
+        await runCommand('element get', async () => {
+            const workspaceId = resolveWorkspaceId(options.workspace);
+            const { client } = await resolveClient();
+            const data = await client.elements.list(workspaceId);
+            const match = coerceList(data, 'elements').find((r) => asRecord(r).id === elementId);
+            if (!match) {
+                throw new Error(`Element "${elementId}" not found in workspace ${workspaceId}.`);
+            }
+            if (!getGlobalOptions().json) {
+                const e = asRecord(match);
+                logHeader(String(e.id));
+                log(`  Component:   ${String(e.componentType ?? '—')}`);
+                log(`  Type:        ${String(e.elementType ?? '—')}`);
+                log(`  Content:     ${String(e.content ?? '—')}`);
+            }
+            return match;
+        });
+    });
+    withWorkspace(element
+        .command('create')
+        .description('Create an element')
+        .option('--content <content>', 'Element content')
+        .option('--component-type <type>', 'Component type')
+        .option('--element-type <type>', 'Element type')
+        .option('--file <path>', 'JSON payload file for the full body ("-" for stdin)')).action(async (options) => {
+        await runCommand('element create', async () => {
+            const workspaceId = resolveWorkspaceId(options.workspace);
+            const body = buildBody(readPayloadFile(options.file), {
+                content: options.content,
+                componentType: options.componentType,
+                elementType: options.elementType,
+            });
+            if (Object.keys(body).length === 0) {
+                throw new UsageError('Nothing to create. Pass element fields as flags or a --file payload.');
+            }
+            const { client } = await resolveClient();
+            const data = await client.elements.create(workspaceId, body);
+            if (!getGlobalOptions().json) {
+                const e = asRecord(asRecord(data).element ?? data);
+                log(chalk.green(`Element created${e.id ? ` (${String(e.id)})` : ''}.`));
+            }
+            return data;
+        });
+    });
+    withWorkspace(element
+        .command('update <element-id>')
+        .description('Update an element')
+        .option('--content <content>', 'Element content')
+        .option('--component-type <type>', 'Component type')
+        .option('--element-type <type>', 'Element type')
+        .option('--file <path>', 'JSON payload file for the full body ("-" for stdin)')).action(async (elementId, options) => {
+        await runCommand('element update', async () => {
+            const workspaceId = resolveWorkspaceId(options.workspace);
+            const body = buildBody(readPayloadFile(options.file), {
+                content: options.content,
+                componentType: options.componentType,
+                elementType: options.elementType,
+            });
+            if (Object.keys(body).length === 0) {
+                throw new UsageError('Nothing to update. Pass element fields as flags or a --file payload.');
+            }
+            const { client } = await resolveClient();
+            const data = await client.elements.update(workspaceId, elementId, body);
+            if (!getGlobalOptions().json)
+                log(chalk.green('Element updated.'));
+            return data;
+        });
+    });
+    withWorkspace(element.command('delete <element-id>').description('Delete an element')).action(async (elementId, options) => {
+        await runCommand('element delete', async () => {
+            const workspaceId = resolveWorkspaceId(options.workspace);
+            const { client } = await resolveClient();
+            const data = await client.elements.delete(workspaceId, elementId);
+            if (!getGlobalOptions().json)
+                log(chalk.green(`Deleted element ${elementId}.`));
+            return data;
+        });
+    });
+    withWorkspace(element
+        .command('validate <element-id>')
+        .description('Run element validation (completeness/coherence)')
+        .option('--file <path>', 'JSON payload file for the request body ("-" for stdin)')).action(async (elementId, options) => {
+        await runCommand('element validate', async () => {
+            const workspaceId = resolveWorkspaceId(options.workspace);
+            const { client } = await resolveClient();
+            const data = await client.elements.validate(workspaceId, elementId, readPayloadFile(options.file) ?? {});
+            if (!getGlobalOptions().json)
+                log(chalk.green('Validation complete.'));
+            return data;
+        });
+    });
+    withWorkspace(element
+        .command('rephrase <element-id>')
+        .description('Rephrase an element')
+        .option('--file <path>', 'JSON payload file for the request body ("-" for stdin)')).action(async (elementId, options) => {
+        await runCommand('element rephrase', async () => {
+            const workspaceId = resolveWorkspaceId(options.workspace);
+            const { client } = await resolveClient();
+            const data = await client.elements.rephrase(workspaceId, elementId, readPayloadFile(options.file) ?? {});
+            if (!getGlobalOptions().json)
+                log(chalk.green('Rephrase complete.'));
+            return data;
+        });
+    });
+    // `element fork <public-element-id> --workspace <target>` forks a published
+    // public element into the target workspace (the workspace in the path is the
+    // destination).
+    withWorkspace(element
+        .command('fork <element-id>')
+        .description('Fork a published element into a workspace')
+        .option('--file <path>', 'JSON payload file for the request body ("-" for stdin)')).action(async (elementId, options) => {
+        await runCommand('element fork', async () => {
+            const workspaceId = resolveWorkspaceId(options.workspace);
+            const { client } = await resolveClient();
+            const data = await client.elements.fork(workspaceId, elementId, readPayloadFile(options.file) ?? {});
+            if (!getGlobalOptions().json) {
+                const e = asRecord(asRecord(data).element ?? data);
+                log(chalk.green(`Forked into ${workspaceId}${e.id ? ` (${String(e.id)})` : ''}.`));
+            }
+            return data;
+        });
+    });
+}

package/dist/commands/export.d.ts

@@ -0,0 +1,9 @@
+import { Command } from 'commander';
+/**
+ * `skhema workspace export` — full-portability export of a whole workspace
+ * (xlsx/csv/json). It hangs off the `workspace` command group owned by the
+ * workspace module, so this registration must run after that group exists; it
+ * finds (or, defensively, creates) the group rather than editing that file.
+ */
+export declare function registerWorkspaceExportCommand(program: Command): void;
+//# sourceMappingURL=export.d.ts.map

package/dist/commands/export.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"export.d.ts","sourceRoot":"","sources":["../../src/commands/export.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAA;AAQnC;;;;;GAKG;AACH,wBAAgB,8BAA8B,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI,CAgDrE"}

package/dist/commands/export.js

@@ -0,0 +1,42 @@
+import { resolveClient } from '../lib/api/client.js';
+import { assertExportOutput, reportExport } from '../lib/api/export-cli.js';
+import { assertFormat, WORKSPACE_FORMATS } from '../lib/api/formats.js';
+import { runCommand } from '../lib/api/run-command.js';
+import { resolveWorkspaceId } from '../lib/api/scope.js';
+import { performExport } from '../lib/api/transfer.js';
+/**
+ * `skhema workspace export` — full-portability export of a whole workspace
+ * (xlsx/csv/json). It hangs off the `workspace` command group owned by the
+ * workspace module, so this registration must run after that group exists; it
+ * finds (or, defensively, creates) the group rather than editing that file.
+ */
+export function registerWorkspaceExportCommand(program) {
+    const workspace = program.commands.find((c) => c.name() === 'workspace') ??
+        program.command('workspace').description('Workspace commands');
+    workspace
+        .command('export')
+        .description('Export a whole workspace (xlsx/csv/json full portability)')
+        .option('--workspace <id>', 'Workspace id (defaults to `skhema workspace use`)')
+        .requiredOption('--format <format>', 'xlsx | csv | json')
+        .option('--out <path>', 'Write to this path (- for stdout; default: server filename in cwd)')
+        .option('--email <recipient>', 'Email the export to an org member instead of downloading')
+        .action(async (opts) => {
+        await runCommand('workspace export', async () => {
+            const { client } = await resolveClient();
+            const ws = resolveWorkspaceId(opts.workspace);
+            const format = assertFormat(opts.format, WORKSPACE_FORMATS);
+            assertExportOutput(opts);
+            const result = await performExport({
+                out: opts.email ? undefined : opts.out,
+                exec: () => client.exports.workspace(ws, {
+                    format,
+                    ...(opts.email
+                        ? { delivery: 'email', recipientEmail: opts.email }
+                        : {}),
+                }),
+            });
+            reportExport(result);
+            return result;
+        });
+    });
+}

package/dist/commands/init.d.ts

@@ -0,0 +1,49 @@
+import { Command } from 'commander';
+export interface InitOptions {
+    apiKey?: string;
+    yes?: boolean;
+    force?: boolean;
+    skipSkills?: boolean;
+    skipMcp?: boolean;
+}
+interface CredentialState {
+    connected: boolean;
+    lane?: string;
+    source?: string;
+    verified?: boolean;
+    organizationId?: string;
+    permission?: string;
+    workspaceCount?: number;
+    stored?: boolean;
+    reason?: string;
+}
+interface SkillsState {
+    skipped?: boolean;
+    platforms?: string[];
+    installed?: number;
+    updated?: number;
+    unchanged?: number;
+}
+interface McpState {
+    serverUrl: string;
+    mutated: boolean;
+    targets: Array<{
+        id: string;
+        name: string;
+        status: string;
+        configPath?: string;
+        backupPath?: string;
+        instructions?: string;
+    }>;
+}
+export interface InitState {
+    credential: CredentialState;
+    skills: SkillsState;
+    mcp: McpState;
+    quickstart: string[];
+}
+/** Orchestrate all init steps and return the machine-readable state. */
+export declare function runInit(options: InitOptions): Promise<InitState>;
+export declare function registerInitCommand(program: Command): void;
+export {};
+//# sourceMappingURL=init.d.ts.map

package/dist/commands/init.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"init.d.ts","sourceRoot":"","sources":["../../src/commands/init.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAA;AAkBnC,MAAM,WAAW,WAAW;IAC1B,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,GAAG,CAAC,EAAE,OAAO,CAAA;IACb,KAAK,CAAC,EAAE,OAAO,CAAA;IACf,UAAU,CAAC,EAAE,OAAO,CAAA;IACpB,OAAO,CAAC,EAAE,OAAO,CAAA;CAClB;AAED,UAAU,eAAe;IACvB,SAAS,EAAE,OAAO,CAAA;IAClB,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,QAAQ,CAAC,EAAE,OAAO,CAAA;IAClB,cAAc,CAAC,EAAE,MAAM,CAAA;IACvB,UAAU,CAAC,EAAE,MAAM,CAAA;IACnB,cAAc,CAAC,EAAE,MAAM,CAAA;IACvB,MAAM,CAAC,EAAE,OAAO,CAAA;IAChB,MAAM,CAAC,EAAE,MAAM,CAAA;CAChB;AAED,UAAU,WAAW;IACnB,OAAO,CAAC,EAAE,OAAO,CAAA;IACjB,SAAS,CAAC,EAAE,MAAM,EAAE,CAAA;IACpB,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,SAAS,CAAC,EAAE,MAAM,CAAA;CACnB;AAED,UAAU,QAAQ;IAChB,SAAS,EAAE,MAAM,CAAA;IACjB,OAAO,EAAE,OAAO,CAAA;IAChB,OAAO,EAAE,KAAK,CAAC;QACb,EAAE,EAAE,MAAM,CAAA;QACV,IAAI,EAAE,MAAM,CAAA;QACZ,MAAM,EAAE,MAAM,CAAA;QACd,UAAU,CAAC,EAAE,MAAM,CAAA;QACnB,UAAU,CAAC,EAAE,MAAM,CAAA;QACnB,YAAY,CAAC,EAAE,MAAM,CAAA;KACtB,CAAC,CAAA;CACH;AAED,MAAM,WAAW,SAAS;IACxB,UAAU,EAAE,eAAe,CAAA;IAC3B,MAAM,EAAE,WAAW,CAAA;IACnB,GAAG,EAAE,QAAQ,CAAA;IACb,UAAU,EAAE,MAAM,EAAE,CAAA;CACrB;AA2LD,wEAAwE;AACxE,wBAAsB,OAAO,CAAC,OAAO,EAAE,WAAW,GAAG,OAAO,CAAC,SAAS,CAAC,CAQtE;AA0FD,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI,CAiB1D"}