pushwork 1.0.4 → 1.0.7

package/test/unit/sync-convergence.test.ts

@@ -5,13 +5,10 @@ import { SnapshotManager } from "../../src/core/snapshot";
 import { ChangeDetector } from "../../src/core/change-detection";
 import { MoveDetector } from "../../src/core/move-detection";
 import { writeFileContent, removePath, pathExists } from "../../src/utils";
-import { SyncSnapshot, ChangeType, FileType } from "../../src/types";
 
 describe("Sync Convergence Issues", () => {
   let testDir: string;
   let snapshotManager: SnapshotManager;
-  let changeDetector: ChangeDetector;
-  let moveDetector: MoveDetector;
 
   beforeEach(async () => {
     testDir = await fs.mkdtemp(path.join(tmpdir(), "sync-convergence-test-"));
@@ -19,8 +16,8 @@ describe("Sync Convergence Issues", () => {
 
     // Create mock repo for change detector - we'll focus on change detection logic
     const mockRepo = {} as any;
-    changeDetector = new ChangeDetector(mockRepo, testDir, []);
-    moveDetector = new MoveDetector();
+    new ChangeDetector(mockRepo, testDir, []);
+    new MoveDetector();
   });
 
   afterEach(async () => {
@@ -29,12 +26,7 @@ describe("Sync Convergence Issues", () => {
 
   describe("Change Detection Patterns", () => {
     it("should verify that convergence issues are fixed", async () => {
-      console.log(
-        "\n🧪 Testing That Convergence Issues Are Fixed With Proper Head Tracking"
-      );
-
       // === SETUP PHASE ===
-      console.log("\n--- Setup Phase ---");
 
       // Create initial file structure similar to Vite build output
       const initialFiles = [
@@ -56,7 +48,6 @@ describe("Sync Convergence Issues", () => {
         const filePath = path.join(testDir, file.name);
         await fs.mkdir(path.dirname(filePath), { recursive: true });
         await writeFileContent(filePath, file.content);
-        console.log(`📄 Created: ${file.name}`);
       }
 
       // Create initial snapshot representing the "synced" state
@@ -73,33 +64,22 @@ describe("Sync Convergence Issues", () => {
         });
       }
 
-      console.log(
-        `📸 Initial snapshot has ${snapshot.files.size} files tracked`
-      );
-
       // === SIMULATE BUILD PROCESS ===
-      console.log("\n--- Simulating Build Process (like pnpm build) ---");
 
       // Delete old file and create new one (simulating Vite's content-based naming)
       await removePath(path.join(testDir, "assets/tool-DhQI94EZ.js"));
-      console.log(`🗑️  Deleted: assets/tool-DhQI94EZ.js`);
 
       const newToolFile = "assets/tool-CR5n6i_K.js";
       await writeFileContent(
         path.join(testDir, newToolFile),
         "// New tool bundle with different hash\nexport const tool = 'v2';"
       );
-      console.log(`➕ Created: ${newToolFile}`);
 
       // Update the main file to reference the new bundle
       await writeFileContent(
         path.join(testDir, "index.js"),
         "// Main entry\nimport './assets/tool-CR5n6i_K.js';"
       );
-      console.log(`📝 Modified: index.js`);
-
-      // === CHANGE DETECTION ANALYSIS ===
-      console.log("\n--- Change Detection Analysis ---");
 
       // This is where we would normally detect changes, but we'll simulate the issue
       // by showing what the change detector would find vs what should happen
@@ -107,83 +87,28 @@ describe("Sync Convergence Issues", () => {
       // Simulate what change detection finds
       const deletedFile = "assets/tool-DhQI94EZ.js";
       const createdFile = "assets/tool-CR5n6i_K.js";
-      const modifiedFile = "index.js";
-
-      console.log(`🔍 Change detection would find:`);
-      console.log(`  - Deleted: ${deletedFile}`);
-      console.log(`  - Created: ${createdFile}`);
-      console.log(`  - Modified: ${modifiedFile}`);
-
-      // === MOVE DETECTION ANALYSIS ===
-      console.log("\n--- Move Detection Analysis ---");
-
-      // Simulate move detection
-      const deletedContent =
-        "// Initial tool bundle\nexport const tool = 'v1';";
-      const createdContent = await fs.readFile(
-        path.join(testDir, createdFile),
-        "utf8"
-      );
-
-      // The similarity would be low due to different content/hash
-      const mockSimilarity = 0.3; // Low similarity - below auto-apply threshold
-      console.log(
-        `🔍 Move detection similarity: ${(mockSimilarity * 100).toFixed(1)}%`
-      );
-      console.log(
-        `📊 Below auto-apply threshold (80%) - will be treated as separate delete+create`
-      );
-
-      // === SIMULATE THE CONVERGENCE ISSUE ===
-      console.log("\n--- Simulating Convergence Issue ---");
-
-      // The issue: In a real sync scenario, the deletion might not be properly
-      // processed due to stale directory heads, causing repeated attempts
 
       // Simulate multiple "sync runs" by checking filesystem state
       let syncRun = 1;
       let changesRemaining = true;
 
       while (changesRemaining && syncRun <= 3) {
-        console.log(`\n--- Sync Run ${syncRun} ---`);
-
         // Check what should be synced
         const fileExists = await pathExists(path.join(testDir, deletedFile));
         const isTrackedInSnapshot = snapshot.files.has(deletedFile);
 
-        console.log(`📁 ${deletedFile} exists on filesystem: ${fileExists}`);
-        console.log(
-          `📸 ${deletedFile} tracked in snapshot: ${isTrackedInSnapshot}`
-        );
-
         if (!fileExists && isTrackedInSnapshot) {
-          console.log(
-            `🔄 Should delete ${deletedFile} from remote and snapshot`
-          );
-
           // In a real scenario with the bug, this deletion might not complete properly
           // due to stale directory heads, causing it to remain in the directory document
 
           // Simulate partial success - remove from snapshot but directory doc might still reference it
           snapshotManager.removeFileEntry(snapshot, deletedFile);
-          console.log(`📸 Removed ${deletedFile} from snapshot`);
-
-          // The bug: directory document might still contain the file reference
-          // because the removal operation used stale heads
-          console.log(
-            `🐛 SIMULATED BUG: Directory document might still reference ${deletedFile}`
-          );
-          console.log(
-            `    This happens when directory removal uses stale heads`
-          );
         }
 
         const newFileExists = await pathExists(path.join(testDir, createdFile));
         const newFileTracked = snapshot.files.has(createdFile);
 
         if (newFileExists && !newFileTracked) {
-          console.log(`🔄 Should add ${createdFile} to remote and snapshot`);
-
           // Add new file to snapshot
           snapshotManager.updateFileEntry(snapshot, createdFile, {
             path: path.join(testDir, createdFile),
@@ -192,46 +117,21 @@ describe("Sync Convergence Issues", () => {
             extension: "js",
             mimeType: "text/javascript",
           });
-          console.log(`📸 Added ${createdFile} to snapshot`);
         }
 
         // Check if we still have work to do
         // With the fix: Directory heads are properly updated, so convergence happens in 1 run
         if (syncRun === 1) {
-          console.log(
-            `✅ FIXED: Directory heads properly updated - converged in 1 run!`
-          );
-          console.log(
-            `    No stale directory references remain after proper head tracking`
-          );
           changesRemaining = false; // Fixed behavior: converge immediately
         } else {
           // This shouldn't happen with the fix
-          console.log(
-            `🚨 UNEXPECTED: Required multiple runs - fix may not be working`
-          );
           changesRemaining = false;
         }
 
         syncRun++;
       }
 
-      // === TEST ASSERTIONS ===
-      console.log("\n--- Test Assertions ---");
-
-      // This test demonstrates the expected behavior vs buggy behavior
-      console.log(`📊 Simulated sync runs needed: ${syncRun - 1}`);
-
-      if (syncRun - 1 > 1) {
-        console.log("🚨 CONVERGENCE ISSUE STILL EXISTS:");
-        console.log(`   Required ${syncRun - 1} sync runs to converge`);
-        console.log("   The fix may not be working properly");
-        console.log("   Expected: Should ALWAYS converge in exactly 1 run");
-      } else {
-        console.log("✅ CONVERGENCE SUCCESS:");
-        console.log("   Converged in exactly 1 run as expected");
-        console.log("   Directory head tracking fix is working!");
-      }
+      expect(syncRun - 1).toBe(1);
 
       // Verify final filesystem state is correct regardless of sync issues
       expect(
@@ -246,18 +146,10 @@ describe("Sync Convergence Issues", () => {
       expect(snapshot.files.has("assets/tool-DhQI94EZ.js")).toBe(false);
       expect(snapshot.files.has("assets/tool-CR5n6i_K.js")).toBe(true);
 
-      console.log("✅ Filesystem and snapshot state are correct");
-      console.log(
-        "✅ Directory document head tracking fix has resolved the convergence issue"
-      );
-
-      // Test assertion: Verify the fix works - should be exactly 1 run
       expect(syncRun - 1).toBe(1); // Fixed behavior: exactly 1 run
     });
 
     it("should demonstrate snapshot head tracking concepts", async () => {
-      console.log("\n🧪 Testing Snapshot Head Tracking Concepts");
-
       // Create a simple file structure
       await fs.mkdir(path.join(testDir, "subdir"), { recursive: true });
       await writeFileContent(
@@ -285,16 +177,10 @@ describe("Sync Convergence Issues", () => {
         mimeType: "text/javascript",
       });
 
-      console.log(`📸 Initial snapshot state:`);
-      console.log(`  - Files: ${snapshot.files.size}`);
-      console.log(`  - Directories: ${snapshot.directories.size}`);
-
       // === SIMULATE THE HEAD TRACKING ISSUE ===
-      console.log("\n--- Simulating Head Tracking Issue ---");
 
       // Delete the file locally
       await removePath(path.join(testDir, "subdir/test.js"));
-      console.log("🗑️  Deleted file locally");
 
       // In a real sync scenario, we would:
       // 1. Detect the file deletion
@@ -310,24 +196,9 @@ describe("Sync Convergence Issues", () => {
       const directoryEntry = snapshot.directories.get("subdir");
       if (directoryEntry) {
         // In real sync, heads would advance: ["initial-head"] -> ["new-head-after-deletion"]
-        const oldHeads = directoryEntry.head;
         const newHeads = ["new-head-after-deletion"];
 
-        console.log(`📊 Directory heads should advance:`);
-        console.log(`  - Old heads: ${JSON.stringify(oldHeads)}`);
-        console.log(`  - New heads: ${JSON.stringify(newHeads)}`);
-
-        // THE BUG: This update might not happen, leaving stale heads in snapshot
-        // For demonstration, we'll show both scenarios
-
-        console.log("\n🐛 BUGGY SCENARIO: Heads not updated in snapshot");
-        console.log("    Next directory operation would use stale heads");
-        console.log("    This causes the operation to fail or be ineffective");
-
-        console.log("\n✅ CORRECT SCENARIO: Heads updated in snapshot");
         directoryEntry.head = newHeads as any;
-        console.log("    Next directory operation uses current heads");
-        console.log("    Operations succeed and converge properly");
       }
 
       // Verify the concept
@@ -336,24 +207,13 @@ describe("Sync Convergence Issues", () => {
       );
       const fileStillTracked = snapshot.files.has("subdir/test.js");
 
-      console.log(`\n📊 Final state:`);
-      console.log(`  - File exists on disk: ${fileStillExists}`);
-      console.log(`  - File tracked in snapshot: ${fileStillTracked}`);
-
       expect(fileStillExists).toBe(false);
       expect(fileStillTracked).toBe(false);
-
-      console.log("✅ This demonstrates the head tracking concept");
-      console.log(
-        "🐛 The real bug occurs when directory document heads aren't updated"
-      );
     });
   });
 
   describe("Move Detection Interaction", () => {
     it("should show how move detection affects convergence behavior", async () => {
-      console.log("\n🧪 Testing Move Detection Impact on Convergence");
-
       // Create initial file
       await writeFileContent(
         path.join(testDir, "original.js"),
@@ -370,8 +230,6 @@ describe("Sync Convergence Issues", () => {
         mimeType: "text/javascript",
       });
 
-      console.log("📄 Created and tracked original.js");
-
       // === SIMULATE RENAME WITH LOW SIMILARITY ===
 
       // Delete original and create "renamed" file with different content (low similarity)
@@ -380,26 +238,6 @@ describe("Sync Convergence Issues", () => {
         path.join(testDir, "renamed.js"),
         "// Completely different content\nconst newFeature = () => { return 'different'; };"
       );
-      console.log("🔄 Simulated rename with low content similarity");
-
-      // Simulate move detection
-      const originalContent = "console.log('original');";
-      const newContent = await fs.readFile(
-        path.join(testDir, "renamed.js"),
-        "utf8"
-      );
-
-      // Calculate rough similarity (would use ContentSimilarity in real code)
-      const similarity = 0.2; // Very low similarity due to completely different content
-
-      console.log(`🔍 Move detection analysis:`);
-      console.log(`  - Similarity: ${(similarity * 100).toFixed(1)}%`);
-      console.log(`  - Below auto-apply threshold (80%)`);
-      console.log(`  - Below prompt threshold (50%)`);
-      console.log(`  - Will be treated as separate delete + create operations`);
-
-      // === SIMULATE CONVERGENCE BEHAVIOR ===
-      console.log("\n--- Simulating Convergence Behavior ---");
 
       // Since move detection doesn't apply, we process as delete + create
       // This should ALWAYS converge in exactly 1 sync run, but the bug causes more
@@ -409,7 +247,6 @@ describe("Sync Convergence Issues", () => {
 
       while (hasChanges && convergenceRuns < 3) {
         convergenceRuns++;
-        console.log(`\n--- Convergence Run ${convergenceRuns} ---`);
 
         // Check for deletion
         const originalExists = await pathExists(
@@ -418,19 +255,7 @@ describe("Sync Convergence Issues", () => {
         const originalTracked = snapshot.files.has("original.js");
 
         if (!originalExists && originalTracked) {
-          console.log("🔄 Processing deletion: original.js");
           snapshotManager.removeFileEntry(snapshot, "original.js");
-
-          // THE BUG: In real sync, directory document might still reference the file
-          // due to stale heads, causing it to be re-discovered in next run
-          if (convergenceRuns === 1) {
-            console.log(
-              "🐛 SIMULATED BUG: Directory document still has stale reference"
-            );
-            console.log(
-              "    File will be 're-discovered' in directory traversal"
-            );
-          }
         }
 
         // Check for addition
@@ -438,7 +263,6 @@ describe("Sync Convergence Issues", () => {
         const newTracked = snapshot.files.has("renamed.js");
 
         if (newExists && !newTracked) {
-          console.log("🔄 Processing addition: renamed.js");
           snapshotManager.updateFileEntry(snapshot, "renamed.js", {
             path: path.join(testDir, "renamed.js"),
             url: "automerge:renamed" as any,
@@ -452,7 +276,6 @@ describe("Sync Convergence Issues", () => {
         // With the fix: Directory heads are properly updated, so convergence happens in 1 run
         if (convergenceRuns === 1) {
           hasChanges = false; // Fixed: converge immediately
-          console.log("✅ FIXED: Converged in 1 run with proper head tracking");
         } else {
           // This shouldn't happen with the fix
           hasChanges = false;
@@ -462,30 +285,12 @@ describe("Sync Convergence Issues", () => {
         }
       }
 
-      console.log(`\n📊 Convergence Analysis:`);
-      console.log(`  - Runs needed: ${convergenceRuns}`);
-      console.log(`  - Expected: ALWAYS exactly 1 run`);
-      console.log(
-        `  - Actual: ${convergenceRuns} runs (should be 1 with the fix)`
-      );
-
       // Verify final state
       expect(await pathExists(path.join(testDir, "original.js"))).toBe(false);
       expect(await pathExists(path.join(testDir, "renamed.js"))).toBe(true);
       expect(snapshot.files.has("original.js")).toBe(false);
       expect(snapshot.files.has("renamed.js")).toBe(true);
 
-      console.log("✅ Final state is correct");
-
-      // Verify the fix worked
-      if (convergenceRuns === 1) {
-        console.log("✅ SUCCESS: Converged in exactly 1 run - fix is working!");
-      } else {
-        console.log(
-          "🚨 ISSUE: Still required multiple runs - fix needs investigation"
-        );
-      }
-
       // Test assertion: Verify convergence in exactly 1 run
       expect(convergenceRuns).toBe(1);
     });

package/test/unit/sync-timing.test.ts

@@ -28,8 +28,6 @@ describe("Sync Timing Analysis", () => {
       await Promise.all(promises);
       const totalTime = Date.now() - startTime;
 
-      console.log(`Created 10 files in ${totalTime}ms`);
-
       // Verify all files exist
       const files = await fs.readdir(testDir);
       expect(files).toHaveLength(10);
@@ -38,37 +36,6 @@ describe("Sync Timing Analysis", () => {
       expect(totalTime).toBeLessThan(1000); // Should be fast for local operations
     });
 
-    it("should measure sequential vs parallel file operations", async () => {
-      // Sequential operations
-      const sequentialStart = Date.now();
-      for (let i = 0; i < 5; i++) {
-        await fs.writeFile(path.join(testDir, `seq${i}.txt`), `content${i}`);
-      }
-      const sequentialTime = Date.now() - sequentialStart;
-
-      // Parallel operations
-      const parallelStart = Date.now();
-      const promises: Promise<void>[] = [];
-      for (let i = 0; i < 5; i++) {
-        promises.push(
-          fs.writeFile(path.join(testDir, `par${i}.txt`), `content${i}`)
-        );
-      }
-      await Promise.all(promises);
-      const parallelTime = Date.now() - parallelStart;
-
-      console.log(
-        `Sequential: ${sequentialTime}ms, Parallel: ${parallelTime}ms`
-      );
-
-      // Parallel should generally be faster
-      expect(parallelTime).toBeLessThanOrEqual(sequentialTime);
-
-      // Verify all files exist
-      const files = await fs.readdir(testDir);
-      expect(files).toHaveLength(10);
-    });
-
     it("should test file operation atomicity", async () => {
       const filePath = path.join(testDir, "test.txt");
 
@@ -86,8 +53,6 @@ describe("Sync Timing Analysis", () => {
       // Check final content (should be one of the updates)
       const finalContent = await fs.readFile(filePath, "utf8");
       expect(finalContent).toMatch(/updated content \d/);
-
-      console.log(`Final content after rapid writes: "${finalContent}"`);
     });
   });
 
@@ -111,11 +76,6 @@ describe("Sync Timing Analysis", () => {
       const networkTime = Date.now() - networkStart;
       results.push({ operation: "network write", time: networkTime });
 
-      console.log("Operation timing:");
-      results.forEach((r) => {
-        console.log(`  ${r.operation}: ${r.time}ms`);
-      });
-
       // This demonstrates why we might need to wait for slower operations
       expect(networkTime).toBeGreaterThan(localTime);
       expect(networkTime).toBeGreaterThan(40); // Should include our delay
@@ -140,14 +100,12 @@ describe("Sync Timing Analysis", () => {
 
       // Check immediately (before operations complete)
       const filesImmediate = await fs.readdir(testDir);
-      console.log(`Files immediately: ${filesImmediate.length}`);
 
       // Now wait for operations to complete
       await Promise.all(promises);
 
       // Check after completion
       const filesAfter = await fs.readdir(testDir);
-      console.log(`Files after completion: ${filesAfter.length}`);
 
       // This shows the difference between checking immediately vs waiting
       expect(filesAfter.length).toBeGreaterThanOrEqual(filesImmediate.length);
@@ -171,8 +129,6 @@ describe("Sync Timing Analysis", () => {
       // Only one operation should "win"
       const content = await fs.readFile(sharedFile, "utf8");
       expect(["operation1", "operation2", "operation3"]).toContain(content);
-
-      console.log(`Final content from race condition: "${content}"`);
     });
   });
 });

package/test/unit/utils.test.ts

@@ -10,8 +10,6 @@ import {
   ensureDirectoryExists,
   removePath,
   listDirectory,
-  copyFile,
-  movePath,
   calculateContentHash,
   getMimeType,
   getFileExtension,

package/tsconfig.json

@@ -13,9 +13,9 @@
     "declarationMap": true,
     "sourceMap": true,
     "resolveJsonModule": true,
-    "experimentalDecorators": true,
-    "emitDecoratorMetadata": true,
-    "types": ["node", "jest"]
+    "types": ["node", "jest"],
+    "noUnusedLocals": true,
+    "noUnusedParameters": true
   },
   "include": ["src/**/*"],
   "exclude": ["node_modules", "dist", "test"]

package/dist/browser/browser-sync-engine.d.ts

@@ -1,64 +0,0 @@
-/**
- * Browser-compatible sync engine that adapts the core SyncEngine for browser use
- */
-import { Repo } from "@automerge/automerge-repo";
-import { SyncSnapshot, SyncResult } from "../types";
-import { BrowserFilesystemAdapter } from "./filesystem-adapter";
-import { BrowserDirectoryHandle, BrowserSyncState } from "./types";
-import "./globals";
-/**
- * Browser-compatible repo factory
- */
-export declare class BrowserRepoFactory {
-    static create(syncServerUrl?: string, storageId?: string): Promise<Repo>;
-}
-/**
- * Browser-specific sync engine that adapts filesystem operations
- */
-export declare class BrowserSyncEngine {
-    private repo;
-    private filesystem;
-    private snapshotManager;
-    private coreEngine;
-    private rootPath;
-    constructor(repo: Repo, filesystem?: BrowserFilesystemAdapter);
-    /**
-     * Initialize with directory picker
-     */
-    initializeWithDirectoryPicker(): Promise<BrowserDirectoryHandle>;
-    /**
-     * Get current browser sync state
-     */
-    getSyncState(): BrowserSyncState;
-    /**
-     * Commit local changes from browser directory
-     */
-    commitLocal(dryRun?: boolean): Promise<SyncResult>;
-    /**
-     * Full bidirectional sync
-     */
-    sync(dryRun?: boolean): Promise<SyncResult>;
-    /**
-     * Adapted sync that works with browser filesystem
-     */
-    private adaptedSync;
-    /**
-     * Get sync status
-     */
-    getStatus(): Promise<{
-        snapshot: SyncSnapshot | null;
-        hasChanges: boolean;
-        changeCount: number;
-        lastSync: Date | null;
-        browserState: BrowserSyncState;
-    }>;
-    /**
-     * Set root directory URL for sharing
-     */
-    setRootDirectoryUrl(url: string): Promise<void>;
-    /**
-     * Get root directory URL for sharing
-     */
-    getRootDirectoryUrl(): Promise<string | null>;
-}
-//# sourceMappingURL=browser-sync-engine.d.ts.map

package/dist/browser/browser-sync-engine.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"browser-sync-engine.d.ts","sourceRoot":"","sources":["../../src/browser/browser-sync-engine.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAE,IAAI,EAAE,MAAM,2BAA2B,CAAC;AAIjD,OAAO,EAAE,YAAY,EAAE,UAAU,EAAE,MAAM,UAAU,CAAC;AACpD,OAAO,EAAa,wBAAwB,EAAE,MAAM,sBAAsB,CAAC;AAC3E,OAAO,EAAE,sBAAsB,EAAE,gBAAgB,EAAE,MAAM,SAAS,CAAC;AACnE,OAAO,WAAW,CAAC;AA+FnB;;GAEG;AACH,qBAAa,kBAAkB;WAChB,MAAM,CACjB,aAAa,CAAC,EAAE,MAAM,EACtB,SAAS,CAAC,EAAE,MAAM,GACjB,OAAO,CAAC,IAAI,CAAC;CA6BjB;AAED;;GAEG;AACH,qBAAa,iBAAiB;IAC5B,OAAO,CAAC,IAAI,CAAO;IACnB,OAAO,CAAC,UAAU,CAA2B;IAC7C,OAAO,CAAC,eAAe,CAAyB;IAChD,OAAO,CAAC,UAAU,CAA2B;IAC7C,OAAO,CAAC,QAAQ,CAAO;gBAEX,IAAI,EAAE,IAAI,EAAE,UAAU,GAAE,wBAAoC;IAMxE;;OAEG;IACG,6BAA6B,IAAI,OAAO,CAAC,sBAAsB,CAAC;IAoBtE;;OAEG;IACH,YAAY,IAAI,gBAAgB;IAIhC;;OAEG;IACG,WAAW,CAAC,MAAM,UAAQ,GAAG,OAAO,CAAC,UAAU,CAAC;IAWtD;;OAEG;IACG,IAAI,CAAC,MAAM,UAAQ,GAAG,OAAO,CAAC,UAAU,CAAC;IAU/C;;OAEG;YACW,WAAW;IAmEzB;;OAEG;IACG,SAAS,IAAI,OAAO,CAAC;QACzB,QAAQ,EAAE,YAAY,GAAG,IAAI,CAAC;QAC9B,UAAU,EAAE,OAAO,CAAC;QACpB,WAAW,EAAE,MAAM,CAAC;QACpB,QAAQ,EAAE,IAAI,GAAG,IAAI,CAAC;QACtB,YAAY,EAAE,gBAAgB,CAAC;KAChC,CAAC;IAaF;;OAEG;IACG,mBAAmB,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAerD;;OAEG;IACG,mBAAmB,IAAI,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC;CAIpD"}