@kerebron/extension-menu 0.4.2 → 0.4.4

package/esm/extension-lsp/src/computeIncrementalChanges.js

@@ -0,0 +1,82 @@
+/**
+ * Compares two strings and computes the minimal set of text changes
+ * using a diff-based approach (simple line-by-line + character diff for simplicity).
+ * Returns an array of TextEdit-like changes that transform `previous` into `current`.
+ */
+export function computeIncrementalChanges(previous, current) {
+    if (previous.length === 0) {
+        return [
+            {
+                text: current,
+            },
+        ];
+    }
+    const prevLines = previous.split(/\r\n|\r|\n/);
+    const currLines = current.split(/\r\n|\r|\n/);
+    const changes = [];
+    let startLine = 0;
+    let insertedText = '';
+    // Find common prefix
+    while (startLine < prevLines.length && startLine < currLines.length) {
+        if (prevLines[startLine] === currLines[startLine]) {
+            startLine++;
+        }
+        else {
+            break;
+        }
+    }
+    // If entire document is the same
+    if (startLine === prevLines.length &&
+        startLine === currLines.length) {
+        return changes; // No changes
+    }
+    // Find common suffix starting from the end
+    let endLinePrev = prevLines.length - 1;
+    let endLineCurr = currLines.length - 1;
+    while (endLinePrev >= startLine &&
+        endLineCurr >= startLine &&
+        prevLines[endLinePrev] === currLines[endLineCurr]) {
+        endLinePrev--;
+        endLineCurr--;
+    }
+    // Region to replace: from startLine to endLinePrev (inclusive)
+    const replaceStart = { line: startLine, character: 0 };
+    let replaceEnd;
+    if (endLinePrev >= startLine) {
+        const lastDeletedLine = prevLines[endLinePrev];
+        replaceEnd = {
+            line: endLinePrev,
+            character: lastDeletedLine.length,
+        };
+    }
+    else {
+        // Deletion ends at the start of the next line
+        replaceEnd = { line: startLine, character: 0 };
+    }
+    // Build inserted text: lines from startLine to endLineCurr
+    const insertedLines = currLines.slice(startLine, endLineCurr + 1);
+    insertedText = insertedLines.join('\n');
+    // If we're inserting at the end of the file, adjust range
+    if (startLine === prevLines.length) {
+        // Inserting after last line
+        replaceEnd = {
+            line: prevLines.length - 1,
+            character: prevLines[prevLines.length - 1].length,
+        };
+        if (insertedLines.length === 0) {
+            // Inserting empty at EOF
+            insertedText = '\n';
+        }
+    }
+    // Create the range for deletion
+    const range = {
+        start: replaceStart,
+        end: replaceEnd,
+    };
+    // Push the incremental change
+    changes.push({
+        range,
+        text: insertedText,
+    });
+    return changes;
+}

package/esm/extension-lsp/src/createLspAutocomplete.d.ts

@@ -0,0 +1,23 @@
+import { DefaultRenderer } from '../../extension-autocomplete/src/DefaultRenderer.js';
+import { TextRange } from '../../editor/src/mod.js';
+import { type AutocompleteProps } from '../../extension-autocomplete/src/mod.js';
+import { ExtensionLsp } from './ExtensionLsp.js';
+interface CompletionItem {
+    label: string;
+    detail: string;
+    insertText: string;
+}
+export declare class CustomRenderer extends DefaultRenderer<CompletionItem> {
+    createListItem(item: CompletionItem, cnt: number): any;
+}
+export declare function cleanPlaceholders(input: string): string;
+export declare function createLspAutocomplete(extensionLsp: ExtensionLsp): {
+    autocompleteConfig: {
+        renderer: CustomRenderer;
+        matchers: import("../../extension-autocomplete/src/types.js").AutocompleteMatcher[];
+        getItems: (query: string, props: AutocompleteProps) => Promise<CompletionItem[]>;
+        onSelect: (selected: CompletionItem, range: TextRange) => Promise<void>;
+    };
+};
+export {};
+//# sourceMappingURL=createLspAutocomplete.d.ts.map

