@difizen/libro-common 0.3.4 → 1.0.0

package/es/core/keybinding/vs/contextKeyService.js

@@ -0,0 +1,755 @@
+var _dec, _class, _descriptor, _NullContext, _dec2, _class2, _dec3, _class3;
+function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
+function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread(); }
+function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+function _iterableToArray(iter) { if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter); }
+function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) return _arrayLikeToArray(arr); }
+function _createForOfIteratorHelper(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it.return != null) it.return(); } finally { if (didErr) throw err; } } }; }
+function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }
+function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; return arr2; }
+function _iterableToArrayLimit(r, l) { var t = null == r ? null : "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (null != t) { var e, n, i, u, a = [], f = !0, o = !1; try { if (i = (t = t.call(r)).next, 0 === l) { if (Object(t) !== t) return; f = !1; } else for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = !0); } catch (r) { o = !0, n = r; } finally { try { if (!f && null != t.return && (u = t.return(), Object(u) !== u)) return; } finally { if (o) throw n; } } return a; } }
+function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
+function _get() { if (typeof Reflect !== "undefined" && Reflect.get) { _get = Reflect.get.bind(); } else { _get = function _get(target, property, receiver) { var base = _superPropBase(target, property); if (!base) return; var desc = Object.getOwnPropertyDescriptor(base, property); if (desc.get) { return desc.get.call(arguments.length < 3 ? target : receiver); } return desc.value; }; } return _get.apply(this, arguments); }
+function _superPropBase(object, property) { while (!Object.prototype.hasOwnProperty.call(object, property)) { object = _getPrototypeOf(object); if (object === null) break; } return object; }
+function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); Object.defineProperty(subClass, "prototype", { writable: false }); if (superClass) _setPrototypeOf(subClass, superClass); }
+function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
+function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
+function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } else if (call !== void 0) { throw new TypeError("Derived constructors may only return object or undefined"); } return _assertThisInitialized(self); }
+function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
+function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
+function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _initializerDefineProperty(target, property, descriptor, context) { if (!descriptor) return; Object.defineProperty(target, property, { enumerable: descriptor.enumerable, configurable: descriptor.configurable, writable: descriptor.writable, value: descriptor.initializer ? descriptor.initializer.call(context) : void 0 }); }
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, _toPropertyKey(descriptor.key), descriptor); } }
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : String(i); }
+function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+function _applyDecoratedDescriptor(target, property, decorators, descriptor, context) { var desc = {}; Object.keys(descriptor).forEach(function (key) { desc[key] = descriptor[key]; }); desc.enumerable = !!desc.enumerable; desc.configurable = !!desc.configurable; if ('value' in desc || desc.initializer) { desc.writable = true; } desc = decorators.slice().reverse().reduce(function (desc, decorator) { return decorator(target, property, desc) || desc; }, desc); if (context && desc.initializer !== void 0) { desc.value = desc.initializer ? desc.initializer.call(context) : void 0; desc.initializer = undefined; } if (desc.initializer === void 0) { Object.defineProperty(target, property, desc); desc = null; } return desc; }
+function _initializerWarningHelper(descriptor, context) { throw new Error('Decorating class property failed. Please ensure that ' + 'transform-class-properties is enabled and runs after the decorators transform.'); }
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { Iterable } from "../../../common/index.js";
+import { PauseableEmitter } from "../../../common/index.js";
+import { objects } from "../../../common/index.js";
+import { prop } from "../../../observable/index.js";
+import { inject, injectable, singleton } from "../../../ioc/index.js";
+import { DisposableStore, MutableDisposable } from "../../utils";
+import { TernarySearchTree } from "../../utils/map";
+import { ConfigurationTarget, IConfigurationService } from "./configuration/configuration";
+import { SET_CONTEXT_COMMAND_ID, RawContextKey, IContextKeyService } from "./contextkey";
+var KEYBINDING_CONTEXT_ATTR = 'data-mana-keybinding-context';
+export var Context = (_dec = prop(), (_class = /*#__PURE__*/function () {
+  function Context(id, parent) {
+    _classCallCheck(this, Context);
+    _initializerDefineProperty(this, "_value", _descriptor, this);
+    this._id = id;
+    this._parent = parent;
+    this._value = Object.create(null);
+    this._value['_contextId'] = id;
+  }
+  _createClass(Context, [{
+    key: "setValue",
+    value: function setValue(key, value) {
+      if (this._value[key] !== value) {
+        this._value[key] = value;
+        return true;
+      }
+      return false;
+    }
+  }, {
+    key: "removeValue",
+    value: function removeValue(key) {
+      if (key in this._value) {
+        delete this._value[key];
+        return true;
+      }
+      return false;
+    }
+  }, {
+    key: "getValue",
+    value: function getValue(key) {
+      var ret = this._value[key];
+      if (typeof ret === 'undefined' && this._parent) {
+        return this._parent.getValue(key);
+      }
+      return ret;
+    }
+  }, {
+    key: "updateParent",
+    value: function updateParent(parent) {
+      this._parent = parent;
+    }
+  }, {
+    key: "collectAllValues",
+    value: function collectAllValues() {
+      var result = this._parent ? this._parent.collectAllValues() : Object.create(null);
+      result = _objectSpread(_objectSpread({}, result), this._value);
+      delete result._contextId;
+      return result;
+    }
+  }]);
+  return Context;
+}(), (_descriptor = _applyDecoratedDescriptor(_class.prototype, "_value", [_dec], {
+  configurable: true,
+  enumerable: true,
+  writable: true,
+  initializer: null
+})), _class));
+var NullContext = /*#__PURE__*/function (_Context2) {
+  _inherits(NullContext, _Context2);
+  var _super = _createSuper(NullContext);
+  function NullContext() {
+    _classCallCheck(this, NullContext);
+    return _super.call(this, -1, null);
+  }
+  _createClass(NullContext, [{
+    key: "setValue",
+    value: function setValue(_key, _value) {
+      return false;
+    }
+  }, {
+    key: "removeValue",
+    value: function removeValue(_key) {
+      return false;
+    }
+  }, {
+    key: "getValue",
+    value: function getValue(_key) {
+      return undefined;
+    }
+  }, {
+    key: "collectAllValues",
+    value: function collectAllValues() {
+      return Object.create(null);
+    }
+  }]);
+  return NullContext;
+}(Context);
+_NullContext = NullContext;
+NullContext.INSTANCE = new _NullContext();
+var ConfigAwareContextValuesContainer = /*#__PURE__*/function (_Context3) {
+  _inherits(ConfigAwareContextValuesContainer, _Context3);
+  var _super2 = _createSuper(ConfigAwareContextValuesContainer);
+  function ConfigAwareContextValuesContainer(id, _configurationService, emitter) {
+    var _this;
+    _classCallCheck(this, ConfigAwareContextValuesContainer);
+    _this = _super2.call(this, id, null);
+    _this._values = TernarySearchTree.forConfigKeys();
+    _this._configurationService = _configurationService;
+    _this._listener = _this._configurationService.onDidChangeConfiguration(function (event) {
+      if (event.source === ConfigurationTarget.DEFAULT) {
+        // new setting, reset everything
+        var allKeys = Array.from(Iterable.map(_this._values, function (_ref) {
+          var _ref2 = _slicedToArray(_ref, 1),
+            k = _ref2[0];
+          return k;
+        }));
+        _this._values.clear();
+        emitter.fire(new ArrayContextKeyChangeEvent(allKeys));
+      } else {
+        var changedKeys = [];
+        var _iterator = _createForOfIteratorHelper(event.affectedKeys),
+          _step;
+        try {
+          for (_iterator.s(); !(_step = _iterator.n()).done;) {
+            var configKey = _step.value;
+            var contextKey = "config.".concat(configKey);
+            var cachedItems = _this._values.findSuperstr(contextKey);
+            if (cachedItems !== undefined) {
+              changedKeys.push.apply(changedKeys, _toConsumableArray(Iterable.map(cachedItems, function (_ref3) {
+                var _ref4 = _slicedToArray(_ref3, 1),
+                  key = _ref4[0];
+                return key;
+              })));
+              _this._values.deleteSuperstr(contextKey);
+            }
+            if (_this._values.has(contextKey)) {
+              changedKeys.push(contextKey);
+              _this._values.delete(contextKey);
+            }
+          }
+        } catch (err) {
+          _iterator.e(err);
+        } finally {
+          _iterator.f();
+        }
+        emitter.fire(new ArrayContextKeyChangeEvent(changedKeys));
+      }
+    });
+    return _this;
+  }
+  _createClass(ConfigAwareContextValuesContainer, [{
+    key: "dispose",
+    value: function dispose() {
+      this._listener.dispose();
+    }
+  }, {
+    key: "getValue",
+    value: function getValue(key) {
+      if (key.indexOf(ConfigAwareContextValuesContainer._keyPrefix) !== 0) {
+        return _get(_getPrototypeOf(ConfigAwareContextValuesContainer.prototype), "getValue", this).call(this, key);
+      }
+      if (this._values.has(key)) {
+        return this._values.get(key);
+      }
+      var configKey = key.substr(ConfigAwareContextValuesContainer._keyPrefix.length);
+      var configValue = this._configurationService.getValue(configKey);
+      var value;
+      switch (_typeof(configValue)) {
+        case 'number':
+        case 'boolean':
+        case 'string':
+          value = configValue;
+          break;
+        default:
+          if (Array.isArray(configValue)) {
+            value = JSON.stringify(configValue);
+          } else {
+            value = configValue;
+          }
+      }
+      this._values.set(key, value);
+      return value;
+    }
+  }, {
+    key: "setValue",
+    value: function setValue(key, value) {
+      return _get(_getPrototypeOf(ConfigAwareContextValuesContainer.prototype), "setValue", this).call(this, key, value);
+    }
+  }, {
+    key: "removeValue",
+    value: function removeValue(key) {
+      return _get(_getPrototypeOf(ConfigAwareContextValuesContainer.prototype), "removeValue", this).call(this, key);
+    }
+  }, {
+    key: "collectAllValues",
+    value: function collectAllValues() {
+      var result = Object.create(null);
+      this._values.forEach(function (value, index) {
+        return result[index] = value;
+      });
+      return _objectSpread(_objectSpread({}, result), _get(_getPrototypeOf(ConfigAwareContextValuesContainer.prototype), "collectAllValues", this).call(this));
+    }
+  }]);
+  return ConfigAwareContextValuesContainer;
+}(Context);
+ConfigAwareContextValuesContainer._keyPrefix = 'config.';
+var ContextKey = /*#__PURE__*/function () {
+  function ContextKey(service, key, defaultValue) {
+    _classCallCheck(this, ContextKey);
+    this._service = service;
+    this._key = key;
+    this._defaultValue = defaultValue;
+    this.reset();
+  }
+  _createClass(ContextKey, [{
+    key: "set",
+    value: function set(value) {
+      this._service.setContext(this._key, value);
+    }
+  }, {
+    key: "reset",
+    value: function reset() {
+      if (typeof this._defaultValue === 'undefined') {
+        this._service.removeContext(this._key);
+      } else {
+        this._service.setContext(this._key, this._defaultValue);
+      }
+    }
+  }, {
+    key: "get",
+    value: function get() {
+      return this._service.getContextKeyValue(this._key);
+    }
+  }]);
+  return ContextKey;
+}();
+var SimpleContextKeyChangeEvent = /*#__PURE__*/function () {
+  function SimpleContextKeyChangeEvent(key) {
+    _classCallCheck(this, SimpleContextKeyChangeEvent);
+    this.key = key;
+  }
+  _createClass(SimpleContextKeyChangeEvent, [{
+    key: "affectsSome",
+    value: function affectsSome(keys) {
+      return keys.has(this.key);
+    }
+  }]);
+  return SimpleContextKeyChangeEvent;
+}();
+var ArrayContextKeyChangeEvent = /*#__PURE__*/function () {
+  function ArrayContextKeyChangeEvent(keys) {
+    _classCallCheck(this, ArrayContextKeyChangeEvent);
+    this.keys = keys;
+  }
+  _createClass(ArrayContextKeyChangeEvent, [{
+    key: "affectsSome",
+    value: function affectsSome(keys) {
+      var _iterator2 = _createForOfIteratorHelper(this.keys),
+        _step2;
+      try {
+        for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+          var key = _step2.value;
+          if (keys.has(key)) {
+            return true;
+          }
+        }
+      } catch (err) {
+        _iterator2.e(err);
+      } finally {
+        _iterator2.f();
+      }
+      return false;
+    }
+  }]);
+  return ArrayContextKeyChangeEvent;
+}();
+var CompositeContextKeyChangeEvent = /*#__PURE__*/function () {
+  function CompositeContextKeyChangeEvent(events) {
+    _classCallCheck(this, CompositeContextKeyChangeEvent);
+    this.events = events;
+  }
+  _createClass(CompositeContextKeyChangeEvent, [{
+    key: "affectsSome",
+    value: function affectsSome(keys) {
+      var _iterator3 = _createForOfIteratorHelper(this.events),
+        _step3;
+      try {
+        for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
+          var e = _step3.value;
+          if (e.affectsSome(keys)) {
+            return true;
+          }
+        }
+      } catch (err) {
+        _iterator3.e(err);
+      } finally {
+        _iterator3.f();
+      }
+      return false;
+    }
+  }]);
+  return CompositeContextKeyChangeEvent;
+}();
+export var AbstractContextKeyService = (_dec2 = injectable(), _dec2(_class2 = /*#__PURE__*/function () {
+  function AbstractContextKeyService(myContextId) {
+    _classCallCheck(this, AbstractContextKeyService);
+    this._onDidChangeContext = new PauseableEmitter({
+      merge: function merge(input) {
+        return new CompositeContextKeyChangeEvent(input);
+      }
+    });
+    this.onDidChangeContext = this._onDidChangeContext.event;
+    this._isDisposed = false;
+    this._myContextId = myContextId;
+  }
+  _createClass(AbstractContextKeyService, [{
+    key: "contextId",
+    get: function get() {
+      return this._myContextId;
+    }
+  }, {
+    key: "createKey",
+    value: function createKey(key, defaultValue) {
+      if (this._isDisposed) {
+        throw new Error("AbstractContextKeyService has been disposed");
+      }
+      return new ContextKey(this, key, defaultValue);
+    }
+  }, {
+    key: "bufferChangeEvents",
+    value: function bufferChangeEvents(callback) {
+      this._onDidChangeContext.pause();
+      try {
+        callback();
+      } finally {
+        this._onDidChangeContext.resume();
+      }
+    }
+  }, {
+    key: "createScoped",
+    value: function createScoped(domNode) {
+      if (this._isDisposed) {
+        throw new Error("AbstractContextKeyService has been disposed");
+      }
+      return new ScopedContextKeyService(this, domNode);
+    }
+  }, {
+    key: "createOverlay",
+    value: function createOverlay() {
+      var overlay = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : Iterable.empty();
+      if (this._isDisposed) {
+        throw new Error("AbstractContextKeyService has been disposed");
+      }
+      return new OverlayContextKeyService(this, overlay);
+    }
+  }, {
+    key: "contextMatchesRules",
+    value: function contextMatchesRules(rules) {
+      if (this._isDisposed) {
+        throw new Error("AbstractContextKeyService has been disposed");
+      }
+      var context = this.getContextValuesContainer(this._myContextId);
+      if (!rules) {
+        return true;
+      }
+      return rules.evaluate(context);
+      // console.group(rules.serialize() + ' -> ' + result);
+      // rules.keys().forEach(key => { console.log(key, ctx[key]); });
+      // console.groupEnd();
+      // return result;
+    }
+  }, {
+    key: "getContextKeyValue",
+    value: function getContextKeyValue(key) {
+      if (this._isDisposed) {
+        return undefined;
+      }
+      return this.getContextValuesContainer(this._myContextId).getValue(key);
+    }
+  }, {
+    key: "setContext",
+    value: function setContext(key, value) {
+      if (this._isDisposed) {
+        return;
+      }
+      var myContext = this.getContextValuesContainer(this._myContextId);
+      if (!myContext) {
+        return;
+      }
+      if (myContext.setValue(key, value)) {
+        this._onDidChangeContext.fire(new SimpleContextKeyChangeEvent(key));
+      }
+    }
+  }, {
+    key: "removeContext",
+    value: function removeContext(key) {
+      if (this._isDisposed) {
+        return;
+      }
+      if (this.getContextValuesContainer(this._myContextId).removeValue(key)) {
+        this._onDidChangeContext.fire(new SimpleContextKeyChangeEvent(key));
+      }
+    }
+  }, {
+    key: "getContext",
+    value: function getContext(target) {
+      if (this._isDisposed) {
+        return NullContext.INSTANCE;
+      }
+      return this.getContextValuesContainer(findContextAttr(target));
+    }
+  }]);
+  return AbstractContextKeyService;
+}()) || _class2);
+export var VSContextKeyService = (_dec3 = singleton({
+  contrib: IContextKeyService
+}), _dec3(_class3 = /*#__PURE__*/function (_AbstractContextKeySe) {
+  _inherits(VSContextKeyService, _AbstractContextKeySe);
+  var _super3 = _createSuper(VSContextKeyService);
+  function VSContextKeyService(configurationService) {
+    var _this2;
+    _classCallCheck(this, VSContextKeyService);
+    _this2 = _super3.call(this, 0);
+    _this2._contexts = new Map();
+    _this2._toDispose = new DisposableStore();
+    _this2.configurationService = configurationService;
+    _this2._lastContextId = 0;
+    var myContext = new ConfigAwareContextValuesContainer(_this2._myContextId, configurationService, _this2._onDidChangeContext);
+    _this2._contexts.set(_this2._myContextId, myContext);
+    _this2._toDispose.add(myContext);
+
+    // Uncomment this to see the contexts continuously logged
+    // let lastLoggedValue: string | null = null;
+    // setInterval(() => {
+    // 	let values = Object.keys(this._contexts).map((key) => this._contexts[key]);
+    // 	let logValue = values.map(v => JSON.stringify(v._value, null, '\t')).join('\n');
+    // 	if (lastLoggedValue !== logValue) {
+    // 		lastLoggedValue = logValue;
+    // 		console.log(lastLoggedValue);
+    // 	}
+    // }, 2000);
+    return _this2;
+  }
+  VSContextKeyService = inject(IConfigurationService)(VSContextKeyService, undefined, 0) || VSContextKeyService;
+  _createClass(VSContextKeyService, [{
+    key: "registerCommands",
+    value: function registerCommands(commands) {
+      var _this3 = this;
+      commands.registerCommand({
+        id: SET_CONTEXT_COMMAND_ID
+      }, {
+        execute: function execute(contextKey, contextValue) {
+          _this3.createKey(String(contextKey), contextValue);
+        }
+      });
+      commands.registerCommand({
+        id: 'getContextKeyInfo',
+        label: 'getContextKeyInfo, A command that returns information about context keys'
+      }, {
+        execute: function execute() {
+          return _toConsumableArray(RawContextKey.all()).sort(function (a, b) {
+            return a.key.localeCompare(b.key);
+          });
+        }
+      });
+      commands.registerCommand({
+        id: '_generateContextKeyInfo'
+      }, {
+        execute: function execute() {
+          var result = [];
+          var seen = new Set();
+          var _iterator4 = _createForOfIteratorHelper(RawContextKey.all()),
+            _step4;
+          try {
+            for (_iterator4.s(); !(_step4 = _iterator4.n()).done;) {
+              var info = _step4.value;
+              if (!seen.has(info.key)) {
+                seen.add(info.key);
+                result.push(info);
+              }
+            }
+          } catch (err) {
+            _iterator4.e(err);
+          } finally {
+            _iterator4.f();
+          }
+          result.sort(function (a, b) {
+            return a.key.localeCompare(b.key);
+          });
+        }
+      });
+    }
+  }, {
+    key: "dispose",
+    value: function dispose() {
+      this._onDidChangeContext.dispose();
+      this._isDisposed = true;
+      this._toDispose.dispose();
+    }
+  }, {
+    key: "getContextValuesContainer",
+    value: function getContextValuesContainer(contextId) {
+      if (this._isDisposed) {
+        return NullContext.INSTANCE;
+      }
+      return this._contexts.get(contextId) || NullContext.INSTANCE;
+    }
+  }, {
+    key: "createChildContext",
+    value: function createChildContext() {
+      var parentContextId = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : this._myContextId;
+      if (this._isDisposed) {
+        throw new Error("ContextKeyService has been disposed");
+      }
+      var id = ++this._lastContextId;
+      this._contexts.set(id, new Context(id, this.getContextValuesContainer(parentContextId)));
+      return id;
+    }
+  }, {
+    key: "disposeContext",
+    value: function disposeContext(contextId) {
+      if (!this._isDisposed) {
+        this._contexts.delete(contextId);
+      }
+    }
+  }, {
+    key: "updateParent",
+    value: function updateParent(_parentContextKeyService) {
+      throw new Error('Cannot update parent of root ContextKeyService');
+    }
+  }]);
+  return VSContextKeyService;
+}(AbstractContextKeyService)) || _class3);
+var ScopedContextKeyService = /*#__PURE__*/function (_AbstractContextKeySe2) {
+  _inherits(ScopedContextKeyService, _AbstractContextKeySe2);
+  var _super4 = _createSuper(ScopedContextKeyService);
+  function ScopedContextKeyService(parent, domNode) {
+    var _this4;
+    _classCallCheck(this, ScopedContextKeyService);
+    _this4 = _super4.call(this, parent.createChildContext());
+    _this4._parentChangeListener = new MutableDisposable();
+    _this4._parent = parent;
+    _this4._updateParentChangeListener();
+    _this4._domNode = domNode;
+    if (_this4._domNode.hasAttribute(KEYBINDING_CONTEXT_ATTR)) {
+      var extraInfo = '';
+      if (_this4._domNode.classList) {
+        extraInfo = Array.from(_this4._domNode.classList.values()).join(', ');
+      }
+      console.error("Element already has context attribute".concat(extraInfo ? ": ".concat(extraInfo) : ''));
+    }
+    _this4._domNode.setAttribute(KEYBINDING_CONTEXT_ATTR, String(_this4._myContextId));
+    return _this4;
+  }
+  _createClass(ScopedContextKeyService, [{
+    key: "_updateParentChangeListener",
+    value: function _updateParentChangeListener() {
+      // Forward parent events to this listener. Parent will change.
+      this._parentChangeListener.value = this._parent.onDidChangeContext(this._onDidChangeContext.fire, this._onDidChangeContext);
+    }
+  }, {
+    key: "dispose",
+    value: function dispose() {
+      if (this._isDisposed) {
+        return;
+      }
+      this._onDidChangeContext.dispose();
+      this._parent.disposeContext(this._myContextId);
+      this._parentChangeListener.dispose();
+      this._domNode.removeAttribute(KEYBINDING_CONTEXT_ATTR);
+      this._isDisposed = true;
+    }
+  }, {
+    key: "getContextValuesContainer",
+    value: function getContextValuesContainer(contextId) {
+      if (this._isDisposed) {
+        return NullContext.INSTANCE;
+      }
+      return this._parent.getContextValuesContainer(contextId);
+    }
+  }, {
+    key: "createChildContext",
+    value: function createChildContext() {
+      var parentContextId = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : this._myContextId;
+      if (this._isDisposed) {
+        throw new Error("ScopedContextKeyService has been disposed");
+      }
+      return this._parent.createChildContext(parentContextId);
+    }
+  }, {
+    key: "disposeContext",
+    value: function disposeContext(contextId) {
+      if (this._isDisposed) {
+        return;
+      }
+      this._parent.disposeContext(contextId);
+    }
+  }, {
+    key: "updateParent",
+    value: function updateParent(parentContextKeyService) {
+      var thisContainer = this._parent.getContextValuesContainer(this._myContextId);
+      var oldAllValues = thisContainer.collectAllValues();
+      this._parent = parentContextKeyService;
+      this._updateParentChangeListener();
+      var newParentContainer = this._parent.getContextValuesContainer(this._parent.contextId);
+      thisContainer.updateParent(newParentContainer);
+      var newAllValues = thisContainer.collectAllValues();
+      var allValuesDiff = _objectSpread(_objectSpread({}, objects.distinct(oldAllValues, newAllValues)), objects.distinct(newAllValues, oldAllValues));
+      var changedKeys = Object.keys(allValuesDiff);
+      this._onDidChangeContext.fire(new ArrayContextKeyChangeEvent(changedKeys));
+    }
+  }]);
+  return ScopedContextKeyService;
+}(AbstractContextKeyService);
+var OverlayContext = /*#__PURE__*/function () {
+  function OverlayContext(parent, overlay) {
+    _classCallCheck(this, OverlayContext);
+    this.parent = parent;
+    this.overlay = overlay;
+  }
+  _createClass(OverlayContext, [{
+    key: "getValue",
+    value: function getValue(key) {
+      return this.overlay.has(key) ? this.overlay.get(key) : this.parent.getValue(key);
+    }
+  }]);
+  return OverlayContext;
+}();
+export var OverlayContextKeyService = /*#__PURE__*/function () {
+  function OverlayContextKeyService(parent, overlay) {
+    _classCallCheck(this, OverlayContextKeyService);
+    this.parent = parent;
+    this.overlay = new Map(overlay);
+  }
+  _createClass(OverlayContextKeyService, [{
+    key: "contextId",
+    get: function get() {
+      return this.parent.contextId;
+    }
+  }, {
+    key: "onDidChangeContext",
+    get: function get() {
+      return this.parent.onDidChangeContext;
+    }
+  }, {
+    key: "bufferChangeEvents",
+    value: function bufferChangeEvents(callback) {
+      this.parent.bufferChangeEvents(callback);
+    }
+  }, {
+    key: "createKey",
+    value: function createKey() {
+      throw new Error('Not supported.');
+    }
+  }, {
+    key: "getContext",
+    value: function getContext(target) {
+      return new OverlayContext(this.parent.getContext(target), this.overlay);
+    }
+  }, {
+    key: "getContextValuesContainer",
+    value: function getContextValuesContainer(contextId) {
+      var parentContext = this.parent.getContextValuesContainer(contextId);
+      return new OverlayContext(parentContext, this.overlay);
+    }
+  }, {
+    key: "contextMatchesRules",
+    value: function contextMatchesRules(rules) {
+      var context = this.getContextValuesContainer(this.contextId);
+      if (!rules) {
+        return true;
+      }
+      return rules.evaluate(context);
+      // return result;
+    }
+  }, {
+    key: "getContextKeyValue",
+    value: function getContextKeyValue(key) {
+      return this.overlay.has(key) ? this.overlay.get(key) : this.parent.getContextKeyValue(key);
+    }
+  }, {
+    key: "createScoped",
+    value: function createScoped() {
+      throw new Error('Not supported.');
+    }
+  }, {
+    key: "createOverlay",
+    value: function createOverlay() {
+      var overlay = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : Iterable.empty();
+      return new OverlayContextKeyService(this, overlay);
+    }
+  }, {
+    key: "updateParent",
+    value: function updateParent() {
+      throw new Error('Not supported.');
+    }
+  }, {
+    key: "dispose",
+    value: function dispose() {
+      // noop
+    }
+  }]);
+  return OverlayContextKeyService;
+}();
+function findContextAttr(domNode) {
+  while (domNode) {
+    if (domNode.hasAttribute(KEYBINDING_CONTEXT_ATTR)) {
+      var attr = domNode.getAttribute(KEYBINDING_CONTEXT_ATTR);
+      if (attr) {
+        return parseInt(attr, 10);
+      }
+      return NaN;
+    }
+    domNode = domNode.parentElement;
+  }
+  return 0;
+}