@mercuryo-ai/magicpay-cli 0.1.0

package/dist/fillable-form-state.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fillable-form-state.d.ts","sourceRoot":"","sources":["../src/fillable-form-state.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,0BAA0B,CAAC;AACpE,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,yCAAyC,CAAC;AAsBjF,wBAAgB,eAAe,CAC7B,OAAO,EAAE,mBAAmB,EAC5B,OAAO,EAAE,MAAM,GACd,iBAAiB,GAAG,IAAI,CAG1B;AAED,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,mBAAmB,GAAG,iBAAiB,EAAE,CAGnF"}

package/dist/fillable-form-state.js

@@ -0,0 +1,22 @@
+function normalizeFillableForm(session, form) {
+    const pageScopeEpoch = session.runtime?.pages?.[form.pageRef]?.scopeEpoch ?? 0;
+    const scopeEpoch = form.scopeEpoch ?? pageScopeEpoch;
+    const presence = form.presence === 'absent'
+        ? 'absent'
+        : form.presence === 'unknown' || scopeEpoch < pageScopeEpoch
+            ? 'unknown'
+            : 'present';
+    return {
+        ...form,
+        scopeEpoch,
+        presence,
+    };
+}
+export function getFillableForm(session, fillRef) {
+    const form = session.runtime?.fillableForms?.[fillRef];
+    return form ? normalizeFillableForm(session, form) : null;
+}
+export function listFillableForms(session) {
+    const forms = Object.values(session.runtime?.fillableForms ?? {});
+    return forms.map((form) => normalizeFillableForm(session, form));
+}

package/dist/gateway.d.ts

@@ -0,0 +1,10 @@
+import { buildMagicPayAgentMeUrl, MagicPayRequestError, type AgentBackendProfile, type MagicPayGatewayConfig } from '@mercuryo-ai/magicpay-sdk/gateway';
+export declare function tryResolveMagicPayGatewayConfig(): MagicPayGatewayConfig | null;
+export declare function resolveMagicPayGatewayConfig(): MagicPayGatewayConfig;
+export declare function buildMagicPayTelemetryTracesUrl(apiUrl: string): string;
+export { buildMagicPayAgentMeUrl, MagicPayRequestError };
+export type { AgentBackendProfile, MagicPayGatewayConfig };
+export declare function getAuthenticatedAgent(options?: {
+    fetchImpl?: typeof fetch;
+}): Promise<AgentBackendProfile>;
+//# sourceMappingURL=gateway.d.ts.map

package/dist/gateway.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"gateway.d.ts","sourceRoot":"","sources":["../src/gateway.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,uBAAuB,EACvB,oBAAoB,EACpB,KAAK,mBAAmB,EACxB,KAAK,qBAAqB,EAE3B,MAAM,mCAAmC,CAAC;AA6B3C,wBAAgB,+BAA+B,IAAI,qBAAqB,GAAG,IAAI,CAiB9E;AAED,wBAAgB,4BAA4B,IAAI,qBAAqB,CAMpE;AAED,wBAAgB,+BAA+B,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAEtE;AAED,OAAO,EAAE,uBAAuB,EAAE,oBAAoB,EAAE,CAAC;AACzD,YAAY,EAAE,mBAAmB,EAAE,qBAAqB,EAAE,CAAC;AAE3D,wBAAsB,qBAAqB,CACzC,OAAO,GAAE;IAAE,SAAS,CAAC,EAAE,OAAO,KAAK,CAAA;CAAO,GACzC,OAAO,CAAC,mBAAmB,CAAC,CAE9B"}

package/dist/gateway.js