package/esm/extension-lsp/src/createLspAutocomplete.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"createLspAutocomplete.d.ts","sourceRoot":"","sources":["../../../src/extension-lsp/src/createLspAutocomplete.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,qDAAqD,CAAC;AACtF,OAAO,EAAmB,SAAS,EAAE,MAAM,yBAAyB,CAAC;AAErE,OAAO,EACL,KAAK,iBAAiB,EAEvB,MAAM,yCAAyC,CAAC;AAEjD,OAAO,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AAEjD,UAAU,cAAc;IACtB,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;IACf,UAAU,EAAE,MAAM,CAAC;CACpB;AAED,qBAAa,cAAe,SAAQ,eAAe,CAAC,cAAc,CAAC;IACxD,cAAc,CAAC,IAAI,EAAE,cAAc,EAAE,GAAG,EAAE,MAAM;CAa1D;AAED,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAGvD;AAED,wBAAgB,qBAAqB,CAAC,YAAY,EAAE,YAAY;;;;0BAOpC,MAAM,SAAS,iBAAiB;6BAiC7B,cAAc,SAAS,SAAS;;EAiB9D"}

package/esm/extension-lsp/src/createLspAutocomplete.js

@@ -0,0 +1,68 @@
+import { DefaultRenderer } from '../../extension-autocomplete/src/DefaultRenderer.js';
+import { createRegexMatcher, } from '../../extension-autocomplete/src/mod.js';
+export class CustomRenderer extends DefaultRenderer {
+    createListItem(item, cnt) {
+        const li = document.createElement('li');
+        if (cnt === this.pos) {
+            li.classList.add('active');
+        }
+        li.innerText = item.label;
+        li.title = item.detail;
+        li.style.cursor = 'pointer';
+        li.addEventListener('click', () => {
+            this.command(item);
+        });
+        return li;
+    }
+}
+export function cleanPlaceholders(input) {
+    const regex = /\$\{\d+:([^}]+)}/g;
+    return input.replace(regex, '$1');
+}
+export function createLspAutocomplete(extensionLsp) {
+    const editor = extensionLsp.getEditor();
+    const renderer = new CustomRenderer(editor);
+    const config = {
+        renderer,
+        matchers: [createRegexMatcher([/\w+/, /(^|\s)@\w*/, /^#\w*/])],
+        getItems: async (query, props) => {
+            const { mapper } = extensionLsp.source.getMappedContent();
+            const lspPos = mapper.toRawTextLspPos(props.range.from);
+            const client = extensionLsp.getClient(extensionLsp.mainLang);
+            if (client) {
+                client.sync();
+                try {
+                    const completions = await client.request('textDocument/completion', {
+                        textDocument: { uri: extensionLsp.uri },
+                        position: lspPos,
+                        context: { triggerKind: 2, triggerCharacter: query },
+                    });
+                    if (Array.isArray(completions)) {
+                        return completions;
+                    }
+                    return completions.items;
+                }
+                catch (err) {
+                    console.error(err.message);
+                    return [];
+                }
+            }
+            else {
+                return [];
+            }
+        },
+        onSelect: async (selected, range) => {
+            const rawText = cleanPlaceholders(selected.insertText);
+            const slice = await extensionLsp.extensionMarkdown.fromMarkdown(rawText);
+            if (slice.content.content.length === 1) {
+                const first = slice.content.content[0];
+                if (first.isBlock) {
+                    editor.chain().insertBlockSmart(range.from, first).run();
+                    return;
+                }
+            }
+            editor.chain().replaceRangeSlice(range, slice).run();
+        },
+    };
+    return { autocompleteConfig: config };
+}

package/esm/extension-lsp/src/workspace.d.ts

@@ -0,0 +1,62 @@
+import type * as lsp from 'vscode-languageserver-protocol';
+import type { EditorUi } from '../../editor/src/mod.js';
+import { LSPClient } from './LSPClient.js';
+import { PositionMapper } from '../../extension-markdown/src/PositionMapper.js';
+export interface LspSource {
+    ui: EditorUi;
+    getMappedContent(): {
+        content: string;
+        mapper: PositionMapper;
+    };
+}
+export interface WorkspaceFile {
+    uri: string;
+    languageId: string;
+    version: number;
+    content: string;
+    source: LspSource;
+    getUi(): EditorUi | undefined;
+    mapper: PositionMapper;
+}
+interface WorkspaceFileUpdate {
+    file: WorkspaceFile;
+    prevDoc: string;
+    changes: lsp.TextDocumentContentChangeEvent[];
+}
+export declare abstract class Workspace {
+    readonly client: LSPClient;
+    abstract files: WorkspaceFile[];
+    protected isConnected: boolean;
+    constructor(client: LSPClient);
+    getFile(uri: string): WorkspaceFile | null;
+    abstract syncFiles(): readonly WorkspaceFileUpdate[];
+    requestFile(uri: string): Promise<WorkspaceFile | null>;
+    abstract openFile(uri: string, languageId: string, source: LspSource): void;
+    abstract changedFile(uri: string): void;
+    abstract closeFile(uri: string): void;
+    connected(): Promise<void>;
+    disconnected(): void;
+    getUi(uri: string): Promise<EditorUi | undefined>;
+}
+declare class DefaultWorkspaceFile implements WorkspaceFile {
+    readonly uri: string;
+    readonly languageId: string;
+    version: number;
+    content: string;
+    mapper: PositionMapper;
+    source: LspSource;
+    syncedContent: string;
+    constructor(uri: string, languageId: string, version: number, content: string, mapper: PositionMapper, source: LspSource);
+    getUi(): EditorUi;
+}
+export declare class DefaultWorkspace extends Workspace {
+    files: DefaultWorkspaceFile[];
+    private fileVersions;
+    nextFileVersion(uri: string): number;
+    syncFiles(): WorkspaceFileUpdate[];
+    changedFile(uri: string): Promise<void>;
+    openFile(uri: string, languageId: string, source: LspSource): void;
+    closeFile(uri: string): void;
+}
+export {};
+//# sourceMappingURL=workspace.d.ts.map

package/esm/extension-lsp/src/workspace.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"workspace.d.ts","sourceRoot":"","sources":["../../../src/extension-lsp/src/workspace.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,GAAG,MAAM,gCAAgC,CAAC;AAG3D,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,yBAAyB,CAAC;AAExD,OAAO,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAC3C,OAAO,EAAE,cAAc,EAAE,MAAM,gDAAgD,CAAC;AAGhF,MAAM,WAAW,SAAS;IACxB,EAAE,EAAE,QAAQ,CAAC;IACb,gBAAgB,IAAI;QAAE,OAAO,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,cAAc,CAAA;KAAE,CAAC;CACjE;AAED,MAAM,WAAW,aAAa;IAC5B,GAAG,EAAE,MAAM,CAAC;IACZ,UAAU,EAAE,MAAM,CAAC;IACnB,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,SAAS,CAAC;IAClB,KAAK,IAAI,QAAQ,GAAG,SAAS,CAAC;IAC9B,MAAM,EAAE,cAAc,CAAC;CACxB;AAED,UAAU,mBAAmB;IAC3B,IAAI,EAAE,aAAa,CAAC;IACpB,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,GAAG,CAAC,8BAA8B,EAAE,CAAC;CAC/C;AAED,8BAAsB,SAAS;IAK3B,QAAQ,CAAC,MAAM,EAAE,SAAS;IAJ5B,QAAQ,CAAC,KAAK,EAAE,aAAa,EAAE,CAAC;IAChC,SAAS,CAAC,WAAW,UAAS;gBAGnB,MAAM,EAAE,SAAS;IAG5B,OAAO,CAAC,GAAG,EAAE,MAAM,GAAG,aAAa,GAAG,IAAI;IAI1C,QAAQ,CAAC,SAAS,IAAI,SAAS,mBAAmB,EAAE;IAEpD,WAAW,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,aAAa,GAAG,IAAI,CAAC;IAIvD,QAAQ,CAAC,QAAQ,CAAC,GAAG,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,EAAE,MAAM,EAAE,SAAS,GAAG,IAAI;IAC3E,QAAQ,CAAC,WAAW,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI;IACvC,QAAQ,CAAC,SAAS,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI;IAE/B,SAAS,IAAI,OAAO,CAAC,IAAI,CAAC;IAOhC,YAAY,IAAI,IAAI;IAOpB,KAAK,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,QAAQ,GAAG,SAAS,CAAC;CAIlD;AAED,cAAM,oBAAqB,YAAW,aAAa;IAG/C,QAAQ,CAAC,GAAG,EAAE,MAAM;IACpB,QAAQ,CAAC,UAAU,EAAE,MAAM;IACpB,OAAO,EAAE,MAAM;IACf,OAAO,EAAE,MAAM;IACf,MAAM,EAAE,cAAc;IACtB,MAAM,EAAE,SAAS;IAPnB,aAAa,EAAE,MAAM,CAAM;gBAEvB,GAAG,EAAE,MAAM,EACX,UAAU,EAAE,MAAM,EACpB,OAAO,EAAE,MAAM,EACf,OAAO,EAAE,MAAM,EACf,MAAM,EAAE,cAAc,EACtB,MAAM,EAAE,SAAS;IAI1B,KAAK;CAGN;AAED,qBAAa,gBAAiB,SAAQ,SAAS;IAC7C,KAAK,EAAE,oBAAoB,EAAE,CAAM;IACnC,OAAO,CAAC,YAAY,CAAkD;IAEtE,eAAe,CAAC,GAAG,EAAE,MAAM;IAI3B,SAAS;IAaH,WAAW,CAAC,GAAG,EAAE,MAAM;IAkC7B,QAAQ,CAAC,GAAG,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,EAAE,MAAM,EAAE,SAAS;IAsB3D,SAAS,CAAC,GAAG,EAAE,MAAM;CAOtB"}

package/esm/extension-lsp/src/workspace.js

@@ -0,0 +1,168 @@
+import { TextDocumentSyncKind } from 'vscode-languageserver-protocol';
+import { computeIncrementalChanges } from './computeIncrementalChanges.js';
+export class Workspace {
+    constructor(client) {
+        Object.defineProperty(this, "client", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: client
+        });
+        Object.defineProperty(this, "isConnected", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: false
+        });
+    }
+    getFile(uri) {
+        return this.files.find((f) => f.uri == uri) || null;
+    }
+    requestFile(uri) {
+        return Promise.resolve(this.getFile(uri));
+    }
+    async connected() {
+        this.isConnected = true;
+        for await (const file of this.files) {
+            const result = await this.client.didOpen(file);
+        }
+    }
+    disconnected() {
+        for (const file of this.files) {
+            this.client.workspace.closeFile(file.uri);
+        }
+        this.isConnected = false;
+    }
+    getUi(uri) {
+        const file = this.getFile(uri);
+        return Promise.resolve(file ? file.getUi() : undefined);
+    }
+}
+class DefaultWorkspaceFile {
+    constructor(uri, languageId, version, content, mapper, source) {
+        Object.defineProperty(this, "uri", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: uri
+        });
+        Object.defineProperty(this, "languageId", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: languageId
+        });
+        Object.defineProperty(this, "version", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: version
+        });
+        Object.defineProperty(this, "content", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: content
+        });
+        Object.defineProperty(this, "mapper", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: mapper
+        });
+        Object.defineProperty(this, "source", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: source
+        });
+        Object.defineProperty(this, "syncedContent", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: ''
+        });
+    }
+    getUi() {
+        return this.source.ui;
+    }
+}
+export class DefaultWorkspace extends Workspace {
+    constructor() {
+        super(...arguments);
+        Object.defineProperty(this, "files", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: []
+        });
+        Object.defineProperty(this, "fileVersions", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: Object.create(null)
+        });
+    }
+    nextFileVersion(uri) {
+        return this.fileVersions[uri] = (this.fileVersions[uri] ?? -1) + 1;
+    }
+    syncFiles() {
+        if (!this.client.supportSync) {
+            return [];
+        }
+        const result = [];
+        for (const file of this.files) {
+            this.changedFile(file.uri);
+        }
+        return result;
+    }
+    async changedFile(uri) {
+        const file = this.files.find((f) => f.uri == uri) || null;
+        if (file) {
+            const { content, mapper } = file.source.getMappedContent();
+            if (!this.isConnected) {
+                file.content = content;
+                file.mapper = mapper;
+                return;
+            }
+            if (await this.client.notification('textDocument/didChange', {
+                textDocument: { uri: file.uri, version: file.version },
+                contentChanges: contentChangesFor(file, content, mapper, this.client.supportSync == TextDocumentSyncKind.Incremental),
+            })) {
+                file.syncedContent = file.content;
+                file.content = content;
+                file.mapper = mapper;
+                file.version = this.nextFileVersion(file.uri);
+            }
+        }
+    }
+    openFile(uri, languageId, source) {
+        // if (uri) {}
+        if (this.getFile(uri)) {
+            this.closeFile(uri);
+        }
+        const mappedContent = source.getMappedContent();
+        const { content, mapper } = mappedContent;
+        const file = new DefaultWorkspaceFile(uri, languageId, this.nextFileVersion(uri), content, mapper, source);
+        this.files.push(file);
+        this.client.didOpen(file);
+    }
+    closeFile(uri) {
+        const file = this.getFile(uri);
+        if (file) {
+            this.files = this.files.filter((f) => f.uri !== uri);
+            this.client.didClose(uri);
+        }
+    }
+}
+var Sync;
+(function (Sync) {
+    Sync[Sync["AlwaysIfSmaller"] = 1024] = "AlwaysIfSmaller";
+})(Sync || (Sync = {}));
+function contentChangesFor(file, newContent, mapper, supportInc) {
+    if (!supportInc || newContent.length < Sync.AlwaysIfSmaller) {
+        return [{ text: newContent }];
+    }
+    const changes = computeIncrementalChanges(file.content, newContent);
+    return changes.reverse();
+}

