@difizen/libro-common 0.3.3 → 1.0.0

package/es/core/keybinding/vs/configuration/configurationRegistry.d.ts

@@ -0,0 +1,145 @@
+import type { Event, IStringDictionary } from '../../../../common/index.js';
+import type { IJSONSchema } from '../jsonSchema';
+export declare const Extensions: {
+    Configuration: string;
+};
+export interface IConfigurationRegistry {
+    /**
+     * Register a configuration to the registry.
+     */
+    registerConfiguration: (configuration: IConfigurationNode) => void;
+    /**
+     * Register multiple configurations to the registry.
+     */
+    registerConfigurations: (configurations: IConfigurationNode[], validate?: boolean) => void;
+    /**
+     * Deregister multiple configurations from the registry.
+     */
+    deregisterConfigurations: (configurations: IConfigurationNode[]) => void;
+    /**
+     * Register multiple default configurations to the registry.
+     */
+    registerDefaultConfigurations: (defaultConfigurations: IStringDictionary<any>[]) => void;
+    /**
+     * Deregister multiple default configurations from the registry.
+     */
+    deregisterDefaultConfigurations: (defaultConfigurations: IStringDictionary<any>[]) => void;
+    /**
+     * Signal that the schema of a configuration setting has changes. It is currently only supported to change enumeration values.
+     * Property or default value changes are not allowed.
+     */
+    notifyConfigurationSchemaUpdated: (...configurations: IConfigurationNode[]) => void;
+    /**
+     * Event that fires whenver a configuration has been
+     * registered.
+     */
+    onDidSchemaChange: Event<void>;
+    /**
+     * Event that fires whenver a configuration has been
+     * registered.
+     */
+    onDidUpdateConfiguration: Event<string[]>;
+    /**
+     * Returns all configuration nodes contributed to this registry.
+     */
+    getConfigurations: () => IConfigurationNode[];
+    /**
+     * Returns all configurations settings of all configuration nodes contributed to this registry.
+     */
+    getConfigurationProperties: () => Record<string, IConfigurationPropertySchema>;
+    /**
+     * Returns all excluded configurations settings of all configuration nodes contributed to this registry.
+     */
+    getExcludedConfigurationProperties: () => Record<string, IConfigurationPropertySchema>;
+    /**
+     * Register the identifiers for editor configurations
+     */
+    registerOverrideIdentifiers: (identifiers: string[]) => void;
+}
+export declare enum ConfigurationScope {
+    /**
+     * Application specific configuration, which can be configured only in local user settings.
+     */
+    APPLICATION = 1,
+    /**
+     * Machine specific configuration, which can be configured only in local and remote user settings.
+     */
+    MACHINE = 2,
+    /**
+     * Window specific configuration, which can be configured in the user or workspace settings.
+     */
+    WINDOW = 3,
+    /**
+     * Resource specific configuration, which can be configured in the user, workspace or folder settings.
+     */
+    RESOURCE = 4,
+    /**
+     * Resource specific configuration that can be configured in language specific settings
+     */
+    LANGUAGE_OVERRIDABLE = 5,
+    /**
+     * Machine specific configuration that can also be configured in workspace or folder settings.
+     */
+    MACHINE_OVERRIDABLE = 6
+}
+export interface IConfigurationPropertySchema extends IJSONSchema {
+    scope?: ConfigurationScope | undefined;
+    included?: boolean;
+    tags?: string[];
+    /**
+     * When enabled this setting is ignored during sync and user can override this.
+     */
+    ignoreSync?: boolean;
+    /**
+     * When enabled this setting is ignored during sync and user cannot override this.
+     */
+    disallowSyncIgnore?: boolean;
+    enumItemLabels?: string[];
+}
+export interface IConfigurationExtensionInfo {
+    id: string;
+}
+export interface IConfigurationNode {
+    id?: string;
+    order?: number;
+    type?: string | string[];
+    title?: string;
+    description?: string;
+    properties?: Record<string, IConfigurationPropertySchema>;
+    allOf?: IConfigurationNode[];
+    scope?: ConfigurationScope;
+    extensionInfo?: IConfigurationExtensionInfo;
+}
+type SettingProperties = Record<string, any>;
+export declare const allSettings: {
+    properties: SettingProperties;
+    patternProperties: SettingProperties;
+};
+export declare const applicationSettings: {
+    properties: SettingProperties;
+    patternProperties: SettingProperties;
+};
+export declare const machineSettings: {
+    properties: SettingProperties;
+    patternProperties: SettingProperties;
+};
+export declare const machineOverridableSettings: {
+    properties: SettingProperties;
+    patternProperties: SettingProperties;
+};
+export declare const windowSettings: {
+    properties: SettingProperties;
+    patternProperties: SettingProperties;
+};
+export declare const resourceSettings: {
+    properties: SettingProperties;
+    patternProperties: SettingProperties;
+};
+export declare const resourceLanguageSettingsSchemaId = "vscode://schemas/settings/resourceLanguage";
+export declare const OVERRIDE_PROPERTY_PATTERN: RegExp;
+export declare function overrideIdentifierFromKey(key: string): string;
+export declare function getDefaultValue(type: string | string[] | undefined): any;
+export declare function validateProperty(property: string): string | null;
+export declare function getScopes(): [string, ConfigurationScope | undefined][];
+export {};
+//# sourceMappingURL=configurationRegistry.d.ts.map

