@codingame/monaco-vscode-keybindings-service-override 25.1.2 → 26.0.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@codingame/monaco-vscode-keybindings-service-override",
-  "version": "25.1.2",
+  "version": "26.0.1",
   "private": false,
   "description": "VSCode public API plugged on the monaco editor - keybindings service-override",
   "keywords": [],
@@ -15,8 +15,8 @@
   },
   "type": "module",
   "dependencies": {
-    "@codingame/monaco-vscode-api": "25.1.2",
-    "@codingame/monaco-vscode-files-service-override": "25.1.2"
+    "@codingame/monaco-vscode-api": "26.0.1",
+    "@codingame/monaco-vscode-files-service-override": "26.0.1"
   },
   "main": "index.js",
   "module": "index.js",

package/vscode/src/vs/platform/keyboardLayout/common/keyboardConfig.js

@@ -5,39 +5,42 @@ import { Extensions, ConfigurationScope } from '@codingame/monaco-vscode-api/vsc
 import { Registry } from '@codingame/monaco-vscode-api/vscode/vs/platform/registry/common/platform';
 
 var DispatchConfig;
-(function (DispatchConfig) {
+(function(DispatchConfig) {
     DispatchConfig[DispatchConfig["Code"] = 0] = "Code";
     DispatchConfig[DispatchConfig["KeyCode"] = 1] = "KeyCode";
 })(DispatchConfig || (DispatchConfig = {}));
 function readKeyboardConfig(configurationService) {
-    const keyboard = configurationService.getValue('keyboard');
-    const dispatch = (keyboard?.dispatch === 'keyCode' ? DispatchConfig.KeyCode : DispatchConfig.Code);
+    const keyboard = configurationService.getValue("keyboard");
+    const dispatch = (keyboard?.dispatch === "keyCode" ? DispatchConfig.KeyCode : DispatchConfig.Code);
     const mapAltGrToCtrlAlt = Boolean(keyboard?.mapAltGrToCtrlAlt);
-    return { dispatch, mapAltGrToCtrlAlt };
+    return {
+        dispatch,
+        mapAltGrToCtrlAlt
+    };
 }
 const configurationRegistry = ( Registry.as(Extensions.Configuration));
 const keyboardConfiguration = {
-    'id': 'keyboard',
-    'order': 15,
-    'type': 'object',
-    'title': ( localize(1952, "Keyboard")),
-    'properties': {
-        'keyboard.dispatch': {
+    "id": "keyboard",
+    "order": 15,
+    "type": "object",
+    "title": ( localize(1954, "Keyboard")),
+    "properties": {
+        "keyboard.dispatch": {
             scope: ConfigurationScope.APPLICATION,
-            type: 'string',
-            enum: ['code', 'keyCode'],
-            default: 'code',
+            type: "string",
+            enum: ["code", "keyCode"],
+            default: "code",
             markdownDescription: ( localize(
-                1953,
+                1955,
                 "Controls the dispatching logic for key presses to use either `code` (recommended) or `keyCode`."
             )),
             included: OS === OperatingSystem.Macintosh || OS === OperatingSystem.Linux
         },
-        'keyboard.mapAltGrToCtrlAlt': {
+        "keyboard.mapAltGrToCtrlAlt": {
             scope: ConfigurationScope.APPLICATION,
-            type: 'boolean',
+            type: "boolean",
             default: false,
-            markdownDescription: ( localize(1954, "Controls if the AltGraph+ modifier should be treated as Ctrl+Alt+.")),
+            markdownDescription: ( localize(1956, "Controls if the AltGraph+ modifier should be treated as Ctrl+Alt+.")),
             included: OS === OperatingSystem.Windows
         }
     }

package/vscode/src/vs/workbench/contrib/commands/common/commands.contribution.js

@@ -9,53 +9,44 @@ import { INotificationService } from '@codingame/monaco-vscode-api/vscode/vs/pla
 class RunCommands extends Action2 {
     constructor() {
         super({
-            id: 'runCommands',
-            title: ( localize2(6279, "Run Commands")),
+            id: "runCommands",
+            title: ( localize2(6592, "Run Commands")),
             f1: false,
             metadata: {
-                description: ( localize(6280, "Run several commands")),
-                args: [
-                    {
-                        name: 'args',
-                        schema: {
-                            type: 'object',
-                            required: ['commands'],
-                            properties: {
-                                commands: {
-                                    type: 'array',
-                                    description: ( localize(6281, "Commands to run")),
-                                    items: {
-                                        anyOf: [
-                                            {
-                                                $ref: 'vscode://schemas/keybindings#/definitions/commandNames'
-                                            },
-                                            {
-                                                type: 'string',
-                                            },
-                                            {
-                                                type: 'object',
-                                                required: ['command'],
-                                                properties: {
-                                                    command: {
-                                                        'anyOf': [
-                                                            {
-                                                                $ref: 'vscode://schemas/keybindings#/definitions/commandNames'
-                                                            },
-                                                            {
-                                                                type: 'string'
-                                                            },
-                                                        ]
-                                                    }
-                                                },
-                                                $ref: 'vscode://schemas/keybindings#/definitions/commandsSchemas'
+                description: ( localize(6593, "Run several commands")),
+                args: [{
+                    name: "args",
+                    schema: {
+                        type: "object",
+                        required: ["commands"],
+                        properties: {
+                            commands: {
+                                type: "array",
+                                description: ( localize(6594, "Commands to run")),
+                                items: {
+                                    anyOf: [{
+                                        $ref: "vscode://schemas/keybindings#/definitions/commandNames"
+                                    }, {
+                                        type: "string"
+                                    }, {
+                                        type: "object",
+                                        required: ["command"],
+                                        properties: {
+                                            command: {
+                                                "anyOf": [{
+                                                    $ref: "vscode://schemas/keybindings#/definitions/commandNames"
+                                                }, {
+                                                    type: "string"
+                                                }]
                                             }
-                                        ]
-                                    }
+                                        },
+                                        $ref: "vscode://schemas/keybindings#/definitions/commandsSchemas"
+                                    }]
                                 }
                             }
                         }
                     }
-                ]
+                }]
             }
         });
     }
@@ -63,14 +54,14 @@ class RunCommands extends Action2 {
         const notificationService = accessor.get(INotificationService);
         if (!this._isCommandArgs(args)) {
             notificationService.error(( localize(
-                6282,
+                6595,
                 "'runCommands' has received an argument with incorrect type. Please, review the argument passed to the command."
             )));
             return;
         }
         if (args.commands.length === 0) {
             notificationService.warn(( localize(
-                6283,
+                6596,
                 "'runCommands' has not received commands to run. Did you forget to pass commands in the 'runCommands' argument?"
             )));
             return;
@@ -85,24 +76,25 @@ class RunCommands extends Action2 {
                 await this._runCommand(commandService, cmd);
                 logService.debug(`runCommands: executed ${i}-th command`);
             }
-        }
-        catch (err) {
-            logService.debug(`runCommands: executing ${i}-th command resulted in an error: ${err instanceof Error ? err.message : safeStringify(err)}`);
+        } catch (err) {
+            logService.debug(
+                `runCommands: executing ${i}-th command resulted in an error: ${err instanceof Error ? err.message : safeStringify(err)}`
+            );
             notificationService.error(err);
         }
     }
     _isCommandArgs(args) {
-        if (!args || typeof args !== 'object') {
+        if (!args || typeof args !== "object") {
             return false;
         }
-        if (!('commands' in args) || !Array.isArray(args.commands)) {
+        if (!("commands" in args) || !Array.isArray(args.commands)) {
             return false;
         }
         for (const cmd of args.commands) {
-            if (typeof cmd === 'string') {
+            if (typeof cmd === "string") {
                 continue;
             }
-            if (typeof cmd === 'object' && typeof cmd.command === 'string') {
+            if (typeof cmd === "object" && typeof cmd.command === "string") {
                 continue;
             }
             return false;
@@ -111,21 +103,18 @@ class RunCommands extends Action2 {
     }
     _runCommand(commandService, cmd) {
         let commandID, commandArgs;
-        if (typeof cmd === 'string') {
+        if (typeof cmd === "string") {
             commandID = cmd;
-        }
-        else {
+        } else {
             commandID = cmd.command;
             commandArgs = cmd.args;
         }
         if (commandArgs === undefined) {
             return commandService.executeCommand(commandID);
-        }
-        else {
+        } else {
             if (Array.isArray(commandArgs)) {
                 return commandService.executeCommand(commandID, ...commandArgs);
-            }
-            else {
+            } else {
                 return commandService.executeCommand(commandID, commandArgs);
             }
         }

package/vscode/src/vs/workbench/contrib/keybindings/browser/keybindings.contribution.js

@@ -14,8 +14,8 @@ import { Emitter } from '@codingame/monaco-vscode-api/vscode/vs/base/common/even
 class ToggleKeybindingsLogAction extends Action2 {
     constructor() {
         super({
-            id: 'workbench.action.toggleKeybindingsLog',
-            title: ( localize2(8502, "Toggle Keyboard Shortcuts Troubleshooting")),
+            id: "workbench.action.toggleKeybindingsLog",
+            title: ( localize2(8809, "Toggle Keyboard Shortcuts Troubleshooting")),
             category: Categories.Developer,
             f1: true
         });
@@ -34,26 +34,34 @@ class ToggleKeybindingsLogAction extends Action2 {
         const layoutService = accessor.get(ILayoutService);
         const disposables = ( new DisposableStore());
         const container = layoutService.activeContainer;
-        const focusMarker = append(container, $('.focus-troubleshooting-marker'));
+        const focusMarker = append(container, $(".focus-troubleshooting-marker"));
         disposables.add(toDisposable(() => focusMarker.remove()));
         const stylesheet = createStyleSheet(undefined, undefined, disposables);
-        createCSSRule('.focus-troubleshooting-marker', `
-			position: fixed;
-			pointer-events: none;
-			z-index: 100000;
-			background-color: rgba(255, 0, 0, 0.2);
-			border: 2px solid rgba(255, 0, 0, 0.8);
-			border-radius: 2px;
-			display: none;
-		`, stylesheet);
+        createCSSRule(".focus-troubleshooting-marker", `
+            position: fixed;
+            pointer-events: none;
+            z-index: 100000;
+            background-color: rgba(255, 0, 0, 0.2);
+            border: 2px solid rgba(255, 0, 0, 0.8);
+            border-radius: 2px;
+            display: none;
+        `, stylesheet);
         const onKeyDown = disposables.add(( new Emitter()));
         function registerWindowListeners(window, disposables) {
-            disposables.add(addDisposableListener(window, 'keydown', e => onKeyDown.fire(e), true));
+            disposables.add(addDisposableListener(window, "keydown", e => onKeyDown.fire(e), true));
         }
-        for (const { window, disposables } of getWindows()) {
+        for (const {
+            window,
+            disposables
+        } of getWindows()) {
             registerWindowListeners(window, disposables);
         }
-        disposables.add(onDidRegisterWindow(({ window, disposables }) => registerWindowListeners(window, disposables)));
+        disposables.add(onDidRegisterWindow((
+            {
+                window,
+                disposables
+            }
+        ) => registerWindowListeners(window, disposables)));
         disposables.add(layoutService.onDidChangeActiveContainer(() => {
             layoutService.activeContainer.appendChild(focusMarker);
         }));
@@ -65,9 +73,9 @@ class ToggleKeybindingsLogAction extends Action2 {
                 focusMarker.style.left = `${position.left}px`;
                 focusMarker.style.width = `${position.width}px`;
                 focusMarker.style.height = `${position.height}px`;
-                focusMarker.style.display = 'block';
+                focusMarker.style.display = "block";
                 setTimeout(() => {
-                    focusMarker.style.display = 'none';
+                    focusMarker.style.display = "none";
                 }, 800);
             }
         }));

package/vscode/src/vs/workbench/contrib/preferences/browser/keybindingsEditorContribution.js

@@ -24,7 +24,7 @@ import { DEFINE_KEYBINDING_EDITOR_CONTRIB_ID } from '@codingame/monaco-vscode-ap
 
 var KeybindingEditorDecorationsRenderer_1;
 const NLS_KB_LAYOUT_ERROR_MESSAGE = ( localize(
-    9871,
+    10189,
     "You won't be able to produce this key combination under your current keyboard layout."
 ));
 let DefineKeybindingEditorContribution = class DefineKeybindingEditorContribution extends Disposable {
@@ -34,14 +34,15 @@ let DefineKeybindingEditorContribution = class DefineKeybindingEditorContributio
         this._instantiationService = _instantiationService;
         this._userDataProfileService = _userDataProfileService;
         this._keybindingDecorationRenderer = this._register(( new MutableDisposable()));
-        this._defineWidget = this._register(this._instantiationService.createInstance(DefineKeybindingOverlayWidget, this._editor));
+        this._defineWidget = this._register(
+            this._instantiationService.createInstance(DefineKeybindingOverlayWidget, this._editor)
+        );
         this._register(this._editor.onDidChangeModel(e => this._update()));
         this._update();
     }
     _update() {
-        this._keybindingDecorationRenderer.value = isInterestingEditorModel(this._editor, this._userDataProfileService)
-            ? this._instantiationService.createInstance(KeybindingEditorDecorationsRenderer, this._editor)
-            : undefined;
+        this._keybindingDecorationRenderer.value =
+        isInterestingEditorModel(this._editor, this._userDataProfileService) ? this._instantiationService.createInstance(KeybindingEditorDecorationsRenderer, this._editor) : undefined;
     }
     showDefineKeybindingWidget() {
         if (isInterestingEditorModel(this._editor, this._userDataProfileService)) {
@@ -54,26 +55,26 @@ let DefineKeybindingEditorContribution = class DefineKeybindingEditorContributio
             const regexp = ( new RegExp(/\\/g));
             const backslash = regexp.test(keybinding);
             if (backslash) {
-                keybinding = keybinding.slice(0, -1) + '\\\\';
+                keybinding = keybinding.slice(0, -1) + "\\\\";
             }
             let snippetText = [
-                '{',
-                '\t"key": ' + JSON.stringify(keybinding) + ',',
-                '\t"command": "${1:commandId}",',
-                '\t"when": "${2:editorTextFocus}"',
-                '}$0'
-            ].join('\n');
+                "{",
+                "\t\"key\": " + JSON.stringify(keybinding) + ",",
+                "\t\"command\": \"${1:commandId}\",",
+                "\t\"when\": \"${2:editorTextFocus}\"",
+                "}$0"
+            ].join("\n");
             const smartInsertInfo = SmartSnippetInserter.insertSnippet(this._editor.getModel(), this._editor.getPosition());
             snippetText = smartInsertInfo.prepend + snippetText + smartInsertInfo.append;
             this._editor.setPosition(smartInsertInfo.position);
-            SnippetController2.get(this._editor)?.insert(snippetText, { overwriteBefore: 0, overwriteAfter: 0 });
+            SnippetController2.get(this._editor)?.insert(snippetText, {
+                overwriteBefore: 0,
+                overwriteAfter: 0
+            });
         }
     }
 };
-DefineKeybindingEditorContribution = ( __decorate([
-    ( __param(1, IInstantiationService)),
-    ( __param(2, IUserDataProfileService))
-], DefineKeybindingEditorContribution));
+DefineKeybindingEditorContribution = ( __decorate([( __param(1, IInstantiationService)), ( __param(2, IUserDataProfileService))], DefineKeybindingEditorContribution));
 let KeybindingEditorDecorationsRenderer = KeybindingEditorDecorationsRenderer_1 = class KeybindingEditorDecorationsRenderer extends Disposable {
     constructor(_editor, _keybindingService) {
         super();
@@ -83,7 +84,9 @@ let KeybindingEditorDecorationsRenderer = KeybindingEditorDecorationsRenderer_1
         this._updateDecorations = this._register(( new RunOnceScheduler(() => this._updateDecorationsNow(), 500)));
         const model = assertReturnsDefined(this._editor.getModel());
         this._register(model.onDidChangeContent(() => this._updateDecorations.schedule()));
-        this._register(this._keybindingService.onDidUpdateKeybindings(() => this._updateDecorations.schedule()));
+        this._register(
+            this._keybindingService.onDidUpdateKeybindings(() => this._updateDecorations.schedule())
+        );
         this._register({
             dispose: () => {
                 this._dec.clear();
@@ -113,18 +116,18 @@ let KeybindingEditorDecorationsRenderer = KeybindingEditorDecorationsRenderer_1
         }
         for (let i = 0, len = entry.children.length; i < len; i++) {
             const prop = entry.children[i];
-            if (prop.type !== 'property') {
+            if (prop.type !== "property") {
                 continue;
             }
             if (!Array.isArray(prop.children) || prop.children.length !== 2) {
                 continue;
             }
             const key = prop.children[0];
-            if (key.value !== 'key') {
+            if (key.value !== "key") {
                 continue;
             }
             const value = prop.children[1];
-            if (value.type !== 'string') {
+            if (value.type !== "string") {
                 continue;
             }
             const resolvedKeybindings = this._keybindingService.resolveUserBinding(value.value);
@@ -138,7 +141,7 @@ let KeybindingEditorDecorationsRenderer = KeybindingEditorDecorationsRenderer_1
             }
             if (!resolvedKeybinding.isWYSIWYG()) {
                 const uiLabel = resolvedKeybinding.getLabel();
-                if (typeof uiLabel === 'string' && value.value.toLowerCase() === uiLabel.toLowerCase()) {
+                if (typeof uiLabel === "string" && value.value.toLowerCase() === uiLabel.toLowerCase()) {
                     return null;
                 }
                 return this._createDecoration(false, resolvedKeybinding.getLabel(), usLabel, model, value);
@@ -147,7 +150,7 @@ let KeybindingEditorDecorationsRenderer = KeybindingEditorDecorationsRenderer_1
                 return this._createDecoration(false, resolvedKeybinding.getLabel(), usLabel, model, value);
             }
             const expectedUserSettingsLabel = resolvedKeybinding.getUserSettingsLabel();
-            if (typeof expectedUserSettingsLabel === 'string' && !KeybindingEditorDecorationsRenderer_1._userSettingsFuzzyEquals(value.value, expectedUserSettingsLabel)) {
+            if (typeof expectedUserSettingsLabel === "string" && !KeybindingEditorDecorationsRenderer_1._userSettingsFuzzyEquals(value.value, expectedUserSettingsLabel)) {
                 return this._createDecoration(false, resolvedKeybinding.getLabel(), usLabel, model, value);
             }
             return null;
@@ -176,22 +179,20 @@ let KeybindingEditorDecorationsRenderer = KeybindingEditorDecorationsRenderer_1
         let overviewRulerColor;
         if (isError) {
             msg = ( new MarkdownString()).appendText(NLS_KB_LAYOUT_ERROR_MESSAGE);
-            className = 'keybindingError';
+            className = "keybindingError";
             overviewRulerColor = themeColorFromId(overviewRulerError);
-        }
-        else {
+        } else {
             if (usLabel && uiLabel !== usLabel) {
                 msg = ( new MarkdownString(( localize(
-                    9872,
+                    10190,
                     "**{0}** for your current keyboard layout (**{1}** for US standard).",
                     uiLabel,
                     usLabel
                 ))));
+            } else {
+                msg = ( new MarkdownString(( localize(10191, "**{0}** for your current keyboard layout.", uiLabel))));
             }
-            else {
-                msg = ( new MarkdownString(( localize(9873, "**{0}** for your current keyboard layout.", uiLabel))));
-            }
-            className = 'keybindingInfo';
+            className = "keybindingInfo";
             overviewRulerColor = themeColorFromId(overviewRulerInfo);
         }
         const startPosition = model.getPositionAt(keyNode.offset);
@@ -205,7 +206,7 @@ let KeybindingEditorDecorationsRenderer = KeybindingEditorDecorationsRenderer_1
         return {
             range: range,
             options: {
-                description: 'keybindings-widget',
+                description: "keybindings-widget",
                 stickiness: TrackedRangeStickiness.NeverGrowsWhenTypingAtEdges,
                 className: className,
                 hoverMessage: msg,
@@ -217,9 +218,7 @@ let KeybindingEditorDecorationsRenderer = KeybindingEditorDecorationsRenderer_1
         };
     }
 };
-KeybindingEditorDecorationsRenderer = KeybindingEditorDecorationsRenderer_1 = ( __decorate([
-    ( __param(1, IKeybindingService))
-], KeybindingEditorDecorationsRenderer));
+KeybindingEditorDecorationsRenderer = KeybindingEditorDecorationsRenderer_1 = ( __decorate([( __param(1, IKeybindingService))], KeybindingEditorDecorationsRenderer));
 function isInterestingEditorModel(editor, userDataProfileService) {
     const model = editor.getModel();
     if (!model) {
@@ -227,6 +226,10 @@ function isInterestingEditorModel(editor, userDataProfileService) {
     }
     return isEqual(model.uri, userDataProfileService.currentProfile.keybindingsResource);
 }
-registerEditorContribution(DEFINE_KEYBINDING_EDITOR_CONTRIB_ID, DefineKeybindingEditorContribution, EditorContributionInstantiation.AfterFirstRender);
+registerEditorContribution(
+    DEFINE_KEYBINDING_EDITOR_CONTRIB_ID,
+    DefineKeybindingEditorContribution,
+    EditorContributionInstantiation.AfterFirstRender
+);
 
 export { KeybindingEditorDecorationsRenderer };

package/vscode/src/vs/workbench/contrib/preferences/common/smartSnippetInserter.js

@@ -30,7 +30,7 @@ class SmartSnippetInserter {
     static insertSnippet(model, _position) {
         const desiredPosition = model.getValueLengthInRange(( new Range(1, 1, _position.lineNumber, _position.column)));
         let State;
-        (function (State) {
+        (function(State) {
             State[State["INVALID"] = 0] = "INVALID";
             State[State["AFTER_OBJECT"] = 1] = "AFTER_OBJECT";
             State[State["BEFORE_OBJECT"] = 2] = "BEFORE_OBJECT";
@@ -46,8 +46,7 @@ class SmartSnippetInserter {
                 currentState = state;
                 lastValidPos = pos;
                 lastValidState = state;
-            }
-            else {
+            } else {
                 if (currentState !== State.INVALID) {
                     currentState = State.INVALID;
                     lastValidPos = scanner.getTokenOffset();
@@ -59,33 +58,33 @@ class SmartSnippetInserter {
             const kind = scanner.getToken();
             let goodKind = false;
             switch (kind) {
-                case SyntaxKind.OpenBracketToken:
-                    goodKind = true;
-                    arrayLevel++;
-                    checkRangeStatus(currentPos, State.BEFORE_OBJECT);
-                    break;
-                case SyntaxKind.CloseBracketToken:
-                    goodKind = true;
-                    arrayLevel--;
-                    checkRangeStatus(currentPos, State.INVALID);
-                    break;
-                case SyntaxKind.CommaToken:
-                    goodKind = true;
-                    checkRangeStatus(currentPos, State.BEFORE_OBJECT);
-                    break;
-                case SyntaxKind.OpenBraceToken:
-                    goodKind = true;
-                    objLevel++;
-                    checkRangeStatus(currentPos, State.INVALID);
-                    break;
-                case SyntaxKind.CloseBraceToken:
-                    goodKind = true;
-                    objLevel--;
-                    checkRangeStatus(currentPos, State.AFTER_OBJECT);
-                    break;
-                case SyntaxKind.Trivia:
-                case SyntaxKind.LineBreakTrivia:
-                    goodKind = true;
+            case SyntaxKind.OpenBracketToken:
+                goodKind = true;
+                arrayLevel++;
+                checkRangeStatus(currentPos, State.BEFORE_OBJECT);
+                break;
+            case SyntaxKind.CloseBracketToken:
+                goodKind = true;
+                arrayLevel--;
+                checkRangeStatus(currentPos, State.INVALID);
+                break;
+            case SyntaxKind.CommaToken:
+                goodKind = true;
+                checkRangeStatus(currentPos, State.BEFORE_OBJECT);
+                break;
+            case SyntaxKind.OpenBraceToken:
+                goodKind = true;
+                objLevel++;
+                checkRangeStatus(currentPos, State.INVALID);
+                break;
+            case SyntaxKind.CloseBraceToken:
+                goodKind = true;
+                objLevel--;
+                checkRangeStatus(currentPos, State.AFTER_OBJECT);
+                break;
+            case SyntaxKind.Trivia:
+            case SyntaxKind.LineBreakTrivia:
+                goodKind = true;
             }
             if (currentPos >= desiredPosition && (currentState !== State.INVALID || lastValidPos !== -1)) {
                 let acceptPosition;
@@ -93,24 +92,22 @@ class SmartSnippetInserter {
                 if (currentState !== State.INVALID) {
                     acceptPosition = (goodKind ? currentPos : scanner.getTokenOffset());
                     acceptState = currentState;
-                }
-                else {
+                } else {
                     acceptPosition = lastValidPos;
                     acceptState = lastValidState;
                 }
                 if (acceptState === State.AFTER_OBJECT) {
                     return {
                         position: this.offsetToPosition(model, acceptPosition),
-                        prepend: ',',
-                        append: ''
+                        prepend: ",",
+                        append: ""
                     };
-                }
-                else {
+                } else {
                     scanner.setPosition(acceptPosition);
                     return {
                         position: this.offsetToPosition(model, acceptPosition),
-                        prepend: '',
-                        append: this.hasOpenBrace(scanner) ? ',' : ''
+                        prepend: "",
+                        append: this.hasOpenBrace(scanner) ? "," : ""
                     };
                 }
             }
@@ -118,8 +115,8 @@ class SmartSnippetInserter {
         const modelLineCount = model.getLineCount();
         return {
             position: ( new Position(modelLineCount, model.getLineMaxColumn(modelLineCount))),
-            prepend: '\n[',
-            append: ']'
+            prepend: "\n[",
+            append: "]"
         };
     }
 }