package/esm/extension-markdown/src/DocumentMarkdownInlineTokenizer.d.ts

@@ -0,0 +1,36 @@
+import type { Mark, Node } from 'prosemirror-model';
+import { Token } from './types.js';
+export type MarkTokenizerSpec = {
+    open?: string | ((mark: Mark) => Token);
+    close?: string | ((mark: Mark) => Token);
+    mixable?: boolean;
+    expelEnclosingWhitespace?: boolean;
+    escape?: boolean;
+};
+export type DocumentMarkdownTokenizerSpec = {
+    open?: string | ((node: Node) => Token);
+    close?: string | ((node: Node) => Token);
+    selfClose?: string | ((node: Node) => Token);
+};
+export declare class DocumentMarkdownInlineTokenizer {
+    readonly nodes: {
+        [node: string]: (node: Node, index: number) => DocumentMarkdownTokenizerSpec;
+    };
+    readonly marks: {
+        [mark: string]: MarkTokenizerSpec;
+    };
+    readonly options: {
+        hardBreakNodeName: string;
+    };
+    constructor(nodes: {
+        [node: string]: (node: Node, index: number) => DocumentMarkdownTokenizerSpec;
+    }, marks: {
+        [mark: string]: MarkTokenizerSpec;
+    }, options: {
+        hardBreakNodeName: string;
+    });
+    private getMark;
+    renderInline(parent: Node, currentPos: number, level: number): Array<Token>;
+    markString(mark: Mark, open: boolean, tokens: Token[]): void;
+}
+//# sourceMappingURL=DocumentMarkdownInlineTokenizer.d.ts.map

