Here we split them into { wrapper: {}, label: {}, hint: {}, input: {} }
 And make sure to keep any additional options on the input: {}
437217
def extract_options!(options, html_options: nil)
      options.symbolize_keys!
      html_options.symbolize_keys! if html_options

      # effective_bootstrap specific options
      layout = options.delete(:layout) # Symbol
      wrapper = options.delete(:wrapper) # Hash
      input_group = { append: options.delete(:append), prepend: options.delete(:prepend), input_group: options.delete(:input_group) }.compact

      feedback = options.delete(:feedback) # Hash
      label = options.delete(:label) # String or Hash
      hint = options.delete(:hint) # String or Hash

      input_html = options.delete(:input_html) || {} # Hash
      input_js = options.delete(:input_js) || {} # Hash

      # Every other option goes to input
      @options = input = (html_options || options)

      # Merge all the default objects, and intialize everything
      wrapper = merge_defaults!(wrapper, wrapper_options)
      input_group = merge_defaults!(input_group, input_group_options)
      feedback = merge_defaults!(feedback, feedback_options)

      label = merge_defaults!(label, label_options)
      hint = merge_defaults!(hint, hint_options)

      merge_defaults!(input.merge!(input_html), input_html_options)
      merge_defaults!(input_js, input_js_options)

      if input_js.present?
        merge_defaults!(input_js, input_js_options_method_name)
        input['data-input-js-options'] = JSON.generate(input_js)
      end

      { layout: layout, wrapper: wrapper, input_group: input_group, label: label, hint: hint, input: input, feedback: feedback }
    end
275188
def label(method, *args, &block)
      options = args.extract_options!
      i18n = options[:i18n] || {}
      text = object.translate(
          method, i18n.reverse_merge(:include_associations => true)
      ) if object.respond_to? :translate
      text ||= args.first
      super(method, text, options, &block)
    end
75427
function TextInput( options = {} ) {
	Element.call( this , options ) ;

	// TextBufffer needs computed attr, not object one
	this.textAttr = options.textAttr || { bgColor: 'blue' } ;
	this.emptyAttr = options.emptyAttr || { bgColor: 'blue' } ;

	this.hidden = options.hidden ;

	this.labelFocusAttr = options.labelFocusAttr || { bold: true } ;
	this.labelBlurAttr = options.labelBlurAttr || { dim: true } ;

	if ( options.keyBindings ) { this.keyBindings = options.keyBindings ; }

	if ( options.editableTextBoxKeyBindings ) { this.editableTextBoxKeyBindings = options.editableTextBoxKeyBindings ; }
	else if ( options.allowNewLine ) { this.editableTextBoxKeyBindings = this.multiLineEditableTextBoxKeyBindings ; }

	if ( this.label ) {
		this.labelText = new Text( {
			parent: this ,
			content: this.label ,
			x: this.outputX ,
			y: this.outputY ,
			height: 1 ,
			attr: this.labelBlurAttr ,
			leftPadding: this.labelBlurLeftPadding ,
			rightPadding: this.labelBlurRightPadding ,
			noDraw: true
		} ) ;
	}

	this.editableTextBox = new EditableTextBox( {
		parent: this ,
		content: this.value || this.content ,
		x: this.outputX + ( this.labelText ? this.labelText.outputWidth : 0 ) ,
		y: this.outputY ,
		width: this.outputWidth - ( this.labelText ? this.labelText.outputWidth : 0 ) ,
		height: this.outputHeight ,
		hidden: this.hidden ,
		textAttr: this.textAttr ,
		emptyAttr: this.emptyAttr ,
		keyBindings: this.editableTextBoxKeyBindings ,
		noDraw: true
	} ) ;

	this.updateStatus() ;

	this.onKey = this.onKey.bind( this ) ;
	this.onFocus = this.onFocus.bind( this ) ;
	this.onClick = this.onClick.bind( this ) ;

	this.on( 'key' , this.onKey ) ;
	this.on( 'focus' , this.onFocus ) ;
	this.on( 'click' , this.onClick ) ;

	// Only draw if we are not a superclass of the object
	if ( this.elementType === 'TextInput' && ! options.noDraw ) { this.draw() ; }
}
467030
function splitInput(str) {
  if (str.slice(0, 3) !== '---') return;

  var matcher = /\n(\.{3}|-{3})/g;
  var metaEnd = matcher.exec(str);

  return metaEnd && [str.slice(0, metaEnd.index), str.slice(matcher.lastIndex)];
}
1341764
def split_input(val, mapper=None):
    '''
    
    '''
    if mapper is None:
        mapper = lambda x: x
    if isinstance(val, list):
        return list(map(mapper, val))
    try:
        return list(map(mapper, [x.strip() for x in val.split(',')]))
    except AttributeError:
        return list(map(mapper, [x.strip() for x in six.text_type(val).split(',')]))
