@codingame/monaco-editor-wrapper 4.0.0-next.1 → 4.0.0-next.2

package/dist/node_modules/monaco-emacs/lib/emacs/basicInput.js

@@ -0,0 +1,113 @@
+import { __exports as basicInput } from '../../../../_virtual/basicInput.js';
+import require$$0 from '../../../../_virtual/_monaco-editor.js';
+
+Object.defineProperty(basicInput, "__esModule", { value: true });
+basicInput.BasicInputWidget = void 0;
+var monaco = require$$0;
+var BASE_CLASS = 'ext-emacs-basic-input';
+function generateCss() {
+    return "\n  .".concat(BASE_CLASS, " {\n    color: #d4d4d4;\n    transition: top 200ms linear;\n    visibility: hidden;\n    width: 200px;\n    display: flex;\n    align-items: center;\n    padding: 5px;\n  }\n\n  .").concat(BASE_CLASS, ".").concat(BASE_CLASS, "-visible {\n    visibility: visible;\n  }\n\n  .").concat(BASE_CLASS, " input {\n    color: rgb(97, 97, 97);\n    background-color: transparent;\n    display: inline-block;\n    box-sizing: border-box;\n    height: 100%;\n    line-height: inherit;\n    border: none;\n    font-family: inherit;\n    font-size: inherit;\n    resize: none;\n    padding-top: 2px;\n    padding-bottom: 2px;\n    margin-left: 5px;\n    max-width: 50px;\n  }\n\n  .").concat(BASE_CLASS, " input:focus {\n    outline: none;\n  }\n\n  .vs .").concat(BASE_CLASS, " {\n    color: rgb(97, 97, 97);\n    background-color: #efeff2;\n    box-shadow: 0 2px 8px #a8a8a8;\n  }\n\n  .vs-dark .").concat(BASE_CLASS, " {\n    background-color: #2d2d30;\n    box-shadow: 0 2px 8px #000000;\n  }\n\n  .vs-dark .").concat(BASE_CLASS, " input {\n    color: rgb(204, 204, 204);\n  }\n\n  .hc-black .").concat(BASE_CLASS, " {\n    border: 2px solid #6fc3df;\n    background-color: #0c141f;\n    color: #ffffff;\n  }\n\n  .hc-black .").concat(BASE_CLASS, " input {\n    color: #ffffff;\n  }\n");
+}
+var BasicInputWidget = (function () {
+    function BasicInputWidget() {
+        var _this = this;
+        this._pendingPromise = null;
+        this.onKeyDown = function (ev) {
+            if (ev.altKey || ev.ctrlKey || ev.metaKey) {
+                ev.preventDefault();
+                ev.stopPropagation();
+            }
+            if (ev.which === 13) {
+                if (_this._pendingPromise) {
+                    ev.preventDefault();
+                    _this._pendingPromise.resolve(ev.target.value);
+                    _this._pendingPromise = null;
+                }
+            }
+            else if (ev.which === 27) {
+                if (_this._pendingPromise) {
+                    _this._pendingPromise.reject();
+                    _this._pendingPromise = null;
+                }
+            }
+        };
+        this.onBlur = function () {
+            if (_this._pendingPromise) {
+                _this._pendingPromise.reject();
+                _this._pendingPromise = null;
+            }
+        };
+        this._dom = document.createElement('div');
+        this._messageDom = document.createElement('div');
+        var medDom = document.createElement('div');
+        this._dom.setAttribute('class', BASE_CLASS);
+        this._dom.setAttribute('aria-hidden', 'true');
+        this._input = document.createElement('input');
+        this._dom.appendChild(this._messageDom);
+        medDom.appendChild(this._input);
+        this._dom.appendChild(medDom);
+        this.addListeners();
+        this._style = document.createElement('style');
+        this._style.type = 'text/css';
+        this._style.textContent = generateCss();
+        (document.head || document.body).appendChild(this._style);
+    }
+    BasicInputWidget.prototype.getDomNode = function () {
+        return this._dom;
+    };
+    BasicInputWidget.prototype.getId = function () {
+        return 'extension.emacs.basicinput';
+    };
+    BasicInputWidget.prototype.getPosition = function () {
+        return {
+            preference: monaco.editor.OverlayWidgetPositionPreference.TOP_RIGHT_CORNER,
+        };
+    };
+    BasicInputWidget.prototype.addListeners = function () {
+        this._input.addEventListener('keydown', this.onKeyDown);
+        this._input.addEventListener('blur', this.onBlur);
+    };
+    BasicInputWidget.prototype.showWidgetAndFocus = function (message) {
+        this._dom.classList.add("".concat(BASE_CLASS, "-visible"));
+        this._dom.setAttribute('aria-hidden', 'false');
+        this._messageDom.textContent = message;
+        this._input.focus();
+    };
+    BasicInputWidget.prototype.cleanup = function () {
+        this._dom.classList.remove("".concat(BASE_CLASS, "-visible"));
+        this._dom.setAttribute('aria-hidden', 'true');
+        this._messageDom.textContent = '';
+        this._input.placeholder = '';
+        this._input.value = '';
+    };
+    BasicInputWidget.prototype.getInput = function (message) {
+        var _this = this;
+        if (this._pendingPromise) {
+            this._pendingPromise.reject();
+            this._pendingPromise = null;
+        }
+        return new Promise(function (resolve, reject) {
+            _this._pendingPromise = {
+                resolve: function (val) {
+                    resolve(val);
+                    _this.cleanup();
+                },
+                reject: function () {
+                    reject();
+                    _this.cleanup();
+                },
+            };
+            _this.showWidgetAndFocus(message);
+        });
+    };
+    BasicInputWidget.prototype.dispose = function () {
+        this.cleanup();
+        this._input.removeEventListener('keydown', this.onKeyDown);
+        this._input.removeEventListener('blur', this.onBlur);
+        (document.head || document.body).removeChild(this._style);
+    };
+    return BasicInputWidget;
+}());
+basicInput.BasicInputWidget = BasicInputWidget;
+
+export { basicInput as default };

