@opensumi/playwright 2.21.13 → 2.22.0

package/src/text-editor.ts

@@ -0,0 +1,333 @@
+import { ElementHandle, Page } from '@playwright/test';
+
+import { OpenSumiApp } from './app';
+import { OpenSumiContextMenu } from './context-menu';
+import { OpenSumiEditor } from './editor';
+import { OpenSumiTreeNode } from './tree-node';
+import { keypressWithCmdCtrl, keypressWithCmdCtrlAndShift } from './utils';
+
+abstract class ViewsModel {
+  constructor(readonly page: Page) {}
+  protected viewElement: ElementHandle<SVGElement | HTMLElement> | null;
+  async mount(v: ElementHandle<SVGElement | HTMLElement> | null): Promise<void> {
+    this.viewElement = v;
+  }
+}
+
+class GlyphMarginModel extends ViewsModel {
+  async getElement() {
+    const glyphMargin = await this.viewElement?.$('.glyph-margin');
+    const parent = await glyphMargin?.getProperty('parentNode');
+    return parent?.asElement();
+  }
+
+  async getOverlay(lineNumber: number) {
+    const margin = await this.getElement();
+    const overlays = await margin?.$$('.margin-view-overlays > div');
+    if (!overlays) {
+      return;
+    }
+
+    for (const node of overlays) {
+      const lineNode = await node.$('.line-numbers');
+      const content = await lineNode?.textContent();
+      if (content === lineNumber.toString()) {
+        return node;
+      }
+    }
+  }
+
+  async hasBreakpoint(node: ElementHandle<SVGElement | HTMLElement>): Promise<boolean> {
+    return !!(await node.$('.sumi-debug-breakpoint'));
+  }
+
+  async hasTopStackFrame(node: ElementHandle<SVGElement | HTMLElement>): Promise<boolean> {
+    return !!(await node.$('.sumi-debug-top-stack-frame'));
+  }
+
+  async hasTopStackFrameLine(node: ElementHandle<SVGElement | HTMLElement>): Promise<boolean> {
+    return !!(await node.$('.sumi-debug-top-stack-frame-line'));
+  }
+}
+
+class OverlaysModel extends ViewsModel {
+  async getElement() {
+    return await this.viewElement?.$('.view-overlays');
+  }
+
+  async getOverlay(lineNumber: number) {
+    const element = await this.getElement();
+    const overlay = await element?.$(`div:nth-child(${lineNumber})`);
+    return overlay;
+  }
+}
+
+export class OpenSumiTextEditor extends OpenSumiEditor {
+  private glyphMarginModel: GlyphMarginModel;
+  private overlaysModel: OverlaysModel;
+
+  constructor(app: OpenSumiApp, filestatElement: OpenSumiTreeNode) {
+    super(app, filestatElement);
+    this.glyphMarginModel = new GlyphMarginModel(this.page);
+    this.overlaysModel = new OverlaysModel(this.page);
+  }
+
+  async getGlyphMarginModel() {
+    const viewElement = await this.getViewElement();
+    this.glyphMarginModel.mount(viewElement);
+    return this.glyphMarginModel;
+  }
+
+  async getOverlaysModel() {
+    const viewElement = await this.getViewElement();
+    this.overlaysModel.mount(viewElement);
+    return this.overlaysModel;
+  }
+
+  async openLineContextMenuByLineNumber(lineNumber: number) {
+    const existingLine = await this.lineByLineNumber(lineNumber);
+    if (!existingLine) {
+      return;
+    }
+    return OpenSumiContextMenu.open(this.app, async () => existingLine);
+  }
+
+  async openGlyphMarginContextMenu() {
+    const glyphMargin = await this.getGlyphMarginModel();
+    const view = await glyphMargin.getElement();
+    if (!view) {
+      return;
+    }
+    return OpenSumiContextMenu.open(this.app, async () => view);
+  }
+
+  async openTabContextMenu() {
+    const view = await this.getTab();
+    if (!view) {
+      return;
+    }
+    return OpenSumiContextMenu.open(this.app, async () => view);
+  }
+
+  async numberOfLines(): Promise<number | undefined> {
+    await this.activate();
+    const viewElement = await this.getViewElement();
+    const lineElements = await viewElement?.$$('.view-lines .view-line');
+    return lineElements?.length;
+  }
+
+  async textContentOfLineByLineNumber(lineNumber: number): Promise<string | undefined> {
+    const lineElement = await this.lineByLineNumber(lineNumber);
+    const content = await lineElement?.textContent();
+    return content ? this.replaceEditorSymbolsWithSpace(content) : undefined;
+  }
+
+  async replaceLineWithLineNumber(text: string, lineNumber: number): Promise<void> {
+    await this.selectLineWithLineNumber(lineNumber);
+    await this.typeTextAndHitEnter(text);
+  }
+
+  protected async typeTextAndHitEnter(text: string): Promise<void> {
+    await this.page.keyboard.type(text);
+    await this.page.keyboard.press('Enter');
+  }
+
+  async typeText(text: string): Promise<void> {
+    await this.page.keyboard.type(text);
+  }
+  async saveByKeyboard(): Promise<void> {
+    await this.page.keyboard.press(keypressWithCmdCtrl('s'));
+    await this.waitForEditorDone();
+  }
+  async undoByKeyboard(): Promise<void> {
+    await this.page.keyboard.press(keypressWithCmdCtrl('z'));
+    await this.waitForEditorDone();
+  }
+  async redoByKeyboard(): Promise<void> {
+    await this.page.keyboard.press(keypressWithCmdCtrlAndShift('z'));
+    await this.waitForEditorDone();
+  }
+
+  async selectLineWithLineNumber(lineNumber: number): Promise<ElementHandle<SVGElement | HTMLElement> | undefined> {
+    await this.activate();
+    const lineElement = await this.lineByLineNumber(lineNumber);
+    await this.selectLine(lineElement);
+    return lineElement;
+  }
+
+  async placeCursorInLineWithLineNumber(
+    lineNumber: number,
+  ): Promise<ElementHandle<SVGElement | HTMLElement> | undefined> {
+    await this.activate();
+    const lineElement = await this.lineByLineNumber(lineNumber);
+    await this.placeCursorInLine(lineElement);
+    return lineElement;
+  }
+
+  async placeCursorInLineWithPosition(
+    lineNumber: number,
+    columnNumber: number,
+  ): Promise<ElementHandle<SVGElement | HTMLElement> | undefined> {
+    await this.activate();
+    const lineElement = await this.lineByLineNumber(lineNumber);
+    await this.placeCursorInLine(lineElement, 'start');
+    for (let i = 0; i < columnNumber; i++) {
+      await this.page.keyboard.press('ArrowRight', { delay: 200 });
+    }
+    return lineElement;
+  }
+
+  async deleteLineByLineNumber(lineNumber: number): Promise<void> {
+    await this.selectLineWithLineNumber(lineNumber);
+    await this.page.keyboard.press('Backspace');
+  }
+
+  async getGlyphMarginElement() {
+    await this.activate();
+    const viewElement = await this.getViewElement();
+    return await viewElement?.$('.glyph-margin');
+  }
+
+  async getCursorElement(): Promise<ElementHandle<SVGElement | HTMLElement> | undefined> {
+    const viewElement = await this.getViewElement();
+
+    const cursorNode = await viewElement?.$('.cursor.monaco-mouse-cursor-text');
+    if (cursorNode) {
+      return cursorNode;
+    }
+  }
+
+  async getCursorLineNumber(node: ElementHandle<SVGElement | HTMLElement> | undefined) {
+    const style = await node!.getAttribute('style');
+    const tops = style?.match(/top: [0-9]*px;/g) || ['0'];
+    const topNums = tops[0].match(/\d+/g);
+    if (topNums && topNums.length > 0) {
+      let topNum: number | string = topNums[0];
+      topNum = Number(topNum);
+
+      // 每个 view-lines 默认高度都是 18
+      const line = topNum / 18 + 1;
+      return line;
+    }
+    return undefined;
+  }
+  async lineByLineNumber(lineNumber: number): Promise<ElementHandle<SVGElement | HTMLElement> | undefined> {
+    await this.activate();
+    const viewElement = await this.getViewElement();
+
+    const lineNode = await viewElement!.$(`.view-lines > div:nth-child(${lineNumber})`);
+
+    if (!lineNode) {
+      throw new Error(`Couldn't retrieve lines of text editor ${this.tabSelector}`);
+    }
+    return lineNode.asElement();
+  }
+
+  async textContentOfLineContainingText(text: string): Promise<string | undefined> {
+    await this.activate();
+    const lineElement = await this.lineContainingText(text);
+    const content = await lineElement?.textContent();
+    return content ? this.replaceEditorSymbolsWithSpace(content) : undefined;
+  }
+
+  async replaceLineContainingText(newText: string, oldText: string): Promise<void> {
+    await this.selectLineContainingText(oldText);
+    await this.typeTextAndHitEnter(newText);
+  }
+
+  async selectLineContainingText(text: string): Promise<ElementHandle<SVGElement | HTMLElement> | undefined> {
+    await this.activate();
+    const lineElement = await this.lineContainingText(text);
+    await this.selectLine(lineElement);
+    return lineElement;
+  }
+
+  async placeCursorInLineContainingText(text: string): Promise<ElementHandle<SVGElement | HTMLElement> | undefined> {
+    await this.activate();
+    const lineElement = await this.lineContainingText(text);
+    await this.placeCursorInLine(lineElement);
+    return lineElement;
+  }
+
+  async deleteLineContainingText(text: string): Promise<void> {
+    await this.selectLineContainingText(text);
+    await this.page.keyboard.press('Backspace');
+  }
+
+  async addTextToNewLineAfterLineContainingText(textContainedByExistingLine: string, newText: string): Promise<void> {
+    const existingLine = await this.lineContainingText(textContainedByExistingLine);
+    await this.placeCursorInLine(existingLine);
+    await this.page.keyboard.press('End');
+    await this.page.keyboard.press('Enter');
+    await this.page.keyboard.type(newText);
+  }
+
+  async addTextToNewLineAfterLineByLineNumber(lineNumber: number, newText: string): Promise<void> {
+    const existingLine = await this.lineByLineNumber(lineNumber);
+    await this.placeCursorInLine(existingLine);
+    await this.page.keyboard.press('End');
+    await this.page.keyboard.press('Enter');
+    await this.page.keyboard.type(newText);
+  }
+
+  async pasteContentAfterLineByLineNumber(lineNumber: number): Promise<void> {
+    const existingLine = await this.lineByLineNumber(lineNumber);
+    await this.placeCursorInLine(existingLine);
+    await this.page.keyboard.press('End');
+    await this.page.keyboard.press(keypressWithCmdCtrl('KeyV'));
+  }
+
+  protected async lineContainingText(text: string): Promise<ElementHandle<SVGElement | HTMLElement> | undefined> {
+    const viewElement = await this.getViewElement();
+    return viewElement?.waitForSelector(`.view-lines .view-line:has-text("${text}")`);
+  }
+
+  protected async selectLine(lineElement: ElementHandle<SVGElement | HTMLElement> | undefined): Promise<void> {
+    await lineElement?.click({ clickCount: 3 });
+  }
+
+  async placeCursorInLine(
+    lineElement: ElementHandle<SVGElement | HTMLElement> | undefined,
+    point: 'start' | 'end' = 'end',
+  ): Promise<void> {
+    if (!lineElement) {
+      return;
+    }
+
+    if (point === 'start') {
+      await lineElement.click({
+        position: { x: 0, y: 0 },
+      });
+      return;
+    }
+
+    await lineElement.click();
+  }
+
+  protected replaceEditorSymbolsWithSpace(content: string): string | Promise<string | undefined> {
+    // [ ] &nbsp; => \u00a0
+    // [·] &middot; => \u00b7
+    return content.replace(/[\u00a0\u00b7]/g, ' ');
+  }
+
+  protected async selectedSuggestion(): Promise<ElementHandle<SVGElement | HTMLElement>> {
+    return this.page.waitForSelector(this.viewSelector + ' .monaco-list-row.show-file-icons.focused');
+  }
+
+  async getSelectedSuggestionText(): Promise<string> {
+    const suggestion = await this.selectedSuggestion();
+    const text = await suggestion.textContent();
+    if (text === null) {
+      throw new Error('Text content could not be found');
+    }
+    return text;
+  }
+
+  async clearContent() {
+    const line = await this.lineByLineNumber(1);
+    await line?.click();
+    await this.placeCursorInLine(line);
+    await this.page.keyboard.press(keypressWithCmdCtrl('KeyA'));
+    await this.page.keyboard.press('Delete');
+  }
+}

