@ahumandev/autocode 0.0.1

package/dist/skills/test-junit/SKILL.md

@@ -0,0 +1,206 @@
+---
+name: test-junit
+description: Use this skill when writing or fixing unit tests with JUnit 5 (Java).
+---
+
+# JUnit 5 Testing Skill
+
+JUnit 5 (Jupiter) is the standard Java testing framework. It is composed of three modules: JUnit Platform, JUnit Jupiter (the API), and JUnit Vintage (for legacy JUnit 4 tests).
+
+## Detection
+
+JUnit 5 is in use when:
+- `pom.xml` includes `junit-jupiter` or `junit-jupiter-api` dependency
+- `build.gradle` includes `testImplementation 'org.junit.jupiter:junit-jupiter'`
+- Test files use `@Test` from `org.junit.jupiter.api`
+- Test files follow `*Test.java` or `*Tests.java` naming convention
+
+## File Structure
+
+```
+src/
+  main/java/com/example/
+    Foo.java               # production file
+  test/java/com/example/
+    FooTest.java           # test file (mirrors main structure)
+```
+
+## Basic Test Structure
+
+```java
+package com.example;
+
+import org.junit.jupiter.api.*;
+import static org.junit.jupiter.api.Assertions.*;
+
+class FooTest {
+
+  private Foo foo;
+
+  @BeforeEach
+  void setUp() {
+    foo = new Foo();
+  }
+
+  @AfterEach
+  void tearDown() {
+    // cleanup if needed
+  }
+
+  @Test
+  void methodName_shouldReturnExpectedValue_whenGivenValidInput() {
+    // Arrange
+    String input = "hello";
+
+    // Build
+    String result = foo.process(input);
+
+    // Assert
+    assertEquals("HELLO", result);
+  }
+
+  @Test
+  void methodName_shouldThrow_whenInputIsNull() {
+    assertThrows(IllegalArgumentException.class, () -> foo.process(null));
+  }
+}
+```
+
+## Naming Conventions
+
+Use the pattern: `methodName_shouldExpectedBehavior_whenCondition`
+
+Examples:
+- `processInput_shouldReturnUpperCase_whenGivenLowerCaseString`
+- `connect_shouldThrowException_whenHostIsUnreachable`
+- `calculate_shouldReturnZero_whenListIsEmpty`
+
+## Annotations
+
+| Annotation | Purpose |
+|---|---|
+| `@Test` | Marks a method as a test |
+| `@BeforeEach` | Run before each test method |
+| `@AfterEach` | Run after each test method |
+| `@BeforeAll` | Run once before all tests (must be `static`) |
+| `@AfterAll` | Run once after all tests (must be `static`) |
+| `@Disabled` | Skip a test (add reason as value) |
+| `@DisplayName` | Human-readable test name |
+| `@Nested` | Nested test class for grouping |
+| `@ParameterizedTest` | Run test with multiple inputs |
+
+## Common Assertions
+
+```java
+assertEquals(expected, actual)
+assertEquals(expected, actual, "message on failure")
+assertNotEquals(unexpected, actual)
+assertNull(value)
+assertNotNull(value)
+assertTrue(condition)
+assertFalse(condition)
+assertThrows(ExpectedException.class, () -> { code(); })
+assertDoesNotThrow(() -> { code(); })
+assertAll(
+  () -> assertEquals(1, a),
+  () -> assertEquals(2, b)
+)
+```
+
+## Parameterized Tests
+
+```java
+@ParameterizedTest
+@ValueSource(strings = { "hello", "world", "foo" })
+void isNonEmpty_shouldReturnTrue_whenGivenNonEmptyString(String input) {
+  assertTrue(StringUtil.isNonEmpty(input));
+}
+
+@ParameterizedTest
+@CsvSource({ "1, 1, 2", "2, 3, 5", "0, 0, 0" })
+void add_shouldReturnSum(int a, int b, int expected) {
+  assertEquals(expected, calculator.add(a, b));
+}
+
+@ParameterizedTest
+@MethodSource("provideInputs")
+void process_shouldHandleAllCases(String input, String expected) {
+  assertEquals(expected, foo.process(input));
+}
+
+static Stream<Arguments> provideInputs() {
+  return Stream.of(
+    Arguments.of("hello", "HELLO"),
+    Arguments.of("", "")
+  );
+}
+```
+
+## Nested Tests
+
+```java
+@Nested
+@DisplayName("when input is valid")
+class WhenInputIsValid {
+
+  @Test
+  void shouldReturnResult() { ... }
+
+  @Test
+  void shouldNotThrow() { ... }
+}
+
+@Nested
+@DisplayName("when input is null")
+class WhenInputIsNull {
+
+  @Test
+  void shouldThrowIllegalArgument() { ... }
+}
+```
+
+## Running Tests
+
+```bash
+# Maven
+mvn test
+
+# Run a specific test class
+mvn test -Dtest=FooTest
+
+# Run a specific method
+mvn test -Dtest=FooTest#methodName
+
+# Gradle
+./gradlew test
+
+# Run specific test
+./gradlew test --tests "com.example.FooTest"
+```
+
+## pom.xml Dependency
+
+```xml
+<dependency>
+  <groupId>org.junit.jupiter</groupId>
+  <artifactId>junit-jupiter</artifactId>
+  <version>5.10.0</version>
+  <scope>test</scope>
+</dependency>
+```
+
+Also ensure the Surefire plugin version supports JUnit 5:
+```xml
+<plugin>
+  <groupId>org.apache.maven.plugins</groupId>
+  <artifactId>maven-surefire-plugin</artifactId>
+  <version>3.1.2</version>
+</plugin>
+```
+
+## Common Pitfalls
+
+- `@BeforeAll` / `@AfterAll` methods must be `static` unless `@TestInstance(Lifecycle.PER_CLASS)` is used
+- JUnit 5 test classes and methods do NOT need to be `public` — package-private is preferred
+- `assertThrows` returns the thrown exception — use it to assert the exception message too: `assertEquals("msg", ex.getMessage())`
+- Do not mix JUnit 4 (`org.junit.*`) and JUnit 5 (`org.junit.jupiter.*`) imports in the same file

