Return negation attached to an event.

        Example: "states": [{"@type": "State", "type": "NEGATION",
                             "text": "n't"}]
428535
def get_negation(event):
        
        states = event.get('states', [])
        if not states:
            return []
        negs = [state for state in states
                if state.get('type') == 'NEGATION']
        neg_texts = [neg['text'] for neg in negs]
        return neg_texts
1136231
def Negation(expr: Expression) -> Expression:
    """"""
    expr = Expression(_negate(expr.body))
    return ast.fix_missing_locations(expr)
415716
def find_for_event(cls, event, include_hidden=False, **kwargs):
        
        query = cls.find(event_id=event.id, **kwargs)
        if not include_hidden:
            query = query.filter(~cls.hidden)
        return query
835394
function (elements) {
      if (!validateArguments(elements, function () {})) return

      if (!Array.isArray(elements)) {
          elements = [ elements ]
      }

      liveElements.filter(function (e) {
          return elements.indexOf(e.element) !== -1
      }).forEach(function (e) {
          e.element.removeEventListener('input', e.handler)
      })

      liveElements = liveElements.filter(function (e) {
          return elements.indexOf(e.element) === -1
      })

      return this
    }
1325896
def negated(input_words, include_nt=True):
    
    input_words = [str(w).lower() for w in input_words]
    neg_words = []
    neg_words.extend(NEGATE)
    for word in neg_words:
        if word in input_words:
            return True
    if include_nt:
        for word in input_words:
            if "n't" in word:
                return True
    if "least" in input_words:
        i = input_words.index("least")
        if i > 0 and input_words[i - 1] != "at":
            return True
    return False
932098
def contains(self, *args):
        
        self.op = '@>'
        self.negate_op = None
        self.value = self._array_value(args)
        return self
946798
def accepts(regex, negate, *values):
    
    return any(v and regex.search(v) for v in values) != negate
500170
def FnNot(value)
      if value.is_a?(Array)
        Fn.new('Not', value)
      else
        Fn.new('Not', [value])
      end
    end
393432
def negate(self):
        """"""
        self.from_value, self.to_value = self.to_value, self.from_value
        self.include_lower, self.include_upper = self.include_upper, self.include_lower
1348361
function GetOnEvent(title) {
    var retList, i;

    retList = [];
    for(i = 0 ; i < onList.length ; i++) {
        if(onList[i].event.toString() === title.toString()) {
            retList.push(onList[i].callback);
        }
    }
    return retList;
}
382692
function (events)
		{
			var event = {};
			for (e in events)
			{
				var ref=events[e],
					e = 'event-'+e.replace('-','.');
				event[e]=ref;
				event[e].class=ref.class || 'wnEvent';
				event[e].eventName = e.split('-').pop();
				if (this.hasEvent(e))
				{
					_.merge(event[e],this.getEvent(e));
				}
				_eventsConfig[e]=_eventsConfig[e] || {};
				_.merge(_eventsConfig[e], event[e]);
			}
			return this;
		}
56455
function negate(out, a) {
    out[0] = -a[0]
    out[1] = -a[1]
    out[2] = -a[2]
    return out
}
647420
def le(self, value):
        
        self.op = '<='
        self.negate_op = '>'
        self.value = self._value(value)
        return self
1091513
function MessageEvent (type, eventInitDict) {
  Object.defineProperty(this, 'type', { writable: false, value: type, enumerable: true })
  for (var f in eventInitDict) {
    if (eventInitDict.hasOwnProperty(f)) {
      Object.defineProperty(this, f, { writable: false, value: eventInitDict[f], enumerable: true })
    }
  }
}
741392
def text_notag(self):
        
        if self.tag is not None:
            return self.text.replace(self.tag, "")
        else:
            return self.text
329499
public Predicate<T> negate() {
        return new Predicate<T>() {
            @Override
            public boolean test( T input ) {
                return !Predicate.this.test(input);
            }

            @Override
            public Predicate<T> negate() {
                return Predicate.this;
            }
        };
    }
343318
def pre_filter(self):
        
        inner = self._inner.pre_filter()
        if inner:
            if inner.startswith('"not=$') and inner.endswith('"') and '\\' not in inner:
                return inner[6:-1]  # double negation, return inner command
            elif inner.startswith('"'):
                inner = '"$' + inner[1:]
            else:
                inner = '$' + inner
            return 'not=' + inner
        else:
            return ''