@@ -0,0 +1,49 @@
+import { buildMagicPayAgentMeUrl, MagicPayRequestError, getAuthenticatedAgent as getAuthenticatedAgentFromSdk, } from '@mercuryo-ai/magicpay-sdk/gateway';
+import { readConfig } from './config.js';
+import { DEFAULT_MAGICPAY_API_URL } from './generated/build-config.js';
+function trimOrUndefined(value) {
+    if (!value) {
+        return undefined;
+    }
+    const trimmed = value.trim();
+    if (trimmed.length === 0 ||
+        trimmed.toLowerCase() === 'undefined' ||
+        trimmed.toLowerCase() === 'null') {
+        return undefined;
+    }
+    return trimmed;
+}
+function normalizeApiUrl(value) {
+    return value.replace(/\/$/, '');
+}
+function appendApiPath(apiUrl, suffix) {
+    return `${normalizeApiUrl(apiUrl)}${suffix.startsWith('/') ? suffix : `/${suffix}`}`;
+}
+export function tryResolveMagicPayGatewayConfig() {
+    const config = readConfig();
+    const apiKey = trimOrUndefined(process.env.MAGICPAY_API_KEY) || trimOrUndefined(config.gateway?.apiKey);
+    const apiUrl = trimOrUndefined(process.env.MAGICPAY_API_URL) ||
+        trimOrUndefined(config.gateway?.apiUrl) ||
+        DEFAULT_MAGICPAY_API_URL;
+    if (!apiKey) {
+        return null;
+    }
+    return {
+        apiKey,
+        apiUrl: normalizeApiUrl(apiUrl),
+    };
+}
+export function resolveMagicPayGatewayConfig() {
+    const gateway = tryResolveMagicPayGatewayConfig();
+    if (!gateway) {
+        throw new Error('MagicPay API key is required.');
+    }
+    return gateway;
+}
+export function buildMagicPayTelemetryTracesUrl(apiUrl) {
+    return appendApiPath(apiUrl, '/observability/telemetry/traces');
+}
+export { buildMagicPayAgentMeUrl, MagicPayRequestError };
+export async function getAuthenticatedAgent(options = {}) {
+    return getAuthenticatedAgentFromSdk(resolveMagicPayGatewayConfig(), options);
+}

package/dist/generated/build-config.d.ts

@@ -0,0 +1,2 @@
+export declare const DEFAULT_MAGICPAY_API_URL = "https://agents-api.mercuryo.io/functions/v1/api";
+//# sourceMappingURL=build-config.d.ts.map

package/dist/generated/build-config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"build-config.d.ts","sourceRoot":"","sources":["../../src/generated/build-config.ts"],"names":[],"mappings":"AACA,eAAO,MAAM,wBAAwB,oDAAoD,CAAC"}

package/dist/generated/build-config.js

@@ -0,0 +1,2 @@
+// Generated build config. Local development keeps the dev API by default.
+export const DEFAULT_MAGICPAY_API_URL = 'https://agents-api.mercuryo.io/functions/v1/api';

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+#!/usr/bin/env node
+export declare function main(argv?: string[]): Promise<void>;
+export declare function isDirectExecution(metaUrl: string, argv?: string[]): boolean;
+//# 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":";AA0VA,wBAAsB,IAAI,CAAC,IAAI,GAAE,MAAM,EAAiB,GAAG,OAAO,CAAC,IAAI,CAAC,CA4HvE;AAED,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,GAAE,MAAM,EAAiB,GAAG,OAAO,CAWzF"}

package/dist/index.js