package/dist/node_modules/monaco-emacs/lib/emacs/commands.js

@@ -0,0 +1,184 @@
+import { __exports as commands } from '../../../../_virtual/commands.js';
+import './actions.js';
+import { __exports as actions } from '../../../../_virtual/actions.js';
+
+(function (exports) {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	exports.getAllMappings = exports.unregisterKey = exports.registerGlobalCommand = exports.executeCommand = exports.COMMANDS = exports.prefixPreservingKeys = void 0;
+	var Actions = actions;
+	exports.prefixPreservingKeys = {
+	    "M-g": true,
+	    "C-x": true,
+	    "C-q": true,
+	    "C-u": true,
+	};
+	var setMarkAction = new Actions.SetMark();
+	var undoAction = new Actions.UndoAction();
+	var moveCursorDown = new Actions.MoveCursorDown();
+	var moveCursorUp = new Actions.MoveCursorUp();
+	var moveCursorRight = new Actions.MoveCursorRight();
+	var moveCursorLeft = new Actions.MoveCursorLeft();
+	exports.COMMANDS = {
+	    'M-/': {
+	        description: '',
+	        action: 'editor.action.triggerSuggest',
+	    },
+	    'C-\'': {
+	        description: '',
+	        action: 'editor.action.triggerSuggest',
+	    },
+	    'M-;': {
+	        description: '',
+	        action: 'editor.action.commentLine',
+	    },
+	    'C-t': {
+	        description: '',
+	        action: 'editor.action.transposeLetters',
+	    },
+	    'C-x C-p': {
+	        description: '',
+	        action: 'editor.action.selectAll',
+	    },
+	    'Tab': {
+	        description: '',
+	        action: 'editor.action.formatDocument',
+	    },
+	    'C-Backspace': {
+	        description: '',
+	        action: 'deleteWordLeft',
+	    },
+	    'C-d': {
+	        description: '',
+	        action: 'deleteRight',
+	    },
+	    'M-Backspace': {
+	        description: '',
+	        action: 'deleteWordLeft',
+	    },
+	    'M-Delete': {
+	        description: '',
+	        action: 'deleteWordLeft',
+	    },
+	    'C-x C-u': {
+	        description: '',
+	        action: 'editor.action.transformToUppercase',
+	    },
+	    'C-x C-l': {
+	        description: '',
+	        action: 'editor.action.transformToLowercase',
+	    },
+	    'C-v': {
+	        description: '',
+	        action: 'cursorPageDown',
+	    },
+	    'PageDown': {
+	        description: '',
+	        action: 'cursorPageDown',
+	    },
+	    'M-v': {
+	        description: '',
+	        action: 'cursorPageUp',
+	    },
+	    'PageUp': {
+	        description: '',
+	        action: 'cursorPageUp',
+	    },
+	    'M-g n': {
+	        description: '',
+	        action: 'editor.action.marker.next',
+	    },
+	    'M-g p': {
+	        description: '',
+	        action: 'editor.action.marker.prev',
+	    },
+	    'M-C-n': {
+	        description: '',
+	        action: 'editor.action.addSelectionToNextFindMatch',
+	    },
+	    'C-h': {
+	        description: '',
+	        action: 'deleteLeft',
+	    },
+	    'M-d': {
+	        description: '',
+	        action: 'deleteWordRight',
+	    },
+	    'S-C-': {
+	        description: '',
+	        action: 'editor.action.triggerParameterHints',
+	    },
+	    'C-SPC': setMarkAction,
+	    'S-C-2': setMarkAction,
+	    'C-/': undoAction,
+	    'S-C--': undoAction,
+	    'C-z': undoAction,
+	    'C-x u': undoAction,
+	    'C-n': moveCursorDown,
+	    'C-p': moveCursorUp,
+	    'C-f': moveCursorRight,
+	    'C-b': moveCursorLeft,
+	    'S-C-Backspace': new Actions.DeleteLines(),
+	    'M-f': new Actions.MoveCursorWordRight(),
+	    'M-b': new Actions.MoveCursorWordLeft(),
+	    'C-k': new Actions.KillLines(),
+	    'C-m': new Actions.InsertLineAfter(),
+	    'C-w': new Actions.KillSelection(),
+	    'C-o': new Actions.InsertLineBelow(),
+	    'C-g': new Actions.KeyBoardQuit(),
+	    'C-e': new Actions.MoveCursorToLineEnd(),
+	    'C-a': new Actions.MoveCursorToLineStart(),
+	    'C-y': new Actions.Yank(),
+	    'M-w': new Actions.YankSelectionToRing(),
+	    'M-y': new Actions.YankRotate(),
+	    'C-l': new Actions.RevealToCenterAction(),
+	    'C-q Tab': new Actions.InsertTabs(),
+	    'M-r': new Actions.RotateCursorOnScreen(),
+	    'M-g g': new Actions.GotoLine(),
+	    'M-g M-g': new Actions.GotoLine(),
+	    'C-x C-x': new Actions.InvertSelection(),
+	    'S-M-.': new Actions.MoveCursorBottom(),
+	    'S-M-,': new Actions.MoveCursorTop(),
+	    'C-s': new Actions.Search(),
+	    'C-r': new Actions.Search(),
+	    'S-M-5': new Actions.SearchReplace(),
+	};
+	function executeCommand(ext, command, inputBuffer, repeatedTrigger) {
+	    var editor = ext.getEditor();
+	    var repeat = parseInt(inputBuffer) || 1;
+	    if (command.run) {
+	        command.run(editor, ext, repeat, repeatedTrigger);
+	        return;
+	    }
+	    if (typeof command.action === 'string') {
+	        for (var i = 0; i < repeat; i++) {
+	            editor.trigger(Actions.SOURCE, command.action, null);
+	        }
+	    }
+	    else if (Array.isArray(command.action)) {
+	        for (var i = 0; i < repeat; i++) {
+	            command.action.forEach(function (cmd) {
+	                editor.trigger(Actions.SOURCE, cmd, null);
+	            });
+	        }
+	    }
+	}
+	exports.executeCommand = executeCommand;
+	function registerGlobalCommand(key, command) {
+	    exports.COMMANDS[key] = command;
+	}
+	exports.registerGlobalCommand = registerGlobalCommand;
+	function unregisterKey(key) {
+	    if (exports.COMMANDS[key]) {
+	        delete exports.COMMANDS[key];
+	    }
+	}
+	exports.unregisterKey = unregisterKey;
+	function getAllMappings() {
+	    var result = {};
+	    Object.keys(exports.COMMANDS).forEach(function (key) {
+	        result[key] = exports.COMMANDS[key].description;
+	    });
+	    return result;
+	}
+	exports.getAllMappings = getAllMappings; 
+} (commands));