package/dist/skills/test-mockito/SKILL.md

@@ -0,0 +1,209 @@
+---
+name: test-mockito
+description: Use this skill when writing or fixing unit tests that use Mockito for mocking in Java.
+---
+
+# Mockito Testing Skill
+
+Mockito is the standard Java mocking framework, used alongside JUnit 5 to isolate the unit under test by replacing dependencies with controlled test doubles.
+
+## Detection
+
+Mockito is in use when:
+- `pom.xml` includes `mockito-core` or `mockito-junit-jupiter`
+- `build.gradle` includes `testImplementation 'org.mockito:mockito-core'`
+- Test files import from `org.mockito.*`
+
+## Setup with JUnit 5
+
+Use `@ExtendWith(MockitoExtension.class)` to automatically initialize mocks and verify interactions after each test:
+
+```java
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.junit.jupiter.MockitoExtension;
+import static org.mockito.Mockito.*;
+import static org.junit.jupiter.api.Assertions.*;
+
+@ExtendWith(MockitoExtension.class)
+class OrderServiceTest {
+
+  @Mock
+  private PaymentGateway paymentGateway;
+
+  @Mock
+  private InventoryRepository inventoryRepository;
+
+  @InjectMocks
+  private OrderService orderService;  // Mockito injects the mocks above
+
+  @Test
+  void processOrder_shouldChargePayment_whenItemsAreInStock() {
+    // Arrange
+    when(inventoryRepository.isInStock("ITEM-1")).thenReturn(true);
+    when(paymentGateway.charge(100.0)).thenReturn(new PaymentResult(true));
+
+    // Build
+    boolean result = orderService.processOrder("ITEM-1", 100.0);
+
+    // Assert
+    assertTrue(result);
+    verify(paymentGateway).charge(100.0);
+  }
+}
+```
+
+## Annotations
+
+| Annotation | Purpose |
+|---|---|
+| `@Mock` | Creates a mock of the type |
+| `@InjectMocks` | Creates instance and injects `@Mock` fields |
+| `@Spy` | Wraps a real object, allows partial mocking |
+| `@Captor` | Captures argument passed to a mock |
+| `@ExtendWith(MockitoExtension.class)` | Enables annotation-based mock init |
+
+## Stubbing (when/thenReturn)
+
+```java
+// Return a value
+when(mock.method()).thenReturn("value")
+
+// Return different values on consecutive calls
+when(mock.method())
+  .thenReturn("first")
+  .thenReturn("second")
+  .thenReturn("third")
+
+// Throw an exception
+when(mock.method()).thenThrow(new RuntimeException("error"))
+
+// Return void method throwing
+doThrow(new RuntimeException()).when(mock).voidMethod()
+
+// Execute custom logic
+when(mock.method(any())).thenAnswer(invocation -> {
+  String arg = invocation.getArgument(0);
+  return arg.toUpperCase();
+})
+```
+
+## Argument Matchers
+
+```java
+when(mock.method(any()))                     // any non-null object
+when(mock.method(anyString()))               // any String
+when(mock.method(anyInt()))                  // any int
+when(mock.method(eq("exact")))               // exact value
+when(mock.method(isNull()))                  // null
+when(mock.method(argThat(s -> s.length() > 3)))  // custom predicate
+
+// IMPORTANT: if using matchers, ALL arguments must use matchers
+when(mock.method(eq("key"), anyInt()))       // correct
+when(mock.method("key", anyInt()))           // WRONG — mix not allowed
+```
+
+## Verification
+
+```java
+// Verify called once
+verify(mock).method("arg")
+
+// Verify exact number of calls
+verify(mock, times(3)).method()
+
+// Verify never called
+verify(mock, never()).method()
+
+// Verify at least / at most
+verify(mock, atLeast(1)).method()
+verify(mock, atMost(2)).method()
+
+// Verify no other interactions after verified ones
+verifyNoMoreInteractions(mock)
+
+// Verify nothing was ever called
+verifyNoInteractions(mock)
+```
+
+## Argument Captors
+
+```java
+@Captor
+private ArgumentCaptor<String> captor;
+
+@Test
+void shouldPassCorrectArgumentToService() {
+  orderService.submit("order-1");
+
+  verify(emailService).sendConfirmation(captor.capture());
+  assertEquals("order-1", captor.getValue());
+}
+```
+
+## Spy (Partial Mock)
+
+Use `@Spy` or `spy()` when you want a real object but need to stub specific methods:
+
+```java
+@Spy
+private List<String> spyList = new ArrayList<>();
+
+@Test
+void shouldUseRealImplementationExceptStubbedMethod() {
+  doReturn(42).when(spyList).size();  // stub one method
+
+  spyList.add("hello");              // real add
+  assertEquals(42, spyList.size())   // stubbed size
+  assertEquals("hello", spyList.get(0))  // real get
+}
+```
+
+## Void Methods
+
+```java
+// Do nothing (default for void mocks, but explicit)
+doNothing().when(mock).voidMethod()
+
+// Throw from void method
+doThrow(new RuntimeException()).when(mock).voidMethod()
+
+// Execute custom logic for void method
+doAnswer(invocation -> {
+  System.out.println("called");
+  return null;
+}).when(mock).voidMethod()
+```
+
+## Static Methods (Mockito 3.4+)
+
+```java
+try (MockedStatic<Utilities> mocked = mockStatic(Utilities.class)) {
+  mocked.when(Utilities::generateId).thenReturn("test-id");
+  assertEquals("test-id", Utilities.generateId());
+}
+```
+
+## pom.xml Dependency
+
+```xml
+<dependency>
+  <groupId>org.mockito</groupId>
+  <artifactId>mockito-junit-jupiter</artifactId>
+  <version>5.5.0</version>
+  <scope>test</scope>
+</dependency>
+```
+
+`mockito-junit-jupiter` includes `mockito-core` — no need to add both.
+
+## Common Pitfalls
+
+- **Don't stub what you don't verify** — unnecessary stubbing causes `UnnecessaryStubbingException` with `MockitoExtension`
+- **Argument matcher mixing** — if one argument uses a matcher (`any()`), ALL arguments must use matchers
+- **`@InjectMocks` limitations** — constructor injection is preferred; if the class has no single matching constructor, injection may silently fail
+- **Verify after build** — `verify()` calls go AFTER the method call being tested, not before
+- **Don't mock value objects** — mock services, repositories, gateways; use real instances for simple data objects
+- **`spy` on final classes** — not supported by default; enable with Mockito extensions or use a wrapper

