Check for the input and probably replace by correct options elements value
192080
function(event) {
		var input = event.target,
			datalist = input.list;

		if (
			!input.matches('input[list]') ||
			!input.matches('.' + classNameInput) ||
			!datalist
		) {
			return;
		}

		// Query for related option - and escaping the value as doublequotes wouldn't work
		var option = datalist.querySelector(
			'option[value="' +
				getInputValue(input).replace(/\\([\s\S])|(")/g, '\\$1$2') +
				'"]'
		);

		// We're using .getAttribute instead of .dataset here for IE10
		if (option && option.getAttribute('data-originalvalue')) {
			setInputValue(input, option.getAttribute('data-originalvalue'));
		}
	}
1186413
def _check_element(self, lookup_strings, instance):
        
        for q, val in lookup_strings.items():
            if not field_lookup(instance, q, val, True):
                return False

        return True
40188
function(value, element) {
           var html = [],
               checked = $.fn.editableutils.itemsByValue(value, this.sourceData);
               
           if(checked.length) {
               $.each(checked, function(i, v) { html.push($.fn.editableutils.escape(v.text)); });
               $(element).html(html.join('<br>'));
           } else {
               $(element).empty(); 
           }
        }
987430
function (target, value, text) {
			var inst = this._getInst(target),
				onChange = this._get(inst, 'onChange');
			$("#sbSelector_" + inst.uid).text(text);
			$(target).find("option[value='" + value + "']").attr("selected", TRUE);
			if (onChange) {
				onChange.apply((inst.input ? inst.input[0] : null), [value, inst]);
			} else if (inst.input) {
				inst.input.trigger('change');
			}
		}
602464
function stringify(input, options) {
  if (!options) options = {};
  return JSON.stringify(input, options.replacer, options.spaces);
}
1353078
private function correctInputs()
    {
        if (($diff = array_diff_key($this->rules, $this->inputs))) {
            foreach ($diff as $key => $value) {
                $this->inputs[ $key ] = '';
            }
        }
    }
206213
def _validate_value(self, proposal):
        ""
        try:
            return tuple(findvalue(self._options_values, i, self.equals) for i in proposal.value)
        except ValueError:
            raise TraitError('Invalid selection: value not found')
942701
def element_value_should_contain(self, locator, expected):
		""""""

		self._info("Verifying element '%s' value contains '%s'" % (locator, expected))
		
		element = self._element_find(locator, True, True)
		value = str(element.get_attribute('value'))
		
		if expected in value:
			return
		
		else:
			raise AssertionError("Value '%s' did not appear in element '%s'. It's value was '%s'" % (expected, locator, value))
778141
def validate_options(self, k, v):
        """"""

        super().validate_options(k, v)
        if k == 'errors' and v.lower() not in ('strict', 'replace', 'ignore', 'backslashreplace'):
            raise ValueError("{}: '{}' is not a valid value for '{}'".format(self.__class__.__name, v, k))
        if k == 'normalize' and v.upper() not in ('NFC', 'NFKC', 'NFD', 'NFKD'):
            raise ValueError("{}: '{}' is not a valid value for '{}'".format(self.__class__.__name, v, k))
83766
function checkOptions(options) {
  options = options || {};
  // Separators (required)
  if(options.sep && 'string' === typeof options.sep) {
    options.sep = [options.sep];
  } else {
    options.sep = options.sep || csvOpts.sep;
  }
  if(!options.sep.length) {
    throw new Error('The option.sep argument is required.');
  }
  if(options.linesep && 'string' === typeof options.linesep) {
    options.linesep = [options.linesep];
  } else {
    options.linesep = options.linesep || csvOpts.linesep;
  }
  if(!options.linesep.length) {
    throw new Error('The option.sep argument is required.');
  }
  // Quotes (optionnal)
  if(options.quote && 'string' === typeof options.quote) {
    options.quote = [options.quote];
  } else {
    options.quote = options.quote || [];
  }
  // Escape (optionnal)
  if('string' === typeof options.esc) {
    options.esc = [options.esc];
  } else {
    options.esc = options.esc || csvOpts.esc;
  }
  if('string' === typeof options.toEsc) {
    options.toEsc = [options.toEsc];
  }
  if('undefined' === typeof options.toEsc && options.esc.length) {
    options.toEsc = options.quote.concat(options.esc);
    if(!options.quote.length) {
      options.toEsc = options.toEsc.concat(options.sep).concat(options.linesep);
    }
  } else {
    options.toEsc = options.toEsc || [];
  }
  // ToQuote
  if('string' === typeof options.toQuote) {
    options.toQuote = [options.toQuote];
  }
  if('undefined' === typeof options.toQuote && options.quote.length) {
    options.toQuote = options.sep.concat(options.linesep).concat(options.quote)
      .concat(options.esc);
  } else {
    options.toQuote = options.toQuote || [];
  }
  return options;
}
251780
function check( input, expected ) {
            const output = Util.replaceDotsWithSlashes( input );
            expect( output ).toBe( expected.split( '/' ).join( Path.sep ) );
        }
690027
function(element, options)
    {
        // Make sure the transform property is an object
        if(typeof element.transform != "object")
        {
            element.transform = {};
        }

        // If we have an object of options
        if(typeof options[0] == "object")
        {
            // Loop through object properties and save their values
            var keys = Object.keys(options[0]);

            keys.forEach(function(property)
            {
                element.transform[property] = options[0][property];
            });
        }
        
        // Otherwise, loop through all of the options to find values
        else
        {
            var property = options[0];
            var args = [];

            for(var i = 1, l = options.length; i < l; i++)
            {
                args.push(options[i]);
            }

            element.transform[property] = args;
        }
    }
678515
function _reevaluateInputs() {

                    var inputElements = element.find('input');

                    $angular.forEach(inputElements, function forEach(inputElement, index) {

                        inputElement = $angular.element(inputElement);

                        inputElement.val('');
                        inputElement.val(scope._model[index]);

                    });

                }
486862
private function checkUpdateAllInput()
    {
        
        $defaults = array('input' => dirname(__FILE__) . '/../../' . $this->options['extension'] . '/' . self::DEF_INPUT_DIR,
        				  'output' => dirname(__FILE__) . '/../../' . $this->options['extension'] . '/' . self::DEF_OUTPUT_DIR,
        				  'extension' => null);
        
        $this->options = array_merge($defaults, $this->options);
        
    	// The input 'parameter' is optional.
		$this->checkInputOption();

		// The 'output' parameter is optional.
		$this->checkOutputOption();
        
    }
1293689
def _replace_options(string, options)
      # Unescape the string so we can use the returned string
      # to set an elements inner html.
      s = string.gsub('&lt;', '<').gsub('&gt;', '>')

      if options
        # But escape option values to prevent code injection
        s.gsub(/%\{(\w+)\}/) do |m|
          key = ($1 || m.tr("%{}", ""))

          if options.key?(key)
            options[key].to_s.gsub('<', '&lt;').gsub('>', '&gt;')
          else
            key
          end
        end
      else
        s
      end
    end
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
    }
662313
def _string_check(self, value, allow_list=False):
        '''
        
        '''
        if self._optcre is self.OPTCRE or value:
            is_list = isinstance(value, list)
            if is_list and not allow_list:
                raise TypeError('option value cannot be a list unless allow_list is True')
            elif not is_list:
                value = [value]
            if not all(isinstance(x, six.string_types) for x in value):
                raise TypeError('option values must be strings')