@codingame/monaco-vscode-api 1.78.3 → 1.78.4-next.1

package/dist/variableResolver.js

@@ -0,0 +1,586 @@
+import { Range$1, replaceAsync, VariableKind, VariableError, isAbsolute } from './missing-services.js';
+import { equalsIgnoreCase } from 'monaco-editor/esm/vs/base/common/strings.js';
+import { Schemas } from 'monaco-editor/esm/vs/base/common/network.js';
+import { coalesce } from 'monaco-editor/esm/vs/base/common/arrays.js';
+import { CancellationToken } from 'monaco-editor/esm/vs/base/common/cancellation.js';
+import { deepClone } from 'monaco-editor/esm/vs/base/common/objects.js';
+import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
+import { isWindows, isMacintosh, isLinux } from 'monaco-editor/esm/vs/base/common/platform.js';
+import { isString, isObject, isUndefinedOrNull } from 'monaco-editor/esm/vs/base/common/types.js';
+import { sep, basename, dirname, extname, relative } from 'monaco-editor/esm/vs/base/common/path.js';
+import { localize } from 'monaco-editor/esm/vs/nls.js';
+import { normalizeDriveLetter } from 'monaco-editor/esm/vs/base/common/labels.js';
+import { cwd } from 'monaco-editor/esm/vs/base/common/process.js';
+const _formatPIIRegexp = /{([^}]+)}/g;
+function formatPII(value, excludePII, args) {
+    return value.replace(_formatPIIRegexp, function (match, group) {
+        if (excludePII && group.length > 0 && group[0] !== '_') {
+            return match;
+        }
+        return args && args.hasOwnProperty(group) ?
+            args[group] :
+            match;
+    });
+}
+function filterExceptionsFromTelemetry(data) {
+    const output = {};
+    for (const key of ( (Object.keys(data)))) {
+        if (!key.startsWith('!')) {
+            output[key] = data[key];
+        }
+    }
+    return output;
+}
+function isSessionAttach(session) {
+    return session.configuration.request === 'attach' && !getExtensionHostDebugSession(session) && (!session.parentSession || isSessionAttach(session.parentSession));
+}
+function getExtensionHostDebugSession(session) {
+    let type = session.configuration.type;
+    if (!type) {
+        return;
+    }
+    if (type === 'vslsShare') {
+        type = session.configuration.adapterProxy.configuration.type;
+    }
+    if (equalsIgnoreCase(type, 'extensionhost') || equalsIgnoreCase(type, 'pwa-extensionhost')) {
+        return session;
+    }
+    return session.parentSession ? getExtensionHostDebugSession(session.parentSession) : undefined;
+}
+function isDebuggerMainContribution(dbg) {
+    return dbg.type && (dbg.label || dbg.program || dbg.runtime);
+}
+function getExactExpressionStartAndEnd(lineContent, looseStart, looseEnd) {
+    let matchingExpression = undefined;
+    let startOffset = 0;
+    const expression = /([^()\[\]{}<>\s+\-/%~#^;=|,`!]|\->)+/g;
+    let result = null;
+    while (result = expression.exec(lineContent)) {
+        const start = result.index + 1;
+        const end = start + result[0].length;
+        if (start <= looseStart && end >= looseEnd) {
+            matchingExpression = result[0];
+            startOffset = start;
+            break;
+        }
+    }
+    if (matchingExpression) {
+        const subExpression = /\w+/g;
+        let subExpressionResult = null;
+        while (subExpressionResult = subExpression.exec(matchingExpression)) {
+            const subEnd = subExpressionResult.index + 1 + startOffset + subExpressionResult[0].length;
+            if (subEnd >= looseEnd) {
+                break;
+            }
+        }
+        if (subExpressionResult) {
+            matchingExpression = matchingExpression.substring(0, subExpression.lastIndex);
+        }
+    }
+    return matchingExpression ?
+        { start: startOffset, end: startOffset + matchingExpression.length - 1 } :
+        { start: 0, end: 0 };
+}
+async function getEvaluatableExpressionAtPosition(languageFeaturesService, model, position, token) {
+    if (languageFeaturesService.evaluatableExpressionProvider.has(model)) {
+        const supports = languageFeaturesService.evaluatableExpressionProvider.ordered(model);
+        const results = coalesce(await Promise.all(( (supports.map(async (support) => {
+            try {
+                return await support.provideEvaluatableExpression(model, position, token ?? CancellationToken.None);
+            }
+            catch (err) {
+                return undefined;
+            }
+        })))));
+        if (results.length > 0) {
+            let matchingExpression = results[0].expression;
+            const range = results[0].range;
+            if (!matchingExpression) {
+                const lineContent = model.getLineContent(position.lineNumber);
+                matchingExpression = lineContent.substring(range.startColumn - 1, range.endColumn - 1);
+            }
+            return { range, matchingExpression };
+        }
+    }
+    else {
+        const lineContent = model.getLineContent(position.lineNumber);
+        const { start, end } = getExactExpressionStartAndEnd(lineContent, position.column, position.column);
+        const matchingExpression = lineContent.substring(start - 1, end);
+        return {
+            matchingExpression,
+            range: ( (new Range$1(
+                position.lineNumber,
+                start,
+                position.lineNumber,
+                start + matchingExpression.length
+            )))
+        };
+    }
+    return null;
+}
+const _schemePattern = /^[a-zA-Z][a-zA-Z0-9\+\-\.]+:/;
+function isUri(s) {
+    return !!(s && s.match(_schemePattern));
+}
+function stringToUri(source) {
+    if (typeof source.path === 'string') {
+        if (typeof source.sourceReference === 'number' && source.sourceReference > 0) ;
+        else {
+            if (isUri(source.path)) {
+                return ( URI.parse(source.path));
+            }
+            else {
+                if (isAbsolute(source.path)) {
+                    return URI.file(source.path);
+                }
+            }
+        }
+    }
+    return source.path;
+}
+function uriToString(source) {
+    if (typeof source.path === 'object') {
+        const u = URI.revive(source.path);
+        if (u) {
+            if (u.scheme === Schemas.file) {
+                return u.fsPath;
+            }
+            else {
+                return (
+                     (u.toString())
+                );
+            }
+        }
+    }
+    return source.path;
+}
+function convertToDAPaths(message, toUri) {
+    const fixPath = toUri ? stringToUri : uriToString;
+    const msg = deepClone(message);
+    convertPaths(msg, (toDA, source) => {
+        if (toDA && source) {
+            source.path = fixPath(source);
+        }
+    });
+    return msg;
+}
+function convertToVSCPaths(message, toUri) {
+    const fixPath = toUri ? stringToUri : uriToString;
+    const msg = deepClone(message);
+    convertPaths(msg, (toDA, source) => {
+        if (!toDA && source) {
+            source.path = fixPath(source);
+        }
+    });
+    return msg;
+}
+function convertPaths(msg, fixSourcePath) {
+    switch (msg.type) {
+        case 'event': {
+            const event = msg;
+            switch (event.event) {
+                case 'output':
+                    fixSourcePath(false, event.body.source);
+                    break;
+                case 'loadedSource':
+                    fixSourcePath(false, event.body.source);
+                    break;
+                case 'breakpoint':
+                    fixSourcePath(false, event.body.breakpoint.source);
+                    break;
+            }
+            break;
+        }
+        case 'request': {
+            const request = msg;
+            switch (request.command) {
+                case 'setBreakpoints':
+                    fixSourcePath(true, request.arguments.source);
+                    break;
+                case 'breakpointLocations':
+                    fixSourcePath(true, request.arguments.source);
+                    break;
+                case 'source':
+                    fixSourcePath(true, request.arguments.source);
+                    break;
+                case 'gotoTargets':
+                    fixSourcePath(true, request.arguments.source);
+                    break;
+                case 'launchVSCode':
+                    request.arguments.args.forEach((arg) => fixSourcePath(false, arg));
+                    break;
+            }
+            break;
+        }
+        case 'response': {
+            const response = msg;
+            if (response.success && response.body) {
+                switch (response.command) {
+                    case 'stackTrace':
+                        response.body.stackFrames.forEach(frame => fixSourcePath(false, frame.source));
+                        break;
+                    case 'loadedSources':
+                        response.body.sources.forEach(source => fixSourcePath(false, source));
+                        break;
+                    case 'scopes':
+                        response.body.scopes.forEach(scope => fixSourcePath(false, scope.source));
+                        break;
+                    case 'setFunctionBreakpoints':
+                        response.body.breakpoints.forEach(bp => fixSourcePath(false, bp.source));
+                        break;
+                    case 'setBreakpoints':
+                        response.body.breakpoints.forEach(bp => fixSourcePath(false, bp.source));
+                        break;
+                    case 'disassemble':
+                        {
+                            const di = response;
+                            di.body?.instructions.forEach(di => fixSourcePath(false, di.location));
+                        }
+                        break;
+                }
+            }
+            break;
+        }
+    }
+}
+function getVisibleAndSorted(array) {
+    return array.filter(config => !config.presentation?.hidden).sort((first, second) => {
+        if (!first.presentation) {
+            if (!second.presentation) {
+                return 0;
+            }
+            return 1;
+        }
+        if (!second.presentation) {
+            return -1;
+        }
+        if (!first.presentation.group) {
+            if (!second.presentation.group) {
+                return compareOrders(first.presentation.order, second.presentation.order);
+            }
+            return 1;
+        }
+        if (!second.presentation.group) {
+            return -1;
+        }
+        if (first.presentation.group !== second.presentation.group) {
+            return first.presentation.group.localeCompare(second.presentation.group);
+        }
+        return compareOrders(first.presentation.order, second.presentation.order);
+    });
+}
+function compareOrders(first, second) {
+    if (typeof first !== 'number') {
+        if (typeof second !== 'number') {
+            return 0;
+        }
+        return 1;
+    }
+    if (typeof second !== 'number') {
+        return -1;
+    }
+    return first - second;
+}
+async function saveAllBeforeDebugStart(configurationService, editorService) {
+    const saveBeforeStartConfig = configurationService.getValue('debug.saveBeforeStart', { overrideIdentifier: editorService.activeTextEditorLanguageId });
+    if (saveBeforeStartConfig !== 'none') {
+        await editorService.saveAll();
+        if (saveBeforeStartConfig === 'allEditorsInActiveGroup') {
+            const activeEditor = editorService.activeEditorPane;
+            if (activeEditor && activeEditor.input.resource?.scheme === Schemas.untitled) {
+                await editorService.save({ editor: activeEditor.input, groupId: activeEditor.group.id });
+            }
+        }
+    }
+    await configurationService.reloadConfiguration();
+}
+class AbstractVariableResolverService {
+    constructor(_context, _labelService, _userHomePromise, _envVariablesPromise) {
+        this._contributedVariables = ( (new Map()));
+        this._context = _context;
+        this._labelService = _labelService;
+        this._userHomePromise = _userHomePromise;
+        if (_envVariablesPromise) {
+            this._envVariablesPromise = _envVariablesPromise.then(envVariables => {
+                return this.prepareEnv(envVariables);
+            });
+        }
+    }
+    prepareEnv(envVariables) {
+        if (isWindows) {
+            const ev = Object.create(null);
+            ( (Object.keys(envVariables))).forEach(key => {
+                ev[key.toLowerCase()] = envVariables[key];
+            });
+            return ev;
+        }
+        return envVariables;
+    }
+    resolveWithEnvironment(environment, root, value) {
+        return this.recursiveResolve({ env: this.prepareEnv(environment), userHome: undefined }, root ? root.uri : undefined, value);
+    }
+    async resolveAsync(root, value) {
+        const environment = {
+            env: await this._envVariablesPromise,
+            userHome: await this._userHomePromise
+        };
+        return this.recursiveResolve(environment, root ? root.uri : undefined, value);
+    }
+    async resolveAnyBase(workspaceFolder, config, commandValueMapping, resolvedVariables) {
+        const result = deepClone(config);
+        if (isWindows && result.windows) {
+            ( (Object.keys(result.windows))).forEach(key => result[key] = result.windows[key]);
+        }
+        else if (isMacintosh && result.osx) {
+            ( (Object.keys(result.osx))).forEach(key => result[key] = result.osx[key]);
+        }
+        else if (isLinux && result.linux) {
+            ( (Object.keys(result.linux))).forEach(key => result[key] = result.linux[key]);
+        }
+        delete result.windows;
+        delete result.osx;
+        delete result.linux;
+        const environmentPromises = {
+            env: await this._envVariablesPromise,
+            userHome: await this._userHomePromise
+        };
+        return this.recursiveResolve(environmentPromises, workspaceFolder ? workspaceFolder.uri : undefined, result, commandValueMapping, resolvedVariables);
+    }
+    async resolveAnyAsync(workspaceFolder, config, commandValueMapping) {
+        return this.resolveAnyBase(workspaceFolder, config, commandValueMapping);
+    }
+    async resolveAnyMap(workspaceFolder, config, commandValueMapping) {
+        const resolvedVariables = ( (new Map()));
+        const newConfig = await this.resolveAnyBase(workspaceFolder, config, commandValueMapping, resolvedVariables);
+        return { newConfig, resolvedVariables };
+    }
+    resolveWithInteractionReplace(folder, config, section, variables) {
+        throw new Error('resolveWithInteractionReplace not implemented.');
+    }
+    resolveWithInteraction(folder, config, section, variables) {
+        throw new Error('resolveWithInteraction not implemented.');
+    }
+    contributeVariable(variable, resolution) {
+        if (this._contributedVariables.has(variable)) {
+            throw new Error('Variable ' + variable + ' is contributed twice.');
+        }
+        else {
+            this._contributedVariables.set(variable, resolution);
+        }
+    }
+    async recursiveResolve(environment, folderUri, value, commandValueMapping, resolvedVariables) {
+        if (isString(value)) {
+            return this.resolveString(environment, folderUri, value, commandValueMapping, resolvedVariables);
+        }
+        else if (Array.isArray(value)) {
+            return Promise.all(( (value.map(
+                s => this.recursiveResolve(environment, folderUri, s, commandValueMapping, resolvedVariables)
+            ))));
+        }
+        else if (isObject(value)) {
+            const result = Object.create(null);
+            const replaced = await Promise.all(( (( (Object.keys(value))).map(async (key) => {
+                const replaced = await this.resolveString(environment, folderUri, key, commandValueMapping, resolvedVariables);
+                return [replaced, await this.recursiveResolve(environment, folderUri, value[key], commandValueMapping, resolvedVariables)];
+            }))));
+            for (const [key, value] of replaced) {
+                result[key] = value;
+            }
+            return result;
+        }
+        return value;
+    }
+    resolveString(environment, folderUri, value, commandValueMapping, resolvedVariables) {
+        return replaceAsync(value, AbstractVariableResolverService.VARIABLE_REGEXP, async (match, variable) => {
+            if (variable.includes(AbstractVariableResolverService.VARIABLE_LHS)) {
+                return match;
+            }
+            let resolvedValue = await this.evaluateSingleVariable(environment, match, variable, folderUri, commandValueMapping);
+            resolvedVariables?.set(variable, resolvedValue);
+            if ((resolvedValue !== match) && isString(resolvedValue) && resolvedValue.match(AbstractVariableResolverService.VARIABLE_REGEXP)) {
+                resolvedValue = await this.resolveString(environment, folderUri, resolvedValue, commandValueMapping, resolvedVariables);
+            }
+            return resolvedValue;
+        });
+    }
+    fsPath(displayUri) {
+        return this._labelService ? this._labelService.getUriLabel(displayUri, { noPrefix: true }) : displayUri.fsPath;
+    }
+    async evaluateSingleVariable(environment, match, variable, folderUri, commandValueMapping) {
+        let argument;
+        const parts = variable.split(':');
+        if (parts.length > 1) {
+            variable = parts[0];
+            argument = parts[1];
+        }
+        const getFilePath = (variableKind) => {
+            const filePath = this._context.getFilePath();
+            if (filePath) {
+                return normalizeDriveLetter(filePath);
+            }
+            throw new VariableError(variableKind, (localize('canNotResolveFile', "Variable {0} can not be resolved. Please open an editor.", match)));
+        };
+        const getFolderPathForFile = (variableKind) => {
+            const filePath = getFilePath(variableKind);
+            if (this._context.getWorkspaceFolderPathForFile) {
+                const folderPath = this._context.getWorkspaceFolderPathForFile();
+                if (folderPath) {
+                    return normalizeDriveLetter(folderPath);
+                }
+            }
+            throw new VariableError(variableKind, localize('canNotResolveFolderForFile', "Variable {0}: can not find workspace folder of '{1}'.", match, basename(filePath)));
+        };
+        const getFolderUri = (variableKind) => {
+            if (argument) {
+                const folder = this._context.getFolderUri(argument);
+                if (folder) {
+                    return folder;
+                }
+                throw new VariableError(variableKind, localize('canNotFindFolder', "Variable {0} can not be resolved. No such folder '{1}'.", match, argument));
+            }
+            if (folderUri) {
+                return folderUri;
+            }
+            if (this._context.getWorkspaceFolderCount() > 1) {
+                throw new VariableError(variableKind, localize('canNotResolveWorkspaceFolderMultiRoot', "Variable {0} can not be resolved in a multi folder workspace. Scope this variable using ':' and a workspace folder name.", match));
+            }
+            throw new VariableError(variableKind, localize('canNotResolveWorkspaceFolder', "Variable {0} can not be resolved. Please open a folder.", match));
+        };
+        switch (variable) {
+            case 'env':
+                if (argument) {
+                    if (environment.env) {
+                        const env = environment.env[isWindows ? argument.toLowerCase() : argument];
+                        if (isString(env)) {
+                            return env;
+                        }
+                    }
+                    return '';
+                }
+                throw new VariableError(VariableKind.Env, localize('missingEnvVarName', "Variable {0} can not be resolved because no environment variable name is given.", match));
+            case 'config':
+                if (argument) {
+                    const config = this._context.getConfigurationValue(folderUri, argument);
+                    if (isUndefinedOrNull(config)) {
+                        throw new VariableError(VariableKind.Config, localize('configNotFound', "Variable {0} can not be resolved because setting '{1}' not found.", match, argument));
+                    }
+                    if (isObject(config)) {
+                        throw new VariableError(VariableKind.Config, localize('configNoString', "Variable {0} can not be resolved because '{1}' is a structured value.", match, argument));
+                    }
+                    return config;
+                }
+                throw new VariableError(VariableKind.Config, localize('missingConfigName', "Variable {0} can not be resolved because no settings name is given.", match));
+            case 'command':
+                return this.resolveFromMap(VariableKind.Command, match, argument, commandValueMapping, 'command');
+            case 'input':
+                return this.resolveFromMap(VariableKind.Input, match, argument, commandValueMapping, 'input');
+            case 'extensionInstallFolder':
+                if (argument) {
+                    const ext = await this._context.getExtension(argument);
+                    if (!ext) {
+                        throw new VariableError(VariableKind.ExtensionInstallFolder, localize('extensionNotInstalled', "Variable {0} can not be resolved because the extension {1} is not installed.", match, argument));
+                    }
+                    return this.fsPath(ext.extensionLocation);
+                }
+                throw new VariableError(VariableKind.ExtensionInstallFolder, localize('missingExtensionName', "Variable {0} can not be resolved because no extension name is given.", match));
+            default: {
+                switch (variable) {
+                    case 'workspaceRoot':
+                    case 'workspaceFolder':
+                        return normalizeDriveLetter(this.fsPath(getFolderUri(VariableKind.WorkspaceFolder)));
+                    case 'cwd':
+                        return ((folderUri || argument) ? normalizeDriveLetter(this.fsPath(getFolderUri(VariableKind.Cwd))) : cwd());
+                    case 'workspaceRootFolderName':
+                    case 'workspaceFolderBasename':
+                        return normalizeDriveLetter(basename(this.fsPath(getFolderUri(VariableKind.WorkspaceFolderBasename))));
+                    case 'userHome': {
+                        if (environment.userHome) {
+                            return environment.userHome;
+                        }
+                        throw new VariableError(VariableKind.UserHome, localize('canNotResolveUserHome', "Variable {0} can not be resolved. UserHome path is not defined", match));
+                    }
+                    case 'lineNumber': {
+                        const lineNumber = this._context.getLineNumber();
+                        if (lineNumber) {
+                            return lineNumber;
+                        }
+                        throw new VariableError(VariableKind.LineNumber, localize('canNotResolveLineNumber', "Variable {0} can not be resolved. Make sure to have a line selected in the active editor.", match));
+                    }
+                    case 'selectedText': {
+                        const selectedText = this._context.getSelectedText();
+                        if (selectedText) {
+                            return selectedText;
+                        }
+                        throw new VariableError(VariableKind.SelectedText, localize('canNotResolveSelectedText', "Variable {0} can not be resolved. Make sure to have some text selected in the active editor.", match));
+                    }
+                    case 'file':
+                        return getFilePath(VariableKind.File);
+                    case 'fileWorkspaceFolder':
+                        return getFolderPathForFile(VariableKind.FileWorkspaceFolder);
+                    case 'relativeFile':
+                        if (folderUri || argument) {
+                            return relative(this.fsPath(getFolderUri(VariableKind.RelativeFile)), getFilePath(VariableKind.RelativeFile));
+                        }
+                        return getFilePath(VariableKind.RelativeFile);
+                    case 'relativeFileDirname': {
+                        const dirname$1 = dirname(getFilePath(VariableKind.RelativeFileDirname));
+                        if (folderUri || argument) {
+                            const relative$1 = relative(this.fsPath(getFolderUri(VariableKind.RelativeFileDirname)), dirname$1);
+                            return relative$1.length === 0 ? '.' : relative$1;
+                        }
+                        return dirname$1;
+                    }
+                    case 'fileDirname':
+                        return dirname(getFilePath(VariableKind.FileDirname));
+                    case 'fileExtname':
+                        return extname(getFilePath(VariableKind.FileExtname));
+                    case 'fileBasename':
+                        return basename(getFilePath(VariableKind.FileBasename));
+                    case 'fileBasenameNoExtension': {
+                        const basename$1 = basename(getFilePath(VariableKind.FileBasenameNoExtension));
+                        return (basename$1.slice(0, basename$1.length - extname(basename$1).length));
+                    }
+                    case 'fileDirnameBasename':
+                        return basename(dirname(getFilePath(VariableKind.FileDirnameBasename)));
+                    case 'execPath': {
+                        const ep = this._context.getExecPath();
+                        if (ep) {
+                            return ep;
+                        }
+                        return match;
+                    }
+                    case 'execInstallFolder': {
+                        const ar = this._context.getAppRoot();
+                        if (ar) {
+                            return ar;
+                        }
+                        return match;
+                    }
+                    case 'pathSeparator':
+                        return sep;
+                    default:
+                        try {
+                            const key = argument ? `${variable}:${argument}` : variable;
+                            return this.resolveFromMap(VariableKind.Unknown, match, key, commandValueMapping, undefined);
+                        }
+                        catch (error) {
+                            return match;
+                        }
+                }
+            }
+        }
+    }
+    resolveFromMap(variableKind, match, argument, commandValueMapping, prefix) {
+        if (argument && commandValueMapping) {
+            const v = (prefix === undefined) ? commandValueMapping[argument] : commandValueMapping[prefix + ':' + argument];
+            if (typeof v === 'string') {
+                return v;
+            }
+            throw new VariableError(variableKind, localize('noValueForCommand', "Variable {0} can not be resolved because the command has no value.", match));
+        }
+        return match;
+    }
+}
+AbstractVariableResolverService.VARIABLE_LHS = '${';
+AbstractVariableResolverService.VARIABLE_REGEXP = /\$\{(.*?)\}/g;
+export { AbstractVariableResolverService, convertToDAPaths, convertToVSCPaths, filterExceptionsFromTelemetry, formatPII, getEvaluatableExpressionAtPosition, getExtensionHostDebugSession, getVisibleAndSorted, isDebuggerMainContribution, isSessionAttach, isUri, saveAllBeforeDebugStart };

package/dist/vb.js

@@ -1,9 +1,2 @@
-import { registerExtension } from './api2.js';
-import { onExtHostInitialized } from './polyfill.js';
-var manifest = {name:"vb",displayName:"%displayName%",description:"%description%",version:"1.0.0",publisher:"vscode",license:"MIT",engines:{vscode:"*"},scripts:{"update-grammar":"node ../node_modules/vscode-grammar-updater/bin textmate/asp.vb.net.tmbundle Syntaxes/ASP%20VB.net.plist ./syntaxes/asp-vb-net.tmlanguage.json"},contributes:{languages:[{id:"vb",extensions:[".vb",".brs",".vbs",".bas",".vba"],aliases:["Visual Basic","vb"],configuration:"./language-configuration.json"}],grammars:[{language:"vb",scopeName:"source.asp.vb.net",path:"./syntaxes/asp-vb-net.tmlanguage.json"}],snippets:[{language:"vb",path:"./snippets/vb.code-snippets"}]},repository:{type:"git",url:"https://github.com/microsoft/vscode.git"}};
-onExtHostInitialized(() => {
-  const { registerFile } = registerExtension(manifest);
-  registerFile('./language-configuration.json', async () => await import('./language-configuration38.js').then(module => module.default ?? module)),
-  registerFile('./syntaxes/asp-vb-net.tmlanguage.json', async () => await import('./asp-vb-net.tmlanguage.js').then(module => module.default ?? module)),
-  registerFile('./snippets/vb.code-snippets', async () => await import('./vb2.js').then(module => module.default ?? module));
-});
+var vb = "{\n\t\"For Next Loop\": {\n\t\t\"prefix\": \"for\",\n\t\t\"body\": [\n\t\t\t\"For ${1:index} As ${2:ObjectType} = ${3:lower} To ${4:Upper}\",\n\t\t\t\"\\t$0\",\n\t\t\t\"Next ${1:index}\"\n\t\t],\n\t\t\"description\": \"For Next Loop\"\n\t},\n\t\"For Each...Next\": {\n\t\t\"prefix\": \"fore\",\n\t\t\"body\": [\n\t\t\t\"For Each ${1:Variable} As ${2:ObjectType} In ${3:Collection}\",\n\t\t\t\"\\t$0\",\n\t\t\t\"Next\"\n\t\t],\n\t\t\"description\": \"For Each...Next\"\n\t},\n\t\"For i...Next i\": {\n\t\t\"prefix\": \"fori\",\n\t\t\"body\": [\n\t\t\t\"For i As ${1:Integer} = ${2:Lower} To ${3:Upper}\",\n\t\t\t\"\\t$0\",\n\t\t\t\"Next i\"\n\t\t],\n\t\t\"description\": \"For i...Next i\"\n\t},\n\t\"For j...Next j\": {\n\t\t\"prefix\": \"forj\",\n\t\t\"body\": [\n\t\t\t\"For j As ${1:Integer} = ${2:Lower} To ${3:Upper}\",\n\t\t\t\"\\t$0\",\n\t\t\t\"Next j\"\n\t\t],\n\t\t\"description\": \"For j...Next j\"\n\t},\n\t\"Public Function...\": {\n\t\t\"prefix\": \"pf\",\n\t\t\"body\": [\n\t\t\t\"Public Function ${1:FunctionName}(${2:ParameterList}) As ${3:ReturnType}\",\n\t\t\t\"\\tTry\",\n\t\t\t\"\\t\\t$0\",\n\t\t\t\"\\tCatch ex As Exception\",\n\t\t\t\"\\tEnd Try\",\n\t\t\t\"\\tReturn ${3:ReturnValue}\",\n\t\t\t\"End Function\"\n\t\t],\n\t\t\"description\": \"Public Function...\"\n\t},\n\t\"Public Sub ...\": {\n\t\t\"prefix\": \"ps\",\n\t\t\"body\": [\n\t\t\t\"Public Sub ${1:ProcedureName}(${2:ParameterList})\",\n\t\t\t\"\\tTry\",\n\t\t\t\"\\t\\t$0\",\n\t\t\t\"\\tCatch ex As Exception\",\n\t\t\t\"\\tEnd Try\",\n\t\t\t\"End Sub\"\n\t\t],\n\t\t\"description\": \"Public Sub ...\"\n\t},\n\t\"While ... End While\": {\n\t\t\"prefix\": \"while\",\n\t\t\"body\": [\n\t\t\t\"While ${1:Boolean}\",\n\t\t\t\"\\t$0\",\n\t\t\t\"End While\"\n\t\t],\n\t\t\"description\": \"While ... End While\"\n\t},\n\t\"Region Start\": {\n\t\t\"prefix\": \"#Region\",\n\t\t\"body\": [\n\t\t\t\"#Region $0\"\n\t\t],\n\t\t\"description\": \"Folding Region Start\"\n\t},\n\t\"Region End\": {\n\t\t\"prefix\": \"#End Region\",\n\t\t\"body\": [\n\t\t\t\"#End Region\"\n\t\t],\n\t\t\"description\": \"Folding Region End\"\n\t}\n}\n";
+export { vb as default };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@codingame/monaco-vscode-api",
-  "version": "1.78.3",
+  "version": "1.78.4-next.1",
   "private": false,
   "description": "VSCode public API plugged on the monaco editor",
   "keywords": [],
@@ -94,6 +94,10 @@
     "./rollup-vsix-plugin": {
       "types": "./dist/rollup-vsix-plugin.d.ts",
       "default": "./dist/rollup-vsix-plugin.js"
+    },
+    "./rollup-extension-directory-plugin": {
+      "types": "./dist/rollup-extension-directory-plugin.d.ts",
+      "default": "./dist/rollup-extension-directory-plugin.js"
     }
   },
   "typesVersions": {
@@ -150,7 +154,10 @@
         "./dist/webpack-loader.d.ts"
       ],
       "rollup-vsix-plugin": [
-        "./dist/vsix-rollup-plugin.d.ts"
+        "./dist/rollup-vsix-plugin.d.ts"
+      ],
+      "rollup-extension_directory-plugin": [
+        "./dist/rollup-extension_directory-plugin.d.ts"
       ]
     }
   },