package/dist/skills/test-vitest/SKILL.md

@@ -0,0 +1,159 @@
+---
+name: test-vitest
+description: Use this skill when writing or fixing unit tests with Vitest (TypeScript/JavaScript).
+---
+
+# Vitest Testing Skill
+
+Vitest is the recommended test framework for TypeScript/JavaScript projects using Vite. It provides Jest-compatible APIs with first-class ESM support.
+
+## Detection
+
+Vitest is in use when:
+- `package.json` devDependencies includes `vitest`
+- A `vitest.config.ts` or `vitest.config.js` exists
+- Test files use `.spec.ts` or `.test.ts` extensions with `import { describe, it, expect } from 'vitest'`
+
+## File Structure
+
+```
+src/
+  foo.ts                  # production file
+  foo.spec.ts             # test file (co-located)
+  # OR
+  __tests__/
+    foo.test.ts           # alternative location
+```
+
+Place test files co-located with production files unless the project uses a separate `__tests__/` directory — match the existing convention.
+
+## Basic Test Structure
+
+```typescript
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest'
+import { myFunction } from './myModule'
+
+describe('myModule', () => {
+  beforeEach(() => {
+    vi.clearAllMocks()
+  })
+
+  describe('myFunction', () => {
+    it('should return expected value for valid input', () => {
+      // Arrange
+      const input = 'hello'
+
+      // Build
+      const result = myFunction(input)
+
+      // Assert
+      expect(result).toBe('HELLO')
+    })
+
+    it('should throw for invalid input', () => {
+      expect(() => myFunction(null)).toThrow('Input must not be null')
+    })
+  })
+})
+```
+
+## Mocking
+
+### Mock a module
+```typescript
+vi.mock('./dependency', () => ({
+  fetchData: vi.fn().mockResolvedValue({ id: 1, name: 'test' }),
+}))
+```
+
+### Mock a function
+```typescript
+const mockFn = vi.fn().mockReturnValue(42)
+const mockAsync = vi.fn().mockResolvedValue({ ok: true })
+const mockRejected = vi.fn().mockRejectedValue(new Error('fail'))
+```
+
+### Spy on a method
+```typescript
+const spy = vi.spyOn(obj, 'method').mockReturnValue('mocked')
+```
+
+### Reset mocks between tests
+```typescript
+beforeEach(() => {
+  vi.clearAllMocks()    // clear call history
+  vi.resetAllMocks()    // clear call history + reset implementations
+  vi.restoreAllMocks()  // restore original implementations
+})
+```
+
+## Async Tests
+
+```typescript
+it('should resolve promise', async () => {
+  const result = await someAsyncFunction()
+  expect(result).toEqual({ success: true })
+})
+
+it('should reject promise', async () => {
+  await expect(someAsyncFunction()).rejects.toThrow('error message')
+})
+```
+
+## Common Assertions
+
+```typescript
+expect(value).toBe(42)                     // strict equality
+expect(value).toEqual({ a: 1 })            // deep equality
+expect(value).toBeNull()
+expect(value).toBeUndefined()
+expect(value).toBeTruthy()
+expect(value).toBeFalsy()
+expect(array).toHaveLength(3)
+expect(array).toContain('item')
+expect(object).toHaveProperty('key', 'value')
+expect(fn).toHaveBeenCalledWith('arg')
+expect(fn).toHaveBeenCalledTimes(2)
+expect(fn).not.toHaveBeenCalled()
+```
+
+## Running Tests
+
+```bash
+# Run all tests once
+npx vitest run
+
+# Run with coverage
+npx vitest run --coverage
+
+# Run specific file
+npx vitest run src/foo.spec.ts
+
+# Watch mode (development)
+npx vitest
+```
+
+## Coverage
+
+Vitest uses `@vitest/coverage-v8` or `@vitest/coverage-istanbul`. Configure in `vitest.config.ts`:
+
+```typescript
+export default defineConfig({
+  test: {
+    coverage: {
+      provider: 'v8',
+      reporter: ['text', 'lcov'],
+      exclude: ['**/*.spec.ts', '**/*.test.ts', '**/node_modules/**'],
+    },
+  },
+})
+```
+
+Run with: `npx vitest run --coverage`
+
+## Common Pitfalls
+
+- Always call `vi.clearAllMocks()` in `beforeEach` to prevent test pollution
+- Use `vi.mock()` at the top level of the file (not inside `describe`/`it` blocks) — Vitest hoists mock calls
+- For ESM modules, prefer `vi.mock()` with factory functions over `jest.spyOn` patterns
+- When mocking the same module across multiple test files, each file gets its own isolated mock