package/src/tree-node.ts

@@ -0,0 +1,98 @@
+import { ElementHandle } from '@playwright/test';
+
+import { OpenSumiApp } from './app';
+import { OpenSumiContextMenu } from './context-menu';
+
+export interface IOpenSumiTreeNodeSelector {
+  labelClass: string;
+  descriptionClass: string;
+  badgeClass: string;
+  toggleClass: string;
+  selectedClass: string;
+  focusedClass: string;
+  collapsedClass: string;
+}
+
+export abstract class OpenSumiTreeNode {
+  constructor(
+    protected elementHandle: ElementHandle<SVGElement | HTMLElement>,
+    protected app: OpenSumiApp,
+    private selector: IOpenSumiTreeNodeSelector = {
+      labelClass: "[class*='node_displayname__']",
+      descriptionClass: "[class*='node_description__']",
+      badgeClass: "[class*='node_status___']",
+      toggleClass: "[class*='expansion_toggle__']",
+      selectedClass: "[class*='mod_selected__']",
+      focusedClass: "[class*='mod_focused__']",
+      collapsedClass: "[class*='mod_collapsed__']",
+    },
+  ) {}
+
+  async parentElementHandle() {
+    const parent = await this.elementHandle.getProperty('parentNode');
+    return parent.asElement();
+  }
+
+  async label() {
+    const labelElement = await this.elementHandle.$(this.selector.labelClass);
+    if (!labelElement) {
+      throw new Error(`Cannot read label from ${this.selector.labelClass} of ${this.elementHandle}`);
+    }
+    return labelElement.textContent();
+  }
+
+  async description() {
+    const descriptionElement = await this.elementHandle.$(this.selector.descriptionClass);
+    if (!descriptionElement) {
+      throw new Error(`Cannot read description from ${this.selector.descriptionClass} of ${this.elementHandle}`);
+    }
+    return descriptionElement.textContent();
+  }
+
+  async badge() {
+    const badgeElement = await this.elementHandle.$(this.selector.badgeClass);
+    if (!badgeElement) {
+      throw new Error(`Cannot read description from ${this.selector.badgeClass} of ${this.elementHandle}`);
+    }
+    return badgeElement.textContent();
+  }
+
+  async isSelected() {
+    const id = await this.elementHandle.getAttribute('data-id');
+    const parent = await this.parentElementHandle();
+    return !!(await parent?.$(`[data-id='${id}']${this.selector.selectedClass}`));
+  }
+
+  async isCollapsed() {
+    return !!(await this.elementHandle.$(this.selector.collapsedClass));
+  }
+
+  async isExpanded() {
+    return !(await this.elementHandle.$(this.selector.collapsedClass));
+  }
+
+  async expand() {
+    if (await this.isExpanded()) {
+      return;
+    }
+    const toggle = await this.elementHandle.waitForSelector(this.selector.toggleClass);
+    await toggle.click();
+    await this.elementHandle.waitForSelector(`${this.selector.toggleClass}:not(${this.selector.collapsedClass})`);
+  }
+
+  async collapse() {
+    if (await this.isCollapsed()) {
+      return;
+    }
+    const toggle = await this.elementHandle.waitForSelector(this.selector.toggleClass);
+    await toggle.click();
+    await this.elementHandle.waitForSelector(`${this.selector.collapsedClass}`);
+  }
+
+  async openContextMenu() {
+    return OpenSumiContextMenu.open(this.app, () => this.elementHandle.waitForSelector(this.selector.labelClass));
+  }
+
+  abstract getFsPath(): Promise<string | null>;
+  abstract open(preview?: boolean): Promise<void>;
+}

