Normalize case of names that are not name-spaced.  This lower-cases HTML
element and attribute names, but not ones for embedded SVG or MATHML.
964300
static String canonicalName(String elementOrAttribName) {
    return elementOrAttribName.indexOf(':') >= 0
        ? elementOrAttribName : Strings.toLowerCase(elementOrAttribName);
  }
1298024
def element_name_from_Z(Z, normalize=False):
    '''
    '''

    r = element_data_from_Z(Z)[2]
    if normalize:
        return r.capitalize()
    else:
        return r
378319
def norm_slash(name):
    """"""

    if isinstance(name, str):
        return name.replace('/', "\\") if not is_case_sensitive() else name
    else:
        return name.replace(b'/', b"\\") if not is_case_sensitive() else name
688050
def camel_case_to_underscore(name):
    """"""
    res = RE_TOKEN1.sub(r'\1_\2', name)
    res = RE_TOKEN2.sub(r'\1_\2', res)
    return res.lower()
151737
public static function normalize($name)
	{
		if (!static::isValid($name))
		{
			throw new InvalidArgumentException("Invalid tag name '" . $name . "'");
		}

		// Non-namespaced tags are uppercased
		if (strpos($name, ':') === false)
		{
			$name = strtoupper($name);
		}

		return $name;
	}
981451
function dotToCamelCase(name) {
    if (!name) { return name; }

    if (name.substring(name.length - 3) === '.js') {
        name = name.substring(0, name.length - 3);
    }

    name = name.toLowerCase();
    var parts = name.split('.');

    name = parts[0];
    for (var i = 1; i < parts.length; i++) {
        name += parts[i].substring(0, 1).toUpperCase() + parts[i].substring(1);
    }

    return name;
}
1015978
public void normalizeCase() {
        // Scheme and host should be lowercase
        String scheme = uri.getScheme();
        String host = uri.getHost();
        String rURI = toString();
        if (scheme != null) {
            String lc = scheme.toLowerCase();
            if (!scheme.equals(lc)){
                rURI = rURI.replaceFirst(scheme, lc);
            }
        }
        if (host != null) {
            String lc = host.toLowerCase();
            if (!host.equals(lc)){
                rURI = rURI.replaceFirst(host, lc);
            }
        }

        // Percent-encoded characters should be uppercase
        if (rURI.indexOf('%') != -1) {
            Matcher m = PERCENT_ENCODED.matcher(rURI);

            StringBuffer sb = new StringBuffer();
            int lastEnd = 0;
            while(m.find()) {
                sb.append(rURI,lastEnd, m.start());
                sb.append(m.group().toUpperCase());
                lastEnd = m.end();
            }
            sb.append(rURI, lastEnd, rURI.length());
            rURI = sb.toString();
        }
        uri = URI.create(rURI);
    }
1251450
def normalize(self):
        """"""
        chrfunc = chr if py3k else HTMLEntity._unichr
        if self.named:
            return chrfunc(htmlentities.name2codepoint[self.value])
        if self.hexadecimal:
            return chrfunc(int(self.value, 16))
        return chrfunc(int(self.value))
419131
function caseInsensitiveAttribute(name) {
    if (typeof name === 'string') {
        if (this[name])
            return this[name];
        //otherwise make a case insensitive search
        var re = new RegExp('^' + name + '$','i');
        var p = Object.keys(this).filter(function(x) { return re.test(x); })[0];
        if (p)
            return this[p];
    }
}
945094
def normalize_selector(value, name)
      if (str = selector_to_str(value))
        return str
      end

      err = "#{value.inspect} is not a valid selector: it must be a string,\n" +
        "a list of strings, or a list of lists of strings"
      err = "$#{name.to_s.tr('_', '-')}: #{err}" if name
      raise ArgumentError.new(err)
    end
1077883
function normalizeCssText( unparsedCssText, nativeNormalize )
	{
		var styleText;
		if ( nativeNormalize !== false )
		{
			// Injects the style in a temporary span object, so the browser parses it,
			// retrieving its final format.
			var temp = new CKEDITOR.dom.element( 'span' );
			temp.setAttribute( 'style', unparsedCssText );
			styleText = temp.getAttribute( 'style' ) || '';
		}
		else
			styleText = unparsedCssText;

		// Normalize font-family property, ignore quotes and being case insensitive. (#7322)
		// http://www.w3.org/TR/css3-fonts/#font-family-the-font-family-property
		styleText = styleText.replace( /(font-family:)(.*?)(?=;|$)/, function ( match, prop, val )
		{
			var names = val.split( ',' );
			for ( var i = 0; i < names.length; i++ )
				names[ i ] = CKEDITOR.tools.trim( names[ i ].replace( /["']/g, '' ) );
			return prop + names.join( ',' );
		});

		// Shrinking white-spaces around colon and semi-colon (#4147).
		// Compensate tail semi-colon.
		return styleText.replace( /\s*([;:])\s*/, '$1' )
							 .replace( /([^\s;])$/, '$1;')
				 			// Trimming spaces after comma(#4107),
				 			// remove quotations(#6403),
				 			// mostly for differences on "font-family".
							 .replace( /,\s+/g, ',' )
							 .replace( /\"/g,'' )
							 .toLowerCase();
	}
756249
public String normalizeTag(String name) {
        name = name.trim();
        if (!preserveTagCase)
            name = lowerCase(name);
        return name;
    }
942053
function stringCase(str, caseValue) {
		switch (String(caseValue || '').toLowerCase()) {
			case 'lower':
				return str.toLowerCase();
			case 'upper':
				return str.toUpperCase();
		}
		
		return str;
	}
1003536
def normalizeToTag(val):
    
    try:
        val = val.upper()
    except AttributeError:
        raise KeyError("{} is not a tag or name string".format(val))
    if val not in tagsAndNameSetUpper:
        raise KeyError("{} is not a tag or name string".format(val))
    else:
        try:
            return fullToTagDictUpper[val]
        except KeyError:
            return val
909657
function normalize (val, safe) {
    return (
      val == null ? ''
      : val === false ? ''
      : Array.isArray(val) ? val.map(normalize).join('')
      : safe === false ? $.escapeHTML(val)
      : String(val)
    )
  }
721227
def _convert_to_standard_attr(attr):
    '''
    
    '''
    ret_attr = ATTR_MAP.get(attr, None)
    if ret_attr is None:
        # All others convert to lowercase
        return attr.lower()
    return ret_attr
158457
def normalize_text(self, value):
        
        if self.ignore_ws:
            value = self.normalize_whitespace(value)
        if self.ignore_case:
            value = self.normalize_case(value)
        if self.unicode_normal:
            value = self.normalize_unf(value)
        return value