NSUnderlineStyleAttribute

 :underline_style is either a Symbol or Array of symbols which will be OR'd together
323278
def underline_style_attribute(styles={})
      return nil if styles.nil?
      value = styles[:underline_style]
      return underline_style_value(value) if value.is_a? Symbol
      if value.is_a? Array
        bitsauce = 0
        value.each { |s| bitsauce |= underline_style_value(s) }
        bitsauce
      else
        nil
      end
    end
981705
def element_style(attrs, style_def, parent_style):
    """"""
    style = parent_style.copy()
    if 'class' in attrs:
        for css_class in attrs['class'].split():
            css_style = style_def['.' + css_class]
            style.update(css_style)
    if 'style' in attrs:
        immediate_style = dumb_property_dict(attrs['style'])
        style.update(immediate_style)
    return style
794749
def strikethrough_color_attribute(styles={})
      return nil if styles.nil?
      value = styles[:strikethrough_color]
      return nil unless value && value.is_a?(UIColor)
      value
    end
195384
def ligature_attribute(styles={})
      return nil if styles.nil?
      value = styles[:ligature]
      return 0 if [0, :off, :none].include?(value)
      return 1 if [1, :on, :default].include?(value)
      nil
    end
1317960
function(style)
	{
		var result = [];
		
		if (style != null)
		{
			var pairs = style.split(';');
			
			for (var i = 0; i < pairs.length; i++)
			{
				if (pairs[i].indexOf('=') < 0)
				{
					result.push(pairs[i]);
				}
			}
		}
				
		return result;
	}
405239
function (selectorText) {
            var rule, css, selector, cssRules = this.cssRules;
            if (selectorText) {
                rule = cssRules[selectorText];
                return rule ? rule.style.cssText : null;
            } else {
                css = [];
                for (selector in cssRules) {
                    rule = cssRules[selector];
                    css.push(rule.selectorText + ' {' + rule.style.cssText + '}');
                }
                return css.join('\n');
            }
        }