package/src/utils/element.ts

@@ -0,0 +1,35 @@
+import { ElementHandle } from '@playwright/test';
+
+export async function isElementVisible(elementPromise: Promise<ElementHandle<SVGElement | HTMLElement> | null>) {
+  const element = await elementPromise;
+  return element ? element.isVisible() : false;
+}
+
+export async function containsClass(
+  elementPromise: Promise<ElementHandle<SVGElement | HTMLElement> | null> | undefined,
+  cssClass: string,
+) {
+  return elementContainsClass(await elementPromise, cssClass);
+}
+
+export async function elementContainsClass(
+  element: ElementHandle<SVGElement | HTMLElement> | null | undefined,
+  cssClass: string,
+) {
+  if (element) {
+    const classValue = await element.getAttribute('class');
+    if (classValue) {
+      return classValue?.split(' ').includes(cssClass);
+    }
+  }
+  return false;
+}
+
+export async function textContent(elementPromise: Promise<ElementHandle<SVGElement | HTMLElement> | null>) {
+  const element = await elementPromise;
+  if (!element) {
+    return undefined;
+  }
+  const content = await element.textContent();
+  return content ? content : undefined;
+}

package/src/utils/index.ts

@@ -0,0 +1,2 @@
+export * from './element';
+export * from './key';