package/dist/tools/autocode_agent_swap.d.ts

@@ -0,0 +1,13 @@
+import type { OpencodeClient } from "@opencode-ai/sdk";
+export declare function createAutocodeAgentSwapTool(client?: OpencodeClient): {
+    description: string;
+    args: {
+        agent: import("zod").ZodString;
+        prompt: import("zod").ZodString;
+    };
+    execute(args: {
+        agent: string;
+        prompt: string;
+    }, context: import("@opencode-ai/plugin").ToolContext): Promise<import("@opencode-ai/plugin").ToolResult>;
+};
+//# sourceMappingURL=autocode_agent_swap.d.ts.map

package/dist/tools/autocode_agent_swap.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"autocode_agent_swap.d.ts","sourceRoot":"","sources":["../../src/tools/autocode_agent_swap.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAA;AAItD,wBAAgB,2BAA2B,CAAC,MAAM,CAAC,EAAE,cAAc;;;;;;;;;;EA8ClE"}

package/dist/tools/autocode_agent_swap.test.d.ts

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

package/dist/tools/autocode_agent_swap.test.d.ts.map

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

package/dist/tools/autocode_concept_create.d.ts

@@ -0,0 +1,23 @@
+import type { OpencodeClient } from "@opencode-ai/sdk";
+type FileSystem = {
+    mkdir: (dirPath: string, options?: {
+        recursive?: boolean;
+    }) => Promise<string | undefined | void>;
+    stat: (filePath: string) => Promise<{
+        mtimeMs: number;
+    }>;
+    writeFile: (filePath: string, content: string) => Promise<void>;
+};
+export declare function createAutocodeConceptCreateTool(client?: OpencodeClient, fileSystem?: FileSystem, getNow?: () => Date): {
+    description: string;
+    args: {
+        label: import("zod").ZodOptional<import("zod").ZodString>;
+        concept: import("zod").ZodString;
+    };
+    execute(args: {
+        concept: string;
+        label?: string | undefined;
+    }, context: import("@opencode-ai/plugin").ToolContext): Promise<import("@opencode-ai/plugin").ToolResult>;
+};
+export {};
+//# sourceMappingURL=autocode_concept_create.d.ts.map