@@ -0,0 +1,398 @@
+#!/usr/bin/env node
+import { config as loadEnv } from 'dotenv';
+import { realpathSync } from 'node:fs';
+import { fileURLToPath } from 'node:url';
+import { attach } from './commands/attach.js';
+import { endSession } from './commands/end-session.js';
+import { fillSecret } from './commands/fill-secret.js';
+import { findForm } from './commands/find-form.js';
+import { getSecretsCatalog } from './commands/get-secrets-catalog.js';
+import { init } from './commands/init.js';
+import { mockApproveSecret } from './commands/mock-approve-secret.js';
+import { mockDenySecret } from './commands/mock-deny-secret.js';
+import { pollSecret } from './commands/poll-secret.js';
+import { requestSecret } from './commands/request-secret.js';
+import { startSession } from './commands/start-session.js';
+import { status } from './commands/status.js';
+import { submitForm } from './commands/submit-form.js';
+import { info, outputError, outputJSON, fatal } from './output.js';
+import { readCurrentPackageVersion } from './package-version.js';
+import { loadMagicPayBrowserSession, loadMagicPaySession, } from './workflow-state.js';
+loadEnv();
+const KNOWN_COMMANDS = new Set([
+    'init',
+    'status',
+    'attach',
+    'start-session',
+    'end-session',
+    'find-form',
+    'get-secrets-catalog',
+    'request-secret',
+    'mock-approve-secret',
+    'mock-deny-secret',
+    'poll-secret',
+    'fill-secret',
+    'submit-form',
+]);
+function usageText() {
+    return `Usage: magicpay <command> [args] [options]
+
+Commands:
+  init <apiKey> [--api-url <url>] Configure MagicPay gateway access for the payment CLI
+  status                          Check gateway health and authenticated agent identity
+  attach <cdp-url> [options]      Attach the payment CLI to an already prepared browser over CDP
+  start-session [name] [--merchant-name <name>]
+                                  Start workflow session on the attached browser
+  end-session                     Complete the active workflow session without closing the browser
+  find-form [--purpose <kind>]    Find the supported protected form on the current page
+  get-secrets-catalog [url]       Refresh stored-secret metadata for a URL or current page
+  request-secret <fillRef> <storedSecretRef> --merchant-name <name>
+                                  Create or reuse a session-bound secret request for one fill target
+  mock-approve-secret <requestId> Approve a pending mock secret request locally (mock-only)
+  mock-deny-secret <requestId>    Deny a pending mock secret request locally (mock-only)
+  poll-secret <requestId>         Poll one secret request state without blocking
+  fill-secret <fillRef> <requestId>
+                                  Claim an approved secret request, fill protected fields, and auto-submit when a live submit control is available
+  submit-form <fillRef>           Submit the selected protected form without exposing generic act
+
+Options:
+  --api-url <url>                 Override persisted MagicPay API base URL for init
+  --provider <name>               Optional provider label for attach (for example "browserbase")
+  --purpose <kind>                Protected form purpose: auto, login, identity, payment_card
+  --help                          Show this help message
+  --version                       Show installed CLI version
+
+Environment:
+  MAGICPAY_API_KEY                Optional runtime override; use init for persisted config
+  MAGICPAY_API_URL                Optional API base URL override
+  MAGICPAY_ENABLE_MOCK_SECRETS    Enable local mock secret storage for dev/regression flows
+  MAGICPAY_MOCK_SECRET_STORE_PATH Optional override for mock stored-secret catalog path`;
+}
+function ensureMagicpayCommandName() {
+    process.env.MAGICPAY_COMMAND = process.env.MAGICPAY_COMMAND?.trim() || 'magicpay';
+}
+function getCommand(argv = process.argv) {
+    const rawArgs = argv.slice(2);
+    if (rawArgs.length === 0 || rawArgs[0] === '--help') {
+        info(usageText());
+    }
+    if (rawArgs[0] === '--version') {
+        info(readCurrentPackageVersion());
+    }
+    const command = rawArgs[0];
+    return {
+        command,
+        args: rawArgs.slice(1),
+    };
+}
+function getFlag(args, flag) {
+    const idx = args.indexOf(flag);
+    if (idx === -1 || idx + 1 >= args.length) {
+        return undefined;
+    }
+    return args[idx + 1];
+}
+function getPositional(args, valueFlags = []) {
+    const valueFlagSet = new Set(valueFlags);
+    for (let i = 0; i < args.length; i += 1) {
+        const arg = args[i];
+        if (arg.startsWith('--')) {
+            if (valueFlagSet.has(arg)) {
+                i += 1;
+            }
+            continue;
+        }
+        return arg;
+    }
+    return undefined;
+}
+function getPositionals(args, valueFlags = []) {
+    const valueFlagSet = new Set(valueFlags);
+    const values = [];
+    for (let i = 0; i < args.length; i += 1) {
+        const arg = args[i];
+        if (arg.startsWith('--')) {
+            if (valueFlagSet.has(arg)) {
+                i += 1;
+            }
+            continue;
+        }
+        values.push(arg);
+    }
+    return values;
+}
+function parseInitArgs(args) {
+    const apiKey = getPositional(args, ['--api-url']);
+    if (!apiKey) {
+        outputError('Usage: magicpay init <apiKey> [--api-url <url>]');
+    }
+    const apiUrl = getFlag(args, '--api-url');
+    const allowedFlags = new Set(['--api-url']);
+    for (let i = 0; i < args.length; i += 1) {
+        const arg = args[i];
+        if (!arg.startsWith('--')) {
+            continue;
+        }
+        if (!allowedFlags.has(arg)) {
+            outputError(`Unknown init option: ${arg}`);
+        }
+        i += 1;
+    }
+    return {
+        apiKey: apiKey,
+        apiUrl,
+    };
+}
+function parseStartSessionArgs(args) {
+    const nameParts = [];
+    let merchantName;
+    for (let i = 0; i < args.length; i += 1) {
+        const arg = args[i];
+        if (arg === '--merchant-name') {
+            const value = args[i + 1];
+            if (!value || value.startsWith('--')) {
+                outputError('Usage: magicpay start-session [name] [--merchant-name <name>]');
+            }
+            merchantName = value;
+            i += 1;
+            continue;
+        }
+        if (arg.startsWith('--')) {
+            outputError('Usage: magicpay start-session [name] [--merchant-name <name>]');
+        }
+        nameParts.push(arg);
+    }
+    return {
+        name: nameParts.join(' ').trim() || undefined,
+        merchantName,
+    };
+}
+function parseRequestSecretArgs(args) {
+    const positionals = getPositionals(args, ['--merchant-name']);
+    const [fillRef, storedSecretRef] = positionals;
+    const merchantName = getFlag(args, '--merchant-name');
+    if (!fillRef || !storedSecretRef || !merchantName) {
+        outputError('Usage: magicpay request-secret <fillRef> <storedSecretRef> --merchant-name <name>');
+    }
+    return {
+        fillRef: fillRef,
+        storedSecretRef: storedSecretRef,
+        merchantName: merchantName,
+    };
+}
+function parseAttachArgs(args) {
+    let cdpUrl;
+    let provider;
+    for (let i = 0; i < args.length; i += 1) {
+        const arg = args[i];
+        if (arg === '--provider') {
+            const value = args[i + 1];
+            if (!value || value.startsWith('--')) {
+                outputError('Usage: magicpay attach <cdp-url> [--provider <name>]');
+            }
+            provider = value;
+            i += 1;
+            continue;
+        }
+        if (arg.startsWith('--')) {
+            outputError(`Unknown attach option: ${arg}`);
+        }
+        if (cdpUrl) {
+            outputError('Usage: magicpay attach <cdp-url> [--provider <name>]');
+        }
+        cdpUrl = arg;
+    }
+    if (!cdpUrl) {
+        outputError('Usage: magicpay attach <cdp-url> [--provider <name>]');
+    }
+    return {
+        cdpUrl: cdpUrl,
+        ...(provider ? { provider } : {}),
+    };
+}
+function parseFindFormArgs(args) {
+    const allowedPurposes = new Set(['auto', 'login', 'identity', 'payment_card']);
+    let purpose = 'auto';
+    for (let i = 0; i < args.length; i += 1) {
+        const arg = args[i];
+        if (arg === '--purpose') {
+            const value = args[i + 1];
+            if (!value || value.startsWith('--')) {
+                outputError('Usage: magicpay find-form [--purpose <auto|login|identity|payment_card>]');
+            }
+            if (!allowedPurposes.has(value)) {
+                outputError('Usage: magicpay find-form [--purpose <auto|login|identity|payment_card>]');
+            }
+            purpose = value;
+            i += 1;
+            continue;
+        }
+        if (arg.startsWith('--')) {
+            outputError(`Unknown find-form option: ${arg}`);
+        }
+        outputError('Usage: magicpay find-form [--purpose <auto|login|identity|payment_card>]');
+    }
+    return { purpose };
+}
+function requireLaunchedBrowserSessionRecord(command) {
+    const session = loadMagicPaySession() ?? loadMagicPayBrowserSession();
+    if (session) {
+        return session;
+    }
+    return outputJSON({
+        success: false,
+        error: 'browser_session_required',
+        outcomeType: 'blocked',
+        message: `The \`${command}\` command requires an active browser session.`,
+        reason: 'No persisted browser session was found. Run `magicpay attach <cdp-url>` first.',
+    });
+}
+function requireWorkflowSessionRecord(command) {
+    const session = loadMagicPaySession();
+    if (!session) {
+        return outputJSON({
+            success: false,
+            error: 'browser_session_required',
+            outcomeType: 'blocked',
+            message: `The \`${command}\` command requires an active browser session.`,
+            reason: 'No persisted browser session was found. Run `magicpay attach <cdp-url>` first.',
+        });
+    }
+    if (session.intentSessionId && session.activeRunId) {
+        return session;
+    }
+    if (!session.intentSessionId) {
+        return outputJSON({
+            success: false,
+            error: 'workflow_session_required',
+            outcomeType: 'blocked',
+            message: `The \`${command}\` command requires an active workflow session.`,
+            reason: 'A browser session is loaded, but no workflow session is active for it. Run `magicpay start-session` first.',
+        });
+    }
+    return outputJSON({
+        success: false,
+        error: 'workflow_session_required',
+        outcomeType: 'blocked',
+        message: `The \`${command}\` command requires an active workflow session.`,
+        reason: 'The current workflow session is missing its local run binding. Run `magicpay start-session` again to re-bind the current browser session.',
+    });
+}
+export async function main(argv = process.argv) {
+    ensureMagicpayCommandName();
+    const parsed = getCommand(argv);
+    if (!parsed) {
+        process.exit(1);
+    }
+    const { command, args } = parsed;
+    if (!KNOWN_COMMANDS.has(command)) {
+        outputError(`Unknown command: ${command}\n\n${usageText()}`);
+    }
+    switch (command) {
+        case 'init': {
+            const initArgs = parseInitArgs(args);
+            outputJSON(init(initArgs.apiKey, initArgs.apiUrl));
+            return;
+        }
+        case 'status': {
+            outputJSON(await status());
+            return;
+        }
+        case 'attach': {
+            const attachArgs = parseAttachArgs(args);
+            outputJSON(await attach(attachArgs.cdpUrl, {
+                ...(attachArgs.provider ? { provider: attachArgs.provider } : {}),
+            }));
+            return;
+        }
+        case 'start-session': {
+            const startSessionArgs = parseStartSessionArgs(args);
+            outputJSON(await startSession(startSessionArgs.name, {
+                merchantName: startSessionArgs.merchantName,
+            }));
+            return;
+        }
+        case 'end-session': {
+            outputJSON(await endSession(requireWorkflowSessionRecord(command)));
+            return;
+        }
+        case 'find-form': {
+            const findFormArgs = parseFindFormArgs(args);
+            outputJSON(await findForm(requireLaunchedBrowserSessionRecord(command), {
+                purpose: findFormArgs.purpose,
+            }));
+            return;
+        }
+        case 'get-secrets-catalog': {
+            outputJSON(await getSecretsCatalog(requireWorkflowSessionRecord(command), getPositional(args)));
+            return;
+        }
+        case 'request-secret': {
+            const requestSecretArgs = parseRequestSecretArgs(args);
+            outputJSON(await requestSecret(requireWorkflowSessionRecord(command), requestSecretArgs.fillRef, requestSecretArgs.storedSecretRef, requestSecretArgs.merchantName));
+            return;
+        }
+        case 'mock-approve-secret': {
+            const requestId = getPositional(args);
+            if (!requestId) {
+                outputError('Usage: magicpay mock-approve-secret <requestId>');
+            }
+            outputJSON(await mockApproveSecret(requestId));
+            return;
+        }
+        case 'mock-deny-secret': {
+            const requestId = getPositional(args);
+            if (!requestId) {
+                outputError('Usage: magicpay mock-deny-secret <requestId>');
+            }
+            outputJSON(await mockDenySecret(requestId));
+            return;
+        }
+        case 'poll-secret': {
+            const requestId = getPositional(args);
+            if (!requestId) {
+                outputError('Usage: magicpay poll-secret <requestId>');
+            }
+            outputJSON(await pollSecret(requireWorkflowSessionRecord(command), requestId));
+            return;
+        }
+        case 'fill-secret': {
+            const positionals = getPositionals(args);
+            const [fillRef, requestId] = positionals;
+            if (!fillRef || !requestId) {
+                outputError('Usage: magicpay fill-secret <fillRef> <requestId>');
+            }
+            outputJSON(await fillSecret(requireWorkflowSessionRecord(command), fillRef, requestId));
+            return;
+        }
+        case 'submit-form': {
+            const fillRef = getPositional(args);
+            if (!fillRef) {
+                outputError('Usage: magicpay submit-form <fillRef>');
+            }
+            outputJSON(await submitForm(requireLaunchedBrowserSessionRecord(command), fillRef));
+            return;
+        }
+    }
+}
+export function isDirectExecution(metaUrl, argv = process.argv) {
+    const entry = argv[1];
+    if (!entry) {
+        return false;
+    }
+    try {
+        return realpathSync(entry) === realpathSync(fileURLToPath(metaUrl));
+    }
+    catch {
+        return false;
+    }
+}
+if (isDirectExecution(import.meta.url)) {
+    main()
+        .then(() => {
+        process.exit(0);
+    })
+        .catch((err) => {
+        fatal(err instanceof Error ? err.message : String(err));
+    });
+}