package/src/utils/key.ts

@@ -0,0 +1,11 @@
+import { isMacintosh, isWindows } from '@opensumi/ide-utils';
+
+export const keypressWithCmdCtrl = (key: string) => {
+  const modifier = isMacintosh ? 'Meta' : isWindows ? 'Ctrl' : 'Control';
+  return `${modifier}+${key}`;
+};
+
+export const keypressWithCmdCtrlAndShift = (key: string) => {
+  const modifier = isMacintosh ? 'Meta' : isWindows ? 'Ctrl' : 'Control';
+  return `${modifier}+Shift+${key}`;
+};

package/src/view-base.ts

@@ -0,0 +1,11 @@
+import { ElementHandle, Page } from '@playwright/test';
+
+import { OpenSumiApp } from './app';
+
+export abstract class OpenSumiViewBase {
+  constructor(public app: OpenSumiApp) {}
+
+  get page(): Page {
+    return this.app.page;
+  }
+}

package/src/view.ts

@@ -0,0 +1,90 @@
+import { ElementHandle } from '@playwright/test';
+
+import { OpenSumiApp } from './app';
+import { isElementVisible, containsClass } from './utils';
+import { OpenSumiViewBase } from './view-base';
+
+export interface OpenSumiViewInfo {
+  tabSelector: string;
+  viewSelector: string;
+  name?: string;
+}
+
+export class OpenSumiView extends OpenSumiViewBase {
+  constructor(app: OpenSumiApp, private readonly data: OpenSumiViewInfo) {
+    super(app);
+  }
+
+  get tabSelector() {
+    return this.data.tabSelector;
+  }
+
+  get viewSelector() {
+    return this.data.viewSelector;
+  }
+
+  get name() {
+    return this.data.name;
+  }
+
+  getViewElement(): Promise<ElementHandle<SVGElement | HTMLElement> | null> {
+    return this.page.$(this.viewSelector);
+  }
+
+  getTabElement(): Promise<ElementHandle<SVGElement | HTMLElement> | null> {
+    return this.page.$(this.tabSelector);
+  }
+
+  async open(): Promise<OpenSumiView | undefined> {
+    if (!this.name) {
+      return;
+    }
+    await this.app.quickOpenPalette.type('view ');
+    await this.app.quickOpenPalette.trigger(this.name.toUpperCase());
+    await this.waitForVisible();
+    return this;
+  }
+
+  async focus(): Promise<void> {
+    await this.activate();
+    const view = await this.getViewElement();
+    await view?.click();
+  }
+
+  async activate(): Promise<void> {
+    await this.page.waitForSelector(this.tabSelector, { state: 'visible' });
+    if (!(await this.isActive())) {
+      const tab = await this.getTabElement();
+      await tab?.click();
+    }
+    return this.waitForVisible();
+  }
+
+  async waitForVisible(): Promise<void> {
+    await this.page.waitForSelector(this.viewSelector, { state: 'visible' });
+  }
+
+  async isTabVisible(): Promise<boolean> {
+    return isElementVisible(this.getTabElement());
+  }
+
+  async isDisplayed(): Promise<boolean> {
+    return isElementVisible(this.getViewElement());
+  }
+
+  async isActive(): Promise<boolean> {
+    return (await this.isTabVisible()) && containsClass(this.getTabElement(), 'p-mod-current');
+  }
+
+  async isClosable(): Promise<boolean> {
+    return (await this.isTabVisible()) && containsClass(this.getTabElement(), 'p-mod-closable');
+  }
+
+  async isVisible() {
+    return this.isTabVisible();
+  }
+
+  protected async waitUntilClosed(): Promise<void> {
+    await this.page.waitForSelector(this.tabSelector, { state: 'detached' });
+  }
+}

