@nexical/cli 0.11.10 → 0.11.14

package/test/unit/commands/module/list.test.ts

@@ -130,4 +130,209 @@ describe('ModuleListCommand', () => {
       { name: 'mod-a', type: 'backend', version: 'unknown', description: '' },
     ]);
   });
+  it('should handle missing metadata files', async () => {
+    (fs.pathExists as unknown as { mockImplementation: any }).mockImplementation((p: string) => {
+      if (p.includes('apps/backend/modules')) return true; // loc.path exists
+      return false; // metadata files don't exist
+    });
+    (fs.readdir as unknown as { mockImplementation: any }).mockImplementation((p: string) => {
+      if (p.includes('apps/backend/modules')) return ['mod-no-meta'];
+      return [];
+    });
+    (fs.stat as unknown as { mockResolvedValue: any }).mockResolvedValue({
+      isDirectory: () => true,
+    });
+
+    await command.run();
+    // eslint-disable-next-line no-console
+    expect(console.table).toHaveBeenCalledWith([
+      { name: 'mod-no-meta', type: 'backend', version: 'unknown', description: '' },
+    ]);
+  });
+
+  it('should support .yml extension for module config', async () => {
+    (fs.pathExists as unknown as { mockImplementation: any }).mockImplementation((p: string) => {
+      const pStr = p.toString();
+      if (
+        pStr.endsWith('backend/modules') ||
+        pStr.endsWith('frontend/modules') ||
+        pStr.endsWith('legacy/modules')
+      )
+        return true;
+      if (pStr.endsWith('yml-mod')) return true;
+      if (pStr.endsWith('module.yml')) return true;
+      if (pStr.endsWith('module.yaml')) return false;
+      if (pStr.endsWith('package.json')) return false;
+      return false;
+    });
+    (fs.readdir as unknown as { mockImplementation: any }).mockImplementation((p: string) => {
+      if (p.includes('apps/backend/modules')) return ['yml-mod'];
+      return [];
+    });
+    (fs.stat as unknown as { mockResolvedValue: any }).mockResolvedValue({
+      isDirectory: () => true,
+    });
+    (fs.readFile as unknown as { mockImplementation: any }).mockImplementation((p: string) => {
+      if (p.endsWith('module.yml')) return 'name: YmlName\nversion: 1.2.3';
+      return '';
+    });
+
+    await command.run();
+    // eslint-disable-next-line no-console
+    expect(console.table).toHaveBeenCalledWith([
+      { name: 'YmlName', type: 'backend', version: '1.2.3', description: '' },
+    ]);
+  });
+  it('should handle both .yaml and .yml existing (favoring .yaml)', async () => {
+    (fs.pathExists as unknown as { mockImplementation: any }).mockImplementation((p: string) => {
+      const pStr = p.toString();
+      if (
+        pStr.endsWith('backend/modules') ||
+        pStr.endsWith('frontend/modules') ||
+        pStr.endsWith('legacy/modules')
+      )
+        return true;
+      if (pStr.endsWith('dual-mod')) return true;
+      if (pStr.endsWith('module.yaml')) return true;
+      if (pStr.endsWith('module.yml')) return true;
+      return false;
+    });
+    (fs.readdir as unknown as { mockImplementation: any }).mockImplementation((p: string) => {
+      if (p.includes('apps/backend/modules')) return ['dual-mod'];
+      return [];
+    });
+    (fs.stat as unknown as { mockResolvedValue: any }).mockResolvedValue({
+      isDirectory: () => true,
+    });
+    (fs.readFile as unknown as { mockImplementation: any }).mockImplementation((p: string) => {
+      if (p.endsWith('module.yaml')) return 'name: YamlName';
+      if (p.endsWith('module.yml')) return 'name: YmlName';
+      return '';
+    });
+
+    await command.run();
+    // eslint-disable-next-line no-console
+    expect(console.table).toHaveBeenCalledWith(
+      expect.arrayContaining([expect.objectContaining({ name: 'YamlName' })]),
+    );
+  });
+  it('should handle only .yaml existing', async () => {
+    (fs.pathExists as unknown as { mockImplementation: any }).mockImplementation((p: string) => {
+      const pStr = p.toString();
+      if (pStr.endsWith('backend/modules')) return true;
+      if (pStr.endsWith('yaml-only')) return true;
+      if (pStr.endsWith('module.yaml')) return true;
+      if (pStr.endsWith('module.yml')) return false;
+      return false;
+    });
+    (fs.readdir as unknown as { mockImplementation: any }).mockImplementation((p: string) => {
+      if (p.includes('apps/backend/modules')) return ['yaml-only'];
+      return [];
+    });
+    (fs.stat as unknown as { mockResolvedValue: any }).mockResolvedValue({
+      isDirectory: () => true,
+    });
+    (fs.readFile as any).mockResolvedValue('name: YamlOnly');
+    await command.run();
+    expect(console.table).toHaveBeenCalledWith(
+      expect.arrayContaining([expect.objectContaining({ name: 'YamlOnly' })]),
+    );
+  });
+
+  it('should handle both .yaml and .yml missing', async () => {
+    (fs.pathExists as any).mockResolvedValue(false);
+    (fs.readdir as any).mockImplementation((p: string) => {
+      if (p.includes('modules')) return ['no-config'];
+      return [];
+    });
+    (fs.stat as any).mockResolvedValue({ isDirectory: () => true });
+    await command.run();
+    // Should skip it and NOT call console.table since length 0
+    expect(console.table).not.toHaveBeenCalled();
+  });
+  it('should handle all 8 permutations of metadata existence', async () => {
+    const mods = [
+      { id: 't-t-t', pkg: true, yaml: true, yml: true },
+      { id: 't-t-f', pkg: true, yaml: true, yml: false },
+      { id: 't-f-t', pkg: true, yaml: false, yml: true },
+      { id: 't-f-f', pkg: true, yaml: false, yml: false },
+      { id: 'f-t-t', pkg: false, yaml: true, yml: true },
+      { id: 'f-t-f', pkg: false, yaml: true, yml: false },
+      { id: 'f-f-t', pkg: false, yaml: false, yml: true },
+      { id: 'f-f-f', pkg: false, yaml: false, yml: false },
+    ];
+
+    (fs.pathExists as any).mockImplementation((p: string) => {
+      const pStr = p.toString();
+      if (pStr.endsWith('modules')) return true;
+      const mod = mods.find((m) => pStr.includes(m.id));
+      if (!mod) return false;
+      if (pStr.endsWith('package.json')) return mod.pkg;
+      if (pStr.endsWith('module.yaml')) return mod.yaml;
+      if (pStr.endsWith('module.yml')) return mod.yml;
+      return true; // The directory itself
+    });
+
+    (fs.readdir as any).mockImplementation((p: string) => {
+      if (p.includes('apps/backend/modules')) return mods.map((m) => m.id);
+      return [];
+    });
+    (fs.stat as any).mockResolvedValue({ isDirectory: () => true });
+
+    (fs.readJson as any).mockImplementation((p: string) => {
+      const mod = mods.find((m) => p.includes(m.id));
+      if (mod?.pkg) return { version: `pkg-${mod.id}` };
+      return {};
+    });
+
+    (fs.readFile as any).mockImplementation((p: string) => {
+      const mod = mods.find((m) => p.includes(m.id));
+      if (!mod) return '';
+      const isYaml = p.endsWith('module.yaml');
+      const name = isYaml ? `yaml-${mod.id}` : `yml-${mod.id}`;
+      const version = isYaml ? `v-yaml-${mod.id}` : `v-yml-${mod.id}`;
+      return `name: ${name}\nversion: ${version}`;
+    });
+
+    await command.run();
+
+    // Verify specific precedence
+    expect(console.table).toHaveBeenCalledWith(
+      expect.arrayContaining([
+        expect.objectContaining({ name: 'yaml-t-t-t', version: 'pkg-t-t-t' }), // pkg version precedence, yaml name precedence
+        expect.objectContaining({ name: 'yml-f-f-t', version: 'v-yml-f-f-t' }), // yml used if yaml/pkg missing
+        expect.objectContaining({ name: 'f-f-f', version: 'unknown' }), // none
+      ]),
+    );
+  });
+
+  it('should cover catch blocks and falsy returns in all paths', async () => {
+    (fs.pathExists as any).mockImplementation((p: string) => {
+      const pStr = p.toString();
+      if (pStr.includes('apps/backend/modules')) return true;
+      return true; // Every candidate exists to trigger catch blocks
+    });
+    (fs.readdir as any).mockImplementation((p: string) => {
+      if (p.includes('apps/backend/modules')) return ['fail-json', 'fail-yaml'];
+      return [];
+    });
+    (fs.stat as any).mockResolvedValue({ isDirectory: () => true });
+
+    (fs.readJson as any).mockImplementation((p: string) => {
+      if (p.includes('fail-json')) throw new Error('json fail');
+      return null;
+    });
+    (fs.readFile as any).mockImplementation((p: string) => {
+      if (p.includes('fail-yaml')) throw new Error('yaml fail');
+      return '';
+    });
+
+    await command.run();
+    expect(console.table).toHaveBeenCalledWith(
+      expect.arrayContaining([
+        expect.objectContaining({ name: 'fail-json', version: 'unknown' }),
+        expect.objectContaining({ name: 'fail-yaml', version: 'unknown' }),
+      ]),
+    );
+  });
 });