package/es/core/keybinding/vs/configuration/configurationRegistry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"configurationRegistry.d.ts","sourceRoot":"","sources":["../../../../../src/core/keybinding/vs/configuration/configurationRegistry.ts"],"names":[],"mappings":"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"}

package/es/core/keybinding/vs/configuration/configurationRegistry.js

@@ -0,0 +1,500 @@
+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 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 _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 _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 _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 _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 _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 _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); }
+/* eslint-disable @typescript-eslint/no-use-before-define */
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { Emitter, types } from "../../../../common/index.js";
+import * as nls from "../../../nls";
+import { Extensions as JSONExtensions } from "../jsonContributionRegistry";
+import { Registry } from "../platform";
+export var Extensions = {
+  Configuration: 'base.contributions.configuration'
+};
+export var ConfigurationScope = /*#__PURE__*/function (ConfigurationScope) {
+  /**
+   * Application specific configuration, which can be configured only in local user settings.
+   */
+  ConfigurationScope[ConfigurationScope["APPLICATION"] = 1] = "APPLICATION";
+  /**
+   * Machine specific configuration, which can be configured only in local and remote user settings.
+   */
+  ConfigurationScope[ConfigurationScope["MACHINE"] = 2] = "MACHINE";
+  /**
+   * Window specific configuration, which can be configured in the user or workspace settings.
+   */
+  ConfigurationScope[ConfigurationScope["WINDOW"] = 3] = "WINDOW";
+  /**
+   * Resource specific configuration, which can be configured in the user, workspace or folder settings.
+   */
+  ConfigurationScope[ConfigurationScope["RESOURCE"] = 4] = "RESOURCE";
+  /**
+   * Resource specific configuration that can be configured in language specific settings
+   */
+  ConfigurationScope[ConfigurationScope["LANGUAGE_OVERRIDABLE"] = 5] = "LANGUAGE_OVERRIDABLE";
+  /**
+   * Machine specific configuration that can also be configured in workspace or folder settings.
+   */
+  ConfigurationScope[ConfigurationScope["MACHINE_OVERRIDABLE"] = 6] = "MACHINE_OVERRIDABLE";
+  return ConfigurationScope;
+}({});
+export var allSettings = {
+  properties: {},
+  patternProperties: {}
+};
+export var applicationSettings = {
+  properties: {},
+  patternProperties: {}
+};
+export var machineSettings = {
+  properties: {},
+  patternProperties: {}
+};
+export var machineOverridableSettings = {
+  properties: {},
+  patternProperties: {}
+};
+export var windowSettings = {
+  properties: {},
+  patternProperties: {}
+};
+export var resourceSettings = {
+  properties: {},
+  patternProperties: {}
+};
+export var resourceLanguageSettingsSchemaId = 'vscode://schemas/settings/resourceLanguage';
+var contributionRegistry = Registry.as(JSONExtensions.JSONContribution);
+var ConfigurationRegistry = /*#__PURE__*/function () {
+  function ConfigurationRegistry() {
+    _classCallCheck(this, ConfigurationRegistry);
+    this.overrideIdentifiers = new Set();
+    this._onDidSchemaChange = new Emitter();
+    this.onDidSchemaChange = this._onDidSchemaChange.event;
+    this._onDidUpdateConfiguration = new Emitter();
+    this.onDidUpdateConfiguration = this._onDidUpdateConfiguration.event;
+    this.defaultValues = {};
+    this.defaultLanguageConfigurationOverridesNode = {
+      id: 'defaultOverrides',
+      title: nls.localize('defaultLanguageConfigurationOverrides.title', 'Default Language Configuration Overrides'),
+      properties: {}
+    };
+    this.configurationContributors = [this.defaultLanguageConfigurationOverridesNode];
+    this.resourceLanguageSettingsSchema = {
+      properties: {},
+      patternProperties: {},
+      additionalProperties: false,
+      errorMessage: 'Unknown editor configuration setting',
+      allowTrailingCommas: true,
+      allowComments: true
+    };
+    this.configurationProperties = {};
+    this.excludedConfigurationProperties = {};
+    contributionRegistry.registerSchema(resourceLanguageSettingsSchemaId, this.resourceLanguageSettingsSchema);
+  }
+  _createClass(ConfigurationRegistry, [{
+    key: "registerConfiguration",
+    value: function registerConfiguration(configuration) {
+      var validate = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;
+      this.registerConfigurations([configuration], validate);
+    }
+  }, {
+    key: "registerConfigurations",
+    value: function registerConfigurations(configurations) {
+      var _this = this;
+      var validate = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;
+      var properties = [];
+      configurations.forEach(function (configuration) {
+        properties.push.apply(properties, _toConsumableArray(_this.validateAndRegisterProperties(configuration, validate))); // fills in defaults
+        _this.configurationContributors.push(configuration);
+        _this.registerJSONConfiguration(configuration);
+      });
+      contributionRegistry.registerSchema(resourceLanguageSettingsSchemaId, this.resourceLanguageSettingsSchema);
+      this._onDidSchemaChange.fire();
+      this._onDidUpdateConfiguration.fire(properties);
+    }
+  }, {
+    key: "deregisterConfigurations",
+    value: function deregisterConfigurations(configurations) {
+      var _this2 = this;
+      var properties = [];
+      var deregisterConfiguration = function deregisterConfiguration(configuration) {
+        if (configuration.properties) {
+          for (var key in configuration.properties) {
+            properties.push(key);
+            delete _this2.configurationProperties[key];
+            _this2.removeFromSchema(key, configuration.properties[key]);
+          }
+        }
+        if (configuration.allOf) {
+          configuration.allOf.forEach(function (node) {
+            return deregisterConfiguration(node);
+          });
+        }
+      };
+      var _iterator = _createForOfIteratorHelper(configurations),
+        _step;
+      try {
+        for (_iterator.s(); !(_step = _iterator.n()).done;) {
+          var _configuration = _step.value;
+          deregisterConfiguration(_configuration);
+          var index = this.configurationContributors.indexOf(_configuration);
+          if (index !== -1) {
+            this.configurationContributors.splice(index, 1);
+          }
+        }
+      } catch (err) {
+        _iterator.e(err);
+      } finally {
+        _iterator.f();
+      }
+      contributionRegistry.registerSchema(resourceLanguageSettingsSchemaId, this.resourceLanguageSettingsSchema);
+      this._onDidSchemaChange.fire();
+      this._onDidUpdateConfiguration.fire(properties);
+    }
+  }, {
+    key: "registerDefaultConfigurations",
+    value: function registerDefaultConfigurations(defaultConfigurations) {
+      var properties = [];
+      var overrideIdentifiers = [];
+      var _iterator2 = _createForOfIteratorHelper(defaultConfigurations),
+        _step2;
+      try {
+        for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+          var defaultConfiguration = _step2.value;
+          for (var key in defaultConfiguration) {
+            properties.push(key);
+            if (OVERRIDE_PROPERTY_PATTERN.test(key)) {
+              this.defaultValues[key] = _objectSpread(_objectSpread({}, this.defaultValues[key] || {}), defaultConfiguration[key]);
+              var property = {
+                type: 'object',
+                default: this.defaultValues[key],
+                description: nls.localize('defaultLanguageConfiguration.description', 'Configure settings to be overridden for {0} language.', key),
+                $ref: resourceLanguageSettingsSchemaId
+              };
+              overrideIdentifiers.push(overrideIdentifierFromKey(key));
+              this.configurationProperties[key] = property;
+              this.defaultLanguageConfigurationOverridesNode.properties[key] = property;
+            } else {
+              this.defaultValues[key] = defaultConfiguration[key];
+              var _property = this.configurationProperties[key];
+              if (_property) {
+                this.updatePropertyDefaultValue(key, _property);
+                this.updateSchema(key, _property);
+              }
+            }
+          }
+        }
+      } catch (err) {
+        _iterator2.e(err);
+      } finally {
+        _iterator2.f();
+      }
+      this.registerOverrideIdentifiers(overrideIdentifiers);
+      this._onDidSchemaChange.fire();
+      this._onDidUpdateConfiguration.fire(properties);
+    }
+  }, {
+    key: "deregisterDefaultConfigurations",
+    value: function deregisterDefaultConfigurations(defaultConfigurations) {
+      var properties = [];
+      var _iterator3 = _createForOfIteratorHelper(defaultConfigurations),
+        _step3;
+      try {
+        for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
+          var defaultConfiguration = _step3.value;
+          for (var key in defaultConfiguration) {
+            properties.push(key);
+            delete this.defaultValues[key];
+            if (OVERRIDE_PROPERTY_PATTERN.test(key)) {
+              delete this.configurationProperties[key];
+              delete this.defaultLanguageConfigurationOverridesNode.properties[key];
+            } else {
+              var property = this.configurationProperties[key];
+              if (property) {
+                this.updatePropertyDefaultValue(key, property);
+                this.updateSchema(key, property);
+              }
+            }
+          }
+        }
+      } catch (err) {
+        _iterator3.e(err);
+      } finally {
+        _iterator3.f();
+      }
+      this.updateOverridePropertyPatternKey();
+      this._onDidSchemaChange.fire();
+      this._onDidUpdateConfiguration.fire(properties);
+    }
+  }, {
+    key: "notifyConfigurationSchemaUpdated",
+    value: function notifyConfigurationSchemaUpdated() {
+      this._onDidSchemaChange.fire();
+    }
+  }, {
+    key: "registerOverrideIdentifiers",
+    value: function registerOverrideIdentifiers(overrideIdentifiers) {
+      var _iterator4 = _createForOfIteratorHelper(overrideIdentifiers),
+        _step4;
+      try {
+        for (_iterator4.s(); !(_step4 = _iterator4.n()).done;) {
+          var overrideIdentifier = _step4.value;
+          this.overrideIdentifiers.add(overrideIdentifier);
+        }
+      } catch (err) {
+        _iterator4.e(err);
+      } finally {
+        _iterator4.f();
+      }
+      this.updateOverridePropertyPatternKey();
+    }
+  }, {
+    key: "validateAndRegisterProperties",
+    value: function validateAndRegisterProperties(configuration) {
+      var validate = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;
+      var scope = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : ConfigurationScope.WINDOW;
+      scope = types.isUndefinedOrNull(configuration.scope) ? scope : configuration.scope;
+      var propertyKeys = [];
+      var properties = configuration.properties;
+      if (properties) {
+        for (var key in properties) {
+          if (validate && validateProperty(key)) {
+            delete properties[key];
+            continue;
+          }
+          var property = properties[key];
+
+          // update default value
+          this.updatePropertyDefaultValue(key, property);
+
+          // update scope
+          if (OVERRIDE_PROPERTY_PATTERN.test(key)) {
+            property.scope = undefined; // No scope for overridable properties `[${identifier}]`
+          } else {
+            property.scope = types.isUndefinedOrNull(property.scope) ? scope : property.scope;
+          }
+
+          // Add to properties maps
+          // Property is included by default if 'included' is unspecified
+          if (Object.prototype.hasOwnProperty.call(properties[key], 'included') && !properties[key].included) {
+            this.excludedConfigurationProperties[key] = properties[key];
+            delete properties[key];
+            continue;
+          } else {
+            this.configurationProperties[key] = properties[key];
+          }
+          if (!properties[key].deprecationMessage && properties[key].markdownDeprecationMessage) {
+            // If not set, default deprecationMessage to the markdown source
+            properties[key].deprecationMessage = properties[key].markdownDeprecationMessage;
+          }
+          propertyKeys.push(key);
+        }
+      }
+      var subNodes = configuration.allOf;
+      if (subNodes) {
+        var _iterator5 = _createForOfIteratorHelper(subNodes),
+          _step5;
+        try {
+          for (_iterator5.s(); !(_step5 = _iterator5.n()).done;) {
+            var node = _step5.value;
+            propertyKeys.push.apply(propertyKeys, _toConsumableArray(this.validateAndRegisterProperties(node, validate, scope)));
+          }
+        } catch (err) {
+          _iterator5.e(err);
+        } finally {
+          _iterator5.f();
+        }
+      }
+      return propertyKeys;
+    }
+  }, {
+    key: "getConfigurations",
+    value: function getConfigurations() {
+      return this.configurationContributors;
+    }
+  }, {
+    key: "getConfigurationProperties",
+    value: function getConfigurationProperties() {
+      return this.configurationProperties;
+    }
+  }, {
+    key: "getExcludedConfigurationProperties",
+    value: function getExcludedConfigurationProperties() {
+      return this.excludedConfigurationProperties;
+    }
+  }, {
+    key: "registerJSONConfiguration",
+    value: function registerJSONConfiguration(configuration) {
+      var _this3 = this;
+      var register = function register(configuration) {
+        var properties = configuration.properties;
+        if (properties) {
+          for (var key in properties) {
+            _this3.updateSchema(key, properties[key]);
+          }
+        }
+        var subNodes = configuration.allOf;
+        if (subNodes) {
+          subNodes.forEach(register);
+        }
+      };
+      register(configuration);
+    }
+  }, {
+    key: "updateSchema",
+    value: function updateSchema(key, property) {
+      allSettings.properties[key] = property;
+      switch (property.scope) {
+        case ConfigurationScope.APPLICATION:
+          applicationSettings.properties[key] = property;
+          break;
+        case ConfigurationScope.MACHINE:
+          machineSettings.properties[key] = property;
+          break;
+        case ConfigurationScope.MACHINE_OVERRIDABLE:
+          machineOverridableSettings.properties[key] = property;
+          break;
+        case ConfigurationScope.WINDOW:
+          windowSettings.properties[key] = property;
+          break;
+        case ConfigurationScope.RESOURCE:
+          resourceSettings.properties[key] = property;
+          break;
+        case ConfigurationScope.LANGUAGE_OVERRIDABLE:
+          resourceSettings.properties[key] = property;
+          this.resourceLanguageSettingsSchema.properties[key] = property;
+          break;
+      }
+    }
+  }, {
+    key: "removeFromSchema",
+    value: function removeFromSchema(key, property) {
+      delete allSettings.properties[key];
+      switch (property.scope) {
+        case ConfigurationScope.APPLICATION:
+          delete applicationSettings.properties[key];
+          break;
+        case ConfigurationScope.MACHINE:
+          delete machineSettings.properties[key];
+          break;
+        case ConfigurationScope.MACHINE_OVERRIDABLE:
+          delete machineOverridableSettings.properties[key];
+          break;
+        case ConfigurationScope.WINDOW:
+          delete windowSettings.properties[key];
+          break;
+        case ConfigurationScope.RESOURCE:
+        case ConfigurationScope.LANGUAGE_OVERRIDABLE:
+          delete resourceSettings.properties[key];
+          break;
+      }
+    }
+  }, {
+    key: "updateOverridePropertyPatternKey",
+    value: function updateOverridePropertyPatternKey() {
+      var _iterator6 = _createForOfIteratorHelper(this.overrideIdentifiers.values()),
+        _step6;
+      try {
+        for (_iterator6.s(); !(_step6 = _iterator6.n()).done;) {
+          var overrideIdentifier = _step6.value;
+          var overrideIdentifierProperty = "[".concat(overrideIdentifier, "]");
+          var resourceLanguagePropertiesSchema = {
+            type: 'object',
+            description: nls.localize('overrideSettings.defaultDescription', 'Configure editor settings to be overridden for a language.'),
+            errorMessage: nls.localize('overrideSettings.errorMessage', 'This setting does not support per-language configuration.'),
+            $ref: resourceLanguageSettingsSchemaId
+          };
+          this.updatePropertyDefaultValue(overrideIdentifierProperty, resourceLanguagePropertiesSchema);
+          allSettings.properties[overrideIdentifierProperty] = resourceLanguagePropertiesSchema;
+          applicationSettings.properties[overrideIdentifierProperty] = resourceLanguagePropertiesSchema;
+          machineSettings.properties[overrideIdentifierProperty] = resourceLanguagePropertiesSchema;
+          machineOverridableSettings.properties[overrideIdentifierProperty] = resourceLanguagePropertiesSchema;
+          windowSettings.properties[overrideIdentifierProperty] = resourceLanguagePropertiesSchema;
+          resourceSettings.properties[overrideIdentifierProperty] = resourceLanguagePropertiesSchema;
+        }
+      } catch (err) {
+        _iterator6.e(err);
+      } finally {
+        _iterator6.f();
+      }
+      this._onDidSchemaChange.fire();
+    }
+  }, {
+    key: "updatePropertyDefaultValue",
+    value: function updatePropertyDefaultValue(key, property) {
+      var defaultValue = this.defaultValues[key];
+      if (types.isUndefined(defaultValue)) {
+        defaultValue = property.default;
+      }
+      if (types.isUndefined(defaultValue)) {
+        defaultValue = getDefaultValue(property.type);
+      }
+      property.default = defaultValue;
+    }
+  }]);
+  return ConfigurationRegistry;
+}();
+var OVERRIDE_PROPERTY = '\\[.*\\]$';
+export var OVERRIDE_PROPERTY_PATTERN = new RegExp(OVERRIDE_PROPERTY);
+export function overrideIdentifierFromKey(key) {
+  return key.substring(1, key.length - 1);
+}
+export function getDefaultValue(type) {
+  var t = Array.isArray(type) ? type[0] : type;
+  switch (t) {
+    case 'boolean':
+      return false;
+    case 'integer':
+    case 'number':
+      return 0;
+    case 'string':
+      return '';
+    case 'array':
+      return [];
+    case 'object':
+      return {};
+    default:
+      return null;
+  }
+}
+var configurationRegistry = new ConfigurationRegistry();
+Registry.add(Extensions.Configuration, configurationRegistry);
+export function validateProperty(property) {
+  if (!property.trim()) {
+    return nls.localize('config.property.empty', 'Cannot register an empty property');
+  }
+  if (OVERRIDE_PROPERTY_PATTERN.test(property)) {
+    return nls.localize('config.property.languageDefault', "Cannot register '{0}'. This matches property pattern '\\\\[.*\\\\]$' for describing language specific editor settings. Use 'configurationDefaults' contribution.", property);
+  }
+  if (configurationRegistry.getConfigurationProperties()[property] !== undefined) {
+    return nls.localize('config.property.duplicate', "Cannot register '{0}'. This property is already registered.", property);
+  }
+  return null;
+}
+export function getScopes() {
+  var scopes = [];
+  var configurationProperties = configurationRegistry.getConfigurationProperties();
+  for (var _i = 0, _Object$keys = Object.keys(configurationProperties); _i < _Object$keys.length; _i++) {
+    var key = _Object$keys[_i];
+    scopes.push([key, configurationProperties[key].scope]);
+  }
+  scopes.push(['launch', ConfigurationScope.RESOURCE]);
+  scopes.push(['task', ConfigurationScope.RESOURCE]);
+  return scopes;
+}