package/src/workspace.ts

@@ -0,0 +1,36 @@
+import path from 'path';
+
+import fse from 'fs-extra';
+import temp from 'temp';
+
+import { Disposable, URI } from '@opensumi/ide-utils';
+
+export class OpenSumiWorkspace extends Disposable {
+  private workspacePath: string;
+
+  constructor(private filesToWorkspace: string[]) {
+    super();
+    const track = temp.track();
+    this.disposables.push({
+      dispose: () => {
+        track.cleanupSync();
+      },
+    });
+    this.workspacePath = fse.realpathSync(path.join(temp.mkdirSync('workspace')));
+  }
+
+  get workspace() {
+    return new URI(this.workspacePath);
+  }
+
+  async initWorksapce() {
+    if (!fse.existsSync(this.workspacePath)) {
+      await fse.ensureDir(this.workspacePath);
+    }
+    for (const file of this.filesToWorkspace) {
+      if (fse.existsSync(file)) {
+        await fse.copy(file, this.workspacePath);
+      }
+    }
+  }
+}

package/lib/terminal.d.ts

@@ -1,7 +0,0 @@
-import { OpenSumiApp } from './app';
-import { OpenSumiPanel } from './panel';
-export declare class OpenSumiTerminal extends OpenSumiPanel {
-    constructor(app: OpenSumiApp);
-    sendText(text: string): Promise<void>;
-}
-//# sourceMappingURL=terminal.d.ts.map

