@codingame/monaco-editor-wrapper 3.10.0-monaco-update.1 → 3.10.0

package/dist/index.js

@@ -0,0 +1,2207 @@
+import { c as commonjsGlobal, r as require$$0, a as getDefaultExportFromCjs } from './_monaco-editor_commonjs-external.js';
+
+function _mergeNamespaces(n, m) {
+  m.forEach(function (e) {
+    e && typeof e !== 'string' && !Array.isArray(e) && Object.keys(e).forEach(function (k) {
+      if (k !== 'default' && !(k in n)) {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  });
+  return Object.freeze(n);
+}
+
+var lib = {};
+
+var emacs = {};
+
+/**
+ * lodash (Custom Build) <https://lodash.com/>
+ * Build: `lodash modularize exports="npm" -o ./`
+ * Copyright jQuery Foundation and other contributors <https://jquery.org/>
+ * Released under MIT license <https://lodash.com/license>
+ * Based on Underscore.js 1.8.3 <http://underscorejs.org/LICENSE>
+ * Copyright Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors
+ */
+
+/** Used as the `TypeError` message for "Functions" methods. */
+var FUNC_ERROR_TEXT = 'Expected a function';
+
+/** Used as references for various `Number` constants. */
+var NAN = 0 / 0;
+
+/** `Object#toString` result references. */
+var symbolTag$1 = '[object Symbol]';
+
+/** Used to match leading and trailing whitespace. */
+var reTrim = /^\s+|\s+$/g;
+
+/** Used to detect bad signed hexadecimal string values. */
+var reIsBadHex = /^[-+]0x[0-9a-f]+$/i;
+
+/** Used to detect binary string values. */
+var reIsBinary = /^0b[01]+$/i;
+
+/** Used to detect octal string values. */
+var reIsOctal = /^0o[0-7]+$/i;
+
+/** Built-in method references without a dependency on `root`. */
+var freeParseInt = parseInt;
+
+/** Detect free variable `global` from Node.js. */
+var freeGlobal$1 = typeof commonjsGlobal == 'object' && commonjsGlobal && commonjsGlobal.Object === Object && commonjsGlobal;
+
+/** Detect free variable `self`. */
+var freeSelf$1 = typeof self == 'object' && self && self.Object === Object && self;
+
+/** Used as a reference to the global object. */
+var root$1 = freeGlobal$1 || freeSelf$1 || Function('return this')();
+
+/** Used for built-in method references. */
+var objectProto$1 = Object.prototype;
+
+/**
+ * Used to resolve the
+ * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)
+ * of values.
+ */
+var objectToString$1 = objectProto$1.toString;
+
+/* Built-in method references for those with the same name as other `lodash` methods. */
+var nativeMax = Math.max,
+    nativeMin = Math.min;
+
+/**
+ * Gets the timestamp of the number of milliseconds that have elapsed since
+ * the Unix epoch (1 January 1970 00:00:00 UTC).
+ *
+ * @static
+ * @memberOf _
+ * @since 2.4.0
+ * @category Date
+ * @returns {number} Returns the timestamp.
+ * @example
+ *
+ * _.defer(function(stamp) {
+ *   console.log(_.now() - stamp);
+ * }, _.now());
+ * // => Logs the number of milliseconds it took for the deferred invocation.
+ */
+var now = function() {
+  return root$1.Date.now();
+};
+
+/**
+ * Creates a debounced function that delays invoking `func` until after `wait`
+ * milliseconds have elapsed since the last time the debounced function was
+ * invoked. The debounced function comes with a `cancel` method to cancel
+ * delayed `func` invocations and a `flush` method to immediately invoke them.
+ * Provide `options` to indicate whether `func` should be invoked on the
+ * leading and/or trailing edge of the `wait` timeout. The `func` is invoked
+ * with the last arguments provided to the debounced function. Subsequent
+ * calls to the debounced function return the result of the last `func`
+ * invocation.
+ *
+ * **Note:** If `leading` and `trailing` options are `true`, `func` is
+ * invoked on the trailing edge of the timeout only if the debounced function
+ * is invoked more than once during the `wait` timeout.
+ *
+ * If `wait` is `0` and `leading` is `false`, `func` invocation is deferred
+ * until to the next tick, similar to `setTimeout` with a timeout of `0`.
+ *
+ * See [David Corbacho's article](https://css-tricks.com/debouncing-throttling-explained-examples/)
+ * for details over the differences between `_.debounce` and `_.throttle`.
+ *
+ * @static
+ * @memberOf _
+ * @since 0.1.0
+ * @category Function
+ * @param {Function} func The function to debounce.
+ * @param {number} [wait=0] The number of milliseconds to delay.
+ * @param {Object} [options={}] The options object.
+ * @param {boolean} [options.leading=false]
+ *  Specify invoking on the leading edge of the timeout.
+ * @param {number} [options.maxWait]
+ *  The maximum time `func` is allowed to be delayed before it's invoked.
+ * @param {boolean} [options.trailing=true]
+ *  Specify invoking on the trailing edge of the timeout.
+ * @returns {Function} Returns the new debounced function.
+ * @example
+ *
+ * // Avoid costly calculations while the window size is in flux.
+ * jQuery(window).on('resize', _.debounce(calculateLayout, 150));
+ *
+ * // Invoke `sendMail` when clicked, debouncing subsequent calls.
+ * jQuery(element).on('click', _.debounce(sendMail, 300, {
+ *   'leading': true,
+ *   'trailing': false
+ * }));
+ *
+ * // Ensure `batchLog` is invoked once after 1 second of debounced calls.
+ * var debounced = _.debounce(batchLog, 250, { 'maxWait': 1000 });
+ * var source = new EventSource('/stream');
+ * jQuery(source).on('message', debounced);
+ *
+ * // Cancel the trailing debounced invocation.
+ * jQuery(window).on('popstate', debounced.cancel);
+ */
+function debounce(func, wait, options) {
+  var lastArgs,
+      lastThis,
+      maxWait,
+      result,
+      timerId,
+      lastCallTime,
+      lastInvokeTime = 0,
+      leading = false,
+      maxing = false,
+      trailing = true;
+
+  if (typeof func != 'function') {
+    throw new TypeError(FUNC_ERROR_TEXT);
+  }
+  wait = toNumber(wait) || 0;
+  if (isObject(options)) {
+    leading = !!options.leading;
+    maxing = 'maxWait' in options;
+    maxWait = maxing ? nativeMax(toNumber(options.maxWait) || 0, wait) : maxWait;
+    trailing = 'trailing' in options ? !!options.trailing : trailing;
+  }
+
+  function invokeFunc(time) {
+    var args = lastArgs,
+        thisArg = lastThis;
+
+    lastArgs = lastThis = undefined;
+    lastInvokeTime = time;
+    result = func.apply(thisArg, args);
+    return result;
+  }
+
+  function leadingEdge(time) {
+    // Reset any `maxWait` timer.
+    lastInvokeTime = time;
+    // Start the timer for the trailing edge.
+    timerId = setTimeout(timerExpired, wait);
+    // Invoke the leading edge.
+    return leading ? invokeFunc(time) : result;
+  }
+
+  function remainingWait(time) {
+    var timeSinceLastCall = time - lastCallTime,
+        timeSinceLastInvoke = time - lastInvokeTime,
+        result = wait - timeSinceLastCall;
+
+    return maxing ? nativeMin(result, maxWait - timeSinceLastInvoke) : result;
+  }
+
+  function shouldInvoke(time) {
+    var timeSinceLastCall = time - lastCallTime,
+        timeSinceLastInvoke = time - lastInvokeTime;
+
+    // Either this is the first call, activity has stopped and we're at the
+    // trailing edge, the system time has gone backwards and we're treating
+    // it as the trailing edge, or we've hit the `maxWait` limit.
+    return (lastCallTime === undefined || (timeSinceLastCall >= wait) ||
+      (timeSinceLastCall < 0) || (maxing && timeSinceLastInvoke >= maxWait));
+  }
+
+  function timerExpired() {
+    var time = now();
+    if (shouldInvoke(time)) {
+      return trailingEdge(time);
+    }
+    // Restart the timer.
+    timerId = setTimeout(timerExpired, remainingWait(time));
+  }
+
+  function trailingEdge(time) {
+    timerId = undefined;
+
+    // Only invoke if we have `lastArgs` which means `func` has been
+    // debounced at least once.
+    if (trailing && lastArgs) {
+      return invokeFunc(time);
+    }
+    lastArgs = lastThis = undefined;
+    return result;
+  }
+
+  function cancel() {
+    if (timerId !== undefined) {
+      clearTimeout(timerId);
+    }
+    lastInvokeTime = 0;
+    lastArgs = lastCallTime = lastThis = timerId = undefined;
+  }
+
+  function flush() {
+    return timerId === undefined ? result : trailingEdge(now());
+  }
+
+  function debounced() {
+    var time = now(),
+        isInvoking = shouldInvoke(time);
+
+    lastArgs = arguments;
+    lastThis = this;
+    lastCallTime = time;
+
+    if (isInvoking) {
+      if (timerId === undefined) {
+        return leadingEdge(lastCallTime);
+      }
+      if (maxing) {
+        // Handle invocations in a tight loop.
+        timerId = setTimeout(timerExpired, wait);
+        return invokeFunc(lastCallTime);
+      }
+    }
+    if (timerId === undefined) {
+      timerId = setTimeout(timerExpired, wait);
+    }
+    return result;
+  }
+  debounced.cancel = cancel;
+  debounced.flush = flush;
+  return debounced;
+}
+
+/**
+ * Creates a throttled function that only invokes `func` at most once per
+ * every `wait` milliseconds. The throttled function comes with a `cancel`
+ * method to cancel delayed `func` invocations and a `flush` method to
+ * immediately invoke them. Provide `options` to indicate whether `func`
+ * should be invoked on the leading and/or trailing edge of the `wait`
+ * timeout. The `func` is invoked with the last arguments provided to the
+ * throttled function. Subsequent calls to the throttled function return the
+ * result of the last `func` invocation.
+ *
+ * **Note:** If `leading` and `trailing` options are `true`, `func` is
+ * invoked on the trailing edge of the timeout only if the throttled function
+ * is invoked more than once during the `wait` timeout.
+ *
+ * If `wait` is `0` and `leading` is `false`, `func` invocation is deferred
+ * until to the next tick, similar to `setTimeout` with a timeout of `0`.
+ *
+ * See [David Corbacho's article](https://css-tricks.com/debouncing-throttling-explained-examples/)
+ * for details over the differences between `_.throttle` and `_.debounce`.
+ *
+ * @static
+ * @memberOf _
+ * @since 0.1.0
+ * @category Function
+ * @param {Function} func The function to throttle.
+ * @param {number} [wait=0] The number of milliseconds to throttle invocations to.
+ * @param {Object} [options={}] The options object.
+ * @param {boolean} [options.leading=true]
+ *  Specify invoking on the leading edge of the timeout.
+ * @param {boolean} [options.trailing=true]
+ *  Specify invoking on the trailing edge of the timeout.
+ * @returns {Function} Returns the new throttled function.
+ * @example
+ *
+ * // Avoid excessively updating the position while scrolling.
+ * jQuery(window).on('scroll', _.throttle(updatePosition, 100));
+ *
+ * // Invoke `renewToken` when the click event is fired, but not more than once every 5 minutes.
+ * var throttled = _.throttle(renewToken, 300000, { 'trailing': false });
+ * jQuery(element).on('click', throttled);
+ *
+ * // Cancel the trailing throttled invocation.
+ * jQuery(window).on('popstate', throttled.cancel);
+ */
+function throttle$1(func, wait, options) {
+  var leading = true,
+      trailing = true;
+
+  if (typeof func != 'function') {
+    throw new TypeError(FUNC_ERROR_TEXT);
+  }
+  if (isObject(options)) {
+    leading = 'leading' in options ? !!options.leading : leading;
+    trailing = 'trailing' in options ? !!options.trailing : trailing;
+  }
+  return debounce(func, wait, {
+    'leading': leading,
+    'maxWait': wait,
+    'trailing': trailing
+  });
+}
+
+/**
+ * Checks if `value` is the
+ * [language type](http://www.ecma-international.org/ecma-262/7.0/#sec-ecmascript-language-types)
+ * of `Object`. (e.g. arrays, functions, objects, regexes, `new Number(0)`, and `new String('')`)
+ *
+ * @static
+ * @memberOf _
+ * @since 0.1.0
+ * @category Lang
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is an object, else `false`.
+ * @example
+ *
+ * _.isObject({});
+ * // => true
+ *
+ * _.isObject([1, 2, 3]);
+ * // => true
+ *
+ * _.isObject(_.noop);
+ * // => true
+ *
+ * _.isObject(null);
+ * // => false
+ */
+function isObject(value) {
+  var type = typeof value;
+  return !!value && (type == 'object' || type == 'function');
+}
+
+/**
+ * Checks if `value` is object-like. A value is object-like if it's not `null`
+ * and has a `typeof` result of "object".
+ *
+ * @static
+ * @memberOf _
+ * @since 4.0.0
+ * @category Lang
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is object-like, else `false`.
+ * @example
+ *
+ * _.isObjectLike({});
+ * // => true
+ *
+ * _.isObjectLike([1, 2, 3]);
+ * // => true
+ *
+ * _.isObjectLike(_.noop);
+ * // => false
+ *
+ * _.isObjectLike(null);
+ * // => false
+ */
+function isObjectLike$1(value) {
+  return !!value && typeof value == 'object';
+}
+
+/**
+ * Checks if `value` is classified as a `Symbol` primitive or object.
+ *
+ * @static
+ * @memberOf _
+ * @since 4.0.0
+ * @category Lang
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is a symbol, else `false`.
+ * @example
+ *
+ * _.isSymbol(Symbol.iterator);
+ * // => true
+ *
+ * _.isSymbol('abc');
+ * // => false
+ */
+function isSymbol$1(value) {
+  return typeof value == 'symbol' ||
+    (isObjectLike$1(value) && objectToString$1.call(value) == symbolTag$1);
+}
+
+/**
+ * Converts `value` to a number.
+ *
+ * @static
+ * @memberOf _
+ * @since 4.0.0
+ * @category Lang
+ * @param {*} value The value to process.
+ * @returns {number} Returns the number.
+ * @example
+ *
+ * _.toNumber(3.2);
+ * // => 3.2
+ *
+ * _.toNumber(Number.MIN_VALUE);
+ * // => 5e-324
+ *
+ * _.toNumber(Infinity);
+ * // => Infinity
+ *
+ * _.toNumber('3.2');
+ * // => 3.2
+ */
+function toNumber(value) {
+  if (typeof value == 'number') {
+    return value;
+  }
+  if (isSymbol$1(value)) {
+    return NAN;
+  }
+  if (isObject(value)) {
+    var other = typeof value.valueOf == 'function' ? value.valueOf() : value;
+    value = isObject(other) ? (other + '') : other;
+  }
+  if (typeof value != 'string') {
+    return value === 0 ? value : +value;
+  }
+  value = value.replace(reTrim, '');
+  var isBinary = reIsBinary.test(value);
+  return (isBinary || reIsOctal.test(value))
+    ? freeParseInt(value.slice(2), isBinary ? 2 : 8)
+    : (reIsBadHex.test(value) ? NAN : +value);
+}
+
+var lodash_throttle = throttle$1;
+
+/**
+ * lodash (Custom Build) <https://lodash.com/>
+ * Build: `lodash modularize exports="npm" -o ./`
+ * Copyright jQuery Foundation and other contributors <https://jquery.org/>
+ * Released under MIT license <https://lodash.com/license>
+ * Based on Underscore.js 1.8.3 <http://underscorejs.org/LICENSE>
+ * Copyright Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors
+ */
+
+/** Used as references for various `Number` constants. */
+var INFINITY = 1 / 0;
+
+/** `Object#toString` result references. */
+var symbolTag = '[object Symbol]';
+
+/** Used to match words composed of alphanumeric characters. */
+var reAsciiWord = /[^\x00-\x2f\x3a-\x40\x5b-\x60\x7b-\x7f]+/g;
+
+/** Used to match Latin Unicode letters (excluding mathematical operators). */
+var reLatin = /[\xc0-\xd6\xd8-\xf6\xf8-\xff\u0100-\u017f]/g;
+
+/** Used to compose unicode character classes. */
+var rsAstralRange = '\\ud800-\\udfff',
+    rsComboMarksRange = '\\u0300-\\u036f\\ufe20-\\ufe23',
+    rsComboSymbolsRange = '\\u20d0-\\u20f0',
+    rsDingbatRange = '\\u2700-\\u27bf',
+    rsLowerRange = 'a-z\\xdf-\\xf6\\xf8-\\xff',
+    rsMathOpRange = '\\xac\\xb1\\xd7\\xf7',
+    rsNonCharRange = '\\x00-\\x2f\\x3a-\\x40\\x5b-\\x60\\x7b-\\xbf',
+    rsPunctuationRange = '\\u2000-\\u206f',
+    rsSpaceRange = ' \\t\\x0b\\f\\xa0\\ufeff\\n\\r\\u2028\\u2029\\u1680\\u180e\\u2000\\u2001\\u2002\\u2003\\u2004\\u2005\\u2006\\u2007\\u2008\\u2009\\u200a\\u202f\\u205f\\u3000',
+    rsUpperRange = 'A-Z\\xc0-\\xd6\\xd8-\\xde',
+    rsVarRange = '\\ufe0e\\ufe0f',
+    rsBreakRange = rsMathOpRange + rsNonCharRange + rsPunctuationRange + rsSpaceRange;
+
+/** Used to compose unicode capture groups. */
+var rsApos = "['\u2019]",
+    rsBreak = '[' + rsBreakRange + ']',
+    rsCombo = '[' + rsComboMarksRange + rsComboSymbolsRange + ']',
+    rsDigits = '\\d+',
+    rsDingbat = '[' + rsDingbatRange + ']',
+    rsLower = '[' + rsLowerRange + ']',
+    rsMisc = '[^' + rsAstralRange + rsBreakRange + rsDigits + rsDingbatRange + rsLowerRange + rsUpperRange + ']',
+    rsFitz = '\\ud83c[\\udffb-\\udfff]',
+    rsModifier = '(?:' + rsCombo + '|' + rsFitz + ')',
+    rsNonAstral = '[^' + rsAstralRange + ']',
+    rsRegional = '(?:\\ud83c[\\udde6-\\uddff]){2}',
+    rsSurrPair = '[\\ud800-\\udbff][\\udc00-\\udfff]',
+    rsUpper = '[' + rsUpperRange + ']',
+    rsZWJ = '\\u200d';
+
+/** Used to compose unicode regexes. */
+var rsLowerMisc = '(?:' + rsLower + '|' + rsMisc + ')',
+    rsUpperMisc = '(?:' + rsUpper + '|' + rsMisc + ')',
+    rsOptLowerContr = '(?:' + rsApos + '(?:d|ll|m|re|s|t|ve))?',
+    rsOptUpperContr = '(?:' + rsApos + '(?:D|LL|M|RE|S|T|VE))?',
+    reOptMod = rsModifier + '?',
+    rsOptVar = '[' + rsVarRange + ']?',
+    rsOptJoin = '(?:' + rsZWJ + '(?:' + [rsNonAstral, rsRegional, rsSurrPair].join('|') + ')' + rsOptVar + reOptMod + ')*',
+    rsSeq = rsOptVar + reOptMod + rsOptJoin,
+    rsEmoji = '(?:' + [rsDingbat, rsRegional, rsSurrPair].join('|') + ')' + rsSeq;
+
+/** Used to match apostrophes. */
+var reApos = RegExp(rsApos, 'g');
+
+/**
+ * Used to match [combining diacritical marks](https://en.wikipedia.org/wiki/Combining_Diacritical_Marks) and
+ * [combining diacritical marks for symbols](https://en.wikipedia.org/wiki/Combining_Diacritical_Marks_for_Symbols).
+ */
+var reComboMark = RegExp(rsCombo, 'g');
+
+/** Used to match complex or compound words. */
+var reUnicodeWord = RegExp([
+  rsUpper + '?' + rsLower + '+' + rsOptLowerContr + '(?=' + [rsBreak, rsUpper, '$'].join('|') + ')',
+  rsUpperMisc + '+' + rsOptUpperContr + '(?=' + [rsBreak, rsUpper + rsLowerMisc, '$'].join('|') + ')',
+  rsUpper + '?' + rsLowerMisc + '+' + rsOptLowerContr,
+  rsUpper + '+' + rsOptUpperContr,
+  rsDigits,
+  rsEmoji
+].join('|'), 'g');
+
+/** Used to detect strings that need a more robust regexp to match words. */
+var reHasUnicodeWord = /[a-z][A-Z]|[A-Z]{2,}[a-z]|[0-9][a-zA-Z]|[a-zA-Z][0-9]|[^a-zA-Z0-9 ]/;
+
+/** Used to map Latin Unicode letters to basic Latin letters. */
+var deburredLetters = {
+  // Latin-1 Supplement block.
+  '\xc0': 'A',  '\xc1': 'A', '\xc2': 'A', '\xc3': 'A', '\xc4': 'A', '\xc5': 'A',
+  '\xe0': 'a',  '\xe1': 'a', '\xe2': 'a', '\xe3': 'a', '\xe4': 'a', '\xe5': 'a',
+  '\xc7': 'C',  '\xe7': 'c',
+  '\xd0': 'D',  '\xf0': 'd',
+  '\xc8': 'E',  '\xc9': 'E', '\xca': 'E', '\xcb': 'E',
+  '\xe8': 'e',  '\xe9': 'e', '\xea': 'e', '\xeb': 'e',
+  '\xcc': 'I',  '\xcd': 'I', '\xce': 'I', '\xcf': 'I',
+  '\xec': 'i',  '\xed': 'i', '\xee': 'i', '\xef': 'i',
+  '\xd1': 'N',  '\xf1': 'n',
+  '\xd2': 'O',  '\xd3': 'O', '\xd4': 'O', '\xd5': 'O', '\xd6': 'O', '\xd8': 'O',
+  '\xf2': 'o',  '\xf3': 'o', '\xf4': 'o', '\xf5': 'o', '\xf6': 'o', '\xf8': 'o',
+  '\xd9': 'U',  '\xda': 'U', '\xdb': 'U', '\xdc': 'U',
+  '\xf9': 'u',  '\xfa': 'u', '\xfb': 'u', '\xfc': 'u',
+  '\xdd': 'Y',  '\xfd': 'y', '\xff': 'y',
+  '\xc6': 'Ae', '\xe6': 'ae',
+  '\xde': 'Th', '\xfe': 'th',
+  '\xdf': 'ss',
+  // Latin Extended-A block.
+  '\u0100': 'A',  '\u0102': 'A', '\u0104': 'A',
+  '\u0101': 'a',  '\u0103': 'a', '\u0105': 'a',
+  '\u0106': 'C',  '\u0108': 'C', '\u010a': 'C', '\u010c': 'C',
+  '\u0107': 'c',  '\u0109': 'c', '\u010b': 'c', '\u010d': 'c',
+  '\u010e': 'D',  '\u0110': 'D', '\u010f': 'd', '\u0111': 'd',
+  '\u0112': 'E',  '\u0114': 'E', '\u0116': 'E', '\u0118': 'E', '\u011a': 'E',
+  '\u0113': 'e',  '\u0115': 'e', '\u0117': 'e', '\u0119': 'e', '\u011b': 'e',
+  '\u011c': 'G',  '\u011e': 'G', '\u0120': 'G', '\u0122': 'G',
+  '\u011d': 'g',  '\u011f': 'g', '\u0121': 'g', '\u0123': 'g',
+  '\u0124': 'H',  '\u0126': 'H', '\u0125': 'h', '\u0127': 'h',
+  '\u0128': 'I',  '\u012a': 'I', '\u012c': 'I', '\u012e': 'I', '\u0130': 'I',
+  '\u0129': 'i',  '\u012b': 'i', '\u012d': 'i', '\u012f': 'i', '\u0131': 'i',
+  '\u0134': 'J',  '\u0135': 'j',
+  '\u0136': 'K',  '\u0137': 'k', '\u0138': 'k',
+  '\u0139': 'L',  '\u013b': 'L', '\u013d': 'L', '\u013f': 'L', '\u0141': 'L',
+  '\u013a': 'l',  '\u013c': 'l', '\u013e': 'l', '\u0140': 'l', '\u0142': 'l',
+  '\u0143': 'N',  '\u0145': 'N', '\u0147': 'N', '\u014a': 'N',
+  '\u0144': 'n',  '\u0146': 'n', '\u0148': 'n', '\u014b': 'n',
+  '\u014c': 'O',  '\u014e': 'O', '\u0150': 'O',
+  '\u014d': 'o',  '\u014f': 'o', '\u0151': 'o',
+  '\u0154': 'R',  '\u0156': 'R', '\u0158': 'R',
+  '\u0155': 'r',  '\u0157': 'r', '\u0159': 'r',
+  '\u015a': 'S',  '\u015c': 'S', '\u015e': 'S', '\u0160': 'S',
+  '\u015b': 's',  '\u015d': 's', '\u015f': 's', '\u0161': 's',
+  '\u0162': 'T',  '\u0164': 'T', '\u0166': 'T',
+  '\u0163': 't',  '\u0165': 't', '\u0167': 't',
+  '\u0168': 'U',  '\u016a': 'U', '\u016c': 'U', '\u016e': 'U', '\u0170': 'U', '\u0172': 'U',
+  '\u0169': 'u',  '\u016b': 'u', '\u016d': 'u', '\u016f': 'u', '\u0171': 'u', '\u0173': 'u',
+  '\u0174': 'W',  '\u0175': 'w',
+  '\u0176': 'Y',  '\u0177': 'y', '\u0178': 'Y',
+  '\u0179': 'Z',  '\u017b': 'Z', '\u017d': 'Z',
+  '\u017a': 'z',  '\u017c': 'z', '\u017e': 'z',
+  '\u0132': 'IJ', '\u0133': 'ij',
+  '\u0152': 'Oe', '\u0153': 'oe',
+  '\u0149': "'n", '\u017f': 'ss'
+};
+
+/** Detect free variable `global` from Node.js. */
+var freeGlobal = typeof commonjsGlobal == 'object' && commonjsGlobal && commonjsGlobal.Object === Object && commonjsGlobal;
+
+/** Detect free variable `self`. */
+var freeSelf = typeof self == 'object' && self && self.Object === Object && self;
+
+/** Used as a reference to the global object. */
+var root = freeGlobal || freeSelf || Function('return this')();
+
+/**
+ * A specialized version of `_.reduce` for arrays without support for
+ * iteratee shorthands.
+ *
+ * @private
+ * @param {Array} [array] The array to iterate over.
+ * @param {Function} iteratee The function invoked per iteration.
+ * @param {*} [accumulator] The initial value.
+ * @param {boolean} [initAccum] Specify using the first element of `array` as
+ *  the initial value.
+ * @returns {*} Returns the accumulated value.
+ */
+function arrayReduce(array, iteratee, accumulator, initAccum) {
+  var index = -1,
+      length = array ? array.length : 0;
+
+  if (initAccum && length) {
+    accumulator = array[++index];
+  }
+  while (++index < length) {
+    accumulator = iteratee(accumulator, array[index], index, array);
+  }
+  return accumulator;
+}
+
+/**
+ * Splits an ASCII `string` into an array of its words.
+ *
+ * @private
+ * @param {string} The string to inspect.
+ * @returns {Array} Returns the words of `string`.
+ */
+function asciiWords(string) {
+  return string.match(reAsciiWord) || [];
+}
+
+/**
+ * The base implementation of `_.propertyOf` without support for deep paths.
+ *
+ * @private
+ * @param {Object} object The object to query.
+ * @returns {Function} Returns the new accessor function.
+ */
+function basePropertyOf(object) {
+  return function(key) {
+    return object == null ? undefined : object[key];
+  };
+}
+
+/**
+ * Used by `_.deburr` to convert Latin-1 Supplement and Latin Extended-A
+ * letters to basic Latin letters.
+ *
+ * @private
+ * @param {string} letter The matched letter to deburr.
+ * @returns {string} Returns the deburred letter.
+ */
+var deburrLetter = basePropertyOf(deburredLetters);
+
+/**
+ * Checks if `string` contains a word composed of Unicode symbols.
+ *
+ * @private
+ * @param {string} string The string to inspect.
+ * @returns {boolean} Returns `true` if a word is found, else `false`.
+ */
+function hasUnicodeWord(string) {
+  return reHasUnicodeWord.test(string);
+}
+
+/**
+ * Splits a Unicode `string` into an array of its words.
+ *
+ * @private
+ * @param {string} The string to inspect.
+ * @returns {Array} Returns the words of `string`.
+ */
+function unicodeWords(string) {
+  return string.match(reUnicodeWord) || [];
+}
+
+/** Used for built-in method references. */
+var objectProto = Object.prototype;
+
+/**
+ * Used to resolve the
+ * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)
+ * of values.
+ */
+var objectToString = objectProto.toString;
+
+/** Built-in value references. */
+var Symbol = root.Symbol;
+
+/** Used to convert symbols to primitives and strings. */
+var symbolProto = Symbol ? Symbol.prototype : undefined,
+    symbolToString = symbolProto ? symbolProto.toString : undefined;
+
+/**
+ * The base implementation of `_.toString` which doesn't convert nullish
+ * values to empty strings.
+ *
+ * @private
+ * @param {*} value The value to process.
+ * @returns {string} Returns the string.
+ */
+function baseToString(value) {
+  // Exit early for strings to avoid a performance hit in some environments.
+  if (typeof value == 'string') {
+    return value;
+  }
+  if (isSymbol(value)) {
+    return symbolToString ? symbolToString.call(value) : '';
+  }
+  var result = (value + '');
+  return (result == '0' && (1 / value) == -INFINITY) ? '-0' : result;
+}
+
+/**
+ * Creates a function like `_.camelCase`.
+ *
+ * @private
+ * @param {Function} callback The function to combine each word.
+ * @returns {Function} Returns the new compounder function.
+ */
+function createCompounder(callback) {
+  return function(string) {
+    return arrayReduce(words(deburr(string).replace(reApos, '')), callback, '');
+  };
+}
+
+/**
+ * Checks if `value` is object-like. A value is object-like if it's not `null`
+ * and has a `typeof` result of "object".
+ *
+ * @static
+ * @memberOf _
+ * @since 4.0.0
+ * @category Lang
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is object-like, else `false`.
+ * @example
+ *
+ * _.isObjectLike({});
+ * // => true
+ *
+ * _.isObjectLike([1, 2, 3]);
+ * // => true
+ *
+ * _.isObjectLike(_.noop);
+ * // => false
+ *
+ * _.isObjectLike(null);
+ * // => false
+ */
+function isObjectLike(value) {
+  return !!value && typeof value == 'object';
+}
+
+/**
+ * Checks if `value` is classified as a `Symbol` primitive or object.
+ *
+ * @static
+ * @memberOf _
+ * @since 4.0.0
+ * @category Lang
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is a symbol, else `false`.
+ * @example
+ *
+ * _.isSymbol(Symbol.iterator);
+ * // => true
+ *
+ * _.isSymbol('abc');
+ * // => false
+ */
+function isSymbol(value) {
+  return typeof value == 'symbol' ||
+    (isObjectLike(value) && objectToString.call(value) == symbolTag);
+}
+
+/**
+ * Converts `value` to a string. An empty string is returned for `null`
+ * and `undefined` values. The sign of `-0` is preserved.
+ *
+ * @static
+ * @memberOf _
+ * @since 4.0.0
+ * @category Lang
+ * @param {*} value The value to process.
+ * @returns {string} Returns the string.
+ * @example
+ *
+ * _.toString(null);
+ * // => ''
+ *
+ * _.toString(-0);
+ * // => '-0'
+ *
+ * _.toString([1, 2, 3]);
+ * // => '1,2,3'
+ */
+function toString(value) {
+  return value == null ? '' : baseToString(value);
+}
+
+/**
+ * Deburrs `string` by converting
+ * [Latin-1 Supplement](https://en.wikipedia.org/wiki/Latin-1_Supplement_(Unicode_block)#Character_table)
+ * and [Latin Extended-A](https://en.wikipedia.org/wiki/Latin_Extended-A)
+ * letters to basic Latin letters and removing
+ * [combining diacritical marks](https://en.wikipedia.org/wiki/Combining_Diacritical_Marks).
+ *
+ * @static
+ * @memberOf _
+ * @since 3.0.0
+ * @category String
+ * @param {string} [string=''] The string to deburr.
+ * @returns {string} Returns the deburred string.
+ * @example
+ *
+ * _.deburr('déjà vu');
+ * // => 'deja vu'
+ */
+function deburr(string) {
+  string = toString(string);
+  return string && string.replace(reLatin, deburrLetter).replace(reComboMark, '');
+}
+
+/**
+ * Converts `string` to
+ * [kebab case](https://en.wikipedia.org/wiki/Letter_case#Special_case_styles).
+ *
+ * @static
+ * @memberOf _
+ * @since 3.0.0
+ * @category String
+ * @param {string} [string=''] The string to convert.
+ * @returns {string} Returns the kebab cased string.
+ * @example
+ *
+ * _.kebabCase('Foo Bar');
+ * // => 'foo-bar'
+ *
+ * _.kebabCase('fooBar');
+ * // => 'foo-bar'
+ *
+ * _.kebabCase('__FOO_BAR__');
+ * // => 'foo-bar'
+ */
+var kebabCase$1 = createCompounder(function(result, word, index) {
+  return result + (index ? '-' : '') + word.toLowerCase();
+});
+
+/**
+ * Splits `string` into an array of its words.
+ *
+ * @static
+ * @memberOf _
+ * @since 3.0.0
+ * @category String
+ * @param {string} [string=''] The string to inspect.
+ * @param {RegExp|string} [pattern] The pattern to match words.
+ * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.
+ * @returns {Array} Returns the words of `string`.
+ * @example
+ *
+ * _.words('fred, barney, & pebbles');
+ * // => ['fred', 'barney', 'pebbles']
+ *
+ * _.words('fred, barney, & pebbles', /[^, ]+/g);
+ * // => ['fred', 'barney', '&', 'pebbles']
+ */
+function words(string, pattern, guard) {
+  string = toString(string);
+  pattern = guard ? undefined : pattern;
+
+  if (pattern === undefined) {
+    return hasUnicodeWord(string) ? unicodeWords(string) : asciiWords(string);
+  }
+  return string.match(pattern) || [];
+}
+
+var lodash_kebabcase = kebabCase$1;
+
+var commands = {};
+
+var actions = {};
+
+(function (exports) {
+	var __extends = (commonjsGlobal && commonjsGlobal.__extends) || (function () {
+	    var extendStatics = function (d, b) {
+	        extendStatics = Object.setPrototypeOf ||
+	            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+	            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+	        return extendStatics(d, b);
+	    };
+	    return function (d, b) {
+	        if (typeof b !== "function" && b !== null)
+	            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+	        extendStatics(d, b);
+	        function __() { this.constructor = d; }
+	        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+	    };
+	})();
+	Object.defineProperty(exports, "__esModule", { value: true });
+	exports.DeleteLines = exports.SearchReplace = exports.Search = exports.InvertSelection = exports.GotoLine = exports.RotateCursorOnScreen = exports.InsertTabs = exports.RevealToBottomAction = exports.RevealToCenterAction = exports.RevealToTopAction = exports.RevealEditorAction = exports.YankRotate = exports.YankSelectionToRing = exports.Yank = exports.RedoAction = exports.UndoAction = exports.KeyBoardQuit = exports.MoveCursorTop = exports.MoveCursorBottom = exports.MoveCursorWordLeft = exports.MoveCursorWordRight = exports.MoveCursorToLineStart = exports.MoveCursorToLineEnd = exports.MoveCursorRight = exports.MoveCursorLeft = exports.MoveCursorDown = exports.MoveCursorUp = exports.SetMark = exports.InsertLineAfter = exports.InsertLineBelow = exports.KillLines = exports.KillSelection = exports.BaseAction = exports.SOURCE = void 0;
+	var monaco = require$$0;
+	exports.SOURCE = 'extension.emacs';
+	function moveCursor(editor, hasSelection, direction, unit, repeat) {
+	    if (repeat === void 0) { repeat = 1; }
+	    var action = "cursor".concat(unit === 'word' ? 'Word' : '').concat(direction).concat(hasSelection ? 'Select' : '');
+	    for (var i = 0; i < repeat; i++) {
+	        editor.trigger(exports.SOURCE, action, null);
+	    }
+	}
+	var BaseAction = (function () {
+	    function BaseAction() {
+	        this.description = '';
+	    }
+	    return BaseAction;
+	}());
+	exports.BaseAction = BaseAction;
+	var TriggerAction = (function (_super) {
+	    __extends(TriggerAction, _super);
+	    function TriggerAction(trigger) {
+	        var _this = _super.call(this) || this;
+	        _this.trigger = trigger;
+	        return _this;
+	    }
+	    TriggerAction.prototype.run = function (editor) {
+	        editor.trigger(exports.SOURCE, this.trigger, {});
+	    };
+	    return TriggerAction;
+	}(BaseAction));
+	var KillSelection = (function (_super) {
+	    __extends(KillSelection, _super);
+	    function KillSelection() {
+	        return _super !== null && _super.apply(this, arguments) || this;
+	    }
+	    KillSelection.prototype.run = function (editor, ext, repeat, repeatedTrigger) {
+	        var selections = editor.getSelections();
+	        if (!selections.length) {
+	            return;
+	        }
+	        selections.forEach(function (sel) {
+	            var text = editor.getModel().getValueInRange(sel);
+	            ext.state.addToRing(text);
+	            editor.executeEdits(exports.SOURCE, [{
+	                    range: sel,
+	                    text: '',
+	                }]);
+	        });
+	    };
+	    return KillSelection;
+	}(BaseAction));
+	exports.KillSelection = KillSelection;
+	var KillLines = (function (_super) {
+	    __extends(KillLines, _super);
+	    function KillLines() {
+	        return _super !== null && _super.apply(this, arguments) || this;
+	    }
+	    KillLines.prototype.run = function (editor, ext, repeat, repeatedTrigger) {
+	        ext.selectionMode = false;
+	        var model = editor.getModel();
+	        var pos = ext.getCursorAnchor();
+	        var endPos;
+	        if (repeat === 1) {
+	            var lineLength = model.getLineLength(pos.lineNumber);
+	            var isAtEnd = pos.column === lineLength + 1;
+	            if (!lineLength || isAtEnd) {
+	                if (repeatedTrigger) {
+	                    ext.state.growRingTop(model.getEOL());
+	                }
+	                else {
+	                    ext.state.addToRing(model.getEOL());
+	                }
+	                editor.trigger(exports.SOURCE, 'deleteAllRight', null);
+	                return;
+	            }
+	            else {
+	                endPos = new monaco.Position(pos.lineNumber, model.getLineLength(pos.lineNumber) + 1);
+	            }
+	        }
+	        else {
+	            var totalLines = model.getLineCount();
+	            var endLine = (pos.lineNumber + repeat) > totalLines ? totalLines : (pos.lineNumber + repeat);
+	            endPos = new monaco.Position(endLine, model.getLineLength(endLine) + 1);
+	        }
+	        var range = monaco.Range.fromPositions(pos, endPos);
+	        if (repeatedTrigger) {
+	            ext.state.growRingTop(model.getValueInRange(range));
+	        }
+	        else {
+	            ext.state.addToRing(model.getValueInRange(range));
+	        }
+	        editor.executeEdits(exports.SOURCE, [{
+	                range: range,
+	                text: '',
+	            }]);
+	        editor.setSelection(monaco.Selection.fromPositions(pos, pos));
+	    };
+	    return KillLines;
+	}(BaseAction));
+	exports.KillLines = KillLines;
+	var InsertLineBelow = (function (_super) {
+	    __extends(InsertLineBelow, _super);
+	    function InsertLineBelow() {
+	        return _super !== null && _super.apply(this, arguments) || this;
+	    }
+	    InsertLineBelow.prototype.run = function (editor, ext, repeat, repeatedTrigger) {
+	        var pos = editor.getPosition();
+	        editor.trigger(exports.SOURCE, 'editor.action.insertLineAfter', null);
+	        editor.setPosition(pos);
+	    };
+	    return InsertLineBelow;
+	}(BaseAction));
+	exports.InsertLineBelow = InsertLineBelow;
+	var InsertLineAfter = (function (_super) {
+	    __extends(InsertLineAfter, _super);
+	    function InsertLineAfter() {
+	        return _super !== null && _super.apply(this, arguments) || this;
+	    }
+	    InsertLineAfter.prototype.run = function (editor, ext, repeat, repeatedTrigger) {
+	        var text = '';
+	        for (var i = 0; i < repeat; i++) {
+	            text += editor.getModel().getEOL();
+	        }
+	        ext.selectionMode = false;
+	        var pos = ext.getCursorAnchor();
+	        editor.executeEdits(exports.SOURCE, [{
+	                range: monaco.Range.fromPositions(pos),
+	                text: text,
+	                forceMoveMarkers: true,
+	            }]);
+	    };
+	    return InsertLineAfter;
+	}(BaseAction));
+	exports.InsertLineAfter = InsertLineAfter;
+	var SetMark = (function (_super) {
+	    __extends(SetMark, _super);
+	    function SetMark() {
+	        return _super !== null && _super.apply(this, arguments) || this;
+	    }
+	    SetMark.prototype.run = function (editor, ext, repeat, repeatedTrigger) {
+	        ext.selectionMode;
+	        var sel = editor.getSelection();
+	        var selEmpty = sel.isEmpty();
+	        if (!selEmpty) {
+	            var dir = sel.getDirection();
+	            if (dir === monaco.SelectionDirection.LTR) {
+	                editor.setSelection(monaco.Selection.fromPositions(sel.getEndPosition(), sel.getEndPosition()));
+	            }
+	            else {
+	                editor.setSelection(monaco.Selection.fromPositions(sel.getStartPosition(), sel.getStartPosition()));
+	            }
+	        }
+	        if (selEmpty && ext.selectionMode) {
+	            ext.selectionMode = false;
+	        }
+	        else {
+	            ext.selectionMode = true;
+	        }
+	    };
+	    return SetMark;
+	}(BaseAction));
+	exports.SetMark = SetMark;
+	var MoveCursorAction = (function (_super) {
+	    __extends(MoveCursorAction, _super);
+	    function MoveCursorAction() {
+	        var _this = _super !== null && _super.apply(this, arguments) || this;
+	        _this.unit = 'char';
+	        return _this;
+	    }
+	    MoveCursorAction.prototype.run = function (editor, ext, repeat, repeatedTrigger) {
+	        moveCursor(editor, ext.selectionMode, this.direction, this.unit, repeat);
+	    };
+	    return MoveCursorAction;
+	}(BaseAction));
+	var MoveCursorUp = (function (_super) {
+	    __extends(MoveCursorUp, _super);
+	    function MoveCursorUp() {
+	        var _this = _super !== null && _super.apply(this, arguments) || this;
+	        _this.direction = 'Up';
+	        return _this;
+	    }
+	    return MoveCursorUp;
+	}(MoveCursorAction));
+	exports.MoveCursorUp = MoveCursorUp;
+	var MoveCursorDown = (function (_super) {
+	    __extends(MoveCursorDown, _super);
+	    function MoveCursorDown() {
+	        var _this = _super !== null && _super.apply(this, arguments) || this;
+	        _this.direction = 'Down';
+	        return _this;
+	    }
+	    return MoveCursorDown;
+	}(MoveCursorAction));
+	exports.MoveCursorDown = MoveCursorDown;
+	var MoveCursorLeft = (function (_super) {
+	    __extends(MoveCursorLeft, _super);
+	    function MoveCursorLeft() {
+	        var _this = _super !== null && _super.apply(this, arguments) || this;
+	        _this.direction = 'Left';
+	        return _this;
+	    }
+	    return MoveCursorLeft;
+	}(MoveCursorAction));
+	exports.MoveCursorLeft = MoveCursorLeft;
+	var MoveCursorRight = (function (_super) {
+	    __extends(MoveCursorRight, _super);
+	    function MoveCursorRight() {
+	        var _this = _super !== null && _super.apply(this, arguments) || this;
+	        _this.direction = 'Right';
+	        return _this;
+	    }
+	    return MoveCursorRight;
+	}(MoveCursorAction));
+	exports.MoveCursorRight = MoveCursorRight;
+	var MoveCursorToLineEnd = (function (_super) {
+	    __extends(MoveCursorToLineEnd, _super);
+	    function MoveCursorToLineEnd() {
+	        var _this = _super !== null && _super.apply(this, arguments) || this;
+	        _this.direction = 'End';
+	        return _this;
+	    }
+	    return MoveCursorToLineEnd;
+	}(MoveCursorAction));
+	exports.MoveCursorToLineEnd = MoveCursorToLineEnd;
+	var MoveCursorToLineStart = (function (_super) {
+	    __extends(MoveCursorToLineStart, _super);
+	    function MoveCursorToLineStart() {
+	        var _this = _super !== null && _super.apply(this, arguments) || this;
+	        _this.direction = 'Home';
+	        return _this;
+	    }
+	    return MoveCursorToLineStart;
+	}(MoveCursorAction));
+	exports.MoveCursorToLineStart = MoveCursorToLineStart;
+	var MoveCursorWordRight = (function (_super) {
+	    __extends(MoveCursorWordRight, _super);
+	    function MoveCursorWordRight() {
+	        var _this = _super !== null && _super.apply(this, arguments) || this;
+	        _this.unit = 'word';
+	        return _this;
+	    }
+	    return MoveCursorWordRight;
+	}(MoveCursorRight));
+	exports.MoveCursorWordRight = MoveCursorWordRight;
+	var MoveCursorWordLeft = (function (_super) {
+	    __extends(MoveCursorWordLeft, _super);
+	    function MoveCursorWordLeft() {
+	        var _this = _super !== null && _super.apply(this, arguments) || this;
+	        _this.unit = 'word';
+	        return _this;
+	    }
+	    return MoveCursorWordLeft;
+	}(MoveCursorLeft));
+	exports.MoveCursorWordLeft = MoveCursorWordLeft;
+	var MoveCursorBottom = (function (_super) {
+	    __extends(MoveCursorBottom, _super);
+	    function MoveCursorBottom() {
+	        var _this = _super !== null && _super.apply(this, arguments) || this;
+	        _this.direction = 'Bottom';
+	        return _this;
+	    }
+	    return MoveCursorBottom;
+	}(MoveCursorAction));
+	exports.MoveCursorBottom = MoveCursorBottom;
+	var MoveCursorTop = (function (_super) {
+	    __extends(MoveCursorTop, _super);
+	    function MoveCursorTop() {
+	        var _this = _super !== null && _super.apply(this, arguments) || this;
+	        _this.direction = 'Top';
+	        return _this;
+	    }
+	    return MoveCursorTop;
+	}(MoveCursorAction));
+	exports.MoveCursorTop = MoveCursorTop;
+	var KeyBoardQuit = (function (_super) {
+	    __extends(KeyBoardQuit, _super);
+	    function KeyBoardQuit() {
+	        return _super !== null && _super.apply(this, arguments) || this;
+	    }
+	    KeyBoardQuit.prototype.run = function (editor, ext, repeat, repeatedTrigger) {
+	        ext.selectionMode = false;
+	        ext.clearState();
+	        editor.setPosition(editor.getPosition());
+	    };
+	    return KeyBoardQuit;
+	}(BaseAction));
+	exports.KeyBoardQuit = KeyBoardQuit;
+	var HistoryAction = (function (_super) {
+	    __extends(HistoryAction, _super);
+	    function HistoryAction() {
+	        return _super !== null && _super.apply(this, arguments) || this;
+	    }
+	    HistoryAction.prototype.run = function (editor, ext, repeat, repeatedTrigger) {
+	        for (var i = 0; i < repeat; i++) {
+	            editor.trigger(exports.SOURCE, this.action, null);
+	        }
+	    };
+	    return HistoryAction;
+	}(BaseAction));
+	var UndoAction = (function (_super) {
+	    __extends(UndoAction, _super);
+	    function UndoAction() {
+	        var _this = _super !== null && _super.apply(this, arguments) || this;
+	        _this.action = 'undo';
+	        return _this;
+	    }
+	    return UndoAction;
+	}(HistoryAction));
+	exports.UndoAction = UndoAction;
+	var RedoAction = (function (_super) {
+	    __extends(RedoAction, _super);
+	    function RedoAction() {
+	        var _this = _super !== null && _super.apply(this, arguments) || this;
+	        _this.action = 'redo';
+	        return _this;
+	    }
+	    return RedoAction;
+	}(HistoryAction));
+	exports.RedoAction = RedoAction;
+	var Yank = (function (_super) {
+	    __extends(Yank, _super);
+	    function Yank() {
+	        return _super !== null && _super.apply(this, arguments) || this;
+	    }
+	    Yank.prototype.run = function (editor, ext, repeat, repeatedTrigger) {
+	        var text = ext.state.getFromRing(repeat);
+	        if (!text) {
+	            return;
+	        }
+	        var pos = editor.getPosition();
+	        editor.executeEdits(exports.SOURCE, [{
+	                range: monaco.Range.fromPositions(pos, pos),
+	                text: text,
+	                forceMoveMarkers: true,
+	            }]);
+	    };
+	    return Yank;
+	}(BaseAction));
+	exports.Yank = Yank;
+	var YankSelectionToRing = (function (_super) {
+	    __extends(YankSelectionToRing, _super);
+	    function YankSelectionToRing() {
+	        return _super !== null && _super.apply(this, arguments) || this;
+	    }
+	    YankSelectionToRing.prototype.run = function (editor, ext, repeat, repeatedTrigger) {
+	        var sel = editor.getSelection();
+	        if (sel.isEmpty()) {
+	            return;
+	        }
+	        ext.state.addToRing(editor.getModel().getValueInRange(sel));
+	        ext.selectionMode = false;
+	        var pos = ext.getCursorAnchor();
+	        editor.setSelection(monaco.Selection.fromPositions(pos, pos));
+	    };
+	    return YankSelectionToRing;
+	}(BaseAction));
+	exports.YankSelectionToRing = YankSelectionToRing;
+	var YankRotate = (function (_super) {
+	    __extends(YankRotate, _super);
+	    function YankRotate() {
+	        return _super !== null && _super.apply(this, arguments) || this;
+	    }
+	    YankRotate.prototype.run = function (editor, ext, repeat, repeatedTrigger) {
+	        var text = ext.state.popFromRing();
+	        if (!text) {
+	            return;
+	        }
+	        var pos = ext.getCursorAnchor();
+	        editor.executeEdits(exports.SOURCE, [{
+	                range: monaco.Range.fromPositions(pos),
+	                text: text,
+	                forceMoveMarkers: true,
+	            }]);
+	    };
+	    return YankRotate;
+	}(BaseAction));
+	exports.YankRotate = YankRotate;
+	var RevealEditorAction = (function (_super) {
+	    __extends(RevealEditorAction, _super);
+	    function RevealEditorAction() {
+	        return _super !== null && _super.apply(this, arguments) || this;
+	    }
+	    RevealEditorAction.prototype.run = function (editor, ext, repeat, repeatedTrigger) {
+	        var sel = editor.getSelection();
+	        if (this.revealFunction === 'up') {
+	            editor.trigger(exports.SOURCE, 'scrollPageUp', null);
+	        }
+	        else {
+	            editor[this.revealFunction](sel);
+	        }
+	    };
+	    return RevealEditorAction;
+	}(BaseAction));
+	exports.RevealEditorAction = RevealEditorAction;
+	var RevealToTopAction = (function (_super) {
+	    __extends(RevealToTopAction, _super);
+	    function RevealToTopAction() {
+	        var _this = _super !== null && _super.apply(this, arguments) || this;
+	        _this.revealFunction = 'revealRangeAtTop';
+	        return _this;
+	    }
+	    return RevealToTopAction;
+	}(RevealEditorAction));
+	exports.RevealToTopAction = RevealToTopAction;
+	var RevealToCenterAction = (function (_super) {
+	    __extends(RevealToCenterAction, _super);
+	    function RevealToCenterAction() {
+	        var _this = _super !== null && _super.apply(this, arguments) || this;
+	        _this.revealFunction = 'revealRangeInCenter';
+	        return _this;
+	    }
+	    return RevealToCenterAction;
+	}(RevealEditorAction));
+	exports.RevealToCenterAction = RevealToCenterAction;
+	var RevealToBottomAction = (function (_super) {
+	    __extends(RevealToBottomAction, _super);
+	    function RevealToBottomAction() {
+	        var _this = _super !== null && _super.apply(this, arguments) || this;
+	        _this.revealFunction = 'up';
+	        return _this;
+	    }
+	    return RevealToBottomAction;
+	}(RevealEditorAction));
+	exports.RevealToBottomAction = RevealToBottomAction;
+	var InsertTabs = (function (_super) {
+	    __extends(InsertTabs, _super);
+	    function InsertTabs() {
+	        return _super !== null && _super.apply(this, arguments) || this;
+	    }
+	    InsertTabs.prototype.run = function (editor, ext, repeat, repeatedTrigger) {
+	        var model = editor.getModel();
+	        var _a = model.getOptions(), tabSize = _a.tabSize, insertSpaces = _a.insertSpaces;
+	        var text = '';
+	        for (var i = 0; i < repeat; i++) {
+	            var spaces = '';
+	            for (var j = 0; j < tabSize; j++) {
+	                spaces += ' ';
+	            }
+	            text += (insertSpaces ? spaces : '\t');
+	        }
+	        editor.executeEdits(exports.SOURCE, [{
+	                range: editor.getSelection(),
+	                text: text,
+	                forceMoveMarkers: true,
+	            }]);
+	    };
+	    return InsertTabs;
+	}(BaseAction));
+	exports.InsertTabs = InsertTabs;
+	var RotateCursorOnScreen = (function (_super) {
+	    __extends(RotateCursorOnScreen, _super);
+	    function RotateCursorOnScreen() {
+	        return _super !== null && _super.apply(this, arguments) || this;
+	    }
+	    RotateCursorOnScreen.prototype.run = function (editor, ext, repeat, repeatedTrigger) {
+	        var ranges = editor.getVisibleRanges();
+	        if (!ranges.length) {
+	            return;
+	        }
+	        var lineMapping = [];
+	        for (var i = 0; i < ranges.length; i++) {
+	            var range = ranges[i];
+	            for (var j = range.startLineNumber; j <= range.endLineNumber; j++) {
+	                lineMapping.push(j);
+	            }
+	        }
+	        var pos = editor.getPosition();
+	        var expectedCenter = Math.ceil(lineMapping.length / 2);
+	        var toMovePos;
+	        if (pos.lineNumber === lineMapping[expectedCenter]) {
+	            toMovePos = new monaco.Position(lineMapping[0], 1);
+	        }
+	        else if (pos.lineNumber === lineMapping[0]) {
+	            toMovePos = new monaco.Position(lineMapping[lineMapping.length - 1], 1);
+	        }
+	        else {
+	            toMovePos = new monaco.Position(lineMapping[expectedCenter], 1);
+	        }
+	        editor.setPosition(toMovePos);
+	    };
+	    return RotateCursorOnScreen;
+	}(BaseAction));
+	exports.RotateCursorOnScreen = RotateCursorOnScreen;
+	var GotoLine = (function (_super) {
+	    __extends(GotoLine, _super);
+	    function GotoLine() {
+	        return _super !== null && _super.apply(this, arguments) || this;
+	    }
+	    GotoLine.prototype.run = function (editor, ext, repeat, repeatedTrigger) {
+	        ext.getBasicInput('Goto Line: ').then(function (val) {
+	            var line = parseInt(val) || 0;
+	            var model = editor.getModel();
+	            var totalLines = model.getLineCount();
+	            editor.focus();
+	            if (!line) {
+	                line = 1;
+	            }
+	            else if (line > totalLines) {
+	                line = totalLines;
+	            }
+	            var pos = new monaco.Position(line, 1);
+	            var range;
+	            if (!ext.selectionMode) {
+	                range = monaco.Selection.fromPositions(pos);
+	            }
+	            else {
+	                var sel = editor.getSelection();
+	                if (sel.getDirection() === monaco.SelectionDirection.LTR) {
+	                    range = monaco.Selection.fromPositions(sel.getStartPosition(), pos);
+	                }
+	                else {
+	                    range = monaco.Selection.fromPositions(sel.getEndPosition(), pos);
+	                }
+	            }
+	            editor.setSelection(range);
+	            editor.revealRangeInCenter(range);
+	        }).catch(function () {
+	            editor.focus();
+	        });
+	    };
+	    return GotoLine;
+	}(BaseAction));
+	exports.GotoLine = GotoLine;
+	var InvertSelection = (function (_super) {
+	    __extends(InvertSelection, _super);
+	    function InvertSelection() {
+	        return _super !== null && _super.apply(this, arguments) || this;
+	    }
+	    InvertSelection.prototype.run = function (editor, ext, repeat, repeatedTrigger) {
+	        var sel = editor.getSelection();
+	        if (sel.isEmpty()) {
+	            return;
+	        }
+	        var newSel;
+	        if (sel.getDirection() === monaco.SelectionDirection.LTR) {
+	            newSel = monaco.Selection.fromPositions(sel.getEndPosition(), sel.getStartPosition());
+	        }
+	        else {
+	            newSel = monaco.Selection.fromPositions(sel.getStartPosition(), sel.getEndPosition());
+	        }
+	        editor.setSelection(newSel);
+	    };
+	    return InvertSelection;
+	}(BaseAction));
+	exports.InvertSelection = InvertSelection;
+	var Search = (function (_super) {
+	    __extends(Search, _super);
+	    function Search() {
+	        return _super.call(this, 'editor.actions.findWithArgs') || this;
+	    }
+	    return Search;
+	}(TriggerAction));
+	exports.Search = Search;
+	var SearchReplace = (function (_super) {
+	    __extends(SearchReplace, _super);
+	    function SearchReplace() {
+	        return _super.call(this, 'editor.action.startFindReplaceAction') || this;
+	    }
+	    return SearchReplace;
+	}(TriggerAction));
+	exports.SearchReplace = SearchReplace;
+	var DeleteLines = (function (_super) {
+	    __extends(DeleteLines, _super);
+	    function DeleteLines() {
+	        return _super !== null && _super.apply(this, arguments) || this;
+	    }
+	    DeleteLines.prototype.run = function (editor, ext, repeat, repeatedTrigger) {
+	        ext.selectionMode = false;
+	        for (var i = 0; i < repeat; i++) {
+	            editor.trigger(exports.SOURCE, 'editor.action.deleteLines', null);
+	        }
+	    };
+	    return DeleteLines;
+	}(BaseAction));
+	exports.DeleteLines = DeleteLines;
+} (actions));
+
+(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));
+
+var util = {};
+
+(function (exports) {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	exports.Emitter = exports.Event = exports.monacoToEmacsKey = exports.modifierKeys = void 0;
+	var monaco = require$$0;
+	exports.modifierKeys = {
+	    Alt: 'M',
+	    Control: 'C',
+	    Ctrl: 'C',
+	    Meta: 'CMD',
+	    Shift: 'S',
+	};
+	var specialKeys = {
+	    Enter: 'Return',
+	    Space: 'SPC',
+	    Backslash: '\\',
+	    Slash: '/',
+	    Backquote: '`',
+	    BracketRight: ']',
+	    BracketLeft: '[',
+	    Comma: ',',
+	    Period: '.',
+	    Equal: '=',
+	    Minus: '-',
+	    Quote: '\'',
+	    Semicolon: ';',
+	};
+	var oneCharKeyPrefixes = ['Key', 'Numpad'];
+	var arrowSuffix = 'Arrow';
+	function monacoToEmacsKey(ev) {
+	    var keyName = monaco.KeyCode[ev.keyCode];
+	    if (exports.modifierKeys[keyName]) {
+	        return '';
+	    }
+	    var key = oneCharKeyPrefixes.some(function (prefix) { return keyName.startsWith(prefix); }) ? keyName[keyName.length - 1] : keyName;
+	    if (keyName.endsWith(arrowSuffix)) {
+	        key = keyName.substring(0, keyName.length - arrowSuffix.length);
+	    }
+	    else if (specialKeys[keyName]) {
+	        key = specialKeys[key];
+	    }
+	    if (key.length === 1) {
+	        key = key.toLowerCase();
+	    }
+	    if (ev.altKey) {
+	        key = "".concat(exports.modifierKeys.Alt, "-").concat(key);
+	    }
+	    if (ev.ctrlKey) {
+	        key = "".concat(exports.modifierKeys.Ctrl, "-").concat(key);
+	    }
+	    if (ev.metaKey) {
+	        key = "".concat(exports.modifierKeys.Meta, "-").concat(key);
+	    }
+	    if (ev.shiftKey) {
+	        key = "".concat(exports.modifierKeys.Shift, "-").concat(key);
+	    }
+	    return key;
+	}
+	exports.monacoToEmacsKey = monacoToEmacsKey;
+	(function (Event) {
+	    var _disposable = { dispose: function () { } };
+	    Event.None = function () { return _disposable; };
+	})(exports.Event || (exports.Event = {}));
+	var Emitter = (function () {
+	    function Emitter() {
+	        this._listeners = [];
+	    }
+	    Object.defineProperty(Emitter.prototype, "event", {
+	        get: function () {
+	            var _this = this;
+	            if (!this._event) {
+	                this._event = function (listener) {
+	                    _this._listeners.push(listener);
+	                    var result = {
+	                        dispose: function () {
+	                            if (_this._disposed) {
+	                                return;
+	                            }
+	                            var index = _this._listeners.indexOf(listener);
+	                            if (index < 0) {
+	                                return;
+	                            }
+	                            _this._listeners.splice(index, 1);
+	                        }
+	                    };
+	                    return result;
+	                };
+	            }
+	            return this._event;
+	        },
+	        enumerable: false,
+	        configurable: true
+	    });
+	    Emitter.prototype.fire = function (ev) {
+	        if (!this._listeners.length) {
+	            return;
+	        }
+	        this._listeners.forEach(function (l) { return l(ev); });
+	    };
+	    Emitter.prototype.dispose = function () {
+	        if (this._disposed) {
+	            return;
+	        }
+	        this._listeners = undefined;
+	        this._disposed = true;
+	    };
+	    return Emitter;
+	}());
+	exports.Emitter = Emitter;
+} (util));
+
+var basicInput = {};
+
+Object.defineProperty(basicInput, "__esModule", { value: true });
+basicInput.BasicInputWidget = void 0;
+var monaco$1 = 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$1.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;
+
+var state = {};
+
+(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));
+
+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;
+
+(function (exports) {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	exports.Actions = exports.EmacsExtension = exports.unregisterKey = exports.getAllMappings = exports.registerGlobalCommand = void 0;
+	var emacs_1 = emacs;
+	Object.defineProperty(exports, "EmacsExtension", { enumerable: true, get: function () { return emacs_1.EmacsExtension; } });
+	var commands_1 = commands;
+	Object.defineProperty(exports, "registerGlobalCommand", { enumerable: true, get: function () { return commands_1.registerGlobalCommand; } });
+	Object.defineProperty(exports, "getAllMappings", { enumerable: true, get: function () { return commands_1.getAllMappings; } });
+	Object.defineProperty(exports, "unregisterKey", { enumerable: true, get: function () { return commands_1.unregisterKey; } });
+	var Actions = actions;
+	exports.Actions = Actions;
+	exports.default = emacs_1.EmacsExtension;
+} (lib));
+
+var index = /*@__PURE__*/getDefaultExportFromCjs(lib);
+
+var index$1 = /*#__PURE__*/_mergeNamespaces({
+  __proto__: null,
+  default: index
+}, [lib]);
+
+export { index$1 as i };