@codingame/monaco-vscode-katex-common 24.1.0

package/vscode/src/vs/workbench/contrib/chat/common/chatWidgetHistoryService.d.ts

@@ -0,0 +1,55 @@
+import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { IStorageService } from "@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage.service";
+import { IChatModelInputState } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatModel";
+import { IChatWidgetHistoryService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatWidgetHistoryService.service";
+import { ChatAgentLocation } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/constants";
+export type ChatHistoryChange = {
+    kind: "append";
+    entry: IChatModelInputState;
+} | {
+    kind: "clear";
+};
+export declare const ChatInputHistoryMaxEntries = 40;
+export declare class ChatWidgetHistoryService extends Disposable implements IChatWidgetHistoryService {
+    _serviceBrand: undefined;
+    private memento;
+    private viewState;
+    private readonly _onDidChangeHistory;
+    private changed;
+    readonly onDidChangeHistory: import("@codingame/monaco-vscode-api/vscode/vs/base/common/event").Event<ChatHistoryChange>;
+    constructor(storageService: IStorageService);
+    getHistory(location: ChatAgentLocation): IChatModelInputState[];
+    private migrateHistoryEntry;
+    private getKey;
+    append(location: ChatAgentLocation, history: IChatModelInputState): void;
+    clearHistory(): void;
+}
+export declare class ChatHistoryNavigator extends Disposable {
+    private readonly location;
+    private readonly chatWidgetHistoryService;
+    /**
+     * Index of our point in history. Goes 1 past the length of `_history`
+     */
+    private _currentIndex;
+    private _history;
+    private _overlay;
+    get values(): readonly IChatModelInputState[];
+    constructor(location: ChatAgentLocation, chatWidgetHistoryService: IChatWidgetHistoryService);
+    isAtEnd(): boolean;
+    isAtStart(): boolean;
+    /**
+     * Replaces a history entry at the current index in this view of the history.
+     * Allows editing of old history entries while preventing accidental navigation
+     * from losing the edits.
+     */
+    overlay(entry: IChatModelInputState): void;
+    resetCursor(): void;
+    previous(): IChatModelInputState;
+    next(): IChatModelInputState;
+    current(): IChatModelInputState;
+    /**
+     * Appends a new entry to the navigator. Resets the state back to the end
+     * and clears any overlayed entries.
+     */
+    append(entry: IChatModelInputState): void;
+}

package/vscode/src/vs/workbench/contrib/chat/common/chatWidgetHistoryService.js

@@ -0,0 +1,176 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { equals } from '@codingame/monaco-vscode-api/vscode/vs/base/common/arrays';
+import { Emitter } from '@codingame/monaco-vscode-api/vscode/vs/base/common/event';
+import { Disposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { StorageScope, StorageTarget } from '@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage';
+import { IStorageService } from '@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage.service';
+import { Memento } from '@codingame/monaco-vscode-api/vscode/vs/workbench/common/memento';
+import { CHAT_PROVIDER_ID } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatParticipantContribTypes';
+import { IChatWidgetHistoryService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatWidgetHistoryService.service';
+import { ChatModeKind, ChatAgentLocation } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/constants';
+
+let ChatWidgetHistoryService = class ChatWidgetHistoryService extends Disposable {
+    constructor(storageService) {
+        super();
+        this._onDidChangeHistory = this._register(( new Emitter()));
+        this.changed = false;
+        this.onDidChangeHistory = this._onDidChangeHistory.event;
+        this.memento = ( new Memento('interactive-session', storageService));
+        const loadedState = this.memento.getMemento(StorageScope.WORKSPACE, StorageTarget.MACHINE);
+        this.viewState = loadedState;
+        this._register(storageService.onWillSaveState(() => {
+            if (this.changed) {
+                this.memento.saveMemento();
+                this.changed = false;
+            }
+        }));
+    }
+    getHistory(location) {
+        const key = this.getKey(location);
+        const history = this.viewState.history?.[key] ?? [];
+        return ( history.map(entry => this.migrateHistoryEntry(entry)));
+    }
+    migrateHistoryEntry(entry) {
+        if (entry.inputText !== undefined) {
+            return entry;
+        }
+        const oldEntry = entry;
+        const oldState = oldEntry.state ?? {};
+        let modeId;
+        let modeKind;
+        if (oldState.chatMode) {
+            if (typeof oldState.chatMode === 'string') {
+                modeId = oldState.chatMode;
+                modeKind = ( Object.values(ChatModeKind)).includes(oldState.chatMode)
+                    ? oldState.chatMode
+                    : undefined;
+            }
+            else if (typeof oldState.chatMode === 'object' && oldState.chatMode !== null) {
+                const oldMode = oldState.chatMode;
+                modeId = oldMode.id ?? ChatModeKind.Ask;
+                modeKind = oldMode.id && ( Object.values(ChatModeKind)).includes(oldMode.id)
+                    ? oldMode.id
+                    : undefined;
+            }
+            else {
+                modeId = ChatModeKind.Ask;
+                modeKind = ChatModeKind.Ask;
+            }
+        }
+        else {
+            modeId = ChatModeKind.Ask;
+            modeKind = ChatModeKind.Ask;
+        }
+        return {
+            inputText: oldEntry.text ?? '',
+            attachments: oldState.chatContextAttachments ?? [],
+            mode: {
+                id: modeId,
+                kind: modeKind
+            },
+            contrib: oldEntry.state || {},
+            selectedModel: undefined,
+            selections: []
+        };
+    }
+    getKey(location) {
+        return location === ChatAgentLocation.Chat ? CHAT_PROVIDER_ID : location;
+    }
+    append(location, history) {
+        this.viewState.history ??= {};
+        const key = this.getKey(location);
+        this.viewState.history[key] = this.getHistory(location).concat(history).slice(-40);
+        this.changed = true;
+        this._onDidChangeHistory.fire({ kind: 'append', entry: history });
+    }
+    clearHistory() {
+        this.viewState.history = {};
+        this.changed = true;
+        this._onDidChangeHistory.fire({ kind: 'clear' });
+    }
+};
+ChatWidgetHistoryService = ( __decorate([
+    ( __param(0, IStorageService))
+], ChatWidgetHistoryService));
+let ChatHistoryNavigator = class ChatHistoryNavigator extends Disposable {
+    get values() {
+        return this.chatWidgetHistoryService.getHistory(this.location);
+    }
+    constructor(location, chatWidgetHistoryService) {
+        super();
+        this.location = location;
+        this.chatWidgetHistoryService = chatWidgetHistoryService;
+        this._overlay = [];
+        this._history = this.chatWidgetHistoryService.getHistory(this.location);
+        this._currentIndex = this._history.length;
+        this._register(this.chatWidgetHistoryService.onDidChangeHistory(e => {
+            if (e.kind === 'append') {
+                const prevLength = this._history.length;
+                this._history = this.chatWidgetHistoryService.getHistory(this.location);
+                const newLength = this._history.length;
+                if (prevLength === newLength) {
+                    this._overlay.shift();
+                    if (this._currentIndex < this._history.length) {
+                        this._currentIndex = Math.max(this._currentIndex - 1, 0);
+                    }
+                }
+                else if (this._currentIndex === prevLength) {
+                    this._currentIndex = newLength;
+                }
+            }
+            else if (e.kind === 'clear') {
+                this._history = [];
+                this._currentIndex = 0;
+                this._overlay = [];
+            }
+        }));
+    }
+    isAtEnd() {
+        return this._currentIndex === Math.max(this._history.length, this._overlay.length);
+    }
+    isAtStart() {
+        return this._currentIndex === 0;
+    }
+    overlay(entry) {
+        this._overlay[this._currentIndex] = entry;
+    }
+    resetCursor() {
+        this._currentIndex = this._history.length;
+    }
+    previous() {
+        this._currentIndex = Math.max(this._currentIndex - 1, 0);
+        return this.current();
+    }
+    next() {
+        this._currentIndex = Math.min(this._currentIndex + 1, this._history.length);
+        return this.current();
+    }
+    current() {
+        return this._overlay[this._currentIndex] ?? this._history[this._currentIndex];
+    }
+    append(entry) {
+        this._overlay = [];
+        this._currentIndex = this._history.length;
+        if (!entriesEqual(this._history.at(-1), entry)) {
+            this.chatWidgetHistoryService.append(this.location, entry);
+        }
+    }
+};
+ChatHistoryNavigator = ( __decorate([
+    ( __param(1, IChatWidgetHistoryService))
+], ChatHistoryNavigator));
+function entriesEqual(a, b) {
+    if (!a || !b) {
+        return false;
+    }
+    if (a.inputText !== b.inputText) {
+        return false;
+    }
+    if (!equals(a.attachments, b.attachments, (x, y) => x.id === y.id)) {
+        return false;
+    }
+    return true;
+}
+
+export { ChatHistoryNavigator, ChatWidgetHistoryService };

package/vscode/src/vs/workbench/contrib/chat/common/codeBlockModelCollection.d.ts

@@ -0,0 +1,45 @@
+import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { URI } from "@codingame/monaco-vscode-api/vscode/vs/base/common/uri";
+import { ILanguageService } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/languages/language.service";
+import { ITextModel } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/model";
+import { ITextModelService } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/services/resolverService.service";
+import { IMarkdownVulnerability } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/annotations";
+import { IChatRequestViewModel, IChatResponseViewModel } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatViewModel";
+interface CodeBlockContent {
+    readonly text: string;
+    readonly languageId?: string;
+    readonly isComplete: boolean;
+}
+export interface CodeBlockEntry {
+    readonly model: Promise<ITextModel>;
+    readonly vulns: readonly IMarkdownVulnerability[];
+    readonly codemapperUri?: URI;
+    readonly isEdit?: boolean;
+}
+export declare class CodeBlockModelCollection extends Disposable {
+    private readonly tag;
+    private readonly languageService;
+    private readonly textModelService;
+    private readonly _models;
+    /**
+     * Max number of models to keep in memory.
+     *
+     * Currently always maintains the most recently created models.
+     */
+    private readonly maxModelCount;
+    constructor(tag: string | undefined, languageService: ILanguageService, textModelService: ITextModelService);
+    dispose(): void;
+    get(sessionResource: URI, chat: IChatRequestViewModel | IChatResponseViewModel, codeBlockIndex: number): CodeBlockEntry | undefined;
+    getOrCreate(sessionResource: URI, chat: IChatRequestViewModel | IChatResponseViewModel, codeBlockIndex: number): CodeBlockEntry;
+    private delete;
+    clear(): void;
+    updateSync(sessionResource: URI, chat: IChatRequestViewModel | IChatResponseViewModel, codeBlockIndex: number, content: CodeBlockContent): CodeBlockEntry;
+    markCodeBlockCompleted(sessionResource: URI, chat: IChatRequestViewModel | IChatResponseViewModel, codeBlockIndex: number): void;
+    update(sessionResource: URI, chat: IChatRequestViewModel | IChatResponseViewModel, codeBlockIndex: number, content: CodeBlockContent): Promise<CodeBlockEntry>;
+    private updateInternalCodeBlockEntry;
+    private trySetTextModelLanguage;
+    private getKey;
+    private getCodeBlockUri;
+    private getUriMetaData;
+}
+export {};

package/vscode/src/vs/workbench/contrib/chat/common/codeBlockModelCollection.js

@@ -0,0 +1,207 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { encodeBase64, VSBuffer } from '@codingame/monaco-vscode-api/vscode/vs/base/common/buffer';
+import { Iterable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/iterator';
+import { Disposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { Schemas } from '@codingame/monaco-vscode-api/vscode/vs/base/common/network';
+import { URI } from '@codingame/monaco-vscode-api/vscode/vs/base/common/uri';
+import { Range } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/core/range';
+import { ILanguageService } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/languages/language.service';
+import { PLAINTEXT_LANGUAGE_ID } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/languages/modesRegistry';
+import { EndOfLinePreference } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/model';
+import { ITextModelService } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/services/resolverService.service';
+import { extractVulnerabilitiesFromText, extractCodeblockUrisFromText } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/annotations';
+import { isResponseVM } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatViewModel';
+
+let CodeBlockModelCollection = class CodeBlockModelCollection extends Disposable {
+    constructor(tag, languageService, textModelService) {
+        super();
+        this.tag = tag;
+        this.languageService = languageService;
+        this.textModelService = textModelService;
+        this._models = ( new Map());
+        this.maxModelCount = 100;
+        this._register(this.languageService.onDidChange(async () => {
+            for (const entry of ( this._models.values())) {
+                if (!entry.inLanguageId) {
+                    continue;
+                }
+                const model = (await entry.model).object;
+                const existingLanguageId = model.getLanguageId();
+                if (!existingLanguageId || existingLanguageId === PLAINTEXT_LANGUAGE_ID) {
+                    this.trySetTextModelLanguage(entry.inLanguageId, model.textEditorModel);
+                }
+            }
+        }));
+    }
+    dispose() {
+        super.dispose();
+        this.clear();
+    }
+    get(sessionResource, chat, codeBlockIndex) {
+        const entry = this._models.get(this.getKey(sessionResource, chat, codeBlockIndex));
+        if (!entry) {
+            return;
+        }
+        return {
+            model: entry.model.then(ref => ref.object.textEditorModel),
+            vulns: entry.vulns,
+            codemapperUri: entry.codemapperUri,
+            isEdit: entry.isEdit,
+        };
+    }
+    getOrCreate(sessionResource, chat, codeBlockIndex) {
+        const existing = this.get(sessionResource, chat, codeBlockIndex);
+        if (existing) {
+            return existing;
+        }
+        const uri = this.getCodeBlockUri(sessionResource, chat, codeBlockIndex);
+        const model = this.textModelService.createModelReference(uri);
+        this._models.set(this.getKey(sessionResource, chat, codeBlockIndex), {
+            model: model,
+            vulns: [],
+            inLanguageId: undefined,
+            codemapperUri: undefined,
+        });
+        while (this._models.size > this.maxModelCount) {
+            const first = Iterable.first(( this._models.keys()));
+            if (!first) {
+                break;
+            }
+            this.delete(first);
+        }
+        return { model: model.then(x => x.object.textEditorModel), vulns: [], codemapperUri: undefined };
+    }
+    delete(key) {
+        const entry = this._models.get(key);
+        if (!entry) {
+            return;
+        }
+        entry.model.then(ref => ref.dispose());
+        this._models.delete(key);
+    }
+    clear() {
+        this._models.forEach(async (entry) => await entry.model.then(ref => ref.dispose()));
+        this._models.clear();
+    }
+    updateSync(sessionResource, chat, codeBlockIndex, content) {
+        const entry = this.getOrCreate(sessionResource, chat, codeBlockIndex);
+        this.updateInternalCodeBlockEntry(content, sessionResource, chat, codeBlockIndex);
+        return this.get(sessionResource, chat, codeBlockIndex) ?? entry;
+    }
+    markCodeBlockCompleted(sessionResource, chat, codeBlockIndex) {
+        const entry = this._models.get(this.getKey(sessionResource, chat, codeBlockIndex));
+        if (!entry) {
+            return;
+        }
+    }
+    async update(sessionResource, chat, codeBlockIndex, content) {
+        const entry = this.getOrCreate(sessionResource, chat, codeBlockIndex);
+        const newText = this.updateInternalCodeBlockEntry(content, sessionResource, chat, codeBlockIndex);
+        const textModel = await entry.model;
+        if (!textModel || textModel.isDisposed()) {
+            return entry;
+        }
+        if (content.languageId) {
+            this.trySetTextModelLanguage(content.languageId, textModel);
+        }
+        const currentText = textModel.getValue(EndOfLinePreference.LF);
+        if (newText === currentText) {
+            return entry;
+        }
+        if (newText.startsWith(currentText)) {
+            const text = newText.slice(currentText.length);
+            const lastLine = textModel.getLineCount();
+            const lastCol = textModel.getLineMaxColumn(lastLine);
+            textModel.applyEdits([{ range: ( new Range(lastLine, lastCol, lastLine, lastCol)), text }]);
+        }
+        else {
+            textModel.setValue(newText);
+        }
+        return entry;
+    }
+    updateInternalCodeBlockEntry(content, sessionResource, chat, codeBlockIndex) {
+        const entry = this._models.get(this.getKey(sessionResource, chat, codeBlockIndex));
+        if (entry) {
+            entry.inLanguageId = content.languageId;
+        }
+        const extractedVulns = extractVulnerabilitiesFromText(content.text);
+        let newText = fixCodeText(extractedVulns.newText, content.languageId);
+        if (entry) {
+            entry.vulns = extractedVulns.vulnerabilities;
+        }
+        const codeblockUri = extractCodeblockUrisFromText(newText);
+        if (codeblockUri) {
+            if (entry) {
+                entry.codemapperUri = codeblockUri.uri;
+                entry.isEdit = codeblockUri.isEdit;
+            }
+            newText = codeblockUri.textWithoutResult;
+        }
+        if (content.isComplete) {
+            this.markCodeBlockCompleted(sessionResource, chat, codeBlockIndex);
+        }
+        return newText;
+    }
+    trySetTextModelLanguage(inLanguageId, textModel) {
+        const vscodeLanguageId = this.languageService.getLanguageIdByLanguageName(inLanguageId);
+        if (vscodeLanguageId && vscodeLanguageId !== textModel.getLanguageId()) {
+            textModel.setLanguage(vscodeLanguageId);
+        }
+    }
+    getKey(sessionResource, chat, index) {
+        return `${( sessionResource.toString())}/${chat.id}/${index}`;
+    }
+    getCodeBlockUri(sessionResource, chat, index) {
+        const metadata = this.getUriMetaData(chat);
+        const indexPart = this.tag ? `${this.tag}-${index}` : `${index}`;
+        const encodedSessionId = encodeBase64(VSBuffer.wrap(( new TextEncoder()).encode(( sessionResource.toString()))), false, true);
+        return ( URI.from({
+            scheme: Schemas.vscodeChatCodeBlock,
+            authority: encodedSessionId,
+            path: `/${chat.id}/${indexPart}`,
+            fragment: metadata ? JSON.stringify(metadata) : undefined,
+        }));
+    }
+    getUriMetaData(chat) {
+        if (!isResponseVM(chat)) {
+            return undefined;
+        }
+        return {
+            references: ( chat.contentReferences.map(ref => {
+                if (typeof ref.reference === 'string') {
+                    return;
+                }
+                const uriOrLocation = 'variableName' in ref.reference ?
+                    ref.reference.value :
+                    ref.reference;
+                if (!uriOrLocation) {
+                    return;
+                }
+                if (URI.isUri(uriOrLocation)) {
+                    return {
+                        uri: uriOrLocation.toJSON()
+                    };
+                }
+                return {
+                    uri: uriOrLocation.uri.toJSON(),
+                    range: uriOrLocation.range,
+                };
+            }))
+        };
+    }
+};
+CodeBlockModelCollection = ( __decorate([
+    ( __param(1, ILanguageService)),
+    ( __param(2, ITextModelService))
+], CodeBlockModelCollection));
+function fixCodeText(text, languageId) {
+    if (languageId === 'php') {
+        if (!text.trim().startsWith('<?')) {
+            return `<?php\n${text}`;
+        }
+    }
+    return text;
+}
+
+export { CodeBlockModelCollection };

package/vscode/src/vs/workbench/contrib/chat/common/promptSyntax/computeAutomaticInstructions.d.ts

@@ -0,0 +1,48 @@
+import { CancellationToken } from "@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation";
+import { ResourceSet } from "@codingame/monaco-vscode-api/vscode/vs/base/common/map";
+import { IConfigurationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service";
+import { IFileService } from "@codingame/monaco-vscode-api/vscode/vs/platform/files/common/files.service";
+import { ILabelService } from "@codingame/monaco-vscode-api/vscode/vs/platform/label/common/label.service";
+import { ILogService } from "@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service";
+import { ITelemetryService } from "@codingame/monaco-vscode-api/vscode/vs/platform/telemetry/common/telemetry.service";
+import { IWorkspaceContextService } from "@codingame/monaco-vscode-api/vscode/vs/platform/workspace/common/workspace.service";
+import { ChatRequestVariableSet } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatVariableEntries";
+import { IToolAndToolSetEnablementMap } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/languageModelToolsService";
+import { ILanguageModelToolsService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/languageModelToolsService.service";
+import { IPromptPath } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/promptSyntax/service/promptsService";
+import { IPromptsService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/promptSyntax/service/promptsService.service";
+export type InstructionsCollectionEvent = {
+    applyingInstructionsCount: number;
+    referencedInstructionsCount: number;
+    agentInstructionsCount: number;
+    listedInstructionsCount: number;
+    totalInstructionsCount: number;
+};
+export declare function newInstructionsCollectionEvent(): InstructionsCollectionEvent;
+export declare class ComputeAutomaticInstructions {
+    private readonly _enabledTools;
+    private readonly _promptsService;
+    readonly _logService: ILogService;
+    private readonly _labelService;
+    private readonly _configurationService;
+    private readonly _workspaceService;
+    private readonly _fileService;
+    private readonly _telemetryService;
+    private readonly _languageModelToolsService;
+    private _parseResults;
+    constructor(_enabledTools: IToolAndToolSetEnablementMap | undefined, _promptsService: IPromptsService, _logService: ILogService, _labelService: ILabelService, _configurationService: IConfigurationService, _workspaceService: IWorkspaceContextService, _fileService: IFileService, _telemetryService: ITelemetryService, _languageModelToolsService: ILanguageModelToolsService);
+    private _parseInstructionsFile;
+    collect(variables: ChatRequestVariableSet, token: CancellationToken): Promise<void>;
+    private sendTelemetry;
+    /** public for testing */
+    addApplyingInstructions(instructionFiles: readonly IPromptPath[], context: {
+        files: ResourceSet;
+        instructions: ResourceSet;
+    }, variables: ChatRequestVariableSet, telemetryEvent: InstructionsCollectionEvent, token: CancellationToken): Promise<void>;
+    private _getContext;
+    private _addAgentInstructions;
+    private _matches;
+    private _getTool;
+    private _getInstructionsWithPatternsList;
+    private _addReferencedInstructions;
+}