package/test/unit/commands/module/remove.test.ts

@@ -178,4 +178,34 @@ describe('ModuleRemoveCommand', () => {
     expect(fs.readFile).not.toHaveBeenCalled();
     expect(command.success).toHaveBeenCalledWith(expect.stringContaining('removed successfully'));
   });
+  it('should handle missing modules key in config', async () => {
+    (fs.pathExists as any).mockImplementation((p: string) => true);
+    (fs.readFile as any).mockResolvedValue('key: value');
+
+    await command.run({ name: 'test-mod' });
+    expect(fs.writeFile).not.toHaveBeenCalled();
+  });
+
+  it('should do nothing if module not found in config lists', async () => {
+    (fs.pathExists as any).mockImplementation((p: string) => true);
+    (fs.readFile as any).mockResolvedValue('modules:\n  backend:\n    - existing-mod');
+
+    await command.run({ name: 'other-mod' });
+    expect(fs.writeFile).not.toHaveBeenCalled();
+  });
+
+  it('should handle empty or null config from YAML.parse', async () => {
+    (fs.pathExists as any).mockImplementation((p: string) => true);
+    (fs.readFile as any).mockResolvedValue(''); // YAML.parse('') -> null
+
+    await command.run({ name: 'test-mod' });
+    expect(fs.writeFile).not.toHaveBeenCalled();
+  });
+  it('should handle legacy array without the module to remove', async () => {
+    (fs.pathExists as any).mockImplementation((p: string) => true);
+    (fs.readFile as any).mockResolvedValue('modules:\n  - other-mod');
+
+    await command.run({ name: 'test-mod' });
+    expect(fs.writeFile).not.toHaveBeenCalled();
+  });
 });

