@quantform/core 0.3.221 → 0.3.229

package/src/bin.ts

@@ -10,6 +10,7 @@ import { Store } from './store';
 import { instrumentOf } from './domain';
 import { Topic, event, handler } from './common/topic';
 import minimist = require('minimist');
+import { Logger } from './common';
 
 export interface IpcCommand {
   type;
@@ -86,7 +87,7 @@ class ExecutionHandler extends Topic<{ type: string }, ExecutionAccessor> {
   @handler(IpcBacktestModeCommand)
   onBacktestMode(command: IpcBacktestModeCommand, accessor: ExecutionAccessor) {
     return new Promise<void>(async resolve => {
-      accessor.session = backtest(this.descriptor, {
+      const [session, streamer] = backtest(this.descriptor, {
         from: command.from,
         to: command.to,
         balance: command.balance,
@@ -110,9 +111,12 @@ class ExecutionHandler extends Topic<{ type: string }, ExecutionAccessor> {
         }
       });
 
+      accessor.session = session;
+
       this.notify({ type: 'backtest:started' });
 
       await accessor.session.awake();
+      await streamer.tryContinue().catch(it => Logger.error(it));
     });
   }
 
@@ -197,7 +201,7 @@ export async function run(
 export function backtest(
   descriptor: SessionDescriptor,
   options: BacktesterOptions
-): Session {
+): [Session, BacktesterStreamer] {
   const store = new Store();
 
   const streamer = new BacktesterStreamer(store, descriptor.feed, options);
@@ -208,7 +212,7 @@ export function backtest(
     )
   );
 
-  return new Session(store, aggregate, descriptor);
+  return [new Session(store, aggregate, descriptor), streamer];
 }
 
 export function paper(descriptor: SessionDescriptor, options: PaperOptions): Session {

package/src/session/session-descriptor.ts

@@ -8,20 +8,13 @@ import { Observable } from 'rxjs';
 export interface SessionDescriptor {
   id: number;
 
-  /**
-   * defines supported adapters by this strategy.
-   */
+  // provides trading adapters.
   adapter: Adapter[];
 
-  /**
-   * defines input and output feed for backtesting purposes.
-   */
-
+  // provides input and output feed for backtesting purposes.
   feed?: Feed;
 
-  /**
-   * defines measurement storage.
-   */
+  // defines measurement storage.
   measurement?: Measurement;
 
   behaviour?: Behaviour | Behaviour[] | ((session: Session) => Observable<any>);

package/src/session/session.ts

@@ -3,6 +3,7 @@ import {
   filter,
   map,
   mergeMap,
+  share,
   shareReplay,
   startWith,
   switchMap,
@@ -20,13 +21,12 @@ import {
   OrderState
 } from '../domain';
 import { Store } from '../store';
-import { from, Observable, Subscription } from 'rxjs';
+import { concat, from, Observable, Subject, Subscription } from 'rxjs';
 import { Behaviour, CombinedBehaviour, FunctionBehaviour } from '../behaviour';
 import { AdapterAggregate } from '../adapter/adapter-aggregate';
 import { Worker } from '../common';
 import { Trade } from '../domain/trade';
 import { SessionDescriptor } from './session-descriptor';
-import { Measure } from '../storage/measurement';
 import {
   AdapterHistoryQuery,
   AdapterOrderCancelCommand,
@@ -34,12 +34,18 @@ import {
   AdapterSubscribeCommand
 } from '../adapter';
 
+type Optional<T, K extends keyof T> = Omit<T, K> & Partial<T>;
+
 export class Session {
   private initialized = false;
   private subscription: Subscription;
   private behaviour: Behaviour;
   private worker = new Worker();
 
+  get timestamp(): number {
+    return this.store.snapshot.timestamp;
+  }
+
   constructor(
     readonly store: Store,
     readonly aggregate: AdapterAggregate,
@@ -91,30 +97,41 @@ export class Session {
     this.behaviour.statement(output);
   }
 
-  useMeasure<T extends Measure>(
-    params: { key: string; timestamp?: number },
+  useMeasure<T extends { timestamp: number }>(
+    params: { kind: string; timestamp?: number },
     defaultValue: T = undefined
-  ): [Observable<T>, (value: T) => void] {
-    const query$ = from(
+  ): [Observable<T>, (value: Optional<T, 'timestamp'>) => void] {
+    const stored$ = from(
       this.descriptor.measurement.query(this.descriptor.id, {
-        type: params.key,
-        timestamp: params.timestamp ?? this.store.snapshot.timestamp,
-        limit: 1,
-        direction: 'BACKWARD'
+        to: params.timestamp ?? this.timestamp,
+        kind: params.kind,
+        count: 1
       })
-    ).pipe(map(it => (it.length ? (it[0] as T) : defaultValue)));
+    ).pipe(
+      map(it =>
+        it.length ? { timestamp: it[0].timestamp, ...it[0].payload } : defaultValue
+      ),
+      share()
+    );
+
+    const subject$ = new Subject<T>();
 
     const setter = (value: T) => {
+      const timestamp = value.timestamp ?? this.timestamp;
+      const measure = { timestamp, kind: params.kind, payload: value };
+
       this.worker.enqueue(() =>
-        this.descriptor.measurement.save(this.descriptor.id, [value])
+        this.descriptor.measurement.save(this.descriptor.id, [measure])
       );
+
+      subject$.next({ ...value, timestamp });
     };
 
-    return [query$, setter];
+    return [concat(stored$, subject$.asObservable()), setter];
   }
 
   useOptimizer(path: string): any {
-    return 0;
+    return undefined;
   }
 
   async subscribe(instrument: Array<InstrumentSelector>): Promise<void> {

package/src/storage/feed.ts

@@ -1,13 +1,38 @@
 import { StoreEvent } from '../store/event';
 import { InstrumentSelector } from '../domain';
-import { timestamp } from '../common';
+import { Storage, StorageQueryOptions } from './storage';
 
-export interface Feed {
-  read(
+export class Feed {
+  constructor(private readonly storage: Storage) {}
+
+  index(): Promise<Array<string>> {
+    return this.storage.index();
+  }
+
+  save(instrument: InstrumentSelector, events: StoreEvent[]): Promise<void> {
+    return this.storage.save(
+      instrument.toString(),
+      events.map(it => ({
+        timestamp: it.timestamp,
+        kind: it.type,
+        json: JSON.stringify(it, (key, value) =>
+          key != 'timestamp' && key != 'type' && key != 'instrument' ? value : undefined
+        )
+      }))
+    );
+  }
+
+  async query(
     instrument: InstrumentSelector,
-    from: timestamp,
-    to: timestamp
-  ): Promise<StoreEvent[]>;
+    options: StorageQueryOptions
+  ): Promise<StoreEvent[]> {
+    const rows = await this.storage.query(instrument.toString(), options);
 
-  write(instrument: InstrumentSelector, events: StoreEvent[]): Promise<void>;
+    return rows.map(it => ({
+      timestamp: it.timestamp,
+      type: it.kind,
+      instrument,
+      ...JSON.parse(it.json)
+    }));
+  }
 }

package/src/storage/index.ts

@@ -1,4 +1,3 @@
 export * from './feed';
-export * from './in-memory.feed';
-export * from './feed.interceptor';
+export * from './storage';
 export * from './measurement';

package/src/storage/measurement.ts

@@ -1,24 +1,37 @@
 import { timestamp } from '../common';
+import { Storage, StorageQueryOptions } from './storage';
 
 export interface Measure {
   timestamp: timestamp;
-  type: string;
-
-  [key: string]: any;
+  kind: string;
+  payload: any;
 }
 
-export interface Measurement {
-  index(): Promise<Array<number>>;
+export class Measurement {
+  constructor(private readonly storage: Storage) {}
+
+  async index(): Promise<Array<number>> {
+    return (await this.storage.index()).map(it => Number(it));
+  }
+
+  save(session: number, measurements: Measure[]): Promise<void> {
+    return this.storage.save(
+      session.toString(),
+      measurements.map(it => ({
+        timestamp: it.timestamp,
+        kind: it.kind,
+        json: JSON.stringify(it.payload)
+      }))
+    );
+  }
 
-  query(
-    session: number,
-    options: {
-      timestamp: timestamp;
-      type?: string;
-      limit: number;
-      direction: 'FORWARD' | 'BACKWARD';
-    }
-  ): Promise<Measure[]>;
+  async query(session: number, options: StorageQueryOptions): Promise<Measure[]> {
+    const rows = await this.storage.query(session.toString(), options);
 
-  save(session: number, measurements: Measure[]): Promise<void>;
+    return rows.map(it => ({
+      timestamp: it.timestamp,
+      kind: it.kind,
+      payload: JSON.parse(it.json)
+    }));
+  }
 }

package/src/storage/storage.ts

@@ -0,0 +1,76 @@
+export type StorageDocument = {
+  timestamp: number;
+  kind: string;
+  json: string;
+};
+
+export type StorageQueryOptions = {
+  from?: number;
+  to?: number;
+  kind?: string;
+  count: number;
+};
+
+export interface Storage {
+  index(): Promise<Array<string>>;
+
+  save(library: string, documents: StorageDocument[]): Promise<void>;
+
+  query(library: string, options: StorageQueryOptions): Promise<StorageDocument[]>;
+}
+
+export class InMemoryStorage implements Storage {
+  private tables: Record<string, StorageDocument[]> = {};
+
+  async index(): Promise<Array<string>> {
+    return Object.keys(this.tables);
+  }
+
+  async query(library: string, options: StorageQueryOptions): Promise<StorageDocument[]> {
+    if (!this.tables[library]) {
+      return [];
+    }
+
+    let query = this.tables[library];
+
+    if (options.from) {
+      query = query.filter(it => it.timestamp > options.from);
+    }
+
+    if (options.to) {
+      query = query.filter(it => it.timestamp < options.to);
+    }
+
+    if (options.kind) {
+      query = query.filter(it => it.kind == options.kind);
+    }
+
+    if (options.from == undefined && options.to) {
+      query = query.reverse();
+    }
+
+    if (options.count) {
+      query = query.slice(0, options.count);
+    }
+
+    return query;
+  }
+
+  async save(library: string, documents: StorageDocument[]): Promise<void> {
+    if (!this.tables[library]) {
+      this.tables[library] = [];
+    }
+
+    const buffer = this.tables[library];
+
+    for (const document of documents) {
+      buffer.push(document);
+    }
+
+    buffer.sort((lhs, rhs) => lhs.timestamp - rhs.timestamp);
+  }
+
+  clear() {
+    this.tables = {};
+  }
+}

package/src/store/event/store-candle.event.spec.ts

@@ -0,0 +1,32 @@
+import { Asset, Instrument } from '../../domain';
+import { CandleEvent, CandleEventHandler } from '.';
+import { State } from '../store.state';
+import { now } from '../../common';
+
+const instrument = new Instrument(
+  new Asset('btc', 'binance', 8),
+  new Asset('usdt', 'binance', 2),
+  'binance:btc-usdt'
+);
+
+describe('candle patch event tests', () => {
+  test('should patch trade object', () => {
+    const timestamp = now();
+    const state = new State();
+
+    state.universe.instrument[instrument.toString()] = instrument;
+    state.subscription.instrument[instrument.toString()] = instrument;
+
+    const event = new CandleEvent(instrument, 1, 1, 1, 1, 1, 1, timestamp);
+
+    CandleEventHandler(event, state);
+
+    const trade = state.trade[instrument.toString()];
+
+    expect(trade.timestamp).toEqual(timestamp);
+    expect(trade.instrument.toString()).toEqual(instrument.toString());
+    expect(trade.rate).toEqual(1);
+    expect(trade.quantity).toEqual(1);
+    expect(state.timestamp).toEqual(timestamp);
+  });
+});

package/src/store/event/store-candle.event.ts

@@ -1,9 +1,12 @@
 import { TradePatchEventHandler } from './store-trade.event';
+import { OrderbookPatchEventHandler } from './store-orderbook.event';
 import { timestamp } from '../../common/datetime';
 import { InstrumentSelector } from '../../domain';
 import { State } from '../store.state';
 import { StoreEvent } from './store.event';
+import { event } from '../../common/topic';
 
+@event
 export class CandleEvent implements StoreEvent {
   type = 'candle';
 
@@ -20,7 +23,10 @@ export class CandleEvent implements StoreEvent {
 }
 
 export function CandleEventHandler(event: CandleEvent, state: State) {
-  return TradePatchEventHandler(
+  const instrument = state.universe.instrument[event.instrument.toString()];
+
+  // patch trade object
+  const trade = TradePatchEventHandler(
     {
       type: 'trade-patch',
       instrument: event.instrument,
@@ -30,4 +36,22 @@ export function CandleEventHandler(event: CandleEvent, state: State) {
     },
     state
   );
+
+  // patch orderbook by assuming candle close price is mid orderbook price
+  const orderbook = OrderbookPatchEventHandler(
+    {
+      type: 'orderbook-patch',
+      instrument: event.instrument,
+      bestAskQuantity: event.volume * 0.5,
+      bestAskRate: event.close + instrument.quote.tickSize,
+      bestBidQuantity: event.volume * 0.5,
+      bestBidRate: event.close - instrument.quote.tickSize,
+      timestamp: event.timestamp
+    },
+    state
+  );
+
+  state.timestamp = event.timestamp;
+
+  return [trade, orderbook];
 }

package/src/store/event/store-trade.event.spec.ts

@@ -44,7 +44,7 @@ describe('trade patch event tests', () => {
     TradePatchEventHandler(new TradePatchEvent(instrument, 2000, 0.2, timestamp), state);
 
     expect(trade.timestamp).toEqual(timestamp);
-    expect(trade.instrument.toString()).toEqual(trade.instrument.toString());
+    expect(trade.instrument.toString()).toEqual(instrument.toString());
     expect(trade.rate).toEqual(2000);
     expect(trade.quantity).toEqual(0.2);
     expect(state.timestamp).toEqual(timestamp);

package/src/store/store.state.ts

@@ -13,6 +13,7 @@ import {
 export class State {
   timestamp: timestamp;
 
+  // all available trasing assets and instruments
   universe: {
     asset: Record<string, Asset>;
     instrument: Record<string, Instrument>;

package/src/tests/backtester-adapter.spec.ts

@@ -1,7 +1,7 @@
 import { AdapterAwakeCommand } from '../adapter';
 import { AdapterSubscribeCommand } from '../adapter';
 import { Asset, Commision, instrumentOf } from '../domain';
-import { InMemoryFeed } from '../storage';
+import { InMemoryStorage, Feed } from '../storage';
 import { Store } from '../store';
 import { InstrumentPatchEvent, TradePatchEvent } from '../store/event';
 import { Adapter, AdapterContext } from '../adapter/adapter';
@@ -43,7 +43,7 @@ class DefaultAdapter extends Adapter {
 const instrument = instrumentOf('binance:btc-usdt');
 const adapter = new DefaultAdapter();
 const store = new Store();
-const feed = new InMemoryFeed();
+const feed = new Feed(new InMemoryStorage());
 
 describe('backtester adapter tests', () => {
   test('should return proper adapter name and timestamp', () => {
@@ -78,7 +78,7 @@ describe('backtester adapter tests', () => {
       }
     });
 
-    feed.write(instrument, [new TradePatchEvent(instrument, 100, 10, 1)]);
+    feed.save(instrument, [new TradePatchEvent(instrument, 100, 10, 1)]);
 
     const sut = new BacktesterAdapter(adapter, streamer);
 

package/dist/storage/feed.interceptor.d.ts

@@ -1,14 +0,0 @@
-import { InstrumentSelector } from '../domain';
-import { StoreEvent } from '../store/event';
-import { Feed } from './feed';
-export declare abstract class FeedInterceptor implements Feed {
-    private readonly feed;
-    constructor(feed: Feed);
-    abstract intercept(instrument: InstrumentSelector, event: StoreEvent): StoreEvent | StoreEvent[];
-    read(instrument: InstrumentSelector, from: number, to: number): Promise<StoreEvent[]>;
-    write(instrument: InstrumentSelector, events: StoreEvent[]): Promise<void>;
-}
-export declare function fromCandle(feed: Feed, options: {
-    orderbook: boolean;
-    trade: boolean;
-}): Feed;

package/dist/storage/feed.interceptor.js

@@ -1,52 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.fromCandle = exports.FeedInterceptor = void 0;
-const event_1 = require("../store/event");
-class FeedInterceptor {
-    constructor(feed) {
-        this.feed = feed;
-    }
-    async read(instrument, from, to) {
-        const output = new Array();
-        for (const event of await this.feed.read(instrument, from, to)) {
-            const intercepted = this.intercept(instrument, event);
-            if (!intercepted) {
-                continue;
-            }
-            if (Array.isArray(intercepted)) {
-                output.push(...intercepted);
-            }
-            else {
-                output.push(intercepted);
-            }
-        }
-        return output;
-    }
-    write(instrument, events) {
-        return this.feed.write(instrument, events);
-    }
-}
-exports.FeedInterceptor = FeedInterceptor;
-class FeedCandleInterceptor extends FeedInterceptor {
-    constructor(feed, options) {
-        super(feed);
-        this.options = options;
-    }
-    intercept(instrument, event) {
-        const output = [];
-        if (event.type == 'candle') {
-            if (this.options.orderbook) {
-                output.push(new event_1.OrderbookPatchEvent(instrument, event.close, 0, event.close, 0, event.timestamp));
-            }
-            if (this.options.trade) {
-                output.push(new event_1.TradePatchEvent(event.instrument, event.close, 0, event.timestamp));
-            }
-            return output;
-        }
-    }
-}
-function fromCandle(feed, options) {
-    return new FeedCandleInterceptor(feed, options);
-}
-exports.fromCandle = fromCandle;
-//# sourceMappingURL=feed.interceptor.js.map

package/dist/storage/feed.interceptor.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"feed.interceptor.js","sourceRoot":"","sources":["../../src/storage/feed.interceptor.ts"],"names":[],"mappings":";;;AACA,0CAAkF;AAGlF,MAAsB,eAAe;IACnC,YAA6B,IAAU;QAAV,SAAI,GAAJ,IAAI,CAAM;IAAG,CAAC;IAO3C,KAAK,CAAC,IAAI,CACR,UAA8B,EAC9B,IAAY,EACZ,EAAU;QAEV,MAAM,MAAM,GAAG,IAAI,KAAK,EAAc,CAAC;QAEvC,KAAK,MAAM,KAAK,IAAI,MAAM,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,UAAU,EAAE,IAAI,EAAE,EAAE,CAAC,EAAE;YAC9D,MAAM,WAAW,GAAG,IAAI,CAAC,SAAS,CAAC,UAAU,EAAE,KAAK,CAAC,CAAC;YAEtD,IAAI,CAAC,WAAW,EAAE;gBAChB,SAAS;aACV;YAED,IAAI,KAAK,CAAC,OAAO,CAAC,WAAW,CAAC,EAAE;gBAC9B,MAAM,CAAC,IAAI,CAAC,GAAG,WAAW,CAAC,CAAC;aAC7B;iBAAM;gBACL,MAAM,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC;aAC1B;SACF;QAED,OAAO,MAAM,CAAC;IAChB,CAAC;IAED,KAAK,CAAC,UAA8B,EAAE,MAAoB;QACxD,OAAO,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,UAAU,EAAE,MAAM,CAAC,CAAC;IAC7C,CAAC;CACF;AAnCD,0CAmCC;AAED,MAAM,qBAAsB,SAAQ,eAAe;IACjD,YACE,IAAU,EACO,OAGhB;QAED,KAAK,CAAC,IAAI,CAAC,CAAC;QALK,YAAO,GAAP,OAAO,CAGvB;IAGH,CAAC;IAED,SAAS,CACP,UAA8B,EAC9B,KAAuB;QAEvB,MAAM,MAAM,GAAG,EAAE,CAAC;QAElB,IAAI,KAAK,CAAC,IAAI,IAAI,QAAQ,EAAE;YAC1B,IAAI,IAAI,CAAC,OAAO,CAAC,SAAS,EAAE;gBAC1B,MAAM,CAAC,IAAI,CACT,IAAI,2BAAmB,CACrB,UAAU,EACV,KAAK,CAAC,KAAK,EACX,CAAC,EACD,KAAK,CAAC,KAAK,EACX,CAAC,EACD,KAAK,CAAC,SAAS,CAChB,CACF,CAAC;aACH;YAED,IAAI,IAAI,CAAC,OAAO,CAAC,KAAK,EAAE;gBACtB,MAAM,CAAC,IAAI,CACT,IAAI,uBAAe,CAAC,KAAK,CAAC,UAAU,EAAE,KAAK,CAAC,KAAK,EAAE,CAAC,EAAE,KAAK,CAAC,SAAS,CAAC,CACvE,CAAC;aACH;YAED,OAAO,MAAM,CAAC;SACf;IACH,CAAC;CACF;AAED,SAAgB,UAAU,CACxB,IAAU,EACV,OAGC;IAED,OAAO,IAAI,qBAAqB,CAAC,IAAI,EAAE,OAAO,CAAC,CAAC;AAClD,CAAC;AARD,gCAQC"}

package/dist/storage/in-memory.feed.d.ts

@@ -1,10 +0,0 @@
-import { timestamp } from '../common';
-import { InstrumentSelector } from '../domain';
-import { StoreEvent } from '../store/event';
-import { Feed } from '.';
-export declare class InMemoryFeed implements Feed {
-    private data;
-    read(instrument: InstrumentSelector, from: timestamp, to: timestamp): Promise<StoreEvent[]>;
-    write(instrument: InstrumentSelector, events: StoreEvent[]): Promise<void>;
-    clear(): void;
-}

package/dist/storage/in-memory.feed.js

@@ -1,30 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.InMemoryFeed = void 0;
-class InMemoryFeed {
-    constructor() {
-        this.data = {};
-    }
-    async read(instrument, from, to) {
-        if (!this.data[instrument.toString()]) {
-            return [];
-        }
-        return this.data[instrument.toString()]
-            .filter(it => it.timestamp > from && it.timestamp <= to)
-            .sort((lhs, rhs) => lhs.timestamp - rhs.timestamp);
-    }
-    async write(instrument, events) {
-        if (!this.data[instrument.toString()]) {
-            this.data[instrument.toString()] = [];
-        }
-        const buffer = this.data[instrument.toString()];
-        for (const event of events) {
-            buffer.push(event);
-        }
-    }
-    clear() {
-        this.data = {};
-    }
-}
-exports.InMemoryFeed = InMemoryFeed;
-//# sourceMappingURL=in-memory.feed.js.map

package/dist/storage/in-memory.feed.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"in-memory.feed.js","sourceRoot":"","sources":["../../src/storage/in-memory.feed.ts"],"names":[],"mappings":";;;AAKA,MAAa,YAAY;IAAzB;QACU,SAAI,GAAiC,EAAE,CAAC;IA+BlD,CAAC;IA7BC,KAAK,CAAC,IAAI,CACR,UAA8B,EAC9B,IAAe,EACf,EAAa;QAEb,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,UAAU,CAAC,QAAQ,EAAE,CAAC,EAAE;YACrC,OAAO,EAAE,CAAC;SACX;QAED,OAAO,IAAI,CAAC,IAAI,CAAC,UAAU,CAAC,QAAQ,EAAE,CAAC;aACpC,MAAM,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,SAAS,GAAG,IAAI,IAAI,EAAE,CAAC,SAAS,IAAI,EAAE,CAAC;aACvD,IAAI,CAAC,CAAC,GAAG,EAAE,GAAG,EAAE,EAAE,CAAC,GAAG,CAAC,SAAS,GAAG,GAAG,CAAC,SAAS,CAAC,CAAC;IACvD,CAAC;IAED,KAAK,CAAC,KAAK,CAAC,UAA8B,EAAE,MAAoB;QAC9D,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,UAAU,CAAC,QAAQ,EAAE,CAAC,EAAE;YACrC,IAAI,CAAC,IAAI,CAAC,UAAU,CAAC,QAAQ,EAAE,CAAC,GAAG,EAAE,CAAC;SACvC;QAED,MAAM,MAAM,GAAG,IAAI,CAAC,IAAI,CAAC,UAAU,CAAC,QAAQ,EAAE,CAAC,CAAC;QAEhD,KAAK,MAAM,KAAK,IAAI,MAAM,EAAE;YAC1B,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;SACpB;IACH,CAAC;IAED,KAAK;QACH,IAAI,CAAC,IAAI,GAAG,EAAE,CAAC;IACjB,CAAC;CACF;AAhCD,oCAgCC"}