1022448
private void makeFunAnnotations(Constituent cons, String[] funCatLabels) {

		if (funCatLabels != null && funCatLabels.length > 1) {
			String labeltype;
			for (int i = 1; i < funCatLabels.length; i++) {
				labeltype = funTable.get(funCatLabels[i]);
				if (labeltype != null) {
					Class c = cons.getClass();
					if (labeltype.equals("formFuncDisc")) {
						if (c.equals(GENIAConstituent.class))
							((GENIAConstituent) cons)
									.setFormFuncDisc(funCatLabels[i]);
						if (c.equals(PennBioIEConstituent.class))
							((PennBioIEConstituent) cons)
									.setFormFuncDisc(funCatLabels[i]);
						if (c.equals(PTBConstituent.class))
							((PTBConstituent) cons)
									.setFormFuncDisc(funCatLabels[i]);
					}

					if (labeltype.equals("gramRole")) {
						if (c.equals(GENIAConstituent.class))
							((GENIAConstituent) cons)
									.setGramRole(funCatLabels[i]);
						if (c.equals(PennBioIEConstituent.class))
							((PennBioIEConstituent) cons)
									.setGramRole(funCatLabels[i]);
						if (c.equals(PTBConstituent.class))
							((PTBConstituent) cons)
									.setGramRole(funCatLabels[i]);
					}

					if (labeltype.equals("adv")) {
						if (c.equals(GENIAConstituent.class))
							((GENIAConstituent) cons).setAdv(funCatLabels[i]);
						if (c.equals(PennBioIEConstituent.class))
							((PennBioIEConstituent) cons)
									.setAdv(funCatLabels[i]);
						if (c.equals(PTBConstituent.class))
							((PTBConstituent) cons).setAdv(funCatLabels[i]);
					}

					if (labeltype.equals("misc")) {
						if (c.equals(GENIAConstituent.class))
							((GENIAConstituent) cons).setMisc(funCatLabels[i]);
						if (c.equals(PennBioIEConstituent.class))
							((PennBioIEConstituent) cons)
									.setMisc(funCatLabels[i]);
						if (c.equals(PTBConstituent.class))
							((PTBConstituent) cons).setMisc(funCatLabels[i]);
					}

					if (labeltype.equals("syn")) {
						if (c.equals(GENIAConstituent.class))
							((GENIAConstituent) cons).setSyn(funCatLabels[i]);

					}

				}
			}
		}

	}
1246424
function labels (modelName, callback) {

    if (callback) {
        return get(modelName, true).getLabels(callback);
    }

    return get(modelName, true).getLabels();

}
1227363
def AddLabel(self, label):
    
    if not isinstance(label, py2to3.STRING_TYPES):
      raise TypeError('label is not a string type. Is {0:s}'.format(
          type(label)))
    if not self._VALID_LABEL_REGEX.match(label):
      raise ValueError((
          'Unsupported label: "{0:s}". A label must only consist of '
          'alphanumeric characters or underscores.').format(label))

    if label not in self.labels:
      self.labels.append(label)
597811
function ( options ) {
                    var label;

                    options || ( options = {} );
                    label = getLabel( options, this );
                    if ( isIgnoredLabel( label, this ) ) return this;

                    if ( getSelectionSize( this, label ) === this.length ) {
                        this.deselectAll( options );
                    } else {
                        this.selectAll( options );
                    }

                    return this;
                }