package/lib/terminal.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"terminal.d.ts","sourceRoot":"","sources":["../src/terminal.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,OAAO,CAAC;AACpC,OAAO,EAAE,aAAa,EAAE,MAAM,SAAS,CAAC;AAExC,qBAAa,gBAAiB,SAAQ,aAAa;gBACrC,GAAG,EAAE,WAAW;IAItB,QAAQ,CAAC,IAAI,EAAE,MAAM;CAa5B"}

package/lib/terminal.js

@@ -1,25 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.OpenSumiTerminal = void 0;
-const panel_1 = require("./panel");
-class OpenSumiTerminal extends panel_1.OpenSumiPanel {
-    constructor(app) {
-        super(app, 'terminal');
-    }
-    async sendText(text) {
-        var _a;
-        const visible = await this.isVisible();
-        if (!visible) {
-            await this.open();
-        }
-        await this.focus();
-        const box = await ((_a = this.view) === null || _a === void 0 ? void 0 : _a.boundingBox());
-        if (box) {
-            await this.app.page.mouse.click(box.x + (box === null || box === void 0 ? void 0 : box.width) / 2, box.y + (box === null || box === void 0 ? void 0 : box.height) / 2);
-        }
-        await this.page.keyboard.type(text);
-        await this.app.page.keyboard.press('Enter');
-    }
-}
-exports.OpenSumiTerminal = OpenSumiTerminal;
-//# sourceMappingURL=terminal.js.map

package/lib/terminal.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"terminal.js","sourceRoot":"","sources":["../src/terminal.ts"],"names":[],"mappings":";;;AACA,mCAAwC;AAExC,MAAa,gBAAiB,SAAQ,qBAAa;IACjD,YAAY,GAAgB;QAC1B,KAAK,CAAC,GAAG,EAAE,UAAU,CAAC,CAAC;IACzB,CAAC;IAED,KAAK,CAAC,QAAQ,CAAC,IAAY;;QACzB,MAAM,OAAO,GAAG,MAAM,IAAI,CAAC,SAAS,EAAE,CAAC;QACvC,IAAI,CAAC,OAAO,EAAE;YACZ,MAAM,IAAI,CAAC,IAAI,EAAE,CAAC;SACnB;QACD,MAAM,IAAI,CAAC,KAAK,EAAE,CAAC;QACnB,MAAM,GAAG,GAAG,MAAM,CAAA,MAAA,IAAI,CAAC,IAAI,0CAAE,WAAW,EAAE,CAAA,CAAC;QAC3C,IAAI,GAAG,EAAE;YACP,MAAM,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,GAAG,CAAA,GAAG,aAAH,GAAG,uBAAH,GAAG,CAAE,KAAK,IAAG,CAAC,EAAE,GAAG,CAAC,CAAC,GAAG,CAAA,GAAG,aAAH,GAAG,uBAAH,GAAG,CAAE,MAAM,IAAG,CAAC,CAAC,CAAC;SAClF;QACD,MAAM,IAAI,CAAC,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QACpC,MAAM,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,QAAQ,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC;IAC9C,CAAC;CACF;AAlBD,4CAkBC"}