@lastbrain/app 2.0.1 → 2.0.3

package/dist/src/scripts/db-init.js

@@ -0,0 +1,300 @@
+import { spawn, spawnSync, } from "node:child_process";
+import fs from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+// Utiliser PROJECT_ROOT si défini (pour pnpm --filter), sinon process.cwd()
+const projectRoot = process.env.PROJECT_ROOT || process.cwd();
+const supabaseDir = path.join(projectRoot, "supabase");
+const envTargets = [path.join(projectRoot, ".env.local")];
+// Trouver le template dans le package @lastbrain/app
+const packageAppDir = path
+    .dirname(fileURLToPath(import.meta.url))
+    .replace(/dist\/scripts$/, "src");
+const envExampleTemplate = path.join(packageAppDir, "templates/env.example/.env.example");
+function ensureDirectory(dir) {
+    fs.mkdirSync(dir, { recursive: true });
+}
+function runSupabase(...args) {
+    const bin = path.join(projectRoot, "node_modules", ".bin", "supabase");
+    // Ensure PATH includes common binary locations
+    const PATH = process.env.PATH || "";
+    const enhancedPath = `/usr/local/bin:/opt/homebrew/bin:/usr/bin:/bin:${PATH}`;
+    // Check if first argument is a boolean (captureOutput flag)
+    const captureOutput = typeof args[0] === "boolean" ? args.shift() : false;
+    const stdio = captureOutput ? "pipe" : "inherit";
+    const runners = [
+        () => spawnSync("supabase", args, {
+            cwd: projectRoot,
+            stdio: stdio,
+            env: { ...process.env, PATH: enhancedPath },
+            shell: true,
+        }),
+        () => spawnSync(bin, args, {
+            cwd: projectRoot,
+            stdio: stdio,
+            env: { ...process.env, PATH: enhancedPath },
+        }),
+        () => spawnSync("pnpm", ["exec", "supabase", ...args], {
+            cwd: projectRoot,
+            stdio: stdio,
+            env: { ...process.env, PATH: enhancedPath },
+            shell: true,
+        }),
+    ];
+    for (let i = 0; i < runners.length; i++) {
+        const result = runners[i]();
+        if (result.error) {
+            // Si c'est une erreur ENOENT (commande non trouvée), essayer la suivante
+            if (result.error.code === "ENOENT") {
+                continue;
+            }
+            // Si c'est une autre erreur, la propager
+            throw result.error;
+        }
+        // Si le processus s'est terminé avec un code de sortie non nul, propager l'erreur
+        if (result.status !== 0) {
+            const error = new Error(`Command failed with exit code ${result.status}`);
+            error.status = result.status;
+            throw error;
+        }
+        // Succès !
+        return result.stdout || null;
+    }
+    throw new Error("Unable to locate Supabase CLI (install it globally or via pnpm).");
+}
+function ensureSupabaseInit() {
+    const configPath = path.join(supabaseDir, "config.toml");
+    if (!fs.existsSync(configPath)) {
+        runSupabase("init");
+    }
+}
+function parseEnvFile(filePath) {
+    const data = fs.readFileSync(filePath, "utf-8");
+    return Object.fromEntries(data
+        .split("\n")
+        .map((line) => line.trim())
+        .filter((line) => line && !line.startsWith("#"))
+        .map((line) => {
+        const [key, ...value] = line.split("=");
+        return [key, value.join("=")];
+    }));
+}
+function ensureEnvFile(values) {
+    envTargets.forEach((target) => {
+        let existingVars = {};
+        // Lire le fichier .env.local existant pour préserver les variables personnalisées
+        if (fs.existsSync(target)) {
+            try {
+                const existingContent = fs.readFileSync(target, "utf-8");
+                existingVars = Object.fromEntries(existingContent
+                    .split("\n")
+                    .filter((line) => line.includes("=") && !line.startsWith("#"))
+                    .map((line) => {
+                    const [key, ...value] = line.split("=");
+                    return [key, value.join("=")];
+                }));
+            }
+            catch (error) {
+                console.warn(`⚠️  Erreur lors de la lecture de ${target}:`, error);
+            }
+        }
+        // Fusionner les nouvelles valeurs avec les existantes (nouvelles valeurs prioritaires)
+        const mergedValues = { ...existingVars, ...values };
+        const content = Object.entries(mergedValues)
+            .map(([key, value]) => `${key}=${value}`)
+            .join("\n");
+        fs.writeFileSync(target, content);
+        console.log(`📝 Wrote env to ${target}`);
+    });
+}
+function buildEnvPayload(creds) {
+    return {
+        NEXT_PUBLIC_SUPABASE_URL: creds.url ?? "",
+        NEXT_PUBLIC_SUPABASE_ANON_KEY: creds.anon ?? "",
+        SUPABASE_URL: creds.url ?? "",
+        SUPABASE_ANON_KEY: creds.anon ?? "",
+        SUPABASE_SERVICE_ROLE_KEY: creds.service ?? "",
+        SUPABASE_DB_URL: creds.db ?? "",
+        SUPABASE_JWT_SECRET: creds.jwt ?? "",
+    };
+}
+function applyEnvToProcess(values) {
+    process.env.NEXT_PUBLIC_SUPABASE_URL = values.NEXT_PUBLIC_SUPABASE_URL;
+    process.env.NEXT_PUBLIC_SUPABASE_ANON_KEY =
+        values.NEXT_PUBLIC_SUPABASE_ANON_KEY;
+    process.env.SUPABASE_URL = values.SUPABASE_URL;
+    process.env.SUPABASE_ANON_KEY = values.SUPABASE_ANON_KEY;
+    process.env.SUPABASE_SERVICE_ROLE_KEY = values.SUPABASE_SERVICE_ROLE_KEY;
+    process.env.SUPABASE_DB_URL = values.SUPABASE_DB_URL;
+    process.env.SUPABASE_JWT_SECRET = values.SUPABASE_JWT_SECRET;
+}
+function copyEnvExample() {
+    if (!fs.existsSync(envExampleTemplate)) {
+        return null;
+    }
+    const target = envTargets[0];
+    ensureDirectory(path.dirname(target));
+    fs.copyFileSync(envExampleTemplate, target);
+    return target;
+}
+function readSupabaseEnv() {
+    const candidate = path.join(supabaseDir, ".env");
+    if (fs.existsSync(candidate)) {
+        return parseEnvFile(candidate);
+    }
+    const candidateLocal = path.join(supabaseDir, ".env.local");
+    if (fs.existsSync(candidateLocal)) {
+        return parseEnvFile(candidateLocal);
+    }
+    return {};
+}
+function getSupabaseStatusEnv() {
+    try {
+        const result = runSupabase(true, "status", "-o", "env");
+        if (!result)
+            return null;
+        const envString = result.toString();
+        const lines = envString
+            .split("\n")
+            .map((line) => line.trim())
+            .filter((line) => line && !line.startsWith("#") && line.includes("="));
+        const env = {};
+        for (const line of lines) {
+            const equalIndex = line.indexOf("=");
+            if (equalIndex > 0) {
+                const key = line.substring(0, equalIndex);
+                const value = line
+                    .substring(equalIndex + 1)
+                    .replace(/^["']|["']$/g, "");
+                env[key] = value;
+            }
+        }
+        return Object.keys(env).length > 0 ? env : null;
+    }
+    catch {
+        return null;
+    }
+}
+function buildCredsFromStatus(status) {
+    if (!status) {
+        return null;
+    }
+    return {
+        url: status.API_URL ?? status.SUPABASE_URL ?? "",
+        anon: status.ANON_KEY ?? "",
+        service: status.SERVICE_ROLE_KEY ?? status.SECRET_KEY ?? "",
+        jwt: status.JWT_SECRET ?? "",
+        db: status.DB_URL ?? status.DATABASE_URL ?? "",
+    };
+}
+function findLocalKeysFallback() {
+    const env = readSupabaseEnv();
+    if (Object.keys(env).length === 0) {
+        return null;
+    }
+    return {
+        url: env.SUPABASE_URL ?? env.API_URL ?? null,
+        anon: env.SUPABASE_ANON_KEY ?? env.ANON_KEY ?? null,
+        service: env.SUPABASE_SERVICE_ROLE_KEY ?? env.SERVICE_ROLE_KEY ?? null,
+        jwt: env.JWT_SECRET ?? null,
+        db: env.SUPABASE_DB_URL ?? env.DB_URL ?? null,
+    };
+}
+async function wait(ms) {
+    await new Promise((resolve) => setTimeout(resolve, ms));
+}
+async function waitForStatus() {
+    const maxAttempts = 10;
+    for (let attempt = 0; attempt < maxAttempts; attempt += 1) {
+        const status = getSupabaseStatusEnv();
+        if (status && Object.keys(status).length > 0) {
+            return status;
+        }
+        await wait(1000);
+    }
+    return null;
+}
+async function gatherCredentials() {
+    const envStatus = await waitForStatus();
+    let creds = envStatus ? buildCredsFromStatus(envStatus) : null;
+    if (!creds || !creds.url || !creds.anon) {
+        const fallback = findLocalKeysFallback();
+        if (fallback) {
+            creds = {
+                url: fallback.url ?? "",
+                anon: fallback.anon ?? "",
+                service: fallback.service ?? "",
+                jwt: fallback.jwt ?? "",
+                db: fallback.db ?? "",
+            };
+        }
+    }
+    return creds;
+}
+async function main() {
+    ensureSupabaseInit();
+    const PATH = process.env.PATH || "";
+    const enhancedPath = `/usr/local/bin:/opt/homebrew/bin:/usr/bin:/bin:${PATH}`;
+    const migrationResult = spawnSync("pnpm", ["--filter", "web", "db:migrations:sync"], {
+        cwd: projectRoot,
+        stdio: "inherit",
+        env: { ...process.env, PATH: enhancedPath },
+        shell: true,
+    });
+    if (migrationResult.error || migrationResult.status !== 0) {
+        console.warn("⚠️ Migration sync failed, continuing anyway...");
+    }
+    console.log("⚙️ Starting Supabase...");
+    try {
+        runSupabase("start");
+    }
+    catch {
+        console.warn("⚠️ Supabase start had issues, continuing...");
+    }
+    console.log("🔄 Resetting database...");
+    try {
+        runSupabase("db", "reset");
+        console.log("✅ Database reset complete.");
+    }
+    catch (error) {
+        console.error("⚠️ supabase db reset failed:", error);
+        throw error;
+    }
+    console.log("🛠 Waiting for services to restart...");
+    await wait(3000);
+    const creds = await gatherCredentials();
+    if (creds && creds.url && creds.anon) {
+        const payload = buildEnvPayload(creds);
+        ensureEnvFile(payload);
+        applyEnvToProcess(payload);
+        console.log("✅ Environment configured successfully!");
+    }
+    else {
+        const example = copyEnvExample();
+        if (example) {
+            console.log("ℹ️  Copied .env.example into .env.local as fallback.");
+        }
+        console.warn("⚠️  Impossible de récupérer automatiquement les accès Supabase.");
+    }
+    if (process.argv.includes("--with-dev")) {
+        console.log("🚀 Launching Next dev server...");
+        const devProcess = spawn("pnpm", ["--filter", "web", "dev"], {
+            cwd: projectRoot,
+            stdio: "inherit",
+        });
+        devProcess.on("exit", (code) => {
+            console.log("🧹 Stopping Supabase");
+            try {
+                runSupabase("stop");
+            }
+            catch {
+                // Ignore errors when stopping
+            }
+            process.exit(code ?? 0);
+        });
+    }
+}
+main().catch((error) => {
+    console.error(error);
+    process.exit(1);
+});

package/dist/src/scripts/db-migrations-sync.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=db-migrations-sync.d.ts.map

package/dist/src/scripts/db-migrations-sync.d.ts.map

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

package/dist/src/scripts/db-migrations-sync.js

@@ -0,0 +1,84 @@
+import fs from "node:fs";
+import path from "node:path";
+// Utiliser PROJECT_ROOT si défini (pour pnpm --filter), sinon process.cwd()
+const projectRoot = process.env.PROJECT_ROOT || process.cwd();
+const migrationsDir = path.join(projectRoot, "supabase/migrations");
+function ensureDirectory(dir) {
+    fs.mkdirSync(dir, { recursive: true });
+}
+/**
+ * Copie les migrations d'un module vers supabase/migrations
+ */
+function copyModuleMigrations(moduleName, moduleDir) {
+    const sourceMigrationsDir = path.join(moduleDir, "supabase", "migrations");
+    if (!fs.existsSync(sourceMigrationsDir)) {
+        return 0;
+    }
+    const files = fs
+        .readdirSync(sourceMigrationsDir)
+        .filter((file) => file.endsWith(".sql"))
+        .sort();
+    if (files.length === 0) {
+        return 0;
+    }
+    ensureDirectory(migrationsDir);
+    let copiedCount = 0;
+    files.forEach((file) => {
+        const sourceFile = path.join(sourceMigrationsDir, file);
+        const targetFile = path.join(migrationsDir, file);
+        // Ne copier que si le fichier n'existe pas déjà
+        if (!fs.existsSync(targetFile)) {
+            fs.copyFileSync(sourceFile, targetFile);
+            console.log(`📜 Copied migration: ${file} from ${moduleName}`);
+            copiedCount++;
+        }
+        else {
+            console.log(`⏭️  Migration already exists: ${file}`);
+        }
+    });
+    return copiedCount;
+}
+/**
+ * Synchronise les migrations de tous les modules actifs
+ */
+function syncModuleMigrations() {
+    // Charger modules.json
+    const modulesJsonPath = path.join(projectRoot, ".lastbrain", "modules.json");
+    if (!fs.existsSync(modulesJsonPath)) {
+        console.error("❌ modules.json not found");
+        return;
+    }
+    const modulesData = JSON.parse(fs.readFileSync(modulesJsonPath, "utf-8"));
+    const modules = modulesData.modules || [];
+    // Filtrer les modules actifs
+    const activeModules = modules.filter((m) => m.active !== false);
+    console.log(`🔄 Syncing migrations from ${activeModules.length} active module(s)...\n`);
+    let totalCopied = 0;
+    activeModules.forEach((module) => {
+        const moduleName = module.package;
+        // Essayer plusieurs chemins possibles pour trouver le module
+        const possiblePaths = [
+            // Dans node_modules local de l'app
+            path.join(projectRoot, "node_modules", moduleName),
+            // Dans node_modules à la racine du workspace
+            path.join(projectRoot, "..", "..", "node_modules", moduleName),
+            // Directement dans packages/ (pour monorepo)
+            path.join(projectRoot, "..", "..", "packages", moduleName.replace("@lastbrain/", "").replace("@lastbrain-labs/", "")),
+        ];
+        let moduleDir = null;
+        for (const possiblePath of possiblePaths) {
+            if (fs.existsSync(possiblePath)) {
+                moduleDir = possiblePath;
+                break;
+            }
+        }
+        if (!moduleDir) {
+            console.warn(`⚠️  Module not found: ${moduleName}`);
+            return;
+        }
+        const copied = copyModuleMigrations(moduleName, moduleDir);
+        totalCopied += copied;
+    });
+    console.log(`\n✅ Migration sync completed: ${totalCopied} file(s) copied`);
+}
+syncModuleMigrations();

package/dist/src/scripts/dev-sync.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=dev-sync.d.ts.map

package/dist/src/scripts/dev-sync.d.ts.map

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

package/dist/src/scripts/dev-sync.js

@@ -0,0 +1,194 @@
+import fs from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+const GENERATED_HEADER = "// GENERATED BY LASTBRAIN APP-SHELL\n";
+const scriptDir = path.dirname(fileURLToPath(import.meta.url));
+const packageRoot = path.join(scriptDir, "..", "..");
+const projectRoot = path.join(packageRoot, "..", "..");
+const srcAppShell = path.join(projectRoot, "packages/app/src/app-shell");
+const destAppShell = path.join(projectRoot, "apps/web/app");
+const webPackage = path.join(projectRoot, "apps/web/package.json");
+const scriptsToEnsure = {
+    dev: "next dev",
+    build: "next build",
+    "build:modules": "pnpm --filter @lastbrain/app module:build",
+    "db:migrations:sync": "pnpm --filter @lastbrain/app db:migrations:sync",
+    "db:init": "pnpm --filter @lastbrain/app db:init",
+    "readme:create": "pnpm --filter @lastbrain/app readme:create",
+};
+const dependenciesToEnsure = {
+    "@lastbrain/app": "workspace:*",
+    "@lastbrain/core": "workspace:*",
+    "@lastbrain/ui": "workspace:*",
+    "@lastbrain/module-auth": "workspace:*",
+};
+const gitignoreTemplate = path.join(projectRoot, "packages/app/src/templates/gitignore/.gitignore");
+const consumerGitignore = path.join(projectRoot, "apps/web/.gitignore");
+const envTemplate = path.join(projectRoot, "packages/app/src/templates/env.example/.env.example");
+const consumerEnvExample = path.join(projectRoot, "apps/web/.env.example");
+const consumerEnvLocal = path.join(projectRoot, "apps/web/.env.local");
+function ensureDirectory(dir) {
+    fs.mkdirSync(dir, { recursive: true });
+}
+function normalizeContent(data) {
+    const trimmed = data.startsWith(GENERATED_HEADER)
+        ? data.slice(GENERATED_HEADER.length)
+        : data;
+    const sanitized = trimmed.trimStart();
+    return `${GENERATED_HEADER}\n${sanitized}`;
+}
+function syncFile(src, dest) {
+    const relativePath = path.relative(destAppShell, dest);
+    let content;
+    if (relativePath === "layout.tsx") {
+        content = `${GENERATED_HEADER}\nimport { RootLayout } from "@lastbrain/app";\n\nexport default RootLayout;\n`;
+    }
+    else {
+        const data = fs.readFileSync(src, "utf-8");
+        content = normalizeContent(data);
+    }
+    ensureDirectory(path.dirname(dest));
+    fs.writeFileSync(dest, content);
+    return dest;
+}
+function _copyDirectory(srcDir, destDir) {
+    const stats = fs.statSync(srcDir);
+    if (stats.isDirectory()) {
+        ensureDirectory(destDir);
+        const entries = fs.readdirSync(srcDir, { withFileTypes: true });
+        for (const entry of entries) {
+            _copyDirectory(path.join(srcDir, entry.name), path.join(destDir, entry.name));
+        }
+    }
+    else if (stats.isFile()) {
+        syncFile(srcDir, destDir);
+    }
+}
+function syncAppShell() {
+    if (!fs.existsSync(srcAppShell)) {
+        throw new Error(`Source app-shell not found at ${srcAppShell}`);
+    }
+    const copied = [];
+    const recurse = (src, dest) => {
+        const stats = fs.statSync(src);
+        if (stats.isDirectory()) {
+            ensureDirectory(dest);
+            const entries = fs.readdirSync(src, { withFileTypes: true });
+            for (const entry of entries) {
+                recurse(path.join(src, entry.name), path.join(dest, entry.name));
+            }
+        }
+        else {
+            syncFile(src, dest);
+            copied.push(dest);
+        }
+    };
+    recurse(srcAppShell, destAppShell);
+    return copied;
+}
+function cleanupStaleGroupFiles() {
+    const staleFiles = [
+        path.join(destAppShell, "(auth)", "page.tsx"),
+        path.join(destAppShell, "(admin)", "page.tsx"),
+    ];
+    staleFiles.forEach((file) => {
+        if (fs.existsSync(file)) {
+            fs.unlinkSync(file);
+        }
+    });
+    const staleDirs = [
+        path.join(destAppShell, "(auth)", "dashboard"),
+        path.join(destAppShell, "(admin)", "dashboard"),
+    ];
+    staleDirs.forEach((dir) => {
+        if (fs.existsSync(dir)) {
+            fs.rmSync(dir, { recursive: true, force: true });
+        }
+    });
+}
+function mergeScripts(base, additions) {
+    return { ...base, ...additions };
+}
+function syncPackageJson() {
+    ensureDirectory(path.dirname(webPackage));
+    const defaultPkg = {
+        name: "web",
+        private: true,
+        version: "0.1.0",
+        type: "module",
+    };
+    const pkg = fs.existsSync(webPackage)
+        ? JSON.parse(fs.readFileSync(webPackage, "utf-8"))
+        : defaultPkg;
+    pkg.scripts = mergeScripts(pkg.scripts ?? {}, scriptsToEnsure);
+    pkg.dependencies = { ...(pkg.dependencies ?? {}), ...dependenciesToEnsure };
+    fs.writeFileSync(webPackage, JSON.stringify(pkg, null, 2) + "\n");
+    return {
+        scripts: Object.keys(scriptsToEnsure),
+        dependencies: Object.keys(dependenciesToEnsure),
+    };
+}
+function syncEnvExample() {
+    if (!fs.existsSync(envTemplate)) {
+        return null;
+    }
+    const shouldOverwrite = !fs.existsSync(consumerEnvExample) ||
+        fs
+            .readFileSync(consumerEnvExample, "utf-8")
+            .includes("GENERATED BY LASTBRAIN");
+    if (!shouldOverwrite) {
+        return null;
+    }
+    fs.copyFileSync(envTemplate, consumerEnvExample);
+    return consumerEnvExample;
+}
+function ensureEnvLocal() {
+    if (fs.existsSync(consumerEnvLocal)) {
+        return null;
+    }
+    if (!fs.existsSync(envTemplate)) {
+        return null;
+    }
+    fs.copyFileSync(envTemplate, consumerEnvLocal);
+    return consumerEnvLocal;
+}
+function syncGitignore() {
+    if (!fs.existsSync(gitignoreTemplate)) {
+        return null;
+    }
+    const shouldOverwrite = !fs.existsSync(consumerGitignore) ||
+        fs
+            .readFileSync(consumerGitignore, "utf-8")
+            .includes("GENERATED BY LASTBRAIN");
+    if (!shouldOverwrite) {
+        return null;
+    }
+    fs.copyFileSync(gitignoreTemplate, consumerGitignore);
+    return consumerGitignore;
+}
+function main() {
+    ensureDirectory(destAppShell);
+    const copiedFiles = syncAppShell();
+    cleanupStaleGroupFiles();
+    const changes = syncPackageJson();
+    const gitignoreSynced = syncGitignore();
+    const envExampleSynced = syncEnvExample();
+    const envLocalCreated = ensureEnvLocal();
+    console.log("✅ apps/web synced with @lastbrain/app");
+    console.log(`Copied or updated files (${copiedFiles.length}):`);
+    copiedFiles.forEach((file) => console.log(`  • ${path.relative(projectRoot, file)}`));
+    console.log("Scripts ensured in apps/web/package.json:");
+    changes.scripts.forEach((script) => console.log(`  • ${script}`));
+    console.log("Dependencies ensured in apps/web/package.json:");
+    changes.dependencies.forEach((dep) => console.log(`  • ${dep}`));
+    if (gitignoreSynced) {
+        console.log(`.gitignore ensured at ${path.relative(projectRoot, gitignoreSynced)}`);
+    }
+    if (envExampleSynced) {
+        console.log(`.env.example ensured at ${path.relative(projectRoot, envExampleSynced)}`);
+    }
+    if (envLocalCreated) {
+        console.log(`.env.local ensured at ${path.relative(projectRoot, envLocalCreated)}`);
+    }
+}
+main();

package/dist/src/scripts/init-app.d.ts

@@ -0,0 +1,12 @@
+interface InitAppOptions {
+    targetDir: string;
+    force: boolean;
+    projectName: string;
+    useHeroUI: boolean;
+    withAuth?: boolean;
+    interactive?: boolean;
+    isMonorepoProject?: boolean;
+}
+export declare function initApp(options: InitAppOptions): Promise<void>;
+export {};
+//# sourceMappingURL=init-app.d.ts.map

package/dist/src/scripts/init-app.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"init-app.d.ts","sourceRoot":"","sources":["../../../src/scripts/init-app.ts"],"names":[],"mappings":"AAWA,UAAU,cAAc;IACtB,SAAS,EAAE,MAAM,CAAC;IAClB,KAAK,EAAE,OAAO,CAAC;IACf,WAAW,EAAE,MAAM,CAAC;IACpB,SAAS,EAAE,OAAO,CAAC;IACnB,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB,iBAAiB,CAAC,EAAE,OAAO,CAAC;CAC7B;AAED,wBAAsB,OAAO,CAAC,OAAO,EAAE,cAAc,iBAkSpD"}