75298
function stringifyAttrs(attrs, tagName) {
  if (!attrs) {
    return '';
  }
  var attributes = [], value;
  for (var key in attrs) {
    value = attrs[key];
    if (key === 'style') {
      value = stringifyStyle(value);
    } else if (key === 'class') {
      value = stringifyClass(value);
    }
    attributes.push(key + '="' + String(value).replace(/"/g, '\\"') + '"');
  }
  return attributes.join(' ');
}
822384
function _underline(
    t,              // :: Type
    propPath,       // :: PropPath
    formatType3     // :: Type -> Array String -> String -> String
  ) {
    return formatType3 (t) (propPath) (t.format (_, function(k) {
      return K (_underline (t.types[k],
                            Z.concat (propPath, [k]),
                            formatType3));
    }));
  }
723680
def _asStr(self):
        '''
            
        '''

        styleDict = self._styleDict
        if styleDict:
            return '; '.join([name + ': ' + value for name, value in styleDict.items()])
        return ''
370018
def stylize(txt, bold=False, underline=False):
    

    setting = ''
    setting += _SET_BOLD if bold is True else ''
    setting += _SET_UNDERLINE if underline is True else ''
    return setting + str(txt) + _STYLE_RESET
650710
func (s Style) Underline(on bool) Style {
	return s.setAttrs(Style(AttrUnderline), on)
}
410642
def underline(self, msg):
        """"""
        return click.style(msg, underline=True) if self.colorize else msg
192396
function underlinedLink(linkColor = colors.textPrimary) {
  const underlineOffset = 2;
  const underlineWeight = 1;
  const backgroundColor = colors.bgPrimary;
  const underlineColor = rgba(linkColor, 0.4);

  return {
    color: linkColor,
    position: "relative",
    textDecoration: "none",
    transition: `color ${timing.fast} ease`,

    // Draw the underline with a background gradient
    backgroundImage: `linear-gradient(
      to top,
      transparent,
      transparent ${underlineOffset}px,
      ${underlineColor} ${underlineOffset}px,
      ${underlineColor} ${(underlineOffset + underlineWeight)}px,
      transparent ${(underlineOffset + underlineWeight)}px
    )`,

    // Create breaks in the underline
    textShadow: `-1px -1px 0 ${backgroundColor},
      1px -1px 0 ${backgroundColor},
      -1px 1px 0 ${backgroundColor},
      1px 1px 0 ${backgroundColor}`,
  };
}
1149450
protected void doAttributes(AttributedCharacterIterator iter) {
        underline = false;
        Set set = iter.getAttributes().keySet();
        for(Iterator iterator = set.iterator(); iterator.hasNext();) {
            AttributedCharacterIterator.Attribute attribute = (AttributedCharacterIterator.Attribute)iterator.next();
            if (!(attribute instanceof TextAttribute)) {
                continue;
            }
            TextAttribute textattribute = (TextAttribute)attribute;
            if(textattribute.equals(TextAttribute.FONT)) {
                Font font = (Font)iter.getAttributes().get(textattribute);
                setFont(font);
            }
            else if(textattribute.equals(TextAttribute.UNDERLINE)) {
                if(TextAttribute.UNDERLINE_ON.equals(iter.getAttributes().get(textattribute))) {
                    underline = true;
                }
            }
            else if(textattribute.equals(TextAttribute.SIZE)) {
                Object obj = iter.getAttributes().get(textattribute);
                if(obj instanceof Integer) {
                    int i = ((Integer)obj).intValue();
                    setFont(getFont().deriveFont(getFont().getStyle(), i));
                }
                else if(obj instanceof Float) {
                    float f = ((Float)obj).floatValue();
                    setFont(getFont().deriveFont(getFont().getStyle(), f));
                }
            }
            else if(textattribute.equals(TextAttribute.FOREGROUND)) {
                setColor((Color) iter.getAttributes().get(textattribute));
            }
            else if(textattribute.equals(TextAttribute.FAMILY)) {
              Font font = getFont();
              Map fontAttributes = font.getAttributes();
              fontAttributes.put(TextAttribute.FAMILY, iter.getAttributes().get(textattribute));
              setFont(font.deriveFont(fontAttributes));
            }
            else if(textattribute.equals(TextAttribute.POSTURE)) {
              Font font = getFont();
              Map fontAttributes = font.getAttributes();
              fontAttributes.put(TextAttribute.POSTURE, iter.getAttributes().get(textattribute));
              setFont(font.deriveFont(fontAttributes)); 
            }
            else if(textattribute.equals(TextAttribute.WEIGHT)) {
              Font font = getFont();
              Map fontAttributes = font.getAttributes();
              fontAttributes.put(TextAttribute.WEIGHT, iter.getAttributes().get(textattribute));
              setFont(font.deriveFont(fontAttributes)); 
            }
        }
    }
351125
@SuppressLint("InlinedApi")
    private static Object[] parseFontStyle(Context context, AttributeSet attrs, int defStyleAttr) {
        final TypedArray a = context.obtainStyledAttributes(attrs,
                R.styleable.TextAppearance, defStyleAttr, 0);
        final Object[] result = parseFontStyle(a);
        a.recycle();
        return result;
    }
587822
public function set_underline($underline = 1) {
        if ($underline == 1) {
            $this->properties['underline'] = 1;
        } else if ($underline == 2) {
            $this->properties['underline'] = 2;
        } else {
            unset($this->properties['underline']);
        }
    }
772677
function underlineTypeVars(typeInfo, valuesByPath) {
    //  Note: Sorting these keys lexicographically is not "correct", but it
    //  does the right thing for indexes less than 10.
    var paths = Z.map (JSON.parse, sortedKeys (valuesByPath));
    return underline (
      typeInfo,
      K (K (_)),
      function(index) {
        return function(f) {
          return function(t) {
            return function(propPath) {
              var indexedPropPath = Z.concat ([index], propPath);
              return function(s) {
                if (paths.some (isPrefix (indexedPropPath))) {
                  var key = JSON.stringify (indexedPropPath);
                  if (!(hasOwnProperty.call (valuesByPath, key))) return s;
                  if (!(isEmpty (valuesByPath[key]))) return f (s);
                }
                return _ (s);
              };
            };
          };
        };
      }
    );
  }