package/dist/node_modules/monaco-emacs/lib/emacs/index.js

@@ -0,0 +1,186 @@
+import { __exports as emacs } from '../../../../_virtual/index3.js';
+import require$$0 from '../../../../_virtual/_monaco-editor.js';
+import { l as lodash_throttle } from '../../../lodash.throttle/index.js';
+import { l as lodash_kebabcase } from '../../../lodash.kebabcase/index.js';
+import './commands.js';
+import './util.js';
+import './basicInput.js';
+import './state.js';
+import { __exports as commands } from '../../../../_virtual/commands.js';
+import { __exports as util } from '../../../../_virtual/util.js';
+import { __exports as state } from '../../../../_virtual/state.js';
+import { __exports as basicInput } from '../../../../_virtual/basicInput.js';
+
+Object.defineProperty(emacs, "__esModule", { value: true });
+emacs.getConfiguration = emacs.EmacsExtension = void 0;
+var monaco = require$$0;
+var throttle = lodash_throttle;
+var kebabCase = lodash_kebabcase;
+var commands_1 = commands;
+var util_1 = util;
+var basicInput_1 = basicInput;
+var state_1 = state;
+var _a = monaco.editor, TextEditorCursorBlinkingStyle = _a.TextEditorCursorBlinkingStyle, TextEditorCursorStyle = _a.TextEditorCursorStyle;
+var EmacsExtension = (function () {
+    function EmacsExtension(editor) {
+        this._disposables = [];
+        this._inSelectionMode = false;
+        this._changeDisposable = null;
+        this._state = new state_1.State();
+        this._onDidMarkChange = new util_1.Emitter();
+        this.onDidMarkChange = this._onDidMarkChange.event;
+        this._onDidChangeKey = new util_1.Emitter();
+        this.onDidChangeKey = this._onDidChangeKey.event;
+        this._editor = editor;
+        var config = getConfiguration(editor);
+        this._intialCursorType = config.cursorStyle;
+        this._intialCursorBlinking = config.cursorBlinking;
+        this._basicInputWidget = new basicInput_1.BasicInputWidget();
+    }
+    EmacsExtension.prototype.start = function () {
+        if (this._disposables.length) {
+            return;
+        }
+        this.addListeners();
+        this._editor.updateOptions({
+            cursorStyle: kebabCase(TextEditorCursorStyle[TextEditorCursorStyle.Block]),
+            cursorBlinking: kebabCase(TextEditorCursorBlinkingStyle[TextEditorCursorBlinkingStyle.Blink]),
+        });
+        this._editor.addOverlayWidget(this._basicInputWidget);
+    };
+    Object.defineProperty(EmacsExtension.prototype, "state", {
+        get: function () {
+            return this._state;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    EmacsExtension.prototype.getEditor = function () {
+        return this._editor;
+    };
+    EmacsExtension.prototype.addListeners = function () {
+        this._disposables.push(this._editor.onKeyDown(this.onKeyDown.bind(this)));
+        this._throttledScroll = throttle(this.onEditorScroll.bind(this), 500);
+        this._disposables.push(this._editor.onDidScrollChange(this._throttledScroll));
+    };
+    EmacsExtension.prototype.cancelKey = function (ev) {
+        ev.preventDefault();
+        ev.stopPropagation();
+    };
+    EmacsExtension.prototype.onKeyDown = function (ev) {
+        if (ev.browserEvent.defaultPrevented) {
+            return;
+        }
+        var key = (0, util_1.monacoToEmacsKey)(ev);
+        if (!key) {
+            return;
+        }
+        key = this._state.updateAndGetKey(key);
+        this._onDidChangeKey.fire(this._state.getReadableState());
+        if (key === state_1.EAT_UP_KEY) {
+            this._onDidChangeKey.fire(this._state.getReadableState());
+            this.cancelKey(ev);
+            return;
+        }
+        var command = commands_1.COMMANDS[key];
+        if (!command) {
+            this._onDidChangeKey.fire(this._state.getReadableState());
+            this._state.setLastCommandKey(key);
+            return;
+        }
+        this.cancelKey(ev);
+        var repeatedTrigger = this._state.isLastCommandKey(key);
+        (0, commands_1.executeCommand)(this, command, this._state.getInputBuffer(), repeatedTrigger);
+        this._state.setLastCommandKey(key);
+        this._state.updateStateOnExecution();
+    };
+    EmacsExtension.prototype.onEditorScroll = function () {
+        var height = this._editor.getLayoutInfo().height;
+        var layout = this._editor.getScrolledVisiblePosition(this._editor.getPosition());
+        if (layout.top >= 0 && layout.top <= height) {
+            return;
+        }
+        var ranges = this._editor.getVisibleRanges();
+        if (!ranges.length) {
+            return;
+        }
+        var newPos;
+        var sel = this._editor.getSelection();
+        if (layout.top < 0) {
+            newPos = new monaco.Position(ranges[0].getStartPosition().lineNumber, 1);
+        }
+        else if (layout.top > height) {
+            newPos = new monaco.Position(ranges[ranges.length - 1].getEndPosition().lineNumber, 1);
+        }
+        if (this._inSelectionMode) {
+            this._editor.setSelection(monaco.Selection.fromPositions(sel.getStartPosition(), newPos));
+        }
+        else {
+            this._editor.setPosition(newPos);
+        }
+    };
+    EmacsExtension.prototype.onContentChange = function () {
+        this.selectionMode = false;
+    };
+    EmacsExtension.prototype.clearState = function () {
+        this._state.updateStateOnExecution();
+    };
+    Object.defineProperty(EmacsExtension.prototype, "selectionMode", {
+        get: function () {
+            return this._inSelectionMode;
+        },
+        set: function (mode) {
+            if (mode === this._inSelectionMode) {
+                return;
+            }
+            this._inSelectionMode = mode;
+            if (mode) {
+                this._changeDisposable = this._editor.onDidChangeModelContent(this.onContentChange.bind(this));
+            }
+            else if (this._changeDisposable) {
+                this._changeDisposable.dispose();
+                this._changeDisposable = null;
+            }
+            this._onDidMarkChange.fire(mode);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    EmacsExtension.prototype.getCursorAnchor = function () {
+        var sel = this._editor.getSelection();
+        var dir = sel.getDirection();
+        return dir === monaco.SelectionDirection.LTR ? sel.getEndPosition() : sel.getStartPosition();
+    };
+    EmacsExtension.prototype.getBasicInput = function (message) {
+        return this._basicInputWidget.getInput(message);
+    };
+    EmacsExtension.prototype.dispose = function () {
+        this._disposables.forEach(function (d) { return d.dispose(); });
+        this._disposables = undefined;
+        if (this._changeDisposable) {
+            this._changeDisposable.dispose();
+            this._changeDisposable = null;
+        }
+        this._editor.updateOptions({
+            cursorStyle: this._intialCursorType,
+            cursorBlinking: this._intialCursorBlinking,
+        });
+        this._editor.removeOverlayWidget(this._basicInputWidget);
+        this._basicInputWidget.dispose();
+        this._throttledScroll.cancel();
+        this._state = null;
+    };
+    return EmacsExtension;
+}());
+emacs.EmacsExtension = EmacsExtension;
+function getConfiguration(editor) {
+    var cursorStyle = editor.getOption(monaco.editor.EditorOption.cursorStyle);
+    var cursorBlinking = editor.getOption(monaco.editor.EditorOption.cursorBlinking);
+    return {
+        cursorStyle: kebabCase(TextEditorCursorStyle[cursorStyle]),
+        cursorBlinking: kebabCase(TextEditorCursorBlinkingStyle[cursorBlinking]),
+    };
+}
+emacs.getConfiguration = getConfiguration;
+
+export { emacs as default };

package/dist/node_modules/monaco-emacs/lib/emacs/state.js

@@ -0,0 +1,116 @@
+import { __exports as state } from '../../../../_virtual/state.js';
+import './commands.js';
+import { __exports as commands } from '../../../../_virtual/commands.js';
+
+(function (exports) {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	exports.State = exports.EAT_UP_KEY = void 0;
+	var commands_1 = commands;
+	exports.EAT_UP_KEY = '==-==';
+	var State = (function () {
+	    function State() {
+	        this._inargumentMode = false;
+	        this._killRing = [];
+	    }
+	    State.prototype.updateAndGetKey = function (key) {
+	        if (key === 'C-g' && (this._inargumentMode || this._prefixKey)) {
+	            this.resetState();
+	            return exports.EAT_UP_KEY;
+	        }
+	        if (this.updateCuMode(key)) {
+	            return exports.EAT_UP_KEY;
+	        }
+	        if (!this._prefixKey) {
+	            if (commands_1.prefixPreservingKeys[key]) {
+	                this._prefixKey = key;
+	                return exports.EAT_UP_KEY;
+	            }
+	            return key;
+	        }
+	        else {
+	            return "".concat(this._prefixKey, " ").concat(key);
+	        }
+	    };
+	    State.prototype.setLastCommandKey = function (lastCommandKey) {
+	        this._lastCommandKey = lastCommandKey;
+	    };
+	    State.prototype.isLastCommandKey = function (lastCommandKey) {
+	        return this._lastCommandKey == lastCommandKey;
+	    };
+	    State.prototype.resetState = function (setLastInput) {
+	        if (setLastInput === void 0) { setLastInput = false; }
+	        this._inargumentMode = setLastInput;
+	        this._prefixKey = null;
+	        if (setLastInput) {
+	            this._lastInputBuffer = this._inputBuffer;
+	        }
+	        else {
+	            this._lastInputBuffer = null;
+	        }
+	        this._inputBuffer = null;
+	    };
+	    State.prototype.updateCuMode = function (key) {
+	        if (this._inargumentMode) {
+	            if (typeof key === 'string' && (/^\d$/.test(key))) {
+	                this._inputBuffer = (this._inputBuffer || '') + key;
+	                return true;
+	            }
+	            else if (commands_1.prefixPreservingKeys[key]) {
+	                this.resetState(true);
+	                return false;
+	            }
+	        }
+	        else if (!this._prefixKey && key === 'C-u') {
+	            this._inargumentMode = true;
+	            this._inputBuffer = null;
+	            this._lastInputBuffer = null;
+	            return true;
+	        }
+	    };
+	    State.prototype.updateStateOnExecution = function (reset) {
+	        if (reset === void 0) { reset = false; }
+	        this.resetState(reset);
+	    };
+	    State.prototype.getInputBuffer = function () {
+	        return this._lastInputBuffer || this._inputBuffer;
+	    };
+	    State.prototype.addToRing = function (str) {
+	        this._killRing.push(str);
+	        if (this._killRing.length > 50)
+	            this._killRing.shift();
+	    };
+	    State.prototype.growRingTop = function (str) {
+	        if (!this._killRing.length) {
+	            this.addToRing(str);
+	        }
+	        this._killRing[this._killRing.length - 1] += str;
+	    };
+	    State.prototype.getFromRing = function (n) {
+	        return this._killRing[this._killRing.length - (n ? Math.min(n, 1) : 1)] || '';
+	    };
+	    State.prototype.popFromRing = function () {
+	        if (this._killRing.length > 1) {
+	            return this._killRing.pop();
+	        }
+	        return this.getFromRing();
+	    };
+	    State.prototype.getReadableState = function () {
+	        var str = '';
+	        if (this._inargumentMode) {
+	            str += 'C-u';
+	            if (this._inputBuffer) {
+	                str += " ".concat(this._inputBuffer);
+	            }
+	            else if (this._lastInputBuffer) {
+	                str += " ".concat(this._lastInputBuffer);
+	            }
+	        }
+	        if (this._prefixKey) {
+	            str += " ".concat(this._prefixKey);
+	        }
+	        return str;
+	    };
+	    return State;
+	}());
+	exports.State = State; 
+} (state));