192799
def indent_func(input_):
    
    if isinstance(input_, six.string_types):
        # A label was specified
        lbl = input_
        return _indent_decor(lbl)
    elif isinstance(input_, (bool, tuple)):
        # Allow individually turning of of this decorator
        func = input_
        return func
    else:
        # Use the function name as the label
        func = input_
        lbl = '[' + meta_util_six.get_funcname(func) + ']'
        return _indent_decor(lbl)(func)
1245419
function deepSplitString (input, separators) {
  if (input === null || typeof input === 'undefined') {
    return input
  }
  if (separators.length === 0) {
    return input
  }

  const sep = separators.shift()
  let output = input

  if (typeof input === 'string') {
    output = splitString(input, sep)
  } else if (Array.isArray(input)) {
    output = input.map(i => splitString(i, sep))
  } else if (typeof input === 'object') {
    output = {}
    Object.keys(input).forEach(key => {
      output[key] = splitString(input[key], sep)
    })
  }

  if (separators.length > 0) {
    return deepSplitString(output, separators)
  } else {
    return output
  }
}
642326
function setAllowLabel () {
  var values = getCheckedAndUnchecked(
    form.allow.json, form.allow.yaml, form.allow.text, form.allow.empty, form.allow.unknown);

  switch (values.checked.length) {
    case 0:
      form.allow.label.text("No file types allowed");
      break;
    case 1:
      form.allow.label.text("Only allow " + values.checked[0] + " files");
      break;
    case 2:
      form.allow.label.text("Only allow " + values.checked[0] + " and " + values.checked[1]);
      break;
    case 3:
      form.allow.label.text("Don't allow " + values.unchecked[0] + " or " + values.unchecked[1]);
      break;
    case 4:
      form.allow.label.text("Don't allow " + values.unchecked[0] + " files");
      break;
    case 5:
      form.allow.label.text("Allow all file types");
  }
}
491324
def options(self):
        '''
        
        '''
        conv = self.conv
        for python_value, label in self.choices:
            yield conv.from_python(python_value), label
379116
function Delimiters (delims, options) {
  this.options = options || {};
  this.delims = delims || [];

  this.defaults = merge({}, {
    beginning: '^',           // '^' Matches beginning of input.
    matter: '([\\s\\S]+?)',   // The "content" between the delims
    body: '([\\s\\S]+|\\s?)', // The "content" after the delims
    end: '$',                 // '$' Matches end of input.
    flags: ''                 // RegExp flags: g, m, i
  }, options);
}
955417
def flip_labels(obj):
    
    def sub(a, b):
        """
        Substitute all keys that start with a to b
        """
        for label in list(obj.keys()):
            if label.startswith(a):
                new_label = b+label[1:]
                obj[new_label] = obj.pop(label)

    sub('x', 'z')
    sub('y', 'x')
    sub('z', 'y')
    return obj
418777
def enrich_literal(label)
      node = DPLA::MAP::Controlled::Language.new()
      node.providedLabel = label

      match = match_iso(label.to_s)
      match = match_label(label.to_s) if match.node?

      # if match is still a node, we didn't find anything
      return node if match.node?

      node.exactMatch = match 
      node.prefLabel = RDF::ISO_639_3[match.rdf_subject.qname[1]].label.last
      node
    end
35840
function splitField(chunk, strict) {
  const field = String(chunk);
  const index = field.indexOf(':');

  if (index === -1) {
    throw new SyntaxError(`field separator is not found: "${field}"`);
  }

  const label = field.slice(0, index);
  const value = field.slice(index + 1);

  if (strict && !(0, _validator.isValidLabel)(label)) {
    throw new SyntaxError(`unexpected character of label: "${label}"`);
  }

  if (strict && !(0, _validator.isValidValue)(value)) {
    throw new SyntaxError(`unexpected character of value: "${value}"`);
  }

  return {
    label,
    value
  };
}