egaki 0.0.1 → 0.1.0

package/dist/models.d.ts

@@ -0,0 +1,15 @@
+import type { ImageModel, LanguageModel } from 'ai';
+import type { ModelEntry } from './model-catalog.js';
+import type { VideoModelEntry } from './video-model-catalog.js';
+export type AnyModelEntry = ModelEntry | VideoModelEntry;
+export type { ModelEntry, VideoModelEntry };
+export declare const IMAGE_MODELS: [string, ...string[]];
+export declare const VIDEO_MODELS: [string, ...string[]];
+export declare const DEFAULT_MODEL = "nano-banana-pro-preview";
+export declare const DEFAULT_VIDEO_MODEL = "veo-3.1-fast-generate-001";
+export declare function getModelConfig(modelId: string): AnyModelEntry;
+export declare function ensureProviderKey(providerName: string): void;
+export declare function createImageModel(modelId: string): Promise<ImageModel>;
+export declare function createTextModel(modelId: string): Promise<LanguageModel>;
+export declare function createVideoModel(modelId: string): Promise<any>;
+//# sourceMappingURL=models.d.ts.map

package/dist/models.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"models.d.ts","sourceRoot":"","sources":["../src/models.ts"],"names":[],"mappings":"AAiBA,OAAO,KAAK,EAAE,UAAU,EAAE,aAAa,EAAE,MAAM,IAAI,CAAA;AAInD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAA;AAEpD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,0BAA0B,CAAA;AAE/D,MAAM,MAAM,aAAa,GAAG,UAAU,GAAG,eAAe,CAAA;AACxD,YAAY,EAAE,UAAU,EAAE,eAAe,EAAE,CAAA;AAE3C,eAAO,MAAM,YAAY,EAA+B,CAAC,MAAM,EAAE,GAAG,MAAM,EAAE,CAAC,CAAA;AAC7E,eAAO,MAAM,YAAY,EAAqC,CAAC,MAAM,EAAE,GAAG,MAAM,EAAE,CAAC,CAAA;AAEnF,eAAO,MAAM,aAAa,4BAA4B,CAAA;AACtD,eAAO,MAAM,mBAAmB,8BAA8B,CAAA;AAE9D,wBAAgB,cAAc,CAAC,OAAO,EAAE,MAAM,GAAG,aAAa,CAO7D;AAuBD,wBAAgB,iBAAiB,CAAC,YAAY,EAAE,MAAM,GAAG,IAAI,CAmC5D;AAgDD,wBAAsB,gBAAgB,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,UAAU,CAAC,CAkC3E;AAED,wBAAsB,eAAe,CACnC,OAAO,EAAE,MAAM,GACd,OAAO,CAAC,aAAa,CAAC,CAiCxB;AAED,wBAAsB,gBAAgB,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,GAAG,CAAC,CAqCpE"}

package/dist/models.js