package/test/unit/commands/run.test.ts

@@ -316,4 +316,11 @@ describe('RunCommand', () => {
       expect.stringContaining('Failed to read package.json at /mock/root: String error'),
     );
   });
+
+  it('should error if module not found', async () => {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    (fs.pathExists as unknown as { mockResolvedValue: any }).mockResolvedValue(false);
+    await command.run({ script: 'nonexistent:sync', args: [] });
+    expect(command.error).toHaveBeenCalledWith('Module nonexistent not found.');
+  });
 });

package/test/unit/commands/setup.test.ts

@@ -103,7 +103,7 @@ describe('SetupCommand', () => {
     vi.mocked(fs.lstatSync).mockReturnValue({ isSymbolicLink: () => true } as unknown as any);
 
     const error = new Error('Permission denied');
-     
+
     (error as unknown as { code: string }).code = 'EACCES';
     vi.mocked(fs.removeSync).mockImplementationOnce(() => {
       throw error;
@@ -114,6 +114,48 @@ describe('SetupCommand', () => {
     expect(command.error).toHaveBeenCalledWith(expect.stringContaining('Failed to symlink'));
   });
 
+  it('should ignore ENOENT error during removal', async () => {
+    vi.mocked(fs.existsSync).mockReturnValue(true);
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    vi.mocked(fs.lstatSync).mockReturnValue({ isSymbolicLink: () => true } as unknown as any);
+
+    const error = new Error('Not found');
+    (error as unknown as { code: string }).code = 'ENOENT';
+    vi.mocked(fs.removeSync).mockImplementationOnce(() => {
+      throw error;
+    });
+
+    await command.run();
+
+    // Should not log error in outer block as it was re-thrown only for non-ENOENT
+    // Wait, if it's NOT re-thrown (ENOENT), it continues to symlink.
+    expect(fs.symlink).toHaveBeenCalled();
+  });
+
+  it('should re-throw non-object as error during removal', async () => {
+    vi.mocked(fs.existsSync).mockReturnValue(true);
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    vi.mocked(fs.lstatSync).mockReturnValue({ isSymbolicLink: () => true } as unknown as any);
+    vi.mocked(fs.removeSync).mockImplementationOnce(() => {
+      throw 'string fail';
+    });
+
+    await command.run();
+    expect(command.error).toHaveBeenCalledWith(expect.stringContaining('string fail'));
+  });
+
+  it('should re-throw error without code during removal', async () => {
+    vi.mocked(fs.existsSync).mockReturnValue(true);
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    vi.mocked(fs.lstatSync).mockReturnValue({ isSymbolicLink: () => true } as unknown as any);
+    vi.mocked(fs.removeSync).mockImplementationOnce(() => {
+      throw new Error('No code');
+    });
+
+    await command.run();
+    expect(command.error).toHaveBeenCalledWith(expect.stringContaining('No code'));
+  });
+
   it('should log error if symlink fails with Error object', async () => {
     vi.mocked(fs.existsSync).mockReturnValue(true);
     // eslint-disable-next-line @typescript-eslint/no-explicit-any

package/test/unit/deploy/registry.test.ts

@@ -223,5 +223,46 @@ describe('ProviderRegistry', () => {
         expect.stringContaining('Failed to load local provider'),
       );
     });
+
+    it('should handle non-Error exceptions when loading local provider', async () => {
+      const mockRoot = '/mock/root';
+      vi.spyOn(fs, 'readdir').mockResolvedValue(['broken.ts'] as any);
+      mockJitiRequest.mockRejectedValue('String fail');
+
+      await registry.loadLocalProviders(mockRoot);
+      expect(logger.warn).toHaveBeenCalledWith(
+        expect.stringContaining('Failed to load local provider from broken.ts: String fail'),
+      );
+    });
+  });
+
+  describe('Core non-Error cases', () => {
+    it('should handle non-Error in loadCoreProviders readdir', async () => {
+      vi.spyOn(fs, 'access').mockResolvedValue(undefined);
+      vi.spyOn(fs, 'readdir').mockRejectedValue('Readdir string fail');
+      await registry.loadCoreProviders();
+      expect(logger.warn).toHaveBeenCalledWith(expect.stringContaining('Readdir string fail'));
+    });
+
+    it('should handle non-Error during registration in loadCoreProviders', async () => {
+      vi.spyOn(fs, 'access').mockResolvedValue(undefined);
+      vi.spyOn(fs, 'readdir').mockResolvedValue(['fail-registration.js'] as any);
+
+      // Mock registerProviderFromModule to throw a string
+      const regSpy = vi
+        .spyOn(registry as any, 'registerProviderFromModule')
+        .mockImplementation(() => {
+          throw 'Registration string fail';
+        });
+
+      // Mock path.join to return a known string for vi.doMock
+      vi.spyOn(path, 'join').mockReturnValue('MOCK_REG_FAIL');
+      vi.doMock('MOCK_REG_FAIL', () => ({ default: {} }));
+
+      await registry.loadCoreProviders();
+      expect(logger.warn).toHaveBeenCalledWith(expect.stringContaining('Registration string fail'));
+
+      regSpy.mockRestore();
+    });
   });
 });

package/test/unit/utils/git.test.ts

@@ -51,15 +51,59 @@ describe('git utils', () => {
   });
 
   it('should clone repository', async () => {
+    // Mock anonymous to fail to test fallback
+    mocks.exec.mockImplementationOnce((_cmd, _options, callback) => {
+      callback(new Error('Anonymous failed'), '', '');
+    });
+
     await git.clone('http://repo.git', 'dest', { recursive: true });
     expect(runCommand).toHaveBeenCalledWith('git clone --recursive http://repo.git .', 'dest');
   });
 
   it('should clone repository with depth', async () => {
+    // Mock anonymous to fail to test fallback
+    mocks.exec.mockImplementationOnce((_cmd, _options, callback) => {
+      callback(new Error('Anonymous failed'), '', '');
+    });
+
     await git.clone('http://repo.git', 'dest', { depth: 1 });
     expect(runCommand).toHaveBeenCalledWith('git clone --depth 1 http://repo.git .', 'dest');
   });
 
+  it('should try anonymous clone first', async () => {
+    // Mock anonymous to succeed
+    mocks.exec.mockImplementationOnce((_cmd, _options, callback) => {
+      callback(null, 'Done', '');
+    });
+
+    await git.clone('http://repo.git', 'dest');
+    expect(mocks.exec).toHaveBeenCalledWith(
+      expect.stringContaining('-c credential.helper='),
+      expect.any(Object),
+      expect.any(Function),
+    );
+    expect(runCommand).not.toHaveBeenCalled();
+  });
+
+  it('should handle anonymous clone with empty stdout', async () => {
+    mocks.exec.mockImplementationOnce((_cmd, _options, callback) => {
+      callback(null, '', '');
+    });
+
+    await git.clone('http://repo.git', 'dest');
+    expect(mocks.exec).toHaveBeenCalled();
+  });
+
+  it('should handle anonymous clone with non-Error exception', async () => {
+    mocks.exec.mockImplementationOnce((_cmd, _options, callback) => {
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      callback('String error' as any, '', '');
+    });
+
+    await git.clone('http://repo.git', 'dest');
+    expect(runCommand).toHaveBeenCalled();
+  });
+
   it('should update submodules', async () => {
     await git.updateSubmodules('dest');
     expect(runCommand).toHaveBeenCalledWith(
@@ -111,6 +155,50 @@ describe('git utils', () => {
     const url = await git.getRemoteUrl('cwd');
     expect(url).toBe('');
   });
+
+  it('should add submodule', async () => {
+    // Mock anonymous to fail
+    mocks.exec.mockImplementationOnce((_cmd, _options, callback) => {
+      callback(new Error('Anonymous failed'), '', '');
+    });
+
+    await git.addSubmodule('url', 'path', 'cwd');
+    expect(runCommand).toHaveBeenCalledWith('git submodule add url path', 'cwd');
+  });
+
+  it('should try anonymous submodule add first', async () => {
+    // Mock anonymous to succeed
+    mocks.exec.mockImplementationOnce((_cmd, _options, callback) => {
+      callback(null, 'Done', '');
+    });
+
+    await git.addSubmodule('url', 'path', 'cwd');
+    expect(mocks.exec).toHaveBeenCalledWith(
+      expect.stringContaining('-c credential.helper='),
+      expect.any(Object),
+      expect.any(Function),
+    );
+    expect(runCommand).not.toHaveBeenCalled();
+  });
+
+  it('should handle anonymous submodule add with empty stdout', async () => {
+    mocks.exec.mockImplementationOnce((_cmd, _options, callback) => {
+      callback(null, '', '');
+    });
+
+    await git.addSubmodule('url', 'path', 'cwd');
+    expect(mocks.exec).toHaveBeenCalled();
+  });
+
+  it('should handle anonymous submodule add with non-Error exception', async () => {
+    mocks.exec.mockImplementationOnce((_cmd, _options, callback) => {
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      callback('String error' as any, '', '');
+    });
+
+    await git.addSubmodule('url', 'path', 'cwd');
+    expect(runCommand).toHaveBeenCalled();
+  });
 });
 
 it('should add all files', async () => {

package/test/unit/utils/git_utils.test.ts

@@ -15,6 +15,13 @@ vi.mock('node:child_process', () => ({
 
 describe('git utils', () => {
   it('should call git clone', async () => {
+    const { exec } = await import('node:child_process');
+    // Mock anonymous failure
+    vi.mocked(exec).mockImplementationOnce(((cmd: string, opts: any, callback: any) => {
+      callback(new Error('fail'), '', '');
+      return {} as any;
+    }) as any);
+
     await git.clone('url', 'dest');
     expect(runCommand).toHaveBeenCalledWith(expect.stringContaining('git clone'), 'dest');
   });

package/dist/chunk-Q7YLW5HJ.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/utils/git.ts"],"sourcesContent":["import { logger, runCommand } from '@nexical/cli-core';\nimport { exec } from 'node:child_process';\nimport { promisify } from 'node:util';\n\nconst execAsync = promisify(exec);\n\nexport async function clone(\n  url: string,\n  destination: string,\n  options: { recursive?: boolean; depth?: number } = {},\n): Promise<void> {\n  const { recursive = false, depth } = options;\n  const cmd = `git clone ${recursive ? '--recursive ' : ''}${depth ? `--depth ${depth} ` : ''}${url} .`;\n  logger.debug(`Git clone: ${url} to ${destination}`);\n  await runCommand(cmd, destination);\n}\n\nexport async function getRemoteUrl(cwd: string, remote = 'origin'): Promise<string> {\n  try {\n    const { stdout } = await execAsync(`git remote get-url ${remote}`, { cwd });\n    return stdout.trim();\n  } catch (e) {\n    console.error('getRemoteUrl failed:', e);\n    return '';\n  }\n}\n\nexport async function updateSubmodules(cwd: string): Promise<void> {\n  logger.debug(`Updating submodules in ${cwd}`);\n  await runCommand(\n    'git submodule foreach --recursive \"git checkout main && git pull origin main\"',\n    cwd,\n  );\n}\n\nexport async function checkoutOrphan(branch: string, cwd: string): Promise<void> {\n  await runCommand(`git checkout --orphan ${branch}`, cwd);\n}\n\nexport async function addAll(cwd: string): Promise<void> {\n  await runCommand('git add -A', cwd);\n}\n\nexport async function commit(message: string, cwd: string): Promise<void> {\n  // Escape quotes in message if needed, for now assuming simple messages\n  await runCommand(`git commit -m \"${message}\"`, cwd);\n}\n\nexport async function deleteBranch(branch: string, cwd: string): Promise<void> {\n  await runCommand(`git branch -D ${branch}`, cwd);\n}\n\nexport async function renameBranch(branch: string, cwd: string): Promise<void> {\n  await runCommand(`git branch -m ${branch}`, cwd);\n}\n\nexport async function removeRemote(remote: string, cwd: string): Promise<void> {\n  await runCommand(`git remote remove ${remote}`, cwd);\n}\n\nexport async function renameRemote(oldName: string, newName: string, cwd: string): Promise<void> {\n  await runCommand(`git remote rename ${oldName} ${newName}`, cwd);\n}\n\nexport async function branchExists(branch: string, cwd: string): Promise<boolean> {\n  try {\n    await execAsync(`git show-ref --verify --quiet refs/heads/${branch}`, { cwd });\n    return true;\n  } catch {\n    return false;\n  }\n}\n"],"mappings":";;;;;;AAAA;AAAA,SAAS,QAAQ,kBAAkB;AACnC,SAAS,YAAY;AACrB,SAAS,iBAAiB;AAE1B,IAAM,YAAY,UAAU,IAAI;AAEhC,eAAsB,MACpB,KACA,aACA,UAAmD,CAAC,GACrC;AACf,QAAM,EAAE,YAAY,OAAO,MAAM,IAAI;AACrC,QAAM,MAAM,aAAa,YAAY,iBAAiB,EAAE,GAAG,QAAQ,WAAW,KAAK,MAAM,EAAE,GAAG,GAAG;AACjG,SAAO,MAAM,cAAc,GAAG,OAAO,WAAW,EAAE;AAClD,QAAM,WAAW,KAAK,WAAW;AACnC;AAEA,eAAsB,aAAa,KAAa,SAAS,UAA2B;AAClF,MAAI;AACF,UAAM,EAAE,OAAO,IAAI,MAAM,UAAU,sBAAsB,MAAM,IAAI,EAAE,IAAI,CAAC;AAC1E,WAAO,OAAO,KAAK;AAAA,EACrB,SAAS,GAAG;AACV,YAAQ,MAAM,wBAAwB,CAAC;AACvC,WAAO;AAAA,EACT;AACF;AAEA,eAAsB,iBAAiB,KAA4B;AACjE,SAAO,MAAM,0BAA0B,GAAG,EAAE;AAC5C,QAAM;AAAA,IACJ;AAAA,IACA;AAAA,EACF;AACF;AAEA,eAAsB,eAAe,QAAgB,KAA4B;AAC/E,QAAM,WAAW,yBAAyB,MAAM,IAAI,GAAG;AACzD;AAEA,eAAsB,OAAO,KAA4B;AACvD,QAAM,WAAW,cAAc,GAAG;AACpC;AAEA,eAAsB,OAAO,SAAiB,KAA4B;AAExE,QAAM,WAAW,kBAAkB,OAAO,KAAK,GAAG;AACpD;AAEA,eAAsB,aAAa,QAAgB,KAA4B;AAC7E,QAAM,WAAW,iBAAiB,MAAM,IAAI,GAAG;AACjD;AAEA,eAAsB,aAAa,QAAgB,KAA4B;AAC7E,QAAM,WAAW,iBAAiB,MAAM,IAAI,GAAG;AACjD;AAEA,eAAsB,aAAa,QAAgB,KAA4B;AAC7E,QAAM,WAAW,qBAAqB,MAAM,IAAI,GAAG;AACrD;AAEA,eAAsB,aAAa,SAAiB,SAAiB,KAA4B;AAC/F,QAAM,WAAW,qBAAqB,OAAO,IAAI,OAAO,IAAI,GAAG;AACjE;AAEA,eAAsB,aAAa,QAAgB,KAA+B;AAChF,MAAI;AACF,UAAM,UAAU,4CAA4C,MAAM,IAAI,EAAE,IAAI,CAAC;AAC7E,WAAO;AAAA,EACT,QAAQ;AACN,WAAO;AAAA,EACT;AACF;","names":[]}