Used to prevent users from overriding a key without using a function meant to explicitly do so.
Only works when `window.DEV_MODE` is 'strict' or 'warn'
@param {string} key
164096
function checkDefined(key) {
            //noinspection JSPotentiallyInvalidUsageOfThis
            if (! data[`${this.moduleName}.${key}`] && typeof parent.get(key) !== 'undefined' && ! util.squelch()) {
                // Not allowing sub-modules to name variables already defined in the parent (unless using override).
                // Things get weird when expecting a variable defined in two places.
                //noinspection JSPotentiallyInvalidUsageOfThis
                util.throw(`In "${this.moduleName}" variable "${key}" defined in module "${parent.moduleName}". Choose a different name.`);
            }
        }
121400
function remove(...key) {
    const self = this;
	
    if(Array.isArray(key[0])) {
        key = key[0];
    }
    key.forEach(k => {
        self._f = self._f.filter(f => {
            return f !== k;
        });
    });
}
1217293
def stop(self, key):
        
        self._get_limiter(key).stop()
        self._cleanup_limiter(key)
133757
function _handleKey(key) {
        if (_enabled && _keyMap[key]) {
            // The execute() function returns a promise because some commands are async.
            // Generally, commands decide whether they can run or not synchronously,
            // and reject immediately, so we can test for that synchronously.
            var promise = CommandManager.execute(_keyMap[key].commandID);
            return (promise.state() !== "rejected");
        }
        return false;
    }
168200
public static boolean isSensitive(String key) {
		Preconditions.checkNotNull(key, "key is null");
		final String keyInLower = key.toLowerCase();
		for (String hideKey : SENSITIVE_KEYS) {
			if (keyInLower.length() >= hideKey.length()
				&& keyInLower.contains(hideKey)) {
				return true;
			}
		}
		return false;
	}
262799
public Datatype.Builder removeStandardMethodUnderrides(StandardMethod key) {
    Objects.requireNonNull(key);
    standardMethodUnderrides.remove(key);
    return (Datatype.Builder) this;
  }
909158
function setKey(key) {
  this.key = key;
  this.node = this.container[this.key];
  this.type = this.node && this.node.type;
}
174603
function(key) {
    var filepath = this._makeFilepath(key);

    if (!fs.existsSync(filepath)) {
      return;
    }

    fs.unlinkSync(filepath);
  }
631842
function(key) {
    if (arguments.length === 0) {
      // reset all values, including non-enumerable and readonly properties
      this.key_list.forEach(function(key) {
        this._reset(key);
      }, this);

    } else {
      this._reset(key);
    }
  }
221468
private void setOverride(final String key, final String value) {
    final boolean doSecurely = key.startsWith("_");
    final String fullKey = defaultEnvironment + "." + key;
    if (value != null) {
      final String oldValue = _getProperty("", key, null);
      if (value.equals(oldValue)) {
        // Same value, not really an override.
        if (doSecurely) {
          logger.warning("*** IGNORED  *** Ignoring redundant override " + fullKey + "=***PROTECTED***");
        } else {
          logger.warning("*** IGNORED  *** Ignoring redundant override " + fullKey + "='" + value + "'");
        }
      } else {
        logger.warning("*** OVERRIDE *** Setting override " + fullKey);
        if (doSecurely) {
          logger.warning("                 New value=***PROTECTED***");
          logger.warning("                 Old value='" + oldValue + "'");
        } else {
          logger.warning("                 New value='" + value + "'");
          logger.warning("                 Old value='" + oldValue + "'");
        }
        allProperties.setProperty(fullKey, value);
      }
    }
  }
163950
function( key /* or object */, callback ) {
                var me = this;
                Titanium.App.Properties.removeProperty(key);
                if (callback) {
                return this.fn('remove', callback).call(this);
                }
                return this;
            }
168603
function (key, value) {
        'use strict';
        var obj;
        if (!isStr(key)) {
            throw new Error(confKeyStrMsg, 'config-manager');
        }
        if (key.indexOf('.') === -1) {
            conf[key] = value;
        } else {
            obj = getLastNodeKey(key, conf);
            obj.node[obj.key] = value;
        }
        return this;
    }
57966
function (key) {
        let _that = this[PRIVATE];

        key = KEYMAP[key.toUpperCase()];
        if (key < _that.pressed.length && key != null) {
            _that.pressed[key] = true;
        }
    }
1272734
function assignKey(key, scope, method){
    var keys, mods;
    keys = getKeys(key);
    if (method === undefined) {
      method = scope;
      scope = 'all';
    }

    // for each shortcut
    for (var i = 0; i < keys.length; i++) {
      // set modifier keys if any
      mods = [];
      key = keys[i].split('+');
      if (key.length > 1){
        mods = getMods(key);
        key = [key[key.length-1]];
      }
      // convert to keycode and...
      key = key[0]
      key = code(key);
      // ...store handler
      if (!(key in _handlers)) _handlers[key] = [];
      _handlers[key].push({ shortcut: keys[i], scope: scope, method: method, key: keys[i], mods: mods });
    }
  }
523017
function(key){
                                var func = $scope.utils.tryGetFunction($scope.jsonFn[key]);
                                func
                                    ? angular.element($scope.utils.textarea.element).removeClass('invalid').addClass('valid')
                                    : angular.element($scope.utils.textarea.element).removeClass('valid').addClass('invalid');
                            }
1223372
function (obj, key) {
        'use strict';
        var fn = getFnCache[key];
        if (!fn) {
            fn = getFnNestedValue(key);
            getFnCache[key] = fn;
        }
        return fn(obj);
    }
1106536
function(key) {
            this._configs = this._configs || {};
            var config = this._configs[key] || {};
            var map = {}; // returning a copy to prevent overrides
            
            for (key in config) {
                if ( Lang.hasOwnProperty(config, key) ) {
                    map[key] = config[key];
                }
            }
    
            return map;
        }