@codingame/monaco-vscode-api 2.1.4 → 2.2.0-next.1

package/vscode/src/vs/workbench/services/layout/browser/layoutService.js

@@ -34,4 +34,20 @@ const positionsByString = {
 function positionFromString(str) {
     return positionsByString[str];
 }
-export { IWorkbenchLayoutService, Parts, Position, positionFromString, positionToString };
+function panelOpensMaximizedSettingToString(setting) {
+    switch (setting) {
+        case 0 : return 'always';
+        case 1 : return 'never';
+        case 2 : return 'preserve';
+        default: return 'preserve';
+    }
+}
+const panelOpensMaximizedByString = {
+    [panelOpensMaximizedSettingToString(0 )]: 0 ,
+    [panelOpensMaximizedSettingToString(1 )]: 1 ,
+    [panelOpensMaximizedSettingToString(2 )]: 2
+};
+function panelOpensMaximizedFromString(str) {
+    return panelOpensMaximizedByString[str];
+}
+export { IWorkbenchLayoutService, Parts, Position, panelOpensMaximizedFromString, positionFromString, positionToString };

package/vscode/src/vs/workbench/services/lifecycle/common/lifecycle.js

@@ -1,5 +1,12 @@
 import { createDecorator } from '../../../../platform/instantiation/common/instantiation.js';
 const ILifecycleService = ( createDecorator('lifecycleService'));
+function StartupKindToString(startupKind) {
+    switch (startupKind) {
+        case 1 : return 'NewWindow';
+        case 3 : return 'ReloadedWindow';
+        case 4 : return 'ReopenedWindow';
+    }
+}
 function LifecyclePhaseToString(phase) {
     switch (phase) {
         case 1 : return 'Starting';
@@ -8,4 +15,4 @@ function LifecyclePhaseToString(phase) {
         case 4 : return 'Eventually';
     }
 }
-export { ILifecycleService, LifecyclePhaseToString };
+export { ILifecycleService, LifecyclePhaseToString, StartupKindToString };

package/vscode/src/vs/workbench/services/progress/browser/media/progressService.css.js

@@ -0,0 +1,4 @@
+import n from '../../../../../../../../external/rollup-plugin-styles/dist/runtime/inject-css.js';
+var css = ".monaco-workbench .progress-badge>.badge-content:before{background-color:currentColor;background-repeat:no-repeat;bottom:0;content:\"\";height:14px;left:0;margin:auto;mask:url(\"data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHdpZHRoPSIxNCIgaGVpZ2h0PSIxNCIgdmlld0JveD0iMiAyIDE0IDE0Ij48cGF0aCBmaWxsPSIjZmZmIiBkPSJNOSAxNmMtMy44NiAwLTctMy4xNC03LTdzMy4xNC03IDctN2MzLjg1OSAwIDcgMy4xNDEgNyA3cy0zLjE0MSA3LTcgN3pNOSAzLjRDNS45MTIgMy40IDMuNCA1LjkxMyAzLjQgOXMyLjUxMiA1LjYgNS42IDUuNiA1LjYtMi41MTIgNS42LTUuNlMxMi4wODggMy40IDkgMy40em0zLjg2IDcuMUw5LjcgOC42MDRWNC44SDguM3Y0LjU5NmwzLjg0IDIuMzA1LjcyLTEuMjAxeiIvPjwvc3ZnPg==\") no-repeat;-webkit-mask:url(\"data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHdpZHRoPSIxNCIgaGVpZ2h0PSIxNCIgdmlld0JveD0iMiAyIDE0IDE0Ij48cGF0aCBmaWxsPSIjZmZmIiBkPSJNOSAxNmMtMy44NiAwLTctMy4xNC03LTdzMy4xNC03IDctN2MzLjg1OSAwIDcgMy4xNDEgNyA3cy0zLjE0MSA3LTcgN3pNOSAzLjRDNS45MTIgMy40IDMuNCA1LjkxMyAzLjQgOXMyLjUxMiA1LjYgNS42IDUuNiA1LjYtMi41MTIgNS42LTUuNlMxMi4wODggMy40IDkgMy40em0zLjg2IDcuMUw5LjcgOC42MDRWNC44SDguM3Y0LjU5NmwzLjg0IDIuMzA1LjcyLTEuMjAxeiIvPjwvc3ZnPg==\") no-repeat;position:absolute;right:0;top:0;width:14px}";
+n(css,{});
+export { css, css as default };

package/vscode/src/vs/workbench/services/progress/browser/progressService.js

@@ -0,0 +1,521 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import './media/progressService.css.js';
+import { localizeWithPath } from '../../../../nls.js';
+import { Disposable, dispose, DisposableStore, toDisposable } from '../../../../base/common/lifecycle.js';
+import { Progress } from '../../../../platform/progress/common/progress.js';
+import { IStatusbarService } from '../../statusbar/browser/statusbar.js';
+import { timeout, RunOnceScheduler, DeferredPromise } from '../../../../base/common/async.js';
+import { ProgressBadge, IActivityService } from '../../activity/common/activity.js';
+import { NotificationPriority, NotificationsFilter, isNotificationSource, INotificationService, Severity } from '../../../../platform/notification/common/notification.js';
+import { Action } from '../../../../base/common/actions.js';
+import { Emitter, Event } from '../../../../base/common/event.js';
+import { ILayoutService } from '../../../../platform/layout/browser/layoutService.js';
+import { Dialog } from '../../../../base/browser/ui/dialog/dialog.js';
+import { IKeybindingService } from '../../../../platform/keybinding/common/keybinding.js';
+import { EventHelper } from '../../../../base/browser/dom.js';
+import { parseLinkedText } from '../../../../base/common/linkedText.js';
+import { IViewDescriptorService } from '../../../common/views.js';
+import { IViewsService } from '../../views/common/viewsService.js';
+import { IPaneCompositePartService } from '../../panecomposite/browser/panecomposite.js';
+import { stripIcons } from '../../../../base/common/iconLabels.js';
+import { defaultButtonStyles, defaultCheckboxStyles, defaultInputBoxStyles, defaultDialogStyles } from '../../../../platform/theme/browser/defaultStyles.js';
+let ProgressService = class ProgressService extends Disposable {
+    constructor(activityService, paneCompositeService, viewDescriptorService, viewsService, notificationService, statusbarService, layoutService, keybindingService) {
+        super();
+        this.activityService = activityService;
+        this.paneCompositeService = paneCompositeService;
+        this.viewDescriptorService = viewDescriptorService;
+        this.viewsService = viewsService;
+        this.notificationService = notificationService;
+        this.statusbarService = statusbarService;
+        this.layoutService = layoutService;
+        this.keybindingService = keybindingService;
+        this.windowProgressStack = [];
+        this.windowProgressStatusEntry = undefined;
+    }
+    async withProgress(options, task, onDidCancel) {
+        const { location } = options;
+        const handleStringLocation = (location) => {
+            const viewContainer = this.viewDescriptorService.getViewContainerById(location);
+            if (viewContainer) {
+                const viewContainerLocation = this.viewDescriptorService.getViewContainerLocation(viewContainer);
+                if (viewContainerLocation !== null) {
+                    return this.withPaneCompositeProgress(location, viewContainerLocation, task, { ...options, location });
+                }
+            }
+            if (this.viewDescriptorService.getViewDescriptorById(location) !== null) {
+                return this.withViewProgress(location, task, { ...options, location });
+            }
+            throw new Error(`Bad progress location: ${location}`);
+        };
+        if (typeof location === 'string') {
+            return handleStringLocation(location);
+        }
+        switch (location) {
+            case 15 : {
+                let priority = options.priority;
+                if (priority !== NotificationPriority.URGENT) {
+                    if (this.notificationService.getFilter() === NotificationsFilter.ERROR) {
+                        priority = NotificationPriority.SILENT;
+                    }
+                    else if (isNotificationSource(options.source) && this.notificationService.getFilter(options.source) === NotificationsFilter.ERROR) {
+                        priority = NotificationPriority.SILENT;
+                    }
+                }
+                return this.withNotificationProgress({ ...options, location, priority }, task, onDidCancel);
+            }
+            case 10 : {
+                const type = options.type;
+                if (options.command) {
+                    return this.withWindowProgress({ ...options, location, type }, task);
+                }
+                return this.withNotificationProgress({ delay: 150 , ...options, priority: NotificationPriority.SILENT, location: 15 , type }, task, onDidCancel);
+            }
+            case 1 :
+                return this.withPaneCompositeProgress('workbench.view.explorer', 0 , task, { ...options, location });
+            case 3 :
+                return handleStringLocation('workbench.scm');
+            case 5 :
+                return this.withPaneCompositeProgress('workbench.view.extensions', 0 , task, { ...options, location });
+            case 20 :
+                return this.withDialogProgress(options, task, onDidCancel);
+            default:
+                throw new Error(`Bad progress location: ${location}`);
+        }
+    }
+    withWindowProgress(options, callback) {
+        const task = [options, ( new Progress(() => this.updateWindowProgress()))];
+        const promise = callback(task[1]);
+        let delayHandle = setTimeout(() => {
+            delayHandle = undefined;
+            this.windowProgressStack.unshift(task);
+            this.updateWindowProgress();
+            Promise.all([
+                timeout(150),
+                promise
+            ]).finally(() => {
+                const idx = this.windowProgressStack.indexOf(task);
+                this.windowProgressStack.splice(idx, 1);
+                this.updateWindowProgress();
+            });
+        }, 150);
+        return promise.finally(() => clearTimeout(delayHandle));
+    }
+    updateWindowProgress(idx = 0) {
+        if (idx < this.windowProgressStack.length) {
+            const [options, progress] = this.windowProgressStack[idx];
+            const progressTitle = options.title;
+            const progressMessage = progress.value && progress.value.message;
+            const progressCommand = options.command;
+            let text;
+            let title;
+            const source = options.source && typeof options.source !== 'string' ? options.source.label : options.source;
+            if (progressTitle && progressMessage) {
+                text = ( localizeWithPath(
+                    'vs/workbench/services/progress/browser/progressService',
+                    'progress.text2',
+                    "{0}: {1}",
+                    progressTitle,
+                    progressMessage
+                ));
+                title = source ? ( localizeWithPath(
+                    'vs/workbench/services/progress/browser/progressService',
+                    'progress.title3',
+                    "[{0}] {1}: {2}",
+                    source,
+                    progressTitle,
+                    progressMessage
+                )) : text;
+            }
+            else if (progressTitle) {
+                text = progressTitle;
+                title = source ? ( localizeWithPath(
+                    'vs/workbench/services/progress/browser/progressService',
+                    'progress.title2',
+                    "[{0}]: {1}",
+                    source,
+                    progressTitle
+                )) : text;
+            }
+            else if (progressMessage) {
+                text = progressMessage;
+                title = source ? ( localizeWithPath(
+                    'vs/workbench/services/progress/browser/progressService',
+                    'progress.title2',
+                    "[{0}]: {1}",
+                    source,
+                    progressMessage
+                )) : text;
+            }
+            else {
+                this.updateWindowProgress(idx + 1);
+                return;
+            }
+            const statusEntryProperties = {
+                name: ( localizeWithPath(
+                    'vs/workbench/services/progress/browser/progressService',
+                    'status.progress',
+                    "Progress Message"
+                )),
+                text,
+                showProgress: options.type || true,
+                ariaLabel: text,
+                tooltip: title,
+                command: progressCommand
+            };
+            if (this.windowProgressStatusEntry) {
+                this.windowProgressStatusEntry.update(statusEntryProperties);
+            }
+            else {
+                this.windowProgressStatusEntry = this.statusbarService.addEntry(statusEntryProperties, 'status.progress', 0 );
+            }
+        }
+        else {
+            this.windowProgressStatusEntry?.dispose();
+            this.windowProgressStatusEntry = undefined;
+        }
+    }
+    withNotificationProgress(options, callback, onDidCancel) {
+        const progressStateModel = new (class extends Disposable {
+            get step() { return this._step; }
+            get done() { return this._done; }
+            constructor() {
+                super();
+                this._onDidReport = this._register(( new Emitter()));
+                this.onDidReport = this._onDidReport.event;
+                this._onWillDispose = this._register(( new Emitter()));
+                this.onWillDispose = this._onWillDispose.event;
+                this._step = undefined;
+                this._done = false;
+                this.promise = callback(this);
+                this.promise.finally(() => {
+                    this.dispose();
+                });
+            }
+            report(step) {
+                this._step = step;
+                this._onDidReport.fire(step);
+            }
+            cancel(choice) {
+                onDidCancel?.(choice);
+                this.dispose();
+            }
+            dispose() {
+                this._done = true;
+                this._onWillDispose.fire();
+                super.dispose();
+            }
+        });
+        const createWindowProgress = () => {
+            const promise = ( new DeferredPromise());
+            this.withWindowProgress({
+                location: 10 ,
+                title: options.title ? ( parseLinkedText(options.title).toString()) : undefined,
+                command: 'notifications.showList',
+                type: options.type
+            }, progress => {
+                function reportProgress(step) {
+                    if (step.message) {
+                        progress.report({
+                            message: ( parseLinkedText(step.message).toString())
+                        });
+                    }
+                }
+                if (progressStateModel.step) {
+                    reportProgress(progressStateModel.step);
+                }
+                const onDidReportListener = progressStateModel.onDidReport(step => reportProgress(step));
+                promise.p.finally(() => onDidReportListener.dispose());
+                Event.once(progressStateModel.onWillDispose)(() => promise.complete());
+                return promise.p;
+            });
+            return toDisposable(() => promise.complete());
+        };
+        const createNotification = (message, priority, increment) => {
+            const notificationDisposables = ( new DisposableStore());
+            const primaryActions = options.primaryActions ? Array.from(options.primaryActions) : [];
+            const secondaryActions = options.secondaryActions ? Array.from(options.secondaryActions) : [];
+            if (options.buttons) {
+                options.buttons.forEach((button, index) => {
+                    const buttonAction = new (class extends Action {
+                        constructor() {
+                            super(`progress.button.${button}`, button, undefined, true);
+                        }
+                        async run() {
+                            progressStateModel.cancel(index);
+                        }
+                    });
+                    notificationDisposables.add(buttonAction);
+                    primaryActions.push(buttonAction);
+                });
+            }
+            if (options.cancellable) {
+                const cancelAction = new (class extends Action {
+                    constructor() {
+                        super('progress.cancel', ( localizeWithPath(
+                            'vs/workbench/services/progress/browser/progressService',
+                            'cancel',
+                            "Cancel"
+                        )), undefined, true);
+                    }
+                    async run() {
+                        progressStateModel.cancel();
+                    }
+                });
+                notificationDisposables.add(cancelAction);
+                primaryActions.push(cancelAction);
+            }
+            const notification = this.notificationService.notify({
+                severity: Severity.Info,
+                message: stripIcons(message),
+                source: options.source,
+                actions: { primary: primaryActions, secondary: secondaryActions },
+                progress: typeof increment === 'number' && increment >= 0 ? { total: 100, worked: increment } : { infinite: true },
+                priority
+            });
+            let windowProgressDisposable = undefined;
+            const onVisibilityChange = (visible) => {
+                dispose(windowProgressDisposable);
+                if (!visible && !progressStateModel.done) {
+                    windowProgressDisposable = createWindowProgress();
+                }
+            };
+            notificationDisposables.add(notification.onDidChangeVisibility(onVisibilityChange));
+            if (priority === NotificationPriority.SILENT) {
+                onVisibilityChange(false);
+            }
+            Event.once(notification.onDidClose)(() => notificationDisposables.dispose());
+            return notification;
+        };
+        const updateProgress = (notification, increment) => {
+            if (typeof increment === 'number' && increment >= 0) {
+                notification.progress.total(100);
+                notification.progress.worked(increment);
+            }
+            else {
+                notification.progress.infinite();
+            }
+        };
+        let notificationHandle;
+        let notificationTimeout;
+        let titleAndMessage;
+        const updateNotification = (step) => {
+            if (step?.message && options.title) {
+                titleAndMessage = `${options.title}: ${step.message}`;
+            }
+            else {
+                titleAndMessage = options.title || step?.message;
+            }
+            if (!notificationHandle && titleAndMessage) {
+                if (typeof options.delay === 'number' && options.delay > 0) {
+                    if (typeof notificationTimeout !== 'number') {
+                        notificationTimeout = setTimeout(() => notificationHandle = createNotification(titleAndMessage, options.priority, step?.increment), options.delay);
+                    }
+                }
+                else {
+                    notificationHandle = createNotification(titleAndMessage, options.priority, step?.increment);
+                }
+            }
+            if (notificationHandle) {
+                if (titleAndMessage) {
+                    notificationHandle.updateMessage(titleAndMessage);
+                }
+                if (typeof step?.increment === 'number') {
+                    updateProgress(notificationHandle, step.increment);
+                }
+            }
+        };
+        updateNotification(progressStateModel.step);
+        const listener = progressStateModel.onDidReport(step => updateNotification(step));
+        Event.once(progressStateModel.onWillDispose)(() => listener.dispose());
+        (async () => {
+            try {
+                if (typeof options.delay === 'number' && options.delay > 0) {
+                    await progressStateModel.promise;
+                }
+                else {
+                    await Promise.all([timeout(800), progressStateModel.promise]);
+                }
+            }
+            finally {
+                clearTimeout(notificationTimeout);
+                notificationHandle?.close();
+            }
+        })();
+        return progressStateModel.promise;
+    }
+    withPaneCompositeProgress(paneCompositeId, viewContainerLocation, task, options) {
+        const progressIndicator = this.paneCompositeService.getProgressIndicator(paneCompositeId, viewContainerLocation);
+        const promise = progressIndicator ? this.withCompositeProgress(progressIndicator, task, options) : task({ report: () => { } });
+        if (viewContainerLocation === 0 ) {
+            this.showOnActivityBar(paneCompositeId, options, promise);
+        }
+        return promise;
+    }
+    withViewProgress(viewId, task, options) {
+        const progressIndicator = this.viewsService.getViewProgressIndicator(viewId);
+        const promise = progressIndicator ? this.withCompositeProgress(progressIndicator, task, options) : task({ report: () => { } });
+        const location = this.viewDescriptorService.getViewLocationById(viewId);
+        if (location !== 0 ) {
+            return promise;
+        }
+        const viewletId = this.viewDescriptorService.getViewContainerByViewId(viewId)?.id;
+        if (viewletId === undefined) {
+            return promise;
+        }
+        this.showOnActivityBar(viewletId, options, promise);
+        return promise;
+    }
+    showOnActivityBar(viewletId, options, promise) {
+        let activityProgress;
+        let delayHandle = setTimeout(() => {
+            delayHandle = undefined;
+            const handle = this.activityService.showViewContainerActivity(viewletId, { badge: ( new ProgressBadge(() => '')), priority: 100 });
+            const startTimeVisible = Date.now();
+            const minTimeVisible = 300;
+            activityProgress = {
+                dispose() {
+                    const d = Date.now() - startTimeVisible;
+                    if (d < minTimeVisible) {
+                        setTimeout(() => handle.dispose(), minTimeVisible - d);
+                    }
+                    else {
+                        handle.dispose();
+                    }
+                }
+            };
+        }, options.delay || 300);
+        promise.finally(() => {
+            clearTimeout(delayHandle);
+            dispose(activityProgress);
+        });
+    }
+    withCompositeProgress(progressIndicator, task, options) {
+        let discreteProgressRunner = undefined;
+        function updateProgress(stepOrTotal) {
+            let total = undefined;
+            let increment = undefined;
+            if (typeof stepOrTotal !== 'undefined') {
+                if (typeof stepOrTotal === 'number') {
+                    total = stepOrTotal;
+                }
+                else if (typeof stepOrTotal.increment === 'number') {
+                    total = stepOrTotal.total ?? 100;
+                    increment = stepOrTotal.increment;
+                }
+            }
+            if (typeof total === 'number') {
+                if (!discreteProgressRunner) {
+                    discreteProgressRunner = progressIndicator.show(total, options.delay);
+                    promise.catch(() => undefined ).finally(() => discreteProgressRunner?.done());
+                }
+                if (typeof increment === 'number') {
+                    discreteProgressRunner.worked(increment);
+                }
+            }
+            else {
+                discreteProgressRunner?.done();
+                progressIndicator.showWhile(promise, options.delay);
+            }
+            return discreteProgressRunner;
+        }
+        const promise = task({
+            report: progress => {
+                updateProgress(progress);
+            }
+        });
+        updateProgress(options.total);
+        return promise;
+    }
+    withDialogProgress(options, task, onDidCancel) {
+        const disposables = ( new DisposableStore());
+        const allowableCommands = [
+            'workbench.action.quit',
+            'workbench.action.reloadWindow',
+            'copy',
+            'cut',
+            'editor.action.clipboardCopyAction',
+            'editor.action.clipboardCutAction'
+        ];
+        let dialog;
+        const createDialog = (message) => {
+            const buttons = options.buttons || [];
+            if (!options.sticky) {
+                buttons.push(options.cancellable ? ( localizeWithPath(
+                    'vs/workbench/services/progress/browser/progressService',
+                    'cancel',
+                    "Cancel"
+                )) : ( localizeWithPath(
+                    'vs/workbench/services/progress/browser/progressService',
+                    'dismiss',
+                    "Dismiss"
+                )));
+            }
+            dialog = ( new Dialog(this.layoutService.activeContainer, message, buttons, {
+                type: 'pending',
+                detail: options.detail,
+                cancelId: buttons.length - 1,
+                disableCloseAction: options.sticky,
+                disableDefaultAction: options.sticky,
+                keyEventProcessor: (event) => {
+                    const resolved = this.keybindingService.softDispatch(event, this.layoutService.activeContainer);
+                    if (resolved.kind === 2  && resolved.commandId) {
+                        if (!allowableCommands.includes(resolved.commandId)) {
+                            EventHelper.stop(event, true);
+                        }
+                    }
+                },
+                buttonStyles: defaultButtonStyles,
+                checkboxStyles: defaultCheckboxStyles,
+                inputBoxStyles: defaultInputBoxStyles,
+                dialogStyles: defaultDialogStyles
+            }));
+            disposables.add(dialog);
+            dialog.show().then(dialogResult => {
+                onDidCancel?.(dialogResult.button);
+                dispose(dialog);
+            });
+            return dialog;
+        };
+        let delay = options.delay ?? 0;
+        let latestMessage = undefined;
+        const scheduler = disposables.add(( new RunOnceScheduler(() => {
+            delay = 0;
+            if (latestMessage && !dialog) {
+                dialog = createDialog(latestMessage);
+            }
+            else if (latestMessage) {
+                dialog.updateMessage(latestMessage);
+            }
+        }, 0)));
+        const updateDialog = function (message) {
+            latestMessage = message;
+            if (!scheduler.isScheduled()) {
+                scheduler.schedule(delay);
+            }
+        };
+        const promise = task({
+            report: progress => {
+                updateDialog(progress.message);
+            }
+        });
+        promise.finally(() => {
+            dispose(disposables);
+        });
+        if (options.title) {
+            updateDialog(options.title);
+        }
+        return promise;
+    }
+};
+ProgressService = ( __decorate([
+    ( __param(0, IActivityService)),
+    ( __param(1, IPaneCompositePartService)),
+    ( __param(2, IViewDescriptorService)),
+    ( __param(3, IViewsService)),
+    ( __param(4, INotificationService)),
+    ( __param(5, IStatusbarService)),
+    ( __param(6, ILayoutService)),
+    ( __param(7, IKeybindingService))
+], ProgressService));
+export { ProgressService };

package/vscode/src/vs/workbench/services/textMate/common/TMGrammars.js

@@ -0,0 +1,102 @@
+import { localizeWithPath } from '../../../../nls.js';
+import { ExtensionsRegistry } from '../../extensions/common/extensionsRegistry.js';
+import { languagesExtPoint } from '../../language/common/languageService.js';
+const grammarsExtPoint = ( ExtensionsRegistry.registerExtensionPoint({
+    extensionPoint: 'grammars',
+    deps: [languagesExtPoint],
+    jsonSchema: {
+        description: ( localizeWithPath(
+            'vs/workbench/services/textMate/common/TMGrammars',
+            'vscode.extension.contributes.grammars',
+            'Contributes textmate tokenizers.'
+        )),
+        type: 'array',
+        defaultSnippets: [{ body: [{ language: '${1:id}', scopeName: 'source.${2:id}', path: './syntaxes/${3:id}.tmLanguage.' }] }],
+        items: {
+            type: 'object',
+            defaultSnippets: [{ body: { language: '${1:id}', scopeName: 'source.${2:id}', path: './syntaxes/${3:id}.tmLanguage.' } }],
+            properties: {
+                language: {
+                    description: ( localizeWithPath(
+                        'vs/workbench/services/textMate/common/TMGrammars',
+                        'vscode.extension.contributes.grammars.language',
+                        'Language identifier for which this syntax is contributed to.'
+                    )),
+                    type: 'string'
+                },
+                scopeName: {
+                    description: ( localizeWithPath(
+                        'vs/workbench/services/textMate/common/TMGrammars',
+                        'vscode.extension.contributes.grammars.scopeName',
+                        'Textmate scope name used by the tmLanguage file.'
+                    )),
+                    type: 'string'
+                },
+                path: {
+                    description: ( localizeWithPath(
+                        'vs/workbench/services/textMate/common/TMGrammars',
+                        'vscode.extension.contributes.grammars.path',
+                        'Path of the tmLanguage file. The path is relative to the extension folder and typically starts with \'./syntaxes/\'.'
+                    )),
+                    type: 'string'
+                },
+                embeddedLanguages: {
+                    description: ( localizeWithPath(
+                        'vs/workbench/services/textMate/common/TMGrammars',
+                        'vscode.extension.contributes.grammars.embeddedLanguages',
+                        'A map of scope name to language id if this grammar contains embedded languages.'
+                    )),
+                    type: 'object'
+                },
+                tokenTypes: {
+                    description: ( localizeWithPath(
+                        'vs/workbench/services/textMate/common/TMGrammars',
+                        'vscode.extension.contributes.grammars.tokenTypes',
+                        'A map of scope name to token types.'
+                    )),
+                    type: 'object',
+                    additionalProperties: {
+                        enum: ['string', 'comment', 'other']
+                    }
+                },
+                injectTo: {
+                    description: ( localizeWithPath(
+                        'vs/workbench/services/textMate/common/TMGrammars',
+                        'vscode.extension.contributes.grammars.injectTo',
+                        'List of language scope names to which this grammar is injected to.'
+                    )),
+                    type: 'array',
+                    items: {
+                        type: 'string'
+                    }
+                },
+                balancedBracketScopes: {
+                    description: ( localizeWithPath(
+                        'vs/workbench/services/textMate/common/TMGrammars',
+                        'vscode.extension.contributes.grammars.balancedBracketScopes',
+                        'Defines which scope names contain balanced brackets.'
+                    )),
+                    type: 'array',
+                    items: {
+                        type: 'string'
+                    },
+                    default: ['*'],
+                },
+                unbalancedBracketScopes: {
+                    description: ( localizeWithPath(
+                        'vs/workbench/services/textMate/common/TMGrammars',
+                        'vscode.extension.contributes.grammars.unbalancedBracketScopes',
+                        'Defines which scope names do not contain balanced brackets.'
+                    )),
+                    type: 'array',
+                    items: {
+                        type: 'string'
+                    },
+                    default: [],
+                },
+            },
+            required: ['scopeName', 'path']
+        }
+    }
+}));
+export { grammarsExtPoint };