@codingame/monaco-vscode-api 1.69.14 → 1.69.16

package/dist/missing-services.js

@@ -6,7 +6,7 @@ import { Event } from 'monaco-editor/esm/vs/base/common/event.js';
 import { ExtensionIdentifier } from 'monaco-editor/esm/vs/platform/extensions/common/extensions.js';
 import { USLayoutResolvedKeybinding } from 'monaco-editor/esm/vs/platform/keybinding/common/usLayoutResolvedKeybinding.js';
 import { SimpleKeybinding } from 'monaco-editor/esm/vs/base/common/keybindings.js';
-import './polyfill.js';
+import { p as parseTree, f as findNodeAtLocation, c as createScanner } from './polyfill.js';
 import { generateUuid } from 'monaco-editor/esm/vs/base/common/uuid.js';
 import { VSBuffer } from 'monaco-editor/esm/vs/base/common/buffer.js';
 import { Registry } from 'monaco-editor/esm/vs/platform/registry/common/platform.js';
@@ -385,6 +385,15 @@ class NullExtensionService {
 const ILifecycleService = ( (createDecorator('lifecycleService')));
 const ILanguageDetectionService = ( (createDecorator('ILanguageDetectionService')));
 const IKeyboardLayoutService = ( (createDecorator('keyboardLayoutService')));
+function getKeyboardLayoutId(layout) {
+    if (layout.name) {
+        return layout.name;
+    }
+    if (layout.id) {
+        return layout.id;
+    }
+    return layout.layout;
+}
 class MacLinuxFallbackKeyboardMapper {
     constructor(OS) {
         this._OS = OS;
@@ -435,6 +444,328 @@ async function getServiceMachineId(environmentService, fileService, storageServi
     storageService?.store('storage.serviceMachineId', uuid, -1 , 1 );
     return uuid;
 }
+function format(documentText, range, options) {
+    let initialIndentLevel;
+    let formatText;
+    let formatTextStart;
+    let rangeStart;
+    let rangeEnd;
+    if (range) {
+        rangeStart = range.offset;
+        rangeEnd = rangeStart + range.length;
+        formatTextStart = rangeStart;
+        while (formatTextStart > 0 && !isEOL(documentText, formatTextStart - 1)) {
+            formatTextStart--;
+        }
+        let endOffset = rangeEnd;
+        while (endOffset < documentText.length && !isEOL(documentText, endOffset)) {
+            endOffset++;
+        }
+        formatText = documentText.substring(formatTextStart, endOffset);
+        initialIndentLevel = computeIndentLevel(formatText, options);
+    }
+    else {
+        formatText = documentText;
+        initialIndentLevel = 0;
+        formatTextStart = 0;
+        rangeStart = 0;
+        rangeEnd = documentText.length;
+    }
+    const eol = getEOL(options, documentText);
+    let lineBreak = false;
+    let indentLevel = 0;
+    let indentValue;
+    if (options.insertSpaces) {
+        indentValue = repeat(' ', options.tabSize || 4);
+    }
+    else {
+        indentValue = '\t';
+    }
+    const scanner = createScanner(formatText, false);
+    let hasError = false;
+    function newLineAndIndent() {
+        return eol + repeat(indentValue, initialIndentLevel + indentLevel);
+    }
+    function scanNext() {
+        let token = scanner.scan();
+        lineBreak = false;
+        while (token === 15  || token === 14 ) {
+            lineBreak = lineBreak || ((token === 14) );
+            token = scanner.scan();
+        }
+        hasError = token === 16  || scanner.getTokenError() !== 0 ;
+        return token;
+    }
+    const editOperations = [];
+    function addEdit(text, startOffset, endOffset) {
+        if (!hasError && startOffset < rangeEnd && endOffset > rangeStart && documentText.substring(startOffset, endOffset) !== text) {
+            editOperations.push({ offset: startOffset, length: endOffset - startOffset, content: text });
+        }
+    }
+    let firstToken = scanNext();
+    if (firstToken !== 17 ) {
+        const firstTokenStart = scanner.getTokenOffset() + formatTextStart;
+        const initialIndent = repeat(indentValue, initialIndentLevel);
+        addEdit(initialIndent, formatTextStart, firstTokenStart);
+    }
+    while (firstToken !== 17 ) {
+        let firstTokenEnd = scanner.getTokenOffset() + scanner.getTokenLength() + formatTextStart;
+        let secondToken = scanNext();
+        let replaceContent = '';
+        while (!lineBreak && ((secondToken === 12  || secondToken === 13) )) {
+            const commentTokenStart = scanner.getTokenOffset() + formatTextStart;
+            addEdit(' ', firstTokenEnd, commentTokenStart);
+            firstTokenEnd = scanner.getTokenOffset() + scanner.getTokenLength() + formatTextStart;
+            replaceContent = secondToken === 12  ? newLineAndIndent() : '';
+            secondToken = scanNext();
+        }
+        if (secondToken === 2 ) {
+            if (firstToken !== 1 ) {
+                indentLevel--;
+                replaceContent = newLineAndIndent();
+            }
+        }
+        else if (secondToken === 4 ) {
+            if (firstToken !== 3 ) {
+                indentLevel--;
+                replaceContent = newLineAndIndent();
+            }
+        }
+        else {
+            switch (firstToken) {
+                case 3 :
+                case 1 :
+                    indentLevel++;
+                    replaceContent = newLineAndIndent();
+                    break;
+                case 5 :
+                case 12 :
+                    replaceContent = newLineAndIndent();
+                    break;
+                case 13 :
+                    if (lineBreak) {
+                        replaceContent = newLineAndIndent();
+                    }
+                    else {
+                        replaceContent = ' ';
+                    }
+                    break;
+                case 6 :
+                    replaceContent = ' ';
+                    break;
+                case 10 :
+                    if (secondToken === 6 ) {
+                        replaceContent = '';
+                        break;
+                    }
+                case 7 :
+                case 8 :
+                case 9 :
+                case 11 :
+                case 2 :
+                case 4 :
+                    if (secondToken === 12  || secondToken === 13 ) {
+                        replaceContent = ' ';
+                    }
+                    else if (secondToken !== 5  && secondToken !== 17 ) {
+                        hasError = true;
+                    }
+                    break;
+                case 16 :
+                    hasError = true;
+                    break;
+            }
+            if (lineBreak && ((secondToken === 12  || secondToken === 13) )) {
+                replaceContent = newLineAndIndent();
+            }
+        }
+        const secondTokenStart = scanner.getTokenOffset() + formatTextStart;
+        addEdit(replaceContent, firstTokenEnd, secondTokenStart);
+        firstToken = secondToken;
+    }
+    return editOperations;
+}
+function repeat(s, count) {
+    let result = '';
+    for (let i = 0; i < count; i++) {
+        result += s;
+    }
+    return result;
+}
+function computeIndentLevel(content, options) {
+    let i = 0;
+    let nChars = 0;
+    const tabSize = options.tabSize || 4;
+    while (i < content.length) {
+        const ch = content.charAt(i);
+        if (ch === ' ') {
+            nChars++;
+        }
+        else if (ch === '\t') {
+            nChars += tabSize;
+        }
+        else {
+            break;
+        }
+        i++;
+    }
+    return Math.floor(nChars / tabSize);
+}
+function getEOL(options, text) {
+    for (let i = 0; i < text.length; i++) {
+        const ch = text.charAt(i);
+        if (ch === '\r') {
+            if (i + 1 < text.length && text.charAt(i + 1) === '\n') {
+                return '\r\n';
+            }
+            return '\r';
+        }
+        else if (ch === '\n') {
+            return '\n';
+        }
+    }
+    return (options && options.eol) || '\n';
+}
+function isEOL(text, offset) {
+    return '\r\n'.indexOf(text.charAt(offset)) !== -1;
+}
+function setProperty(text, originalPath, value, formattingOptions, getInsertionIndex) {
+    const path = originalPath.slice();
+    const errors = [];
+    const root = parseTree(text, errors);
+    let parent = undefined;
+    let lastSegment = undefined;
+    while (path.length > 0) {
+        lastSegment = path.pop();
+        parent = findNodeAtLocation(root, path);
+        if (parent === undefined && value !== undefined) {
+            if (typeof lastSegment === 'string') {
+                value = { [lastSegment]: value };
+            }
+            else {
+                value = [value];
+            }
+        }
+        else {
+            break;
+        }
+    }
+    if (!parent) {
+        if (value === undefined) {
+            throw new Error('Can not delete in empty document');
+        }
+        return withFormatting(text, { offset: root ? root.offset : 0, length: root ? root.length : 0, content: JSON.stringify(value) }, formattingOptions);
+    }
+    else if (parent.type === 'object' && typeof lastSegment === 'string' && Array.isArray(parent.children)) {
+        const existing = findNodeAtLocation(parent, [lastSegment]);
+        if (existing !== undefined) {
+            if (value === undefined) {
+                if (!existing.parent) {
+                    throw new Error('Malformed AST');
+                }
+                const propertyIndex = parent.children.indexOf(existing.parent);
+                let removeBegin;
+                let removeEnd = existing.parent.offset + existing.parent.length;
+                if (propertyIndex > 0) {
+                    const previous = parent.children[propertyIndex - 1];
+                    removeBegin = previous.offset + previous.length;
+                }
+                else {
+                    removeBegin = parent.offset + 1;
+                    if (parent.children.length > 1) {
+                        const next = parent.children[1];
+                        removeEnd = next.offset;
+                    }
+                }
+                return withFormatting(text, { offset: removeBegin, length: removeEnd - removeBegin, content: '' }, formattingOptions);
+            }
+            else {
+                return withFormatting(text, { offset: existing.offset, length: existing.length, content: JSON.stringify(value) }, formattingOptions);
+            }
+        }
+        else {
+            if (value === undefined) {
+                return [];
+            }
+            const newProperty = `${JSON.stringify(lastSegment)}: ${JSON.stringify(value)}`;
+            const index = getInsertionIndex ? getInsertionIndex(parent.children.map(p => p.children[0].value)) : parent.children.length;
+            let edit;
+            if (index > 0) {
+                const previous = parent.children[index - 1];
+                edit = { offset: previous.offset + previous.length, length: 0, content: ',' + newProperty };
+            }
+            else if (parent.children.length === 0) {
+                edit = { offset: parent.offset + 1, length: 0, content: newProperty };
+            }
+            else {
+                edit = { offset: parent.offset + 1, length: 0, content: newProperty + ',' };
+            }
+            return withFormatting(text, edit, formattingOptions);
+        }
+    }
+    else if (parent.type === 'array' && typeof lastSegment === 'number' && Array.isArray(parent.children)) {
+        if (value !== undefined) {
+            const newProperty = `${JSON.stringify(value)}`;
+            let edit;
+            if (parent.children.length === 0 || lastSegment === 0) {
+                edit = { offset: parent.offset + 1, length: 0, content: parent.children.length === 0 ? newProperty : newProperty + ',' };
+            }
+            else {
+                const index = lastSegment === -1 || lastSegment > parent.children.length ? parent.children.length : lastSegment;
+                const previous = parent.children[index - 1];
+                edit = { offset: previous.offset + previous.length, length: 0, content: ',' + newProperty };
+            }
+            return withFormatting(text, edit, formattingOptions);
+        }
+        else {
+            const removalIndex = lastSegment;
+            const toRemove = parent.children[removalIndex];
+            let edit;
+            if (parent.children.length === 1) {
+                edit = { offset: parent.offset + 1, length: parent.length - 2, content: '' };
+            }
+            else if (parent.children.length - 1 === removalIndex) {
+                const previous = parent.children[removalIndex - 1];
+                const offset = previous.offset + previous.length;
+                const parentEndOffset = parent.offset + parent.length;
+                edit = { offset, length: parentEndOffset - 2 - offset, content: '' };
+            }
+            else {
+                edit = { offset: toRemove.offset, length: parent.children[removalIndex + 1].offset - toRemove.offset, content: '' };
+            }
+            return withFormatting(text, edit, formattingOptions);
+        }
+    }
+    else {
+        throw new Error(`Can not add ${typeof lastSegment !== 'number' ? 'index' : 'property'} to parent of type ${parent.type}`);
+    }
+}
+function withFormatting(text, edit, formattingOptions) {
+    let newText = applyEdit(text, edit);
+    let begin = edit.offset;
+    let end = edit.offset + edit.content.length;
+    if (edit.length === 0 || edit.content.length === 0) {
+        while (begin > 0 && !isEOL(newText, begin - 1)) {
+            begin--;
+        }
+        while (end < newText.length && !isEOL(newText, end)) {
+            end++;
+        }
+    }
+    const edits = format(newText, { offset: begin, length: end - begin }, formattingOptions);
+    for (let i = edits.length - 1; i >= 0; i--) {
+        const curr = edits[i];
+        newText = applyEdit(newText, curr);
+        begin = Math.min(begin, curr.offset);
+        end = Math.max(end, curr.offset + curr.length);
+        end += curr.content.length - curr.length;
+    }
+    const editLength = text.length - (newText.length - end) - begin;
+    return [{ offset: begin, length: editLength, content: newText.substring(begin, end) }];
+}
+function applyEdit(text, edit) {
+    return text.substring(0, edit.offset) + edit.content + text.substring(edit.offset + edit.length);
+}
 const IBrowserWorkbenchEnvironmentService = refineServiceDecorator(IEnvironmentService);
 const allApiProposals = ( (Object.freeze({
     authSession: 'https://raw.githubusercontent.com/microsoft/vscode/main/src/vscode-dts/vscode.proposed.authSession.d.ts',
@@ -1564,6 +1895,8 @@ class WorkbenchEnvironmentService {
         this.skipWelcome = true;
         this.disableWorkspaceTrust = true;
         this.debugRenderer = false;
+        this.keyboardLayoutResource = ( URI.from({ scheme: 'user', path: '/keyboardLayout.json' }));
+        this.snippetsHome = ( URI.from({ scheme: 'user', path: '/snippets' }));
         this.sync = undefined;
         this.isExtensionDevelopment = false;
         this.disableExtensions = false;
@@ -1576,9 +1909,7 @@ class WorkbenchEnvironmentService {
     get extHostLogsPath() { return unsupported(); }
     get webviewExternalEndpoint() { return unsupported(); }
     get userRoamingDataHome() { return unsupported(); }
-    get keyboardLayoutResource() { return unsupported(); }
     get argvResource() { return unsupported(); }
-    get snippetsHome() { return ( URI.from({ scheme: 'user', path: '/snippets' })); }
     get untitledWorkspacesHome() { return unsupported(); }
     get globalStorageHome() { return unsupported(); }
     get workspaceStorageHome() { return unsupported(); }
@@ -1828,4 +2159,4 @@ registerSingleton(ISnippetsService, class SnippetsService {
         this.getSnippetsSync = unsupported;
     }
 });
-export { Barrier as B, ExtensionsRegistry as E, IExtensionService as I, NullPolicyService as N, ResourceQueue as R, Sequencer as S, IntervalCounter as a, ILifecycleService as b, checkProposedApiEnabled as c, ILanguageDetectionService as d, IPolicyService as e, format2 as f, getServiceMachineId as g, ExtensionMessageCollector as h, isProposedApiEnabled as i, IPreferencesService as j, IUserDataProfileService as k, IKeyboardLayoutService as l, ITextMateService as m, IBrowserWorkbenchEnvironmentService as n, IHostColorSchemeService as o, IUserDataInitializationService as p, raceCancellationError as r, unsupported as u };
+export { Barrier as B, ExtensionsRegistry as E, IExtensionService as I, MacLinuxFallbackKeyboardMapper as M, NullPolicyService as N, ResourceQueue as R, Sequencer as S, IntervalCounter as a, ILifecycleService as b, checkProposedApiEnabled as c, ILanguageDetectionService as d, IPolicyService as e, format2 as f, getServiceMachineId as g, ExtensionMessageCollector as h, isProposedApiEnabled as i, IKeyboardLayoutService as j, IPreferencesService as k, getKeyboardLayoutId as l, IUserDataProfileService as m, ITextMateService as n, IBrowserWorkbenchEnvironmentService as o, IHostColorSchemeService as p, IUserDataInitializationService as q, raceCancellationError as r, setProperty as s, unsupported as u };

package/dist/polyfill.js

@@ -1306,6 +1306,96 @@ function parse(text, errors = [], options = ParseOptions.DEFAULT) {
     visit(text, visitor, options);
     return currentParent[0];
 }
+function parseTree(text, errors = [], options = ParseOptions.DEFAULT) {
+    let currentParent = { type: 'array', offset: -1, length: -1, children: [], parent: undefined };
+    function ensurePropertyComplete(endOffset) {
+        if (currentParent.type === 'property') {
+            currentParent.length = endOffset - currentParent.offset;
+            currentParent = currentParent.parent;
+        }
+    }
+    function onValue(valueNode) {
+        currentParent.children.push(valueNode);
+        return valueNode;
+    }
+    const visitor = {
+        onObjectBegin: (offset) => {
+            currentParent = onValue({ type: 'object', offset, length: -1, parent: currentParent, children: [] });
+        },
+        onObjectProperty: (name, offset, length) => {
+            currentParent = onValue({ type: 'property', offset, length: -1, parent: currentParent, children: [] });
+            currentParent.children.push({ type: 'string', value: name, offset, length, parent: currentParent });
+        },
+        onObjectEnd: (offset, length) => {
+            currentParent.length = offset + length - currentParent.offset;
+            currentParent = currentParent.parent;
+            ensurePropertyComplete(offset + length);
+        },
+        onArrayBegin: (offset, length) => {
+            currentParent = onValue({ type: 'array', offset, length: -1, parent: currentParent, children: [] });
+        },
+        onArrayEnd: (offset, length) => {
+            currentParent.length = offset + length - currentParent.offset;
+            currentParent = currentParent.parent;
+            ensurePropertyComplete(offset + length);
+        },
+        onLiteralValue: (value, offset, length) => {
+            onValue({ type: getNodeType(value), offset, length, parent: currentParent, value });
+            ensurePropertyComplete(offset + length);
+        },
+        onSeparator: (sep, offset, length) => {
+            if (currentParent.type === 'property') {
+                if (sep === ':') {
+                    currentParent.colonOffset = offset;
+                }
+                else if (sep === ',') {
+                    ensurePropertyComplete(offset);
+                }
+            }
+        },
+        onError: (error, offset, length) => {
+            errors.push({ error, offset, length });
+        }
+    };
+    visit(text, visitor, options);
+    const result = currentParent.children[0];
+    if (result) {
+        delete result.parent;
+    }
+    return result;
+}
+function findNodeAtLocation(root, path) {
+    if (!root) {
+        return undefined;
+    }
+    let node = root;
+    for (const segment of path) {
+        if (typeof segment === 'string') {
+            if (node.type !== 'object' || !Array.isArray(node.children)) {
+                return undefined;
+            }
+            let found = false;
+            for (const propertyNode of node.children) {
+                if (Array.isArray(propertyNode.children) && propertyNode.children[0].value === segment) {
+                    node = propertyNode.children[1];
+                    found = true;
+                    break;
+                }
+            }
+            if (!found) {
+                return undefined;
+            }
+        }
+        else {
+            const index = segment;
+            if (node.type !== 'array' || index < 0 || !Array.isArray(node.children) || index >= node.children.length) {
+                return undefined;
+            }
+            node = node.children[index];
+        }
+    }
+    return node;
+}
 function visit(text, visitor, options = ParseOptions.DEFAULT) {
     const _scanner = createScanner(text, false);
     function toNoArgVisit(visitFunction) {
@@ -5467,4 +5557,4 @@ function toVSCodeColor(value) {
     return value;
 }
 polyfillPrototype(Color$1.prototype, Color.prototype, toMonacoColor, toVSCodeColor);
-export { ConsoleMainLogger as C, NotImplementedError as N, ResourceSet as R, UserSettings as U, peekReadable as a, bufferToReadable as b, consumeStream as c, disposed as d, isReadableBufferedStream as e, bufferedStreamToBuffer as f, readableToBuffer as g, newWriteableStream as h, isReadableStream as i, parse as j, getNodeType as k, listenStream as l, newWriteableBufferStream as n, peekStream as p, readonly as r, streamToBuffer as s, transform as t };
+export { ConsoleMainLogger as C, NotImplementedError as N, ResourceSet as R, UserSettings as U, peekStream as a, peekReadable as b, createScanner as c, disposed as d, bufferToReadable as e, findNodeAtLocation as f, consumeStream as g, isReadableBufferedStream as h, isReadableStream as i, bufferedStreamToBuffer as j, readableToBuffer as k, listenStream as l, newWriteableStream as m, newWriteableBufferStream as n, parse as o, parseTree as p, getNodeType as q, readonly as r, streamToBuffer as s, transform as t };

package/dist/snippets.js

@@ -1,5 +1,5 @@
-import { j as parse, k as getNodeType } from './polyfill.js';
-import { h as ExtensionMessageCollector, k as IUserDataProfileService, b as ILifecycleService, E as ExtensionsRegistry } from './missing-services.js';
+import { o as parse, q as getNodeType } from './polyfill.js';
+import { h as ExtensionMessageCollector, m as IUserDataProfileService, b as ILifecycleService, E as ExtensionsRegistry } from './missing-services.js';
 import { r as ISnippetsService, S as Services, i as IFileService, h as ITextFileService } from './services2.js';
 import { _ as __decorate, a as __param } from './workspace.js';
 import * as monacoSuggest from 'monaco-editor/esm/vs/editor/contrib/suggest/browser/suggest.js';
@@ -13,7 +13,7 @@ import { SnippetParser, Placeholder, Variable, Text } from 'monaco-editor/esm/vs
 import { tail, insertInto } from 'monaco-editor/esm/vs/base/common/arrays.js';
 import { KnownSnippetVariableNames } from 'monaco-editor/esm/vs/editor/contrib/snippet/browser/snippetVariables.js';
 import { l as languagesExtPoint } from './languageService.js';
-import { bd as DEFAULT_EXTENSION, bk as Range$2 } from './extHost.js';
+import { bd as DEFAULT_EXTENSION, bl as Range$2 } from './extHost.js';
 import { CommandsRegistry } from 'monaco-editor/esm/vs/platform/commands/common/commands.js';
 import { getWordAtText } from 'monaco-editor/esm/vs/editor/common/core/wordHelper.js';
 import { isPatternInWord } from 'monaco-editor/esm/vs/base/common/filters.js';

package/dist/textmate.js

@@ -1,6 +1,6 @@
 import { _ as __decorate, a as __param, E as Emitter } from './workspace.js';
 import './polyfill.js';
-import { h as ExtensionMessageCollector, m as ITextMateService, E as ExtensionsRegistry } from './missing-services.js';
+import { h as ExtensionMessageCollector, n as ITextMateService, E as ExtensionsRegistry } from './missing-services.js';
 import { l as languagesExtPoint } from './languageService.js';
 import { localize } from 'monaco-editor/esm/vs/nls.js';
 import { I as IWorkbenchThemeService } from './workbenchThemeService.js';

package/dist/theme.js

@@ -1,5 +1,5 @@
-import { j as parse$1, k as getNodeType } from './polyfill.js';
-import { E as ExtensionsRegistry, h as ExtensionMessageCollector, S as Sequencer, I as IExtensionService, n as IBrowserWorkbenchEnvironmentService, o as IHostColorSchemeService, p as IUserDataInitializationService } from './missing-services.js';
+import { o as parse$1, q as getNodeType } from './polyfill.js';
+import { E as ExtensionsRegistry, h as ExtensionMessageCollector, S as Sequencer, I as IExtensionService, o as IBrowserWorkbenchEnvironmentService, p as IHostColorSchemeService, q as IUserDataInitializationService } from './missing-services.js';
 import { E as Emitter, _ as __decorate, a as __param } from './workspace.js';
 import { T as ThemeSettings, E as ExtensionData, V as VS_DARK_THEME, a as VS_LIGHT_THEME, b as VS_HC_THEME, c as VS_HC_LIGHT_THEME, d as THEME_SCOPE_OPEN_PAREN, e as THEME_SCOPE_CLOSE_PAREN, f as THEME_SCOPE_WILDCARD, t as themeScopeRegex } from './workbenchThemeService.js';
 import { editorBackground, editorForeground, editorSelectionBackground, editorInactiveSelection, editorSelectionHighlight, editorFindMatchHighlight, editorFindMatch, editorHoverHighlight, editorFindRangeHighlight, workbenchColorsSchemaId, asCssVariableName, Extensions as Extensions$2 } from 'monaco-editor/esm/vs/platform/theme/common/colorRegistry.js';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@codingame/monaco-vscode-api",
-  "version": "1.69.14",
+  "version": "1.69.16",
   "private": false,
   "description": "VSCode public API plugged on the monaco editor",
   "keywords": [],
@@ -143,21 +143,22 @@
   "devDependencies": {
     "@babel/core": "^7.20.12",
     "@babel/plugin-proposal-class-properties": "^7.18.6",
-    "@babel/plugin-proposal-decorators": "^7.20.7",
+    "@babel/plugin-proposal-decorators": "^7.20.13",
     "@babel/preset-env": "^7.20.2",
     "@babel/preset-typescript": "^7.18.6",
     "@codingame/eslint-config": "^1.1.6",
     "@codingame/tsconfig": "^1.1.1",
-    "@octokit/rest": "^19.0.5",
+    "@octokit/rest": "^19.0.7",
+    "@rollup/plugin-dynamic-import-vars": "^2.0.3",
     "@rollup/plugin-node-resolve": "^15.0.1",
     "@rollup/plugin-replace": "^5.0.2",
     "@rollup/plugin-typescript": "^11.0.0",
     "@types/babel__core": "^7.20.0",
     "@types/semver": "^7.3.13",
     "@types/vscode": "~1.69.1",
-    "@typescript-eslint/eslint-plugin": "^5.48.2",
-    "@typescript-eslint/parser": "^5.48.2",
-    "eslint": "^8.32.0",
+    "@typescript-eslint/eslint-plugin": "^5.50.0",
+    "@typescript-eslint/parser": "^5.50.0",
+    "eslint": "^8.33.0",
     "eslint-config-standard": "^17.0.0",
     "eslint-plugin-import": "^2.27.5",
     "eslint-plugin-n": "^15.6.1",
@@ -165,23 +166,23 @@
     "eslint-plugin-unused-imports": "^2.0.0",
     "js-cleanup": "^1.2.0",
     "recast": "^0.22.0",
-    "rollup": "^3.10.0",
+    "rollup": "^3.12.1",
     "rollup-plugin-dts": "^5.1.1",
     "rollup-plugin-styles": "^4.0.0",
     "semver": "^7.3.8",
     "ts-node": "^10.9.1",
-    "typescript": "^4.9.4",
+    "typescript": "^4.9.5",
     "zx": "^7.1.1"
   },
   "dependencies": {},
   "peerDependencies": {
     "monaco-editor": "~0.34.0",
-    "vscode-textmate": "^7.0.1",
-    "vscode-oniguruma": "^1.6.2"
+    "vscode-oniguruma": "^1.6.2",
+    "vscode-textmate": "^7.0.1"
   },
   "overrides": {
     "rollup-plugin-styles": {
-      "rollup": "3.10.0"
+      "rollup": "3.12.1"
     }
   },
   "volta": {