@@ -0,0 +1,196 @@
+import pc from 'picocolors';
+import { PROVIDERS, EGAKI_GATEWAY_URL } from './credentials.js';
+import { CATALOG, findModel } from './model-catalog.js';
+import { VIDEO_CATALOG, findVideoModel } from './video-model-catalog.js';
+export const IMAGE_MODELS = CATALOG.map((m) => m.id);
+export const VIDEO_MODELS = VIDEO_CATALOG.map((m) => m.id);
+export const DEFAULT_MODEL = 'nano-banana-pro-preview';
+export const DEFAULT_VIDEO_MODEL = 'veo-3.1-fast-generate-001';
+export function getModelConfig(modelId) {
+    const entry = findModel(modelId) ?? findVideoModel(modelId);
+    if (!entry) {
+        console.error(pc.red(`Unknown model: ${modelId}`));
+        process.exit(1);
+    }
+    return entry;
+}
+/**
+ * Check if the egaki gateway API key is available (from env or stored credentials).
+ */
+function hasEgakiKey() {
+    const info = PROVIDERS['egaki'];
+    if (!info)
+        return false;
+    return Boolean(process.env[info.envVar]);
+}
+/**
+ * Check if a direct provider key is available for the given provider.
+ */
+function hasDirectProviderKey(providerName) {
+    const info = PROVIDERS[providerName];
+    if (!info)
+        return false;
+    return Boolean(process.env[info.envVar]);
+}
+// Check that the provider's API key is available before making API calls.
+// Prints a user-friendly error with instructions on how to configure it.
+// Prioritizes egaki subscription over individual provider keys.
+export function ensureProviderKey(providerName) {
+    // If direct provider key exists, we're good
+    if (hasDirectProviderKey(providerName))
+        return;
+    // If egaki key exists, we'll route through the gateway
+    if (hasEgakiKey())
+        return;
+    const info = PROVIDERS[providerName];
+    console.error('');
+    console.error(pc.red(pc.bold(`Missing API key for ${info?.label || providerName}`)));
+    console.error('');
+    console.error(`  ${pc.bold('Recommended:')} Use Egaki subscription (all models, one key)`);
+    console.error('');
+    console.error(`    ${pc.cyan('egaki subscribe')}                        get started in 30 seconds`);
+    console.error('');
+    console.error(`  ${pc.dim('Or configure a provider key directly:')}`);
+    console.error('');
+    console.error(`    ${pc.cyan('egaki login')}                           interactive setup`);
+    if (info) {
+        console.error(`    ${pc.cyan(`${info.envVar}=...`)} egaki image ...   inline env var`);
+        console.error(`    ${pc.cyan(`egaki login --provider ${providerName} --key <key>`)}`);
+        console.error('');
+        console.error(`  ${pc.dim(info.hint)}`);
+    }
+    console.error('');
+    process.exit(1);
+}
+/**
+ * Create a gateway-backed image model using createGateway from the AI SDK.
+ * The model ID is sent as provider/model format to the gateway.
+ */
+async function createGatewayImageModel(modelId, provider) {
+    const { createGateway } = await import('ai');
+    const gateway = createGateway({
+        apiKey: process.env['EGAKI_API_KEY'],
+        baseURL: EGAKI_GATEWAY_URL,
+    });
+    // Gateway expects provider/model format for routing
+    const gatewayModelId = `${provider}/${modelId}`;
+    return gateway.image(gatewayModelId);
+}
+/**
+ * Create a gateway-backed text model using createGateway from the AI SDK.
+ */
+async function createGatewayTextModel(modelId, provider) {
+    const { createGateway } = await import('ai');
+    const gateway = createGateway({
+        apiKey: process.env['EGAKI_API_KEY'],
+        baseURL: EGAKI_GATEWAY_URL,
+    });
+    const gatewayModelId = `${provider}/${modelId}`;
+    return gateway(gatewayModelId);
+}
+/**
+ * Create a gateway-backed video model using createGateway from the AI SDK.
+ */
+async function createGatewayVideoModel(modelId, provider) {
+    const { createGateway } = await import('ai');
+    const gateway = createGateway({
+        apiKey: process.env['EGAKI_API_KEY'],
+        baseURL: EGAKI_GATEWAY_URL,
+    });
+    const gatewayModelId = `${provider}/${modelId}`;
+    return gateway.video(gatewayModelId);
+}
+// Lazily import the provider and create the right model instance.
+// This avoids loading all provider SDKs upfront — only the one needed
+// for the selected model gets imported.
+//
+// Priority: direct provider key > egaki gateway > error
+export async function createImageModel(modelId) {
+    const config = getModelConfig(modelId);
+    ensureProviderKey(config.provider);
+    // If the user has a direct provider key, use the provider SDK directly
+    if (hasDirectProviderKey(config.provider)) {
+        switch (config.provider) {
+            case 'google': {
+                const { google } = await import('@ai-sdk/google');
+                return google.image(modelId);
+            }
+            case 'openai': {
+                const { openai } = await import('@ai-sdk/openai');
+                return openai.image(modelId);
+            }
+            case 'replicate': {
+                const { replicate } = await import('@ai-sdk/replicate');
+                return replicate.image(modelId);
+            }
+            case 'fal': {
+                const { fal } = await import('@ai-sdk/fal');
+                return fal.image(modelId);
+            }
+        }
+    }
+    // Fall back to egaki gateway
+    if (hasEgakiKey()) {
+        return createGatewayImageModel(modelId, config.provider);
+    }
+    // Should not reach here — ensureProviderKey would have exited
+    console.error(pc.red(`No API key available for provider: ${config.provider}`));
+    process.exit(1);
+}
+export async function createTextModel(modelId) {
+    const config = getModelConfig(modelId);
+    if (config.strategy !== 'text') {
+        console.error(pc.red(`Model ${modelId} is not a text model`));
+        process.exit(1);
+    }
+    ensureProviderKey(config.provider);
+    // Direct provider key takes priority
+    if (hasDirectProviderKey(config.provider)) {
+        switch (config.provider) {
+            case 'google': {
+                const { google } = await import('@ai-sdk/google');
+                return google(modelId);
+            }
+            default:
+                // Only Google supports generateText with responseModalities for images
+                console.error(pc.red(`Text+image generation is only supported for Google models, got provider: ${config.provider}`));
+                process.exit(1);
+        }
+    }
+    // Fall back to egaki gateway
+    if (hasEgakiKey()) {
+        return createGatewayTextModel(modelId, config.provider);
+    }
+    console.error(pc.red(`No API key available for provider: ${config.provider}`));
+    process.exit(1);
+}
+export async function createVideoModel(modelId) {
+    const config = getModelConfig(modelId);
+    if (config.strategy !== 'video') {
+        console.error(pc.red(`Model ${modelId} is not a video model`));
+        process.exit(1);
+    }
+    ensureProviderKey(config.provider);
+    // Direct provider key takes priority
+    if (hasDirectProviderKey(config.provider)) {
+        switch (config.provider) {
+            case 'google': {
+                const { google } = await import('@ai-sdk/google');
+                return google.video(modelId);
+            }
+            case 'fal': {
+                const { fal } = await import('@ai-sdk/fal');
+                return fal.video(modelId);
+            }
+            default:
+                console.error(pc.red(`Direct video generation is only supported for Google and Fal keys, got provider: ${config.provider}`));
+                process.exit(1);
+        }
+    }
+    // Fall back to egaki gateway
+    if (hasEgakiKey()) {
+        return createGatewayVideoModel(modelId, config.provider);
+    }
+    console.error(pc.red(`No API key available for provider: ${config.provider}`));
+    process.exit(1);
+}