@@ -159,14 +166,14 @@
     "README.md"
   ],
   "scripts": {
-    "build": "npm run lint && npm run clean && npm run compile && npm run generate-types && npm run compile-webpack-loader && npm run compile-rollup-vsix-plugin",
-    "compile": "NODE_OPTIONS=--max_old_space_size=8192 rollup --config rollup/rollup.config.ts --configPlugin 'typescript={tsconfig: `tsconfig.rollup.json`}' --vscode-version ${npm_package_config_vscode_version}",
+    "build": "npm run lint && npm run clean && npm run compile-rollup-plugins && npm run compile && npm run generate-types && npm run compile-webpack-loader",
+    "compile": "NODE_OPTIONS=--max_old_space_size=8192 rollup --config rollup/rollup.config.ts --configPlugin 'typescript={tsconfig: `tsconfig.rollup-config.json`}' --vscode-version ${npm_package_config_vscode_version}",
     "clean": "rm -rf dist/",
     "compile-webpack-loader": "tsc --target es2020 -lib es2020 --module commonjs --skipLibCheck --moduleResolution node --declaration --outDir dist src/webpack-loader.ts && mv dist/webpack-loader.js dist/webpack-loader.cjs",
-    "compile-rollup-vsix-plugin": "tsc --target es2020 -lib es2020 --module esnext --skipLibCheck --moduleResolution node --declaration --outDir dist src/rollup-vsix-plugin.ts",
+    "compile-rollup-plugins": "rollup --config rollup/rollup.rollup-plugins.config.ts --configPlugin 'typescript={tsconfig: `tsconfig.rollup-config.json`, include: [`./rollup/rollup.rollup-plugins.config.ts`]}'",
     "preprepare": "./scripts/install-vscode",
     "lint": "eslint {/src/**/*.ts,./rollup/*.ts,./*.ts}",
-    "generate-types": "tsc --project tsconfig.types.json && rollup --config rollup/rollup.types.config.ts --configPlugin 'typescript={tsconfig: `tsconfig.rollup.json`}' && rm -rf ./dist/types",
+    "generate-types": "tsc --project tsconfig.types.json && rollup --config rollup/rollup.types.config.ts --configPlugin 'typescript={tsconfig: `tsconfig.rollup-config.json`}' && rm -rf ./dist/types",
     "release": "node --loader ts-node/esm release.ts ${npm_package_config_vscode_version}"
   },
   "config": {

package/dist/bat.js

@@ -1,9 +0,0 @@
-import { registerExtension } from './api2.js';
-import { onExtHostInitialized } from './polyfill.js';
-var manifest = {name:"bat",displayName:"%displayName%",description:"%description%",version:"1.0.0",publisher:"vscode",license:"MIT",engines:{vscode:"^1.52.0"},scripts:{"update-grammar":"node ../node_modules/vscode-grammar-updater/bin mmims/language-batchfile grammars/batchfile.cson ./syntaxes/batchfile.tmLanguage.json"},contributes:{languages:[{id:"bat",extensions:[".bat",".cmd"],aliases:["Batch","bat"],configuration:"./language-configuration.json"}],grammars:[{language:"bat",scopeName:"source.batchfile",path:"./syntaxes/batchfile.tmLanguage.json"}],snippets:[{language:"bat",path:"./snippets/batchfile.code-snippets"}]},repository:{type:"git",url:"https://github.com/microsoft/vscode.git"}};
-onExtHostInitialized(() => {
-  const { registerFile } = registerExtension(manifest);
-  registerFile('./language-configuration.json', async () => await import('./language-configuration.js').then(module => module.default ?? module)),
-  registerFile('./syntaxes/batchfile.tmLanguage.json', async () => await import('./batchfile.tmLanguage.js').then(module => module.default ?? module)),
-  registerFile('./snippets/batchfile.code-snippets', async () => await import('./batchfile.js').then(module => module.default ?? module));
-});