package/esm/extension-markdown/src/DocumentMarkdownInlineTokenizer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DocumentMarkdownInlineTokenizer.d.ts","sourceRoot":"","sources":["../../../src/extension-markdown/src/DocumentMarkdownInlineTokenizer.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,IAAI,EAAE,MAAM,mBAAmB,CAAC;AACpD,OAAO,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC;AAEnC,MAAM,MAAM,iBAAiB,GAAG;IAC9B,IAAI,CAAC,EAAE,MAAM,GAAG,CAAC,CAAC,IAAI,EAAE,IAAI,KAAK,KAAK,CAAC,CAAC;IACxC,KAAK,CAAC,EAAE,MAAM,GAAG,CAAC,CAAC,IAAI,EAAE,IAAI,KAAK,KAAK,CAAC,CAAC;IACzC,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,wBAAwB,CAAC,EAAE,OAAO,CAAC;IACnC,MAAM,CAAC,EAAE,OAAO,CAAC;CAClB,CAAC;AAEF,MAAM,MAAM,6BAA6B,GAAG;IAC1C,IAAI,CAAC,EAAE,MAAM,GAAG,CAAC,CAAC,IAAI,EAAE,IAAI,KAAK,KAAK,CAAC,CAAC;IACxC,KAAK,CAAC,EAAE,MAAM,GAAG,CAAC,CAAC,IAAI,EAAE,IAAI,KAAK,KAAK,CAAC,CAAC;IACzC,SAAS,CAAC,EAAE,MAAM,GAAG,CAAC,CAAC,IAAI,EAAE,IAAI,KAAK,KAAK,CAAC,CAAC;CAC9C,CAAC;AAuCF,qBAAa,+BAA+B;IAExC,QAAQ,CAAC,KAAK,EAAE;QACd,CAAC,IAAI,EAAE,MAAM,GAAG,CACd,IAAI,EAAE,IAAI,EACV,KAAK,EAAE,MAAM,KACV,6BAA6B,CAAC;KACpC;IACD,QAAQ,CAAC,KAAK,EAAE;QAAE,CAAC,IAAI,EAAE,MAAM,GAAG,iBAAiB,CAAA;KAAE;IACrD,QAAQ,CAAC,OAAO,EAAE;QAAE,iBAAiB,EAAE,MAAM,CAAA;KAAE;gBAPtC,KAAK,EAAE;QACd,CAAC,IAAI,EAAE,MAAM,GAAG,CACd,IAAI,EAAE,IAAI,EACV,KAAK,EAAE,MAAM,KACV,6BAA6B,CAAC;KACpC,EACQ,KAAK,EAAE;QAAE,CAAC,IAAI,EAAE,MAAM,GAAG,iBAAiB,CAAA;KAAE,EAC5C,OAAO,EAAE;QAAE,iBAAiB,EAAE,MAAM,CAAA;KAAE;IAIjD,OAAO,CAAC,OAAO;IAaf,YAAY,CAAC,MAAM,EAAE,IAAI,EAAE,UAAU,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,KAAK,CAAC,KAAK,CAAC;IAwK3E,UAAU,CAAC,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE;CAoCtD"}