sonamu 0.10.7 → 0.10.9

package/dist/naite/naite-reporter.d.ts

@@ -6,6 +6,11 @@
  *
  * 프로젝트별로 고유한 소켓을 사용하기 위해 sonamu.config.ts 경로의 해시를 사용합니다.
  *
+ * 모듈 싱글턴이지만 인스턴스는 프로세스마다 별개입니다. run/start·run/end는
+ * Vitest 메인 프로세스(NaiteVitestReporter 커스텀 리포터)에서, test/result는
+ * 각 worker 프로세스(bootstrap의 afterEach)에서 전송되므로 buffer와 소켓
+ * 연결을 서로 공유하지 않습니다.
+ *
  * fs mock 충돌을 피하기 위해 net 모듈만 사용합니다.
  */
  
@@ -24,17 +29,17 @@ declare class NaiteReporterClass {
      */
     private send;
     /**
-     * beforeAll에서 호출합니다.
+     * Vitest 커스텀 리포터(NaiteVitestReporter)의 onTestRunStart에서 호출합니다.
      * 테스트 run 시작을 알립니다 (데이터 클리어 신호).
      */
     startTestRun(): Promise<void>;
     /**
-     * afterEach에서 호출합니다.
+     * bootstrap()의 afterEach에서 호출합니다.
      * 테스트 케이스 결과를 traces와 함께 전송합니다.
      */
     reportTestResult(result: Omit<NaiteMessagingTypes.TestResult, "receivedAt">): Promise<void>;
     /**
-     * afterAll에서 호출합니다.
+     * Vitest 커스텀 리포터(NaiteVitestReporter)의 onTestRunEnd에서 호출합니다.
      * 테스트 run 종료를 알립니다.
      */
     endTestRun(): Promise<void>;

package/dist/naite/naite-reporter.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"naite-reporter.d.ts","sourceRoot":"","sources":["../../src/naite/naite-reporter.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;;AAUH,OAAO,EAAE,KAAK,mBAAmB,EAAE,MAAM,mBAAmB,CAAC;AA+B7D,cAAM,kBAAkB;IACtB,OAAO,CAAC,UAAU,CAAuB;IACzC,OAAO,CAAC,MAAM,CAAuB;IACrC,OAAO,CAAC,SAAS,CAAS;IAC1B,OAAO,CAAC,MAAM,CAAgB;IAE9B;;OAEG;YACW,gBAAgB;IAmC9B;;OAEG;YACW,IAAI;IAgBlB;;;OAGG;IACG,YAAY,IAAI,OAAO,CAAC,IAAI,CAAC;IAWnC;;;OAGG;IACG,gBAAgB,CACpB,MAAM,EAAE,IAAI,CAAC,mBAAmB,CAAC,UAAU,EAAE,YAAY,CAAC,GACzD,OAAO,CAAC,IAAI,CAAC;IAYhB;;;OAGG;IACG,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;CAiBlC;AAED,eAAO,MAAM,aAAa,oBAA2B,CAAC"}
+{"version":3,"file":"naite-reporter.d.ts","sourceRoot":"","sources":["../../src/naite/naite-reporter.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;;AAUH,OAAO,EAAE,KAAK,mBAAmB,EAAE,MAAM,mBAAmB,CAAC;AA+B7D,cAAM,kBAAkB;IACtB,OAAO,CAAC,UAAU,CAAuB;IACzC,OAAO,CAAC,MAAM,CAAuB;IACrC,OAAO,CAAC,SAAS,CAAS;IAC1B,OAAO,CAAC,MAAM,CAAgB;IAE9B;;OAEG;YACW,gBAAgB;IAmC9B;;OAEG;YACW,IAAI;IAgBlB;;;OAGG;IACG,YAAY,IAAI,OAAO,CAAC,IAAI,CAAC;IAWnC;;;OAGG;IACG,gBAAgB,CACpB,MAAM,EAAE,IAAI,CAAC,mBAAmB,CAAC,UAAU,EAAE,YAAY,CAAC,GACzD,OAAO,CAAC,IAAI,CAAC;IAYhB;;;OAGG;IACG,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;CAiBlC;AAED,eAAO,MAAM,aAAa,oBAA2B,CAAC"}

package/dist/naite/naite-reporter.js

@@ -12,6 +12,11 @@ import { connect } from "net";
 *
 * 프로젝트별로 고유한 소켓을 사용하기 위해 sonamu.config.ts 경로의 해시를 사용합니다.
 *
+* 모듈 싱글턴이지만 인스턴스는 프로세스마다 별개입니다. run/start·run/end는
+* Vitest 메인 프로세스(NaiteVitestReporter 커스텀 리포터)에서, test/result는
+* 각 worker 프로세스(bootstrap의 afterEach)에서 전송되므로 buffer와 소켓
+* 연결을 서로 공유하지 않습니다.
+*
 * fs mock 충돌을 피하기 위해 net 모듈만 사용합니다.
 */
 init_utils();
@@ -78,7 +83,7 @@ var NaiteReporterClass = class {
 		}
 	}
 	/**
-	* beforeAll에서 호출합니다.
+	* Vitest 커스텀 리포터(NaiteVitestReporter)의 onTestRunStart에서 호출합니다.
 	* 테스트 run 시작을 알립니다 (데이터 클리어 신호).
 	*/
 	async startTestRun() {
@@ -89,7 +94,7 @@ var NaiteReporterClass = class {
 		});
 	}
 	/**
-	* afterEach에서 호출합니다.
+	* bootstrap()의 afterEach에서 호출합니다.
 	* 테스트 케이스 결과를 traces와 함께 전송합니다.
 	*/
 	async reportTestResult(result) {
@@ -101,7 +106,7 @@ var NaiteReporterClass = class {
 		});
 	}
 	/**
-	* afterAll에서 호출합니다.
+	* Vitest 커스텀 리포터(NaiteVitestReporter)의 onTestRunEnd에서 호출합니다.
 	* 테스트 run 종료를 알립니다.
 	*/
 	async endTestRun() {
@@ -121,4 +126,4 @@ const NaiteReporter = new NaiteReporterClass();
 //#endregion
 export { NaiteReporter };
 
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"naite-reporter.js","names":[],"sources":["../../src/naite/naite-reporter.ts"],"sourcesContent":["/**\n * NaiteReporter\n *\n * 테스트 결과와 Trace 정보를 Unix Socket으로 VS Code extension에 전달합니다.\n * extension이 ~/.sonamu/naite-{hash}.sock에 소켓 서버를 열어둡니다.\n *\n * 프로젝트별로 고유한 소켓을 사용하기 위해 sonamu.config.ts 경로의 해시를 사용합니다.\n *\n * fs mock 충돌을 피하기 위해 net 모듈만 사용합니다.\n */\n/* oxlint-disable @typescript-eslint/no-explicit-any */ // Naite는 expect와 호응하도록 any를 허용함\n\nimport { createHash } from \"crypto\";\nimport { connect } from \"net\";\nimport { type Socket } from \"net\";\nimport { homedir } from \"os\";\nimport { join } from \"path\";\n\nimport { findApiRootPath } from \"../utils/utils\";\nimport { type NaiteMessagingTypes } from \"./messaging-types\";\n\n/**\n * sonamu.config.ts 경로를 받아서 프로젝트별 고유 해시를 생성합니다.\n * 익스텐션과 동일한 방식으로 계산해야 합니다.\n */\nfunction getProjectHash(configPath: string): string {\n  return createHash(\"md5\").update(configPath).digest(\"hex\").slice(0, 8);\n}\n\n/**\n * 현재 프로젝트의 소켓 경로를 계산합니다.\n * Sonamu.apiRootPath가 설정된 후에 호출해야 합니다.\n */\nfunction getSocketPath(): string {\n  // sonamu.config.ts의 절대 경로 계산\n  // apiRootPath는 /project/api 형태이고, config는 /project/api/src/sonamu.config.ts에 있음\n  const configPath = join(findApiRootPath(), \"src\", \"sonamu.config.ts\");\n  const hash = getProjectHash(configPath);\n\n  return process.platform === \"win32\"\n    ? `\\\\\\\\.\\\\pipe\\\\naite-${hash}`\n    : join(homedir(), \".sonamu\", `naite-${hash}.sock`);\n}\n\n/**\n * 연결 실패가 지속될 때(extension 미실행 등) buffer가 무한히 커지지 않도록\n * 최근 메시지만 이 개수만큼 유지합니다.\n */\nconst MAX_BUFFERED_MESSAGES = 1000;\n\nclass NaiteReporterClass {\n  private socketPath: string | null = null;\n  private socket: Socket | null = null;\n  private connected = false;\n  private buffer: string[] = [];\n\n  /**\n   * 소켓 연결 시도\n   */\n  private async ensureConnection(): Promise<void> {\n    if (this.connected || this.socket) {\n      return;\n    }\n\n    return new Promise((res, rej) => {\n      if (!this.socketPath) {\n        this.socketPath = getSocketPath();\n      }\n      this.socket = connect(this.socketPath);\n\n      this.socket.on(\"connect\", () => {\n        this.connected = true;\n        // 버퍼에 쌓인 메시지 전송\n        for (const msg of this.buffer) {\n          this.socket?.write(msg);\n        }\n        this.buffer = [];\n        res();\n      });\n\n      this.socket.on(\"error\", (e) => {\n        // 연결 실패 무시 (extension이 꺼져있을 수 있음)\n        this.connected = false;\n        this.socket = null;\n        rej(e);\n      });\n\n      this.socket.on(\"close\", () => {\n        this.connected = false;\n        this.socket = null;\n      });\n    });\n  }\n\n  /**\n   * 메시지 전송 (줄바꿈으로 구분)\n   */\n  private async send(data: NaiteMessagingTypes.NaiteMessage): Promise<void> {\n    const msg = `${JSON.stringify(data)}\\n`;\n\n    await this.ensureConnection().catch((_) => {});\n\n    if (this.connected && this.socket) {\n      this.socket.write(msg);\n    } else {\n      // 연결 대기 중이면 버퍼에 저장, 상한 초과 시 오래된 메시지부터 폐기\n      this.buffer.push(msg);\n      if (this.buffer.length > MAX_BUFFERED_MESSAGES) {\n        this.buffer.shift();\n      }\n    }\n  }\n\n  /**\n   * beforeAll에서 호출합니다.\n   * 테스트 run 시작을 알립니다 (데이터 클리어 신호).\n   */\n  async startTestRun(): Promise<void> {\n    if (process.env.CI) {\n      return;\n    }\n\n    await this.send({\n      type: \"run/start\",\n      startedAt: new Date().toISOString(),\n    });\n  }\n\n  /**\n   * afterEach에서 호출합니다.\n   * 테스트 케이스 결과를 traces와 함께 전송합니다.\n   */\n  async reportTestResult(\n    result: Omit<NaiteMessagingTypes.TestResult, \"receivedAt\">,\n  ): Promise<void> {\n    if (process.env.CI) {\n      return;\n    }\n\n    await this.send({\n      type: \"test/result\",\n      receivedAt: new Date().toISOString(),\n      ...result,\n    });\n  }\n\n  /**\n   * afterAll에서 호출합니다.\n   * 테스트 run 종료를 알립니다.\n   */\n  async endTestRun(): Promise<void> {\n    if (process.env.CI) {\n      return;\n    }\n\n    await this.send({\n      type: \"run/end\",\n      endedAt: new Date().toISOString(),\n    });\n\n    // 연결 종료\n    if (this.socket) {\n      this.socket.end();\n      this.socket = null;\n      this.connected = false;\n    }\n  }\n}\n\nexport const NaiteReporter = new NaiteReporterClass();\n"],"mappings":";;;;;;;;;;;;;;;;WAkBgD;;;;;AAOhD,SAAS,eAAe,YAA4B;CAClD,OAAO,WAAW,KAAK,CAAC,CAAC,OAAO,UAAU,CAAC,CAAC,OAAO,KAAK,CAAC,CAAC,MAAM,GAAG,CAAC;AACtE;;;;;AAMA,SAAS,gBAAwB;CAI/B,MAAM,OAAO,eADM,KAAK,gBAAgB,GAAG,OAAO,kBACtB,CAAU;CAEtC,OAAO,QAAQ,aAAa,UACxB,sBAAsB,SACtB,KAAK,QAAQ,GAAG,WAAW,SAAS,KAAK,MAAM;AACrD;;;;;AAMA,MAAM,wBAAwB;AAE9B,IAAM,qBAAN,MAAyB;CACvB,aAAoC;CACpC,SAAgC;CAChC,YAAoB;CACpB,SAA2B,CAAC;;;;CAK5B,MAAc,mBAAkC;EAC9C,IAAI,KAAK,aAAa,KAAK,QACzB;EAGF,OAAO,IAAI,SAAS,KAAK,QAAQ;GAC/B,IAAI,CAAC,KAAK,YACR,KAAK,aAAa,cAAc;GAElC,KAAK,SAAS,QAAQ,KAAK,UAAU;GAErC,KAAK,OAAO,GAAG,iBAAiB;IAC9B,KAAK,YAAY;IAEjB,KAAK,MAAM,OAAO,KAAK,QACrB,KAAK,QAAQ,MAAM,GAAG;IAExB,KAAK,SAAS,CAAC;IACf,IAAI;GACN,CAAC;GAED,KAAK,OAAO,GAAG,UAAU,MAAM;IAE7B,KAAK,YAAY;IACjB,KAAK,SAAS;IACd,IAAI,CAAC;GACP,CAAC;GAED,KAAK,OAAO,GAAG,eAAe;IAC5B,KAAK,YAAY;IACjB,KAAK,SAAS;GAChB,CAAC;EACH,CAAC;CACH;;;;CAKA,MAAc,KAAK,MAAuD;EACxE,MAAM,MAAM,GAAG,KAAK,UAAU,IAAI,EAAE;EAEpC,MAAM,KAAK,iBAAiB,CAAC,CAAC,OAAO,MAAM,CAAC,CAAC;EAE7C,IAAI,KAAK,aAAa,KAAK,QACzB,KAAK,OAAO,MAAM,GAAG;OAChB;GAEL,KAAK,OAAO,KAAK,GAAG;GACpB,IAAI,KAAK,OAAO,SAAS,uBACvB,KAAK,OAAO,MAAM;EAEtB;CACF;;;;;CAMA,MAAM,eAA8B;EAClC,IAAI,QAAQ,IAAI,IACd;EAGF,MAAM,KAAK,KAAK;GACd,MAAM;GACN,4BAAW,IAAI,KAAK,EAAC,CAAC,YAAY;EACpC,CAAC;CACH;;;;;CAMA,MAAM,iBACJ,QACe;EACf,IAAI,QAAQ,IAAI,IACd;EAGF,MAAM,KAAK,KAAK;GACd,MAAM;GACN,6BAAY,IAAI,KAAK,EAAC,CAAC,YAAY;GACnC,GAAG;EACL,CAAC;CACH;;;;;CAMA,MAAM,aAA4B;EAChC,IAAI,QAAQ,IAAI,IACd;EAGF,MAAM,KAAK,KAAK;GACd,MAAM;GACN,0BAAS,IAAI,KAAK,EAAC,CAAC,YAAY;EAClC,CAAC;EAGD,IAAI,KAAK,QAAQ;GACf,KAAK,OAAO,IAAI;GAChB,KAAK,SAAS;GACd,KAAK,YAAY;EACnB;CACF;AACF;AAEA,MAAa,gBAAgB,IAAI,mBAAmB"}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"naite-reporter.js","names":[],"sources":["../../src/naite/naite-reporter.ts"],"sourcesContent":["/**\n * NaiteReporter\n *\n * 테스트 결과와 Trace 정보를 Unix Socket으로 VS Code extension에 전달합니다.\n * extension이 ~/.sonamu/naite-{hash}.sock에 소켓 서버를 열어둡니다.\n *\n * 프로젝트별로 고유한 소켓을 사용하기 위해 sonamu.config.ts 경로의 해시를 사용합니다.\n *\n * 모듈 싱글턴이지만 인스턴스는 프로세스마다 별개입니다. run/start·run/end는\n * Vitest 메인 프로세스(NaiteVitestReporter 커스텀 리포터)에서, test/result는\n * 각 worker 프로세스(bootstrap의 afterEach)에서 전송되므로 buffer와 소켓\n * 연결을 서로 공유하지 않습니다.\n *\n * fs mock 충돌을 피하기 위해 net 모듈만 사용합니다.\n */\n/* oxlint-disable @typescript-eslint/no-explicit-any */ // Naite는 expect와 호응하도록 any를 허용함\n\nimport { createHash } from \"crypto\";\nimport { connect } from \"net\";\nimport { type Socket } from \"net\";\nimport { homedir } from \"os\";\nimport { join } from \"path\";\n\nimport { findApiRootPath } from \"../utils/utils\";\nimport { type NaiteMessagingTypes } from \"./messaging-types\";\n\n/**\n * sonamu.config.ts 경로를 받아서 프로젝트별 고유 해시를 생성합니다.\n * 익스텐션과 동일한 방식으로 계산해야 합니다.\n */\nfunction getProjectHash(configPath: string): string {\n  return createHash(\"md5\").update(configPath).digest(\"hex\").slice(0, 8);\n}\n\n/**\n * 현재 프로젝트의 소켓 경로를 계산합니다.\n * Sonamu.apiRootPath가 설정된 후에 호출해야 합니다.\n */\nfunction getSocketPath(): string {\n  // sonamu.config.ts의 절대 경로 계산\n  // apiRootPath는 /project/api 형태이고, config는 /project/api/src/sonamu.config.ts에 있음\n  const configPath = join(findApiRootPath(), \"src\", \"sonamu.config.ts\");\n  const hash = getProjectHash(configPath);\n\n  return process.platform === \"win32\"\n    ? `\\\\\\\\.\\\\pipe\\\\naite-${hash}`\n    : join(homedir(), \".sonamu\", `naite-${hash}.sock`);\n}\n\n/**\n * 연결 실패가 지속될 때(extension 미실행 등) buffer가 무한히 커지지 않도록\n * 최근 메시지만 이 개수만큼 유지합니다.\n */\nconst MAX_BUFFERED_MESSAGES = 1000;\n\nclass NaiteReporterClass {\n  private socketPath: string | null = null;\n  private socket: Socket | null = null;\n  private connected = false;\n  private buffer: string[] = [];\n\n  /**\n   * 소켓 연결 시도\n   */\n  private async ensureConnection(): Promise<void> {\n    if (this.connected || this.socket) {\n      return;\n    }\n\n    return new Promise((res, rej) => {\n      if (!this.socketPath) {\n        this.socketPath = getSocketPath();\n      }\n      this.socket = connect(this.socketPath);\n\n      this.socket.on(\"connect\", () => {\n        this.connected = true;\n        // 버퍼에 쌓인 메시지 전송\n        for (const msg of this.buffer) {\n          this.socket?.write(msg);\n        }\n        this.buffer = [];\n        res();\n      });\n\n      this.socket.on(\"error\", (e) => {\n        // 연결 실패 무시 (extension이 꺼져있을 수 있음)\n        this.connected = false;\n        this.socket = null;\n        rej(e);\n      });\n\n      this.socket.on(\"close\", () => {\n        this.connected = false;\n        this.socket = null;\n      });\n    });\n  }\n\n  /**\n   * 메시지 전송 (줄바꿈으로 구분)\n   */\n  private async send(data: NaiteMessagingTypes.NaiteMessage): Promise<void> {\n    const msg = `${JSON.stringify(data)}\\n`;\n\n    await this.ensureConnection().catch((_) => {});\n\n    if (this.connected && this.socket) {\n      this.socket.write(msg);\n    } else {\n      // 연결 대기 중이면 버퍼에 저장, 상한 초과 시 오래된 메시지부터 폐기\n      this.buffer.push(msg);\n      if (this.buffer.length > MAX_BUFFERED_MESSAGES) {\n        this.buffer.shift();\n      }\n    }\n  }\n\n  /**\n   * Vitest 커스텀 리포터(NaiteVitestReporter)의 onTestRunStart에서 호출합니다.\n   * 테스트 run 시작을 알립니다 (데이터 클리어 신호).\n   */\n  async startTestRun(): Promise<void> {\n    if (process.env.CI) {\n      return;\n    }\n\n    await this.send({\n      type: \"run/start\",\n      startedAt: new Date().toISOString(),\n    });\n  }\n\n  /**\n   * bootstrap()의 afterEach에서 호출합니다.\n   * 테스트 케이스 결과를 traces와 함께 전송합니다.\n   */\n  async reportTestResult(\n    result: Omit<NaiteMessagingTypes.TestResult, \"receivedAt\">,\n  ): Promise<void> {\n    if (process.env.CI) {\n      return;\n    }\n\n    await this.send({\n      type: \"test/result\",\n      receivedAt: new Date().toISOString(),\n      ...result,\n    });\n  }\n\n  /**\n   * Vitest 커스텀 리포터(NaiteVitestReporter)의 onTestRunEnd에서 호출합니다.\n   * 테스트 run 종료를 알립니다.\n   */\n  async endTestRun(): Promise<void> {\n    if (process.env.CI) {\n      return;\n    }\n\n    await this.send({\n      type: \"run/end\",\n      endedAt: new Date().toISOString(),\n    });\n\n    // 연결 종료\n    if (this.socket) {\n      this.socket.end();\n      this.socket = null;\n      this.connected = false;\n    }\n  }\n}\n\nexport const NaiteReporter = new NaiteReporterClass();\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;WAuBgD;;;;;AAOhD,SAAS,eAAe,YAA4B;CAClD,OAAO,WAAW,KAAK,CAAC,CAAC,OAAO,UAAU,CAAC,CAAC,OAAO,KAAK,CAAC,CAAC,MAAM,GAAG,CAAC;AACtE;;;;;AAMA,SAAS,gBAAwB;CAI/B,MAAM,OAAO,eADM,KAAK,gBAAgB,GAAG,OAAO,kBACtB,CAAU;CAEtC,OAAO,QAAQ,aAAa,UACxB,sBAAsB,SACtB,KAAK,QAAQ,GAAG,WAAW,SAAS,KAAK,MAAM;AACrD;;;;;AAMA,MAAM,wBAAwB;AAE9B,IAAM,qBAAN,MAAyB;CACvB,aAAoC;CACpC,SAAgC;CAChC,YAAoB;CACpB,SAA2B,CAAC;;;;CAK5B,MAAc,mBAAkC;EAC9C,IAAI,KAAK,aAAa,KAAK,QACzB;EAGF,OAAO,IAAI,SAAS,KAAK,QAAQ;GAC/B,IAAI,CAAC,KAAK,YACR,KAAK,aAAa,cAAc;GAElC,KAAK,SAAS,QAAQ,KAAK,UAAU;GAErC,KAAK,OAAO,GAAG,iBAAiB;IAC9B,KAAK,YAAY;IAEjB,KAAK,MAAM,OAAO,KAAK,QACrB,KAAK,QAAQ,MAAM,GAAG;IAExB,KAAK,SAAS,CAAC;IACf,IAAI;GACN,CAAC;GAED,KAAK,OAAO,GAAG,UAAU,MAAM;IAE7B,KAAK,YAAY;IACjB,KAAK,SAAS;IACd,IAAI,CAAC;GACP,CAAC;GAED,KAAK,OAAO,GAAG,eAAe;IAC5B,KAAK,YAAY;IACjB,KAAK,SAAS;GAChB,CAAC;EACH,CAAC;CACH;;;;CAKA,MAAc,KAAK,MAAuD;EACxE,MAAM,MAAM,GAAG,KAAK,UAAU,IAAI,EAAE;EAEpC,MAAM,KAAK,iBAAiB,CAAC,CAAC,OAAO,MAAM,CAAC,CAAC;EAE7C,IAAI,KAAK,aAAa,KAAK,QACzB,KAAK,OAAO,MAAM,GAAG;OAChB;GAEL,KAAK,OAAO,KAAK,GAAG;GACpB,IAAI,KAAK,OAAO,SAAS,uBACvB,KAAK,OAAO,MAAM;EAEtB;CACF;;;;;CAMA,MAAM,eAA8B;EAClC,IAAI,QAAQ,IAAI,IACd;EAGF,MAAM,KAAK,KAAK;GACd,MAAM;GACN,4BAAW,IAAI,KAAK,EAAC,CAAC,YAAY;EACpC,CAAC;CACH;;;;;CAMA,MAAM,iBACJ,QACe;EACf,IAAI,QAAQ,IAAI,IACd;EAGF,MAAM,KAAK,KAAK;GACd,MAAM;GACN,6BAAY,IAAI,KAAK,EAAC,CAAC,YAAY;GACnC,GAAG;EACL,CAAC;CACH;;;;;CAMA,MAAM,aAA4B;EAChC,IAAI,QAAQ,IAAI,IACd;EAGF,MAAM,KAAK,KAAK;GACd,MAAM;GACN,0BAAS,IAAI,KAAK,EAAC,CAAC,YAAY;EAClC,CAAC;EAGD,IAAI,KAAK,QAAQ;GACf,KAAK,OAAO,IAAI;GAChB,KAAK,SAAS;GACd,KAAK,YAAY;EACnB;CACF;AACF;AAEA,MAAa,gBAAgB,IAAI,mBAAmB"}