package/dist/open-browser.d.ts

@@ -0,0 +1,2 @@
+export declare function openUrlInBrowser(url: string): boolean;
+//# sourceMappingURL=open-browser.d.ts.map

package/dist/open-browser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"open-browser.d.ts","sourceRoot":"","sources":["../src/open-browser.ts"],"names":[],"mappings":"AAyBA,wBAAgB,gBAAgB,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAsBrD"}

package/dist/open-browser.js

@@ -0,0 +1,37 @@
+// Cross-platform browser opener for URLs used by CLI flows.
+// Never throws: missing OS commands are handled gracefully.
+import { spawnSync } from 'node:child_process';
+function getOpenCommands(url) {
+    if (process.platform === 'darwin') {
+        return [{ command: 'open', args: [url] }];
+    }
+    if (process.platform === 'win32') {
+        // `start` is a cmd builtin, so invoke through cmd.exe.
+        return [{ command: 'cmd', args: ['/c', 'start', '', url] }];
+    }
+    return [
+        { command: 'xdg-open', args: [url] },
+        { command: 'gio', args: ['open', url] },
+    ];
+}
+export function openUrlInBrowser(url) {
+    // Avoid launching browser commands in non-interactive contexts (CI/pipes).
+    if (!process.stdout.isTTY || !process.stdin.isTTY) {
+        return false;
+    }
+    for (const candidate of getOpenCommands(url)) {
+        try {
+            const result = spawnSync(candidate.command, candidate.args, {
+                stdio: 'ignore',
+                windowsHide: true,
+            });
+            if (!result.error && result.status === 0) {
+                return true;
+            }
+        }
+        catch {
+            // Keep trying fallback commands. This helper must never crash the CLI.
+        }
+    }
+    return false;
+}

