@rpgjs/client 5.0.0-alpha.4 → 5.0.0-alpha.41

package/src/services/mmorpg.ts

@@ -2,49 +2,151 @@ import { Context } from "@signe/di";
 import { connectionRoom } from "@signe/sync/client";
 import { RpgGui } from "../Gui/Gui";
 import { RpgClientEngine } from "../RpgClientEngine";
-import { AbstractWebsocket, WebSocketToken } from "./AbstractSocket";
+import { AbstractWebsocket, SocketUpdateProperties, WebSocketToken } from "./AbstractSocket";
 import { UpdateMapService, UpdateMapToken } from "@rpgjs/common";
+import { provideKeyboardControls } from "./keyboardControls";
+import { provideSaveClient } from "./save";
 
 interface MmorpgOptions {
-    host: string;
+    host?: string;
+    connectionId?: string;
+    connectionIdScope?: "local" | "session" | "ephemeral";
 }
 
 class BridgeWebsocket extends AbstractWebsocket {
-    private socket: any;
+  private socket: any;
+  private privateId: string;
+  private pendingOn: Array<{ event: string; callback: (data: any) => void }> = [];
+  private targetRoom = "lobby-1";
 
-  constructor(protected context: Context, private options: MmorpgOptions) {
+  constructor(protected context: Context, private options: MmorpgOptions = {}) {
     super(context);
+    this.privateId = this.resolveConnectionId();
   }
 
-  async connection() {
+  private resolveConnectionId(): string {
+    if (this.options.connectionId) {
+      return this.options.connectionId;
+    }
+
+    const scope = this.options.connectionIdScope ?? "local";
+    const key = "rpgjs-user-id";
+
+    if (scope === "ephemeral") {
+      return crypto.randomUUID();
+    }
+
+    const storage =
+      scope === "session"
+        ? window.sessionStorage
+        : window.localStorage;
+
+    const existing = storage.getItem(key);
+    if (existing) {
+      return existing;
+    }
+
+    const id = crypto.randomUUID();
+    storage.setItem(key, id);
+    return id;
+  }
+
+  async connection(listeners?: (data: any) => void) {
     // tmp
     class Room {
         
     }
     const instance = new Room()
-    this.socket = await connectionRoom(this.options, instance)
+    const host = this.options.host || window.location.host;
+    this.socket = await connectionRoom({
+        host,
+        room: this.targetRoom,
+        id: this.privateId
+    }, instance)
+
+    listeners?.(this.socket)
+    this.pendingOn.forEach(({ event, callback }) => this.socket.on(event, callback));
+    this.pendingOn = [];
   }
 
   on(key: string, callback: (data: any) => void) {
+    if (!this.socket) {
+      this.pendingOn.push({ event: key, callback });
+      return;
+    }
     this.socket.on(key, callback);
   }
 
   off(event: string, callback: (data: any) => void) {
+    if (!this.socket) return;
     this.socket.off(event, callback);
   }
 
   emit(event: string, data: any) {
     this.socket.emit(event, data);
   }
+
+  updateProperties({ room, host, query }: SocketUpdateProperties) {
+    if (!this.socket?.conn) return;
+    this.targetRoom = room;
+    this.socket.conn.updateProperties({
+      room,
+      id: this.privateId,
+      host: host || this.options.host || window.location.host,
+      query,
+    })
+  }
+
+  private waitForNextOpen(conn: any, timeoutMs = 10000): Promise<void> {
+    return new Promise((resolve, reject) => {
+      let timeoutId: number | undefined;
+      const onOpen = () => {
+        cleanup();
+        resolve();
+      };
+      const onError = () => {
+        cleanup();
+        reject(new Error("WebSocket reconnect failed"));
+      };
+      const cleanup = () => {
+        conn.removeEventListener("open", onOpen);
+        conn.removeEventListener("error", onError);
+        if (timeoutId !== undefined) {
+          window.clearTimeout(timeoutId);
+        }
+      };
+
+      conn.addEventListener("open", onOpen);
+      conn.addEventListener("error", onError);
+      timeoutId = window.setTimeout(() => {
+        cleanup();
+        reject(new Error("WebSocket reconnect timeout"));
+      }, timeoutMs);
+    });
+  }
+
+  async reconnect(_listeners?: (data: any) => void): Promise<void> {
+    if (!this.socket?.conn) return;
+    const conn = this.socket.conn;
+    const opened = this.waitForNextOpen(conn);
+    conn.reconnect();
+    await opened;
+  }
+
+  getCurrentRoom(): string {
+    return this.targetRoom || this.socket?.conn?.room || "lobby-1";
+  }
 }
 
 class UpdateMapStandaloneService extends UpdateMapService {
-  constructor(protected context: Context, private options: MmorpgOptions) {
+  constructor(protected context: Context, private _options: MmorpgOptions) {
     super(context);
   }
 
-  async update(map: any) {
-    // nothing
+  async update(_map: any) {
+    // In MMORPG mode, clients are untrusted and must not push map definitions.
+    // Map bootstrap/update is handled server-side by @rpgjs/vite.
+    return;
   }
 }
 
@@ -58,6 +160,8 @@ export function provideMmorpg(options: MmorpgOptions) {
       provide: UpdateMapToken,
       useFactory: (context: Context) => new UpdateMapStandaloneService(context, options),
     },
+    provideKeyboardControls(),
+    provideSaveClient(),
     RpgGui,
     RpgClientEngine,
   ];

package/src/services/save.ts

@@ -0,0 +1,103 @@
+import type { SaveSlotList, SaveSlotMeta } from "@rpgjs/common";
+import { inject } from "../core/inject";
+import { AbstractWebsocket, WebSocketToken } from "./AbstractSocket";
+
+export const SaveClientToken = "SaveClientToken";
+
+type SaveListResult = {
+  requestId: string;
+  slots: SaveSlotList;
+};
+
+type SaveSaveResult = {
+  requestId: string;
+  index: number;
+  slots: SaveSlotList;
+};
+
+type SaveLoadResult = {
+  requestId: string;
+  index: number;
+  ok: boolean;
+  slot?: SaveSlotMeta;
+};
+
+type SaveErrorResult = {
+  requestId: string;
+  message: string;
+};
+
+type PendingRequest = {
+  resolve: (value: any) => void;
+  reject: (error: Error) => void;
+};
+
+export class SaveClientService {
+  private webSocket: AbstractWebsocket = inject(WebSocketToken);
+  private pending: Map<string, PendingRequest> = new Map();
+  private requestCounter = 0;
+
+  initialize() {
+    const saveListResult = (data: SaveListResult) => this.resolveRequest(data.requestId, data);
+    const saveSaveResult = (data: SaveSaveResult) => this.resolveRequest(data.requestId, data);
+    const saveLoadResult = (data: SaveLoadResult) => this.resolveRequest(data.requestId, data);
+    const saveErrorResult = (data: SaveErrorResult) => this.rejectRequest(data.requestId, data.message);
+    this.webSocket.off("save.list.result", saveListResult);
+    this.webSocket.off("save.save.result", saveSaveResult);
+    this.webSocket.off("save.load.result", saveLoadResult);
+    this.webSocket.off("save.error", saveErrorResult);
+    this.webSocket.on("save.list.result", saveListResult);
+    this.webSocket.on("save.save.result", saveSaveResult);
+    this.webSocket.on("save.load.result", saveLoadResult);
+    this.webSocket.on("save.error", saveErrorResult);
+  }
+
+  listSlots(): Promise<SaveSlotList> {
+    return this.request<SaveListResult>("save.list", {}).then((result) => result.slots);
+  }
+
+  saveSlot(index: number, meta: SaveSlotMeta = {}): Promise<SaveSlotList> {
+    return this.request<SaveSaveResult>("save.save", { index, meta }).then((result) => result.slots);
+  }
+
+  loadSlot(index: number): Promise<boolean> {
+    return this.request<SaveLoadResult>("save.load", { index }).then((result) => result.ok);
+  }
+
+  private request<T>(event: string, payload: Record<string, any>): Promise<T> {
+    return new Promise((resolve, reject) => {
+      if (!this.webSocket) {
+        this.initialize();
+      }
+      const requestId = this.nextRequestId();
+      this.pending.set(requestId, { resolve, reject });
+      this.webSocket?.emit(event, { requestId, ...payload });
+    });
+  }
+
+  private resolveRequest(requestId: string, result: any) {
+    const pending = this.pending.get(requestId);
+    if (!pending) return;
+    this.pending.delete(requestId);
+    pending.resolve(result);
+  }
+
+  private rejectRequest(requestId: string, message: string) {
+    const pending = this.pending.get(requestId);
+    if (!pending) return;
+    this.pending.delete(requestId);
+    pending.reject(new Error(message));
+  }
+
+  private nextRequestId(): string {
+    this.requestCounter += 1;
+    return `${Date.now()}-${this.requestCounter}`;
+  }
+}
+
+export function provideSaveClient() {
+  return {
+    provide: SaveClientService,
+    useClass: SaveClientService,
+  };
+}

package/src/services/standalone.ts

@@ -1,29 +1,55 @@
-import { AbstractWebsocket, WebSocketToken } from "./AbstractSocket";
+import { AbstractWebsocket, SocketUpdateProperties, WebSocketToken } from "./AbstractSocket";
 import { ClientIo, ServerIo } from "@signe/room";
 import { Context } from "@signe/di";
 import { RpgClientEngine } from "../RpgClientEngine";
 import { UpdateMapService, UpdateMapToken } from "@rpgjs/common";
 import { LoadMapToken } from "./loadMap";
 import { RpgGui } from "../Gui/Gui";
+import { provideKeyboardControls } from "./keyboardControls";
+import { provideSaveClient } from "./save";
 
 type ServerIo = any;
 type ClientIo = any;
 
+interface StandaloneOptions {
+  env?: Record<string, any>;
+}
+
 class BridgeWebsocket extends AbstractWebsocket {
   private room: ServerIo;
   private socket: ClientIo;
+  private pendingOn: Array<{ event: string; callback: (data: any) => void }> = [];
+  private rooms = {
+    partyFn: async (roomId: string) => {
+      this.room = new ServerIo(roomId, this.rooms);
+      const server = new this.server(this.room)
+      await server.onStart();
+      await server.subRoom.onStart()
+      this.context.set('server', server)
+      return server
+    },
+    env: {}
+  }
+  private serverInstance: any;
 
-  constructor(protected context: Context, private server: any) {
+  constructor(protected context: Context, private server: any, options: StandaloneOptions = {}) {
     super(context);
     // fake room
-    this.room = new ServerIo("lobby-1");
+    this.rooms.env = options.env || {};
+    this.room = new ServerIo("lobby-1", this.rooms);
   }
 
   async connection(listeners?: (data: any) => void) {
-    const server = new this.server(this.room);
-    await server.onStart();
-    this.context.set('server', server)
-    this.socket = new ClientIo(server);
+    this.serverInstance = new this.server(this.room);
+    await this.serverInstance.onStart();
+    await this.serverInstance.subRoom.onStart()
+    this.context.set('server', this.serverInstance)
+    return this._connection(listeners)
+  }
+
+  private async _connection(listeners?: (data: any) => void) {
+    this.serverInstance = this.context.get('server')
+    this.socket = new ClientIo(this.serverInstance, 'player-client-id');
     const url = new URL('http://localhost')
     const request = new Request(url.toString(), {
       method: 'GET',
@@ -32,21 +58,29 @@ class BridgeWebsocket extends AbstractWebsocket {
       }
     })
     listeners?.(this.socket)
-    await server.onConnect(this.socket.conn as any, { request } as any);
+    await this.serverInstance.onConnect(this.socket.conn as any, { request } as any);
     this.room.clients.set(this.socket.id, this.socket);
+    this.pendingOn.forEach(({ event, callback }) => this.socket.addEventListener(event, callback));
+    this.pendingOn = [];
     return this.socket
   }
 
   on(key: string, callback: (data: any) => void) {
-    this.socket.addEventListener("message", (event) => {
+    const handler = (event) => {
       const object = JSON.parse(event);
       if (object.type === key) {
         callback(object.value);
       }
-    });
+    };
+    if (!this.socket) {
+      this.pendingOn.push({ event: "message", callback: handler });
+      return;
+    }
+    this.socket.addEventListener("message", handler);
   }
 
   off(event: string, callback: (data: any) => void) {
+    if (!this.socket) return;
     this.socket.removeEventListener(event, callback);
   }
 
@@ -57,24 +91,80 @@ class BridgeWebsocket extends AbstractWebsocket {
     });
   }
 
-  updateProperties({ room }: { room: any }) {
-    this.room = new ServerIo(room);
+  /**
+   * Update underlying connection properties before a reconnect
+   *
+   * Design
+   * - Dynamically register a factory for the requested room to ensure a fresh server instance
+   * - Swap the internal ServerIo to target the new room
+   *
+   * @param params - Properties to update
+   * @param params.room - The target room id (e.g. `map-simplemap2`)
+   *
+   * @example
+   * ```ts
+   * websocket.updateProperties({ room: 'map-simplemap2' })
+   * await websocket.reconnect()
+   * ```
+   */
+  updateProperties(_params: SocketUpdateProperties) {
+    // empty
   }
 
-  async reconnect(listeners?: (data: any) => void) {
-    await this.connection((socket) => {
+  /**
+   * Reconnect the client to the current Party room
+   *
+   * Design
+   * - Must be called after `updateProperties()` when switching rooms
+   * - Rebuilds the client <-> server bridge and re-triggers connection listeners
+   *
+   * @param listeners - Optional callback to re-bind event handlers on the new socket
+   *
+   * @example
+   * ```ts
+   * websocket.updateProperties({ room: 'map-dungeon' })
+   * await websocket.reconnect((socket) => {
+   *   // re-bind events here
+   * })
+   * ```
+   */
+  async reconnect(listeners?: (data: any) => void): Promise<void> {
+    await this._connection((socket) => {
       listeners?.(socket)
     })
   }
+
+  getServer() {
+    return this.serverInstance
+  }
+
+  getSocket() {
+    return this.socket
+  }
 }
 
 class UpdateMapStandaloneService extends UpdateMapService {
   private server: any;
 
-  async update(mapId: string, map: any) {
+  /**
+   * Update the current room map data on the server side
+   *
+   * Design
+   * - Uses the in-memory server instance stored in context (standalone mode)
+   * - Builds a local HTTP-like request to the current Party room endpoint
+   *
+   * @param map - The map payload to apply on the server
+   *
+   * @example
+   * ```ts
+   * await updateMapService.update({ width: 1024, height: 768, events: [] })
+   * ```
+   */
+  async update(map: any) {
     this.server = this.context.get('server')
+    const roomId = this.server?.room?.id ?? 'lobby-1'
     const req = {
-      url: `http://localhost/parties/main/${mapId}/map/update`,
+      url: `http://localhost/parties/main/${roomId}/map/update`,
       method: 'POST',
       headers: new Headers({}),
       json: async () => {
@@ -85,16 +175,18 @@ class UpdateMapStandaloneService extends UpdateMapService {
   }
 }
 
-export function provideRpg(server: any) {
+export function provideRpg(server: any, options: StandaloneOptions = {}) {
   return [
     {
       provide: WebSocketToken,
-      useFactory: (context: Context) => new BridgeWebsocket(context, server),
+      useFactory: (context: Context) => new BridgeWebsocket(context, server, options),
     },
     {
       provide: UpdateMapToken,
       useClass: UpdateMapStandaloneService,
     },
+    provideKeyboardControls(),
+    provideSaveClient(),
     RpgGui,
     RpgClientEngine,
   ];

package/src/utils/getEntityProp.ts

@@ -0,0 +1,87 @@
+import { computed, Signal } from "canvasengine";
+import { RpgClientObject } from "../Game/Object";
+
+const BUILTIN_PARAM_KEYS = [
+  "maxHp",
+  "maxSp",
+  "atk",
+  "pdef",
+  "sdef",
+  "str",
+  "agi",
+  "int",
+  "dex",
+] as const;
+
+type BuiltInParamKey = typeof BUILTIN_PARAM_KEYS[number];
+type ParamPropKey = `params.${BuiltInParamKey}` | `params.${string}`;
+
+const entityPropMap = {
+  level: (entity: RpgClientObject) => entity._level(),
+  exp: (entity: RpgClientObject) => entity._exp(),
+  gold: (entity: RpgClientObject) => entity._gold(),
+  hp: (entity: RpgClientObject) => entity.hpSignal(),
+  sp: (entity: RpgClientObject) => entity.spSignal(),
+  name: (entity: RpgClientObject) => entity.name(),
+  type: (entity: RpgClientObject) => entity.type(),
+  x: (entity: RpgClientObject) => entity.x(),
+  y: (entity: RpgClientObject) => entity.y(),
+  z: (entity: RpgClientObject) => entity.z(),
+  tint: (entity: RpgClientObject) => entity.tint(),
+  direction: (entity: RpgClientObject) => entity.direction(),
+  speed: (entity: RpgClientObject) => entity.speed(),
+  hitbox: (entity: RpgClientObject) => entity.hitbox(),
+  animation: (entity: RpgClientObject) => entity.animationName(),
+  canMove: (entity: RpgClientObject) => entity.canMove(),
+  graphics: (entity: RpgClientObject) => entity.graphics(),
+  items: (entity: RpgClientObject) => entity.items(),
+  equipments: (entity: RpgClientObject) => entity.equipments(),
+  states: (entity: RpgClientObject) => entity.states(),
+  skills: (entity: RpgClientObject) => entity.skills(),
+  effects: (entity: RpgClientObject) => entity._effects(),
+  componentsTop: (entity: RpgClientObject) => entity.componentsTop(),
+  componentsBottom: (entity: RpgClientObject) => entity.componentsBottom(),
+  componentsCenter: (entity: RpgClientObject) => entity.componentsCenter(),
+  componentsLeft: (entity: RpgClientObject) => entity.componentsLeft(),
+  componentsRight: (entity: RpgClientObject) => entity.componentsRight(),
+} as const;
+
+type EntityPropMap = typeof entityPropMap;
+type EntityPropKey = keyof EntityPropMap | ParamPropKey;
+type EntityPropValue<K extends EntityPropKey> = K extends keyof EntityPropMap
+  ? ReturnType<EntityPropMap[K]>
+  : K extends `params.${string}`
+  ? number | undefined
+  : never;
+
+const isSignal = <T>(value: unknown): value is Signal<T> =>
+  typeof value === "function";
+
+const toSignal = <T>(value: Signal<T> | T): Signal<T> =>
+  isSignal<T>(value) ? value : computed(() => value);
+
+export const getEntityProp = <K extends EntityPropKey>(
+  entity: Signal<RpgClientObject | undefined> | RpgClientObject | undefined,
+  key: K
+): Signal<EntityPropValue<K>> => {
+  const entitySignal = toSignal(entity);
+
+  return computed(() => {
+    const current = entitySignal();
+    if (!current) {
+      return undefined as EntityPropValue<K>;
+    }
+
+    if (Object.prototype.hasOwnProperty.call(entityPropMap, key)) {
+      const getter = entityPropMap[key as keyof EntityPropMap];
+      return getter(current) as EntityPropValue<K>;
+    }
+
+    if (key.startsWith("params.")) {
+      const paramKey = key.slice("params.".length);
+      return current._param?.()?.[paramKey] as EntityPropValue<K>;
+    }
+
+    return undefined as EntityPropValue<K>;
+  });
+};

package/tsconfig.json

@@ -30,6 +30,6 @@
     ],
     "typeRoots": [
         "node_modules/@types",
-        "src/types"
+        "node_modules/@rpgjs/client"
     ],
   }

package/vite.config.ts

@@ -19,12 +19,14 @@ export default defineConfig({
     sourcemap: true,
     minify: false,
     lib: {
-      entry: 'src/index.ts',
+      entry: {
+        index: 'src/index.ts'
+      },
       formats: ['es'],
-      fileName: 'index'
+      fileName: (format, entryName) => `${entryName}.js`
     },
     rollupOptions: {
-      external: [/@rpgjs/, 'esbuild', 'canvasengine', '@canvasengine/presets', 'rxjs'],
+      external: [/@rpgjs/, 'esbuild', 'canvasengine', '@canvasengine/presets', 'rxjs', 'pixi.js'],
       output: {
         preserveModules: true,
         preserveModulesRoot: 'src'

package/dist/Game/EffectManager.d.ts

@@ -1,5 +0,0 @@
-import { RpgCommonPlayer } from '@rpgjs/common';
-export declare class EffectManager {
-    current: import('canvasengine').WritableArraySignal<any[]>;
-    displayEffect(params: any, player: RpgCommonPlayer): void;
-}

package/dist/components/effects/index.d.ts

@@ -1,4 +0,0 @@
-export declare const PrebuiltEffects: {
-    Hit: any;
-    Animation: any;
-};

package/dist/index10.js

@@ -1,8 +0,0 @@
-import component from './index22.js';
-
-const PrebuiltGui = {
-  Dialogbox: component
-};
-
-export { PrebuiltGui };
-//# sourceMappingURL=index10.js.map

package/dist/index10.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"index10.js","sources":["../src/components/gui/index.ts"],"sourcesContent":["import Dialogbox from \"./dialogbox/index.ce\";\n\nexport const PrebuiltGui = {\n    Dialogbox\n}"],"names":["Dialogbox"],"mappings":";;AAEO,MAAM,WAAc,GAAA;AAAA,aACvBA;AACJ;;;;"}

package/dist/index11.js

@@ -1,10 +0,0 @@
-import component$1 from './index23.js';
-import component from './index24.js';
-
-const PrebuiltEffects = {
-  Hit: component$1,
-  Animation: component
-};
-
-export { PrebuiltEffects };
-//# sourceMappingURL=index11.js.map

package/dist/index11.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"index11.js","sources":["../src/components/effects/index.ts"],"sourcesContent":["import Hit from \"./hit.ce\";\nimport Animation from \"./animation.ce\";\n\nexport const PrebuiltEffects = {\n    Hit,\n    Animation\n}"],"names":["Hit","Animation"],"mappings":";;;AAGO,MAAM,eAAkB,GAAA;AAAA,OAC3BA,WAAA;AAAA,aACAC;AACJ;;;;"}

package/dist/index12.js

@@ -1,8 +0,0 @@
-import { RMSpritesheet } from './index25.js';
-
-const Presets = {
-  RMSpritesheet
-};
-
-export { Presets };
-//# sourceMappingURL=index12.js.map

package/dist/index12.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"index12.js","sources":["../src/presets/index.ts"],"sourcesContent":["import { RMSpritesheet } from \"./rmspritesheet\";\n\nexport const Presets = {\n    RMSpritesheet\n}"],"names":[],"mappings":";;AAEO,MAAM,OAAU,GAAA;AAAA,EACnB;AACJ;;;;"}

package/dist/index13.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"index13.js","sources":["../src/components/scenes/event-layer.ce"],"sourcesContent":["<Container sortableChildren={true}>\n    @for ((event,id) of events) {\n        <Character id={id} object={event} isMe={false}  />\n    }\n\n    @for ((player,id) of players) {\n        <Character id={id} object={player} isMe={true} />\n    }\n</Container>\n\n<script>\n    import { effect, signal, computed, mount } from 'canvasengine'\n    import { inject } from \"../../core/inject\";\n    import { RpgClientEngine } from \"../../RpgClientEngine\";\n    import Character from \"../character.ce\";\n   \n    const engine = inject(RpgClientEngine);\n    const players = engine.sceneMap.players\n    const events = engine.sceneMap.events\n</script>"],"names":["Character"],"mappings":";;;;;AAQqB,SAAS,SAAS,CAAC,OAAO,EAAE;AACjD,QAAuB,QAAQ,CAAC,OAAO;AACvC,QAA4B,cAAc,CAAC,OAAO;AAClD,QAAQ,IAAI,MAAM,GAAG,MAAM,CAAC,eAAe,CAAC;AAC5C,IAAI,OAAO,GAAG,MAAM,CAAC,QAAQ,CAAC,OAAO;AACrC,IAAI,MAAM,GAAG,MAAM,CAAC,QAAQ,CAAC;AAC7B,QAAQ,IAAI,KAAK,GAAG,CAAC,CAAC,SAAS,EAAE,EAAE,gBAAgB,EAAE,IAAI,EAAE,EAAE,CAAC,IAAI,CAAC,MAAM,EAAE,CAAC,KAAK,EAAE,EAAE,KAAK,CAAC,CAACA,WAAS,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,MAAM,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,CAAC,CAAC,EAAE,IAAI,CAAC,OAAO,EAAE,CAAC,MAAM,EAAE,EAAE,KAAK,CAAC,CAACA,WAAS,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,IAAI,EAAE,CAAC,CAAC,CAAC;AACrO,QAAQ,OAAO;AACf;;;;"}