package/dist/mock-secret-cabinet.d.ts

@@ -0,0 +1,37 @@
+import type { ClaimSecretRequestResult, CreateSecretRequestInput, CreateSecretRequestResult, SecretRequestHintField, SecretRequestPollOutcome, SecretRequestSnapshot } from '@mercuryo-ai/magicpay-sdk';
+type MockClaimRecord = {
+    claimId: string;
+    issuedAt: string;
+};
+export interface MockSecretRequestRecord extends SecretRequestSnapshot {
+    sessionId: string;
+    purpose: string;
+    fields: SecretRequestHintField[];
+    claims: MockClaimRecord[];
+    approvedAt?: string;
+}
+type MockSecretRequestStore = {
+    version: 2;
+    nextRequest: number;
+    requests: Record<string, MockSecretRequestRecord>;
+};
+type LifecycleOptions = {
+    now?: string;
+};
+declare function readMockStore(): MockSecretRequestStore;
+declare function defaultExpiry(createdAt: string): string;
+export declare function setMockSecretRequestStorePathForTests(storePath?: string): void;
+export declare function createOrReuseMockSecretRequest(input: CreateSecretRequestInput, options?: LifecycleOptions): CreateSecretRequestResult;
+export declare function pollMockSecretRequest(sessionId: string, requestId: string, options?: LifecycleOptions): SecretRequestPollOutcome;
+export declare function approveMockSecretRequest(requestId: string, options?: LifecycleOptions): MockSecretRequestRecord;
+export declare function denyMockSecretRequest(requestId: string, options?: LifecycleOptions): MockSecretRequestRecord;
+export declare function claimMockSecretRequest(sessionId: string, requestId: string, claimId: string, options: LifecycleOptions & {
+    resolveValues: (storedSecretRef: string) => Record<string, string> | null;
+}): ClaimSecretRequestResult;
+export declare function resetMockSecretRequestStore(): void;
+export declare const __testMockSecretCabinet: {
+    defaultExpiry: typeof defaultExpiry;
+    readMockStore: typeof readMockStore;
+};
+export {};
+//# sourceMappingURL=mock-secret-cabinet.d.ts.map