package/dist/subscription.d.ts

@@ -0,0 +1,5 @@
+export declare function subscribeInteractive(): Promise<void>;
+export declare function subscribeNonInteractive(email?: string, plan?: string): void;
+export declare function unsubscribe(): Promise<void>;
+export declare function showUsage(): Promise<void>;
+//# sourceMappingURL=subscription.d.ts.map

package/dist/subscription.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"subscription.d.ts","sourceRoot":"","sources":["../src/subscription.ts"],"names":[],"mappings":"AAsDA,wBAAsB,oBAAoB,IAAI,OAAO,CAAC,IAAI,CAAC,CA8H1D;AAED,wBAAgB,uBAAuB,CAAC,KAAK,CAAC,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,MAAM,GAAG,IAAI,CA6B3E;AAID,wBAAsB,WAAW,IAAI,OAAO,CAAC,IAAI,CAAC,CAgCjD;AAID,wBAAsB,SAAS,IAAI,OAAO,CAAC,IAAI,CAAC,CA8C/C"}

package/dist/subscription.js

@@ -0,0 +1,216 @@
+// Subscription management for egaki.
+// Handles the subscribe, unsubscribe, and usage flows.
+// Communicates with the egaki gateway API at egaki.org.
+import pc from 'picocolors';
+import { intro, outro, text, select, confirm, isCancel, cancel, log, note, spinner, } from '@clack/prompts';
+import { EGAKI_GATEWAY_URL, saveProviderKey, getProviderKey } from './credentials.js';
+import { openUrlInBrowser } from './open-browser.js';
+// Strip /vN/ai suffix to get the base URL for non-proxy endpoints (/buy, /api/*)
+const GATEWAY_BASE = EGAKI_GATEWAY_URL.replace(/\/v\d+\/ai$/, '');
+// ── Subscribe ─────────────────────────────────────────────────────────────
+export async function subscribeInteractive() {
+    intro(pc.bold('egaki subscribe'));
+    // Fetch available plans
+    const s = spinner();
+    s.start('Fetching plans...');
+    let plans;
+    try {
+        const res = await fetch(`${GATEWAY_BASE}/api/plans`);
+        if (!res.ok)
+            throw new Error(`HTTP ${res.status}`);
+        const data = (await res.json());
+        plans = data.plans;
+        s.stop('Plans loaded');
+    }
+    catch {
+        s.stop('Failed to fetch plans');
+        log.error('Could not connect to egaki.org. Check your internet connection.');
+        process.exit(1);
+    }
+    // Select plan
+    const planId = await select({
+        message: 'Choose a plan',
+        options: plans.map((p) => ({
+            value: p.id,
+            label: `${p.name} — ${p.priceFormatted}`,
+            hint: `$${p.spendingCap} spending cap, all models`,
+        })),
+    });
+    if (isCancel(planId)) {
+        cancel('Subscribe cancelled.');
+        process.exit(0);
+    }
+    // Optional email prefill for checkout
+    const prefillEmail = await confirm({
+        message: 'Prefill your email in checkout URL? (optional)',
+    });
+    if (isCancel(prefillEmail)) {
+        cancel('Subscribe cancelled.');
+        process.exit(0);
+    }
+    let email;
+    if (prefillEmail) {
+        const enteredEmail = await text({
+            message: 'Email for the subscription',
+            placeholder: 'you@example.com',
+            validate: (value) => {
+                if (!value || !value.includes('@')) {
+                    return 'Please enter a valid email';
+                }
+            },
+        });
+        if (isCancel(enteredEmail)) {
+            cancel('Subscribe cancelled.');
+            process.exit(0);
+        }
+        email = enteredEmail;
+    }
+    // Show checkout URL
+    const params = new URLSearchParams({ plan: planId });
+    if (email) {
+        params.set('email', email);
+    }
+    const checkoutUrl = `${GATEWAY_BASE}/buy?${params.toString()}`;
+    log.info('');
+    note([
+        `Open this URL to complete payment:`,
+        '',
+        pc.cyan(checkoutUrl),
+        '',
+        `After payment, you'll receive your API key via email.`,
+        `Then run:`,
+        '',
+        `  ${pc.cyan('egaki login --provider egaki --key egaki_...')}`,
+    ].join('\n'), 'Checkout');
+    const opened = openUrlInBrowser(checkoutUrl);
+    if (opened) {
+        log.success('Opened checkout URL in your browser');
+    }
+    else if (process.stdout.isTTY && process.stdin.isTTY) {
+        log.info('Could not auto-open a browser. Open the URL above manually.');
+    }
+    // Ask if they want to enter the key now
+    const hasKey = await confirm({
+        message: 'Do you already have your API key?',
+    });
+    if (isCancel(hasKey)) {
+        outro('You can enter your key later with: egaki login --provider egaki --key <key>');
+        return;
+    }
+    if (hasKey) {
+        const key = await text({
+            message: 'Paste your egaki API key',
+            placeholder: 'egaki_...',
+            validate: (value) => {
+                if (!value || !value.startsWith('egaki_')) {
+                    return 'API key should start with egaki_';
+                }
+            },
+        });
+        if (isCancel(key)) {
+            outro('You can enter your key later with: egaki login --provider egaki --key <key>');
+            return;
+        }
+        saveProviderKey('egaki', key.trim());
+        log.success('API key saved');
+        outro('You can now generate images with any model: egaki image "your prompt"');
+    }
+    else {
+        outro('After payment, run: egaki login --provider egaki --key <your-key>');
+    }
+}
+export function subscribeNonInteractive(email, plan) {
+    const emailParam = email ? `&email=${encodeURIComponent(email)}` : '';
+    if (plan) {
+        // Specific plan requested
+        const checkoutUrl = `${GATEWAY_BASE}/buy?plan=${plan}${emailParam}`;
+        console.log(pc.bold('Egaki Subscription'));
+        console.log('');
+        console.log('Open this URL to complete payment:');
+        console.log('');
+        console.log(pc.cyan(checkoutUrl));
+    }
+    else {
+        // No plan specified — show all options
+        console.log(pc.bold('Egaki Subscription'));
+        console.log('');
+        console.log('Choose a plan:');
+        console.log('');
+        console.log(`  ${pc.bold('Plus')}  $29/mo  ${pc.cyan(`${GATEWAY_BASE}/buy?plan=plus${emailParam}`)}`);
+        console.log(`  ${pc.bold('Pro')}   $99/mo  ${pc.cyan(`${GATEWAY_BASE}/buy?plan=pro${emailParam}`)}`);
+    }
+    console.log('');
+    console.log('After payment, your API key is shown on the success page.');
+    console.log('If an email was provided to Stripe checkout, a copy is also sent by email.');
+    console.log(`Then run: ${pc.cyan('egaki login --provider egaki --key egaki_...')}`);
+    console.log('');
+    console.log('Tip: egaki supports both BYOK and subscription mode.');
+    console.log('BYOK = add provider keys (google/openai/replicate/fal) with egaki login.');
+    console.log('Subscription = one egaki key to access all models without per-provider key setup.');
+}
+// ── Unsubscribe ───────────────────────────────────────────────────────────
+export async function unsubscribe() {
+    const apiKey = getProviderKey('egaki') || process.env['EGAKI_API_KEY'];
+    if (!apiKey) {
+        console.error(pc.red('No egaki API key found.'));
+        console.error(`If you have a key, set it first: ${pc.cyan('egaki login --provider egaki --key <key>')}`);
+        process.exit(1);
+    }
+    console.error(pc.dim('Canceling subscription...'));
+    try {
+        const res = await fetch(`${GATEWAY_BASE}/api/cancel`, {
+            method: 'POST',
+            headers: { Authorization: `Bearer ${apiKey}` },
+        });
+        const data = (await res.json());
+        if (!res.ok) {
+            console.error(pc.red(data.error || 'Failed to cancel subscription'));
+            process.exit(1);
+        }
+        console.log(pc.green(data.message || 'Subscription canceled.'));
+        console.log(pc.dim('You can resubscribe anytime with: egaki subscribe'));
+    }
+    catch {
+        console.error(pc.red('Could not connect to egaki.org. Check your internet connection.'));
+        process.exit(1);
+    }
+}
+// ── Usage ─────────────────────────────────────────────────────────────────
+export async function showUsage() {
+    const apiKey = getProviderKey('egaki') || process.env['EGAKI_API_KEY'];
+    if (!apiKey) {
+        console.error(pc.red('No egaki API key found.'));
+        console.error(`Set your key first: ${pc.cyan('egaki login --provider egaki --key <key>')}`);
+        console.error(`Or subscribe: ${pc.cyan('egaki subscribe')}`);
+        process.exit(1);
+    }
+    try {
+        const res = await fetch(`${GATEWAY_BASE}/api/usage`, {
+            headers: { Authorization: `Bearer ${apiKey}` },
+        });
+        if (!res.ok) {
+            const data = (await res.json());
+            console.error(pc.red(data.error || 'Failed to fetch usage'));
+            process.exit(1);
+        }
+        const usage = (await res.json());
+        const pct = usage.spendingCap > 0
+            ? Math.round((usage.dollarsUsed / usage.spendingCap) * 100)
+            : 0;
+        const remaining = Math.max(0, usage.spendingCap - usage.dollarsUsed);
+        console.log(pc.bold(`Egaki ${usage.planName} Plan\n`));
+        console.log(`  Status:    ${usage.status === 'active' ? pc.green('active') : pc.red(usage.status)}`);
+        console.log(`  Spent:     $${usage.dollarsUsed.toFixed(2)} / $${usage.spendingCap.toFixed(2)} (${pct}%)`);
+        console.log(`  Remaining: $${remaining.toFixed(2)}`);
+        console.log(`  Period:    started ${new Date(usage.periodStart).toLocaleDateString()}`);
+        if (pct >= 90) {
+            console.log('');
+            console.log(pc.yellow('  Running low on budget! Consider upgrading your plan.'));
+            console.log(pc.dim(`  Visit: https://egaki.org/buy`));
+        }
+    }
+    catch {
+        console.error(pc.red('Could not connect to egaki.org. Check your internet connection.'));
+        process.exit(1);
+    }
+}

