Filters the context object to only contain keys specified in
`contextTypes`, and asserts that they are valid.

@param {object} context
@return {?object}
@private
332121
function (context) {
	    var maskedContext = this._maskContext(context);
	    if (process.env.NODE_ENV !== 'production') {
	      var Component = this._currentElement.type;
	      if (Component.contextTypes) {
	        this._checkContextTypes(Component.contextTypes, maskedContext, ReactPropTypeLocations.context);
	      }
	    }
	    return maskedContext;
	  }
430945
function (context) {
                context.setCookie = function (name, value, options) {
                    var cookieStr = cookie.serialize(name, value, options);
                    if (res) {
                        var header = res.getHeader('Set-Cookie') || [];
                        if (!Array.isArray(header)) {
                            header = [header];
                        }
 
                        header.push(cookieStr);
                        res.setHeader('Set-Cookie', header);
                    } else {
                        document.cookie = cookieStr;
                    }
                    cookies[name] = value;
                };
                context.clearCookie = function (name, options) {
                    context.setCookie(name, "", merge({ expires: new Date(1), path: '/' }, options));
                    delete cookies[name];
                };
                context.getCookie = function (name) {
                    return cookies[name];
                };
            }
727147
public <ReqT, RespT> Context serverFilterContext(Context context) {
    Context ctx = checkNotNull(context, "context");
    for (StreamTracer tracer : tracers) {
      ctx = ((ServerStreamTracer) tracer).filterContext(ctx);
      checkNotNull(ctx, "%s returns null context", tracer);
    }
    return ctx;
  }
131803
def for_context(context)
      contexts = hash.keys.select { |ckey| context.matches?([ckey]) }
      contexts.map { |exc| hash[exc] }
    end
773398
function (filter) {
            if (!filter) {
                filter = null;
            }
            var comments = this.__comments;

            if (filter !== null) {
                comments = comments.filter(function (c) {
                    return c.context === filter;
                });
            }

            return comments;
        }
1168055
function _filterInContextWishes(wishes) {
  const inContextWishes = []
  _each(wishes, wish => {
    if (wish && _wishInContext(wish)) {
      inContextWishes.push(wish)
    }
  })
  return inContextWishes
}
827088
function getTypeFromContext (context) {
  if (!context.method.returns) return undefined

  const returns = [].concat(context.method.returns)
  for (var i = 0, l = returns.length; i < l; i++) {
    if (typeof returns[i] !== 'object' || returns[i].root !== true) continue
    return returns[i].type
  }
}
863627
function(context, all) {
  return Object.keys(all).reduce(function(bound, key) {
    if (typeof all[key] == 'object') bound[key] = bindAllTo(context, all[key]);
    else if (typeof all[key] == 'function') bound[key] = all[key].bind(context);
    else bound[key] = all[key];
    return bound;
  }, {});
}
1186857
function (contextModel, properties) {
                    var cacheId = this.createContextCacheId(contextModel, properties);

                    if (!cacheId) {
                        // empty cacheId indicates the current context
                        return this;
                    }

                    if (!this.$contextCache.hasOwnProperty(cacheId)) {
                        this.$contextCache[cacheId] = this.$dataSource.createContext(contextModel, properties, this);
                    }

                    return this.$contextCache[cacheId];
                }
1248047
function (id, context) {
            context = context || {};
            return this.base.get(this.prefix + id, this.base._getContext(context));
        }
662729
function Context() {
	/**
	 * @member {Object}
	 * @property {Object} client
	 * @property {Object<Call>} client.map - map from call name and call id
	 * @property {Array<Call>} client.list
	 * @property {Object} server
	 * @property {Object<Call>} server.map - map from call name and call id
	 * @property {Array<Call>} server.list
	 * @private
	 */
	this._calls = {
		client: {
			map: Object.create(null),
			list: []
		},
		server: {
			map: Object.create(null),
			list: []
		}
	}

	/**
	 * @member {Object}
	 * @property {Object} client
	 * @property {Object<Message>} client.map - map from message name and message id
	 * @property {Array<Message>} client.list
	 * @property {Object} server
	 * @property {Object<Message>} server.map - map from message name and message id
	 * @property {Array<Message>} server.list
	 * @private
	 */
	this._messages = {
		client: {
			map: Object.create(null),
			list: []
		},
		server: {
			map: Object.create(null),
			list: []
		}
	}
}
942507
function (cb, context) {
        context !== void 0 && (cb = bind(cb, context));
        for (var key in this.data) {
            this.data.hasOwnProperty(key) && cb(this.data[key], key);
        }
    }
320420
function(context) {
      var element = context.createElement("div"),
          html5   = "<article>foo</article>";
      element.innerHTML = html5;
      return element.innerHTML.toLowerCase() === html5;
    }
1057623
function(context) {
    var maskedContext = this._maskContext(context);
    if ("production" !== "development") {
      var Component = ReactNativeComponent.getComponentClassForElement(
        this._currentElement
      );
      if (Component.contextTypes) {
        this._checkPropTypes(
          Component.contextTypes,
          maskedContext,
          ReactPropTypeLocations.context
        );
      }
    }
    return maskedContext;
  }
764171
function (rule, context) {
        return _.find(this.members, _.isFunction(rule) && _.isObject(context) ? rule.bind(context) : rule);
    }
423331
function(context, args, stack) {
		var ctx = new Context(args[0], args[1] || context);
		stack.push(ctx);
		return ctx;
	}
1097948
function isNodeInContext(node, context) {
	'use strict';

	var include =
		context.include &&
		getDeepest(
			context.include.filter(function(candidate) {
				return axe.utils.contains(candidate, node);
			})
		);
	var exclude =
		context.exclude &&
		getDeepest(
			context.exclude.filter(function(candidate) {
				return axe.utils.contains(candidate, node);
			})
		);
	if (
		(!exclude && include) ||
		(exclude && axe.utils.contains(exclude, include))
	) {
		return true;
	}
	return false;
}