@deephaven/console 0.5.2-matplotlib.2 → 0.6.0

package/dist/monaco/MonacoUtils.js

@@ -1,9 +1,3 @@
-function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
-
-function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
-
-function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
-
 /**
  * Exports a function for initializing monaco with the deephaven theme/config
  */
@@ -64,358 +58,348 @@ import 'monaco-editor/esm/vs/editor/contrib/wordOperations/wordOperations';
 import 'monaco-editor/esm/vs/editor/contrib/wordPartOperations/wordPartOperations';
 import Log from '@deephaven/log';
 import MonacoTheme from "./MonacoTheme.module.css";
-import PyLang from './lang/python';
-import GroovyLang from './lang/groovy';
-import ScalaLang from './lang/scala';
-import DbLang from './lang/db';
-import LogLang from './lang/log';
+import PyLang from "./lang/python.js";
+import GroovyLang from "./lang/groovy.js";
+import ScalaLang from "./lang/scala.js";
+import DbLang from "./lang/db.js";
+import LogLang from "./lang/log.js";
 var log = Log.module('MonacoUtils');
 
-var MonacoUtils = /*#__PURE__*/function () {
-  function MonacoUtils() {
-    _classCallCheck(this, MonacoUtils);
+class MonacoUtils {
+  static init() {
+    log.debug('Initializing Monaco...');
+    var {
+      registerLanguages,
+      removeHashtag
+    } = MonacoUtils;
+    var dhDarkRules = [{
+      token: '',
+      foreground: removeHashtag(MonacoTheme.foreground)
+    }, {
+      token: 'string',
+      foreground: removeHashtag(MonacoTheme.string)
+    }, {
+      token: 'string.delim',
+      foreground: removeHashtag(MonacoTheme['string-delim'])
+    }, {
+      token: 'keyword',
+      foreground: removeHashtag(MonacoTheme.keyword)
+    }, {
+      token: 'identifier.js',
+      foreground: removeHashtag(MonacoTheme['identifier-js'])
+    }, {
+      token: 'delimiter',
+      foreground: removeHashtag(MonacoTheme.delimiter)
+    }, {
+      token: 'comment',
+      foreground: removeHashtag(MonacoTheme.comment)
+    }, {
+      token: 'number',
+      foreground: removeHashtag(MonacoTheme.number)
+    }, {
+      token: 'storage',
+      foreground: removeHashtag(MonacoTheme.storage)
+    }, {
+      token: 'identifier',
+      foreground: removeHashtag(MonacoTheme.identifier)
+    }, {
+      token: 'namespace.identifier',
+      foreground: removeHashtag(MonacoTheme['namespace-identifier'])
+    }, {
+      token: 'operator',
+      foreground: removeHashtag(MonacoTheme.operator)
+    }, {
+      token: 'predefined',
+      foreground: removeHashtag(MonacoTheme.predefined)
+    }, {
+      token: 'error.log',
+      foreground: MonacoTheme['log-error'].substring(1)
+    }, {
+      token: 'warn.log',
+      foreground: removeHashtag(MonacoTheme['log-warn'])
+    }, {
+      token: 'info.log',
+      foreground: removeHashtag(MonacoTheme['log-info'])
+    }, {
+      token: 'stdout.log',
+      foreground: removeHashtag(MonacoTheme['log-stdout'])
+    }, {
+      token: 'trace.log',
+      foreground: removeHashtag(MonacoTheme['log-trace'])
+    }, {
+      token: 'debug.log',
+      foreground: removeHashtag(MonacoTheme['log-debug'])
+    }, {
+      token: 'date.log',
+      foreground: removeHashtag(MonacoTheme['log-date'])
+    }];
+    var dhDarkColors = {
+      errorForeground: MonacoTheme['error-foreground'],
+      'inputOption.activeBorder': MonacoTheme['input-option-active-border'],
+      'editor.background': MonacoTheme.background,
+      'editor.foreground': MonacoTheme.foreground,
+      'editor.lineHighlightBackground': MonacoTheme['editor-line-highlight-bg'],
+      'editorLineNumber.foreground': MonacoTheme['editor-line-number-foreground'],
+      'editor.selectionBackground': MonacoTheme['editor-selection-background'],
+      'editor.findMatchBackground': MonacoTheme['editor-find-match-background'],
+      'editor.findMatchHighlightBackground': MonacoTheme['editor-find-match-highlight-background'],
+      'editorSuggestWidget.background': MonacoTheme['editor-suggest-widget-background'],
+      'editorSuggestWidget.border': MonacoTheme['editor-suggest-widget-border'],
+      'editorSuggestWidget.foreground': MonacoTheme['editor-suggest-widget-foreground'],
+      'editorSuggestWidget.selectedBackground': MonacoTheme['editor-suggest-widget-selected-background'],
+      'editorSuggestWidget.highlightForeground': MonacoTheme['editor-suggest-widget-highlightForeground'],
+      'list.hoverBackground': MonacoTheme['list-hover-background'],
+      'dropdown.background': MonacoTheme['context-menu-background'],
+      'dropdown.foreground': MonacoTheme['context-menu-foreground'],
+      'menu.selectionBackground': MonacoTheme['menu-selection-background'],
+      'list.focusBackground': MonacoTheme['menu-selection-background'],
+      'editorWidget.background': MonacoTheme['editor-widget-background'],
+      'inputOption.activeBackground': MonacoTheme['input-option-active-background'],
+      'inputOption.activeForeground': MonacoTheme['input-option-active-foreground'],
+      focusBorder: MonacoTheme['focus-border'],
+      'input.background': MonacoTheme['input-background'],
+      'input.foreground': MonacoTheme['input-foreground'],
+      'input.border': MonacoTheme['input-border']
+    };
+    monaco.editor.defineTheme('dh-dark', {
+      base: 'vs-dark',
+      inherit: true,
+      rules: dhDarkRules,
+      colors: dhDarkColors
+    });
+    log.debug2('monaco theme: ', MonacoTheme);
+    monaco.editor.setTheme('dh-dark');
+    registerLanguages([DbLang, PyLang, GroovyLang, LogLang, ScalaLang]);
+    log.debug('Monaco initialized.');
   }
+  /**
+   * Remove the hashtag prefix from a CSS color string.
+   * Monaco expects colors to be the value only, no hashtag.
+   * @param {String} color The hex color string to remove the hashtag from, eg. '#ffffff'
+   */
 
-  _createClass(MonacoUtils, null, [{
-    key: "init",
-    value: function init() {
-      log.debug('Initializing Monaco...');
-      var registerLanguages = MonacoUtils.registerLanguages,
-          removeHashtag = MonacoUtils.removeHashtag;
-      var dhDarkRules = [{
-        token: '',
-        foreground: removeHashtag(MonacoTheme.foreground)
-      }, {
-        token: 'string',
-        foreground: removeHashtag(MonacoTheme.string)
-      }, {
-        token: 'string.delim',
-        foreground: removeHashtag(MonacoTheme['string-delim'])
-      }, {
-        token: 'keyword',
-        foreground: removeHashtag(MonacoTheme.keyword)
-      }, {
-        token: 'identifier.js',
-        foreground: removeHashtag(MonacoTheme['identifier-js'])
-      }, {
-        token: 'delimiter',
-        foreground: removeHashtag(MonacoTheme.delimiter)
-      }, {
-        token: 'comment',
-        foreground: removeHashtag(MonacoTheme.comment)
-      }, {
-        token: 'number',
-        foreground: removeHashtag(MonacoTheme.number)
-      }, {
-        token: 'storage',
-        foreground: removeHashtag(MonacoTheme.storage)
-      }, {
-        token: 'identifier',
-        foreground: removeHashtag(MonacoTheme.identifier)
-      }, {
-        token: 'namespace.identifier',
-        foreground: removeHashtag(MonacoTheme['namespace-identifier'])
-      }, {
-        token: 'operator',
-        foreground: removeHashtag(MonacoTheme.operator)
-      }, {
-        token: 'predefined',
-        foreground: removeHashtag(MonacoTheme.predefined)
-      }, {
-        token: 'error.log',
-        foreground: MonacoTheme['log-error'].substring(1)
-      }, {
-        token: 'warn.log',
-        foreground: removeHashtag(MonacoTheme['log-warn'])
-      }, {
-        token: 'info.log',
-        foreground: removeHashtag(MonacoTheme['log-info'])
-      }, {
-        token: 'stdout.log',
-        foreground: removeHashtag(MonacoTheme['log-stdout'])
-      }, {
-        token: 'trace.log',
-        foreground: removeHashtag(MonacoTheme['log-trace'])
-      }, {
-        token: 'debug.log',
-        foreground: removeHashtag(MonacoTheme['log-debug'])
-      }, {
-        token: 'date.log',
-        foreground: removeHashtag(MonacoTheme['log-date'])
-      }];
-      var dhDarkColors = {
-        errorForeground: MonacoTheme['error-foreground'],
-        'inputOption.activeBorder': MonacoTheme['input-option-active-border'],
-        'editor.background': MonacoTheme.background,
-        'editor.foreground': MonacoTheme.foreground,
-        'editor.lineHighlightBackground': MonacoTheme['editor-line-highlight-bg'],
-        'editorLineNumber.foreground': MonacoTheme['editor-line-number-foreground'],
-        'editor.selectionBackground': MonacoTheme['editor-selection-background'],
-        'editor.findMatchBackground': MonacoTheme['editor-find-match-background'],
-        'editor.findMatchHighlightBackground': MonacoTheme['editor-find-match-highlight-background'],
-        'editorSuggestWidget.background': MonacoTheme['editor-suggest-widget-background'],
-        'editorSuggestWidget.border': MonacoTheme['editor-suggest-widget-border'],
-        'editorSuggestWidget.foreground': MonacoTheme['editor-suggest-widget-foreground'],
-        'editorSuggestWidget.selectedBackground': MonacoTheme['editor-suggest-widget-selected-background'],
-        'editorSuggestWidget.highlightForeground': MonacoTheme['editor-suggest-widget-highlightForeground'],
-        'list.hoverBackground': MonacoTheme['list-hover-background'],
-        'dropdown.background': MonacoTheme['context-menu-background'],
-        'dropdown.foreground': MonacoTheme['context-menu-foreground'],
-        'menu.selectionBackground': MonacoTheme['menu-selection-background'],
-        'list.focusBackground': MonacoTheme['menu-selection-background'],
-        'editorWidget.background': MonacoTheme['editor-widget-background'],
-        'inputOption.activeBackground': MonacoTheme['input-option-active-background'],
-        'inputOption.activeForeground': MonacoTheme['input-option-active-foreground'],
-        focusBorder: MonacoTheme['focus-border'],
-        'input.background': MonacoTheme['input-background'],
-        'input.foreground': MonacoTheme['input-foreground'],
-        'input.border': MonacoTheme['input-border']
-      };
-      monaco.editor.defineTheme('dh-dark', {
-        base: 'vs-dark',
-        inherit: true,
-        rules: dhDarkRules,
-        colors: dhDarkColors
-      });
-      log.debug2('monaco theme: ', MonacoTheme);
-      monaco.editor.setTheme('dh-dark');
-      registerLanguages([DbLang, PyLang, GroovyLang, LogLang, ScalaLang]);
-      log.debug('Monaco initialized.');
-    }
-    /**
-     * Remove the hashtag prefix from a CSS color string.
-     * Monaco expects colors to be the value only, no hashtag.
-     * @param {String} color The hex color string to remove the hashtag from, eg. '#ffffff'
-     */
 
-  }, {
-    key: "removeHashtag",
-    value: function removeHashtag(color) {
-      return color.substring(1);
-    }
-  }, {
-    key: "registerLanguages",
-    value: function registerLanguages(languages) {
-      // First override the default loader for any language we have a custom definition for
-      // https://github.com/Microsoft/monaco-editor/issues/252#issuecomment-482786867
-      var languageIds = languages.map(function (_ref) {
-        var id = _ref.id;
-        return id;
-      });
-      monaco.languages.getLanguages().filter(function (_ref2) {
-        var id = _ref2.id;
-        return languageIds.includes(id);
-      }).forEach(function (languageParam) {
-        var language = languageParam;
-        log.debug2('Overriding default language loader:', language.id);
+  static removeHashtag(color) {
+    return color.substring(1);
+  }
 
-        language.loader = function () {
-          return {
-            then: function then() {}
-          };
-        };
-      }); // Then register our language definitions
+  static registerLanguages(languages) {
+    // First override the default loader for any language we have a custom definition for
+    // https://github.com/Microsoft/monaco-editor/issues/252#issuecomment-482786867
+    var languageIds = languages.map((_ref) => {
+      var {
+        id
+      } = _ref;
+      return id;
+    });
+    monaco.languages.getLanguages().filter((_ref2) => {
+      var {
+        id
+      } = _ref2;
+      return languageIds.includes(id);
+    }).forEach(languageParam => {
+      var language = languageParam;
+      log.debug2('Overriding default language loader:', language.id);
 
-      languages.forEach(function (language) {
-        MonacoUtils.registerLanguage(language);
+      language.loader = () => ({
+        then: () => {}
       });
-    }
-  }, {
-    key: "registerLanguage",
-    value: function registerLanguage(language) {
-      log.debug2('Registering language: ', language.id);
-      monaco.languages.register(language);
-      monaco.languages.onLanguage(language.id, function () {
-        monaco.languages.setLanguageConfiguration(language.id, language.conf);
-        monaco.languages.setMonarchTokensProvider(language.id, language.language);
-      });
-    }
-    /**
-     * Set EOL preference for the editor
-     * @param {monaco.editor.IEditor} editor The editor to set the EOL for
-     * @param {monaco.editor.EndOfLineSequence} eolSequence EOL sequence
-     */
+    }); // Then register our language definitions
 
-  }, {
-    key: "setEOL",
-    value: function setEOL(editor) {
-      var eolSequence = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : monaco.editor.EndOfLineSequence.LF;
-      editor.getModel().setEOL(eolSequence);
-    }
-    /**
-     * Links an editor with a provided session to provide completion items.
-     * @param {dh.IdeSession} session The IdeSession to link
-     * @param {monaco.editor.IEditor} editor The editor to link the session to
-     * @return A cleanup function for disposing of the created listeners
-     */
+    languages.forEach(language => {
+      MonacoUtils.registerLanguage(language);
+    });
+  }
+
+  static registerLanguage(language) {
+    log.debug2('Registering language: ', language.id);
+    monaco.languages.register(language);
+    monaco.languages.onLanguage(language.id, () => {
+      monaco.languages.setLanguageConfiguration(language.id, language.conf);
+      monaco.languages.setMonarchTokensProvider(language.id, language.language);
+    });
+  }
+  /**
+   * Set EOL preference for the editor
+   * @param {monaco.editor.IEditor} editor The editor to set the EOL for
+   * @param {monaco.editor.EndOfLineSequence} eolSequence EOL sequence
+   */
 
-  }, {
-    key: "openDocument",
-    value: function openDocument(editor, session) {
-      var model = editor.getModel();
-      var didOpenDocumentParams = {
-        textDocument: {
-          uri: "".concat(model.uri),
-          languageId: model.getModeId(),
-          version: model.getVersionId(),
-          text: model.getValue()
-        }
-      };
-      log.debug2('didOpenDocumentParams: ', didOpenDocumentParams);
-      session.openDocument(didOpenDocumentParams);
-      var dispose = editor.onDidChangeModelContent(function (changedEvent) {
-        var changes = changedEvent.changes,
-            versionId = changedEvent.versionId;
-        var contentChanges = [];
 
-        for (var i = 0; i < changes.length; i += 1) {
-          var change = changes[i];
-          var range = change.range,
-              rangeLength = change.rangeLength,
-              text = change.text;
-          var contentChange = {
-            range: {
-              start: {
-                line: range.startLineNumber - 1,
-                character: range.startColumn - 1
-              },
-              end: {
-                line: range.endLineNumber - 1,
-                character: range.endColumn - 1
-              }
-            },
-            rangeLength: rangeLength,
-            text: text
-          };
-          contentChanges.push(contentChange);
-        }
+  static setEOL(editor) {
+    var eolSequence = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : monaco.editor.EndOfLineSequence.LF;
+    editor.getModel().setEOL(eolSequence);
+  }
+  /**
+   * Links an editor with a provided session to provide completion items.
+   * @param {dh.IdeSession} session The IdeSession to link
+   * @param {monaco.editor.IEditor} editor The editor to link the session to
+   * @return A cleanup function for disposing of the created listeners
+   */
 
-        if (contentChanges.length > 0) {
-          var didChangeDocumentParams = {
-            textDocument: {
-              version: versionId,
-              uri: "".concat(model.uri)
+
+  static openDocument(editor, session) {
+    var model = editor.getModel();
+    var didOpenDocumentParams = {
+      textDocument: {
+        uri: "".concat(model.uri),
+        languageId: model.getModeId(),
+        version: model.getVersionId(),
+        text: model.getValue()
+      }
+    };
+    log.debug2('didOpenDocumentParams: ', didOpenDocumentParams);
+    session.openDocument(didOpenDocumentParams);
+    var dispose = editor.onDidChangeModelContent(changedEvent => {
+      var {
+        changes,
+        versionId
+      } = changedEvent;
+      var contentChanges = [];
+
+      for (var i = 0; i < changes.length; i += 1) {
+        var change = changes[i];
+        var {
+          range,
+          rangeLength,
+          text
+        } = change;
+        var contentChange = {
+          range: {
+            start: {
+              line: range.startLineNumber - 1,
+              character: range.startColumn - 1
             },
-            contentChanges: contentChanges
-          };
-          log.debug2('didChangeDocumentParams', didChangeDocumentParams);
-          session.changeDocument(didChangeDocumentParams);
-        }
-      });
-      return dispose;
-    }
-  }, {
-    key: "closeDocument",
-    value: function closeDocument(editor, session) {
-      var model = editor.getModel();
-      var didCloseDocumentParams = {
-        textDocument: {
-          uri: "".concat(model.uri)
-        }
-      };
-      session.closeDocument(didCloseDocumentParams);
-    }
-    /**
-     * Register a paste handle to clean up any garbage code pasted.
-     * Most of this comes from copying from Slack, which has a bad habit of injecting their own characters in your code snippets.
-     * I've emailed Slack about the issue and they're working on it. I can't reference a ticket number because their ticket system is entirely internally facing.
-     * @param {Monaco.editor} editor The editor the register the paste handler for
-     */
+            end: {
+              line: range.endLineNumber - 1,
+              character: range.endColumn - 1
+            }
+          },
+          rangeLength,
+          text
+        };
+        contentChanges.push(contentChange);
+      }
 
-  }, {
-    key: "registerPasteHandler",
-    value: function registerPasteHandler(editor) {
-      editor.onDidPaste(function (pasteEvent) {
-        var smartQuotes = /“|”/g;
-        var invalidChars = /\u200b/g;
-        var editorModel = editor.getModel();
-        var pastedText = editorModel.getValueInRange(pasteEvent.range);
+      if (contentChanges.length > 0) {
+        var didChangeDocumentParams = {
+          textDocument: {
+            version: versionId,
+            uri: "".concat(model.uri)
+          },
+          contentChanges
+        };
+        log.debug2('didChangeDocumentParams', didChangeDocumentParams);
+        session.changeDocument(didChangeDocumentParams);
+      }
+    });
+    return dispose;
+  }
+
+  static closeDocument(editor, session) {
+    var model = editor.getModel();
+    var didCloseDocumentParams = {
+      textDocument: {
+        uri: "".concat(model.uri)
+      }
+    };
+    session.closeDocument(didCloseDocumentParams);
+  }
+  /**
+   * Register a paste handle to clean up any garbage code pasted.
+   * Most of this comes from copying from Slack, which has a bad habit of injecting their own characters in your code snippets.
+   * I've emailed Slack about the issue and they're working on it. I can't reference a ticket number because their ticket system is entirely internally facing.
+   * @param {Monaco.editor} editor The editor the register the paste handler for
+   */
 
-        if (smartQuotes.test(pastedText) || invalidChars.test(pastedText)) {
-          editorModel.applyEdits([{
-            range: pasteEvent.range,
-            text: pastedText.replace(smartQuotes, '"').replace(invalidChars, '')
-          }]);
-        }
-      });
-    }
-  }, {
-    key: "isMacPlatform",
-    value: function isMacPlatform() {
-      var platform = window.navigator.platform;
-      return platform.startsWith('Mac');
-    }
-    /**
-     * Remove any keybindings which are used for our own shortcuts.
-     * This allows the key events to bubble up so a component higher up can capture them
-     * @param {Monaco.editor} editor The editor to remove the keybindings from
-     */
 
-  }, {
-    key: "removeConflictingKeybindings",
-    value: function removeConflictingKeybindings(editor) {
-      // Multi-mod key events have a specific order
-      // E.g. ctrl+alt+UpArrow is not found, but alt+ctrl+UpArrow is found
-      // meta is WindowsKey on Windows and cmd on Mac
-      // ctrl is ctrl Windows and ctrl on Mac
-      // alt is alt on Windows and option on Mac
-      var keybindings = [{
-        windows: 'ctrl+D',
-        mac: 'meta+D'
-      }, {
-        windows: 'ctrl+H'
-      }];
+  static registerPasteHandler(editor) {
+    editor.onDidPaste(pasteEvent => {
+      var smartQuotes = /“|”/g;
+      var invalidChars = /\u200b/g;
+      var editorModel = editor.getModel();
+      var pastedText = editorModel.getValueInRange(pasteEvent.range);
 
-      try {
-        keybindings.forEach(function (keybinding) {
-          return MonacoUtils.removeKeybinding(editor, MonacoUtils.isMacPlatform() ? keybinding.mac : keybinding.windows);
-        });
-      } catch (err) {
-        // This is probably only caused by Monaco changing private methods used here
-        log.error(err);
+      if (smartQuotes.test(pastedText) || invalidChars.test(pastedText)) {
+        editorModel.applyEdits([{
+          range: pasteEvent.range,
+          text: pastedText.replace(smartQuotes, '"').replace(invalidChars, '')
+        }]);
       }
+    });
+  }
+
+  static isMacPlatform() {
+    var {
+      platform
+    } = window.navigator;
+    return platform.startsWith('Mac');
+  }
+  /**
+   * Remove any keybindings which are used for our own shortcuts.
+   * This allows the key events to bubble up so a component higher up can capture them
+   * @param {Monaco.editor} editor The editor to remove the keybindings from
+   */
+
+
+  static removeConflictingKeybindings(editor) {
+    // Multi-mod key events have a specific order
+    // E.g. ctrl+alt+UpArrow is not found, but alt+ctrl+UpArrow is found
+    // meta is WindowsKey on Windows and cmd on Mac
+    // ctrl is ctrl Windows and ctrl on Mac
+    // alt is alt on Windows and option on Mac
+    var keybindings = [{
+      windows: 'ctrl+D',
+      mac: 'meta+D'
+    }, {
+      windows: 'ctrl+H'
+    }];
+
+    try {
+      keybindings.forEach(keybinding => MonacoUtils.removeKeybinding(editor, MonacoUtils.isMacPlatform() ? keybinding.mac : keybinding.windows));
+    } catch (err) {
+      // This is probably only caused by Monaco changing private methods used here
+      log.error(err);
     }
-    /**
-     * Remove a keybinding and allow the events to bubble up
-     * If you want the keybinding removed for all editors, add it to removeConflictingKeybindings
-     * Monaco still captures the event if you choose to override the keybinding with a no-op function
-     *
-     * Based on the following comment to remove a keybinding and let the event bubble up
-     * https://github.com/microsoft/monaco-editor/issues/287#issuecomment-331447475
-     * The issue for an API for this has apparently been open since 2016. Link below
-     * https://github.com/microsoft/monaco-editor/issues/102
-     * @param {Monaco.editor} editor The editor to remove the keybinding from
-     * @param {string} keybinding The key string to remove. E.g. 'ctrl+C' for copy on Windows
-     */
+  }
+  /**
+   * Remove a keybinding and allow the events to bubble up
+   * If you want the keybinding removed for all editors, add it to removeConflictingKeybindings
+   * Monaco still captures the event if you choose to override the keybinding with a no-op function
+   *
+   * Based on the following comment to remove a keybinding and let the event bubble up
+   * https://github.com/microsoft/monaco-editor/issues/287#issuecomment-331447475
+   * The issue for an API for this has apparently been open since 2016. Link below
+   * https://github.com/microsoft/monaco-editor/issues/102
+   * @param {Monaco.editor} editor The editor to remove the keybinding from
+   * @param {string} keybinding The key string to remove. E.g. 'ctrl+C' for copy on Windows
+   */
 
-  }, {
-    key: "removeKeybinding",
-    value: function removeKeybinding(editor, keybinding) {
-      if (!keybinding) {
-        return;
-      }
-      /* eslint-disable no-underscore-dangle */
-      // It's possible a single keybinding has multiple commands depending on context
 
+  static removeKeybinding(editor, keybinding) {
+    if (!keybinding) {
+      return;
+    }
+    /* eslint-disable no-underscore-dangle */
+    // It's possible a single keybinding has multiple commands depending on context
 
-      var keybindings = editor._standaloneKeybindingService._getResolver()._map.get(keybinding);
 
-      if (keybindings) {
-        keybindings.forEach(function (elem) {
-          log.debug2("Removing Monaco keybinding ".concat(keybinding, " for ").concat(elem.command));
+    var keybindings = editor._standaloneKeybindingService._getResolver()._map.get(keybinding);
 
-          editor._standaloneKeybindingService.addDynamicKeybinding("-".concat(elem.command), null, function () {});
-        });
-      } else {
-        log.warn("Did not find any keybindings to remove for ".concat(keybinding));
-      }
-      /* eslint-enable no-underscore-dangle */
+    if (keybindings) {
+      keybindings.forEach(elem => {
+        log.debug2("Removing Monaco keybinding ".concat(keybinding, " for ").concat(elem.command));
 
+        editor._standaloneKeybindingService.addDynamicKeybinding("-".concat(elem.command), null, () => {});
+      });
+    } else {
+      log.warn("Did not find any keybindings to remove for ".concat(keybinding));
     }
-  }]);
+    /* eslint-enable no-underscore-dangle */
+
+  }
 
-  return MonacoUtils;
-}();
+}
 
 export default MonacoUtils;
 //# sourceMappingURL=MonacoUtils.js.map