package/dist/video-model-catalog.d.ts

@@ -0,0 +1,52 @@
+export type VideoDurationPricingTier = {
+    /** USD per second for this variant */
+    costPerSecond: number;
+    /** Optional resolution discriminator (e.g. 720p, 1080p, 4k) */
+    resolution?: string;
+    /** Optional mode discriminator (e.g. std, pro) */
+    mode?: string;
+    /** Optional audio discriminator */
+    audio?: boolean;
+};
+export type PerVideoSecondCost = {
+    type: 'per-video-second';
+    /** Fallback duration when request does not specify one (seconds) */
+    defaultDurationSec: number;
+    tiers: VideoDurationPricingTier[];
+};
+export type UnknownVideoCost = {
+    type: 'unknown';
+};
+export type VideoModelCost = PerVideoSecondCost | UnknownVideoCost;
+export type VideoModelFeatures = {
+    /** Supports text prompt to video generation */
+    textToVideo: boolean;
+    /** Supports image-to-video prompt object ({ image, text }) */
+    imageToVideo: boolean;
+    /** Optional capabilities exposed by provider */
+    capabilities: Array<'t2v' | 'i2v' | 'r2v' | 'motion-control' | 'editing'>;
+    /** Optional supported aspect ratios */
+    aspectRatios?: string[];
+    /** Optional supported resolutions */
+    resolutions?: string[];
+    /** Optional duration range in seconds */
+    durationRangeSec?: {
+        min: number;
+        max: number;
+    };
+    seed: boolean;
+    multipleVideos: boolean;
+};
+export type VideoModelEntry = {
+    id: string;
+    name: string;
+    description?: string;
+    provider: string;
+    strategy: 'video';
+    released: string;
+    cost: VideoModelCost;
+    features: VideoModelFeatures;
+};
+export declare const VIDEO_CATALOG: VideoModelEntry[];
+export declare function findVideoModel(id: string): VideoModelEntry | undefined;
+//# sourceMappingURL=video-model-catalog.d.ts.map