package/dist/tools/autocode_concept_create.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"autocode_concept_create.d.ts","sourceRoot":"","sources":["../../src/tools/autocode_concept_create.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAA;AAMtD,KAAK,UAAU,GAAG;IACd,KAAK,EAAE,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE;QAAE,SAAS,CAAC,EAAE,OAAO,CAAA;KAAE,KAAK,OAAO,CAAC,MAAM,GAAG,SAAS,GAAG,IAAI,CAAC,CAAA;IACjG,IAAI,EAAE,CAAC,QAAQ,EAAE,MAAM,KAAK,OAAO,CAAC;QAAE,OAAO,EAAE,MAAM,CAAA;KAAE,CAAC,CAAA;IACxD,SAAS,EAAE,CAAC,QAAQ,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,CAAA;CAClE,CAAA;AAqED,wBAAgB,+BAA+B,CAC3C,MAAM,CAAC,EAAE,cAAc,EACvB,UAAU,GAAE,UAA8B,EAC1C,MAAM,GAAE,MAAM,IAAuB;;;;;;;;;;EA4DxC"}

package/dist/tools/autocode_concept_list.d.ts

@@ -0,0 +1,14 @@
+import type { Dirent } from "fs";
+type FileSystem = {
+    readdir: (filePath: string, options: {
+        withFileTypes: true;
+    }) => Promise<Dirent[]>;
+    readFile: (filePath: string, encoding: "utf8") => Promise<string>;
+};
+export declare function createAutocodeConceptListTool(fileSystem?: FileSystem): {
+    description: string;
+    args: {};
+    execute(args: Record<string, never>, context: import("@opencode-ai/plugin").ToolContext): Promise<import("@opencode-ai/plugin").ToolResult>;
+};
+export {};
+//# sourceMappingURL=autocode_concept_list.d.ts.map