package/dist/mock-secret-cabinet.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mock-secret-cabinet.d.ts","sourceRoot":"","sources":["../src/mock-secret-cabinet.ts"],"names":[],"mappings":"AAUA,OAAO,KAAK,EACV,wBAAwB,EACxB,wBAAwB,EACxB,yBAAyB,EACzB,sBAAsB,EACtB,wBAAwB,EAExB,qBAAqB,EAItB,MAAM,2BAA2B,CAAC;AAMnC,KAAK,eAAe,GAAG;IACrB,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,EAAE,MAAM,CAAC;CAClB,CAAC;AAEF,MAAM,WAAW,uBAAwB,SAAQ,qBAAqB;IACpE,SAAS,EAAE,MAAM,CAAC;IAClB,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,sBAAsB,EAAE,CAAC;IACjC,MAAM,EAAE,eAAe,EAAE,CAAC;IAC1B,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAED,KAAK,sBAAsB,GAAG;IAC5B,OAAO,EAAE,CAAC,CAAC;IACX,WAAW,EAAE,MAAM,CAAC;IACpB,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,uBAAuB,CAAC,CAAC;CACnD,CAAC;AAEF,KAAK,gBAAgB,GAAG;IACtB,GAAG,CAAC,EAAE,MAAM,CAAC;CACd,CAAC;AAyBF,iBAAS,aAAa,IAAI,sBAAsB,CAwB/C;AAWD,iBAAS,aAAa,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,CAEhD;AA8ID,wBAAgB,qCAAqC,CAAC,SAAS,CAAC,EAAE,MAAM,GAAG,IAAI,CAE9E;AAED,wBAAgB,8BAA8B,CAC5C,KAAK,EAAE,wBAAwB,EAC/B,OAAO,GAAE,gBAAqB,GAC7B,yBAAyB,CA8D3B;AAED,wBAAgB,qBAAqB,CACnC,SAAS,EAAE,MAAM,EACjB,SAAS,EAAE,MAAM,EACjB,OAAO,GAAE,gBAAqB,GAC7B,wBAAwB,CAsB1B;AAqCD,wBAAgB,wBAAwB,CACtC,SAAS,EAAE,MAAM,EACjB,OAAO,GAAE,gBAAqB,GAC7B,uBAAuB,CAEzB;AAED,wBAAgB,qBAAqB,CACnC,SAAS,EAAE,MAAM,EACjB,OAAO,GAAE,gBAAqB,GAC7B,uBAAuB,CAEzB;AAED,wBAAgB,sBAAsB,CACpC,SAAS,EAAE,MAAM,EACjB,SAAS,EAAE,MAAM,EACjB,OAAO,EAAE,MAAM,EACf,OAAO,EAAE,gBAAgB,GAAG;IAC1B,aAAa,EAAE,CAAC,eAAe,EAAE,MAAM,KAAK,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,IAAI,CAAC;CAC3E,GACA,wBAAwB,CAiD1B;AAED,wBAAgB,2BAA2B,IAAI,IAAI,CAKlD;AAED,eAAO,MAAM,uBAAuB;;;CAGnC,CAAC"}