package/dist/video-model-catalog.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"video-model-catalog.d.ts","sourceRoot":"","sources":["../src/video-model-catalog.ts"],"names":[],"mappings":"AAIA,MAAM,MAAM,wBAAwB,GAAG;IACrC,sCAAsC;IACtC,aAAa,EAAE,MAAM,CAAA;IACrB,+DAA+D;IAC/D,UAAU,CAAC,EAAE,MAAM,CAAA;IACnB,kDAAkD;IAClD,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,mCAAmC;IACnC,KAAK,CAAC,EAAE,OAAO,CAAA;CAChB,CAAA;AAED,MAAM,MAAM,kBAAkB,GAAG;IAC/B,IAAI,EAAE,kBAAkB,CAAA;IACxB,oEAAoE;IACpE,kBAAkB,EAAE,MAAM,CAAA;IAC1B,KAAK,EAAE,wBAAwB,EAAE,CAAA;CAClC,CAAA;AAED,MAAM,MAAM,gBAAgB,GAAG;IAC7B,IAAI,EAAE,SAAS,CAAA;CAChB,CAAA;AAED,MAAM,MAAM,cAAc,GAAG,kBAAkB,GAAG,gBAAgB,CAAA;AAElE,MAAM,MAAM,kBAAkB,GAAG;IAC/B,+CAA+C;IAC/C,WAAW,EAAE,OAAO,CAAA;IACpB,8DAA8D;IAC9D,YAAY,EAAE,OAAO,CAAA;IACrB,gDAAgD;IAChD,YAAY,EAAE,KAAK,CAAC,KAAK,GAAG,KAAK,GAAG,KAAK,GAAG,gBAAgB,GAAG,SAAS,CAAC,CAAA;IACzE,uCAAuC;IACvC,YAAY,CAAC,EAAE,MAAM,EAAE,CAAA;IACvB,qCAAqC;IACrC,WAAW,CAAC,EAAE,MAAM,EAAE,CAAA;IACtB,yCAAyC;IACzC,gBAAgB,CAAC,EAAE;QAAE,GAAG,EAAE,MAAM,CAAC;QAAC,GAAG,EAAE,MAAM,CAAA;KAAE,CAAA;IAC/C,IAAI,EAAE,OAAO,CAAA;IACb,cAAc,EAAE,OAAO,CAAA;CACxB,CAAA;AAED,MAAM,MAAM,eAAe,GAAG;IAC5B,EAAE,EAAE,MAAM,CAAA;IACV,IAAI,EAAE,MAAM,CAAA;IACZ,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,QAAQ,EAAE,MAAM,CAAA;IAChB,QAAQ,EAAE,OAAO,CAAA;IACjB,QAAQ,EAAE,MAAM,CAAA;IAChB,IAAI,EAAE,cAAc,CAAA;IACpB,QAAQ,EAAE,kBAAkB,CAAA;CAC7B,CAAA;AAID,eAAO,MAAM,aAAa,EAAE,eAAe,EA6O1C,CAAA;AAID,wBAAgB,cAAc,CAAC,EAAE,EAAE,MAAM,GAAG,eAAe,GAAG,SAAS,CAEtE"}