package/dist/tools/autocode_concept_list.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"autocode_concept_list.d.ts","sourceRoot":"","sources":["../../src/tools/autocode_concept_list.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,IAAI,CAAA;AAMhC,KAAK,UAAU,GAAG;IACd,OAAO,EAAE,CAAC,QAAQ,EAAE,MAAM,EAAE,OAAO,EAAE;QAAE,aAAa,EAAE,IAAI,CAAA;KAAE,KAAK,OAAO,CAAC,MAAM,EAAE,CAAC,CAAA;IAClF,QAAQ,EAAE,CAAC,QAAQ,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,KAAK,OAAO,CAAC,MAAM,CAAC,CAAA;CACpE,CAAA;AAsBD,wBAAgB,6BAA6B,CAAC,UAAU,GAAE,UAA8B;;;;EA2BvF"}

package/dist/tools/autocode_concept_read.d.ts

@@ -0,0 +1,20 @@
+import type { OpencodeClient } from "@opencode-ai/sdk";
+type FileSystem = {
+    mkdir?: (dirPath: string, options?: {
+        recursive?: boolean;
+    }) => Promise<string | undefined | void>;
+    readFile: (filePath: string, encoding: "utf8") => Promise<string>;
+    rename?: (oldPath: string, newPath: string) => Promise<void>;
+    writeFile?: (filePath: string, content: string) => Promise<void>;
+};
+export declare function createAutocodeConceptReadTool(clientOrFileSystem?: OpencodeClient | FileSystem, maybeFileSystem?: FileSystem): {
+    description: string;
+    args: {
+        label: import("zod").ZodString;
+    };
+    execute(args: {
+        label: string;
+    }, context: import("@opencode-ai/plugin").ToolContext): Promise<import("@opencode-ai/plugin").ToolResult>;
+};
+export {};
+//# sourceMappingURL=autocode_concept_read.d.ts.map

package/dist/tools/autocode_concept_read.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"autocode_concept_read.d.ts","sourceRoot":"","sources":["../../src/tools/autocode_concept_read.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAA;AAOtD,KAAK,UAAU,GAAG;IACd,KAAK,CAAC,EAAE,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE;QAAE,SAAS,CAAC,EAAE,OAAO,CAAA;KAAE,KAAK,OAAO,CAAC,MAAM,GAAG,SAAS,GAAG,IAAI,CAAC,CAAA;IAClG,QAAQ,EAAE,CAAC,QAAQ,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,KAAK,OAAO,CAAC,MAAM,CAAC,CAAA;IACjE,MAAM,CAAC,EAAE,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,CAAA;IAC5D,SAAS,CAAC,EAAE,CAAC,QAAQ,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,CAAA;CACnE,CAAA;AA6BD,wBAAgB,6BAA6B,CAAC,kBAAkB,CAAC,EAAE,cAAc,GAAG,UAAU,EAAE,eAAe,CAAC,EAAE,UAAU;;;;;;;;EAmC3H"}