standard-css-notate CamelCased string.
@param {String} string
@returns {String}
9159
function(string) {
			return string.replace(/[A-Z]/g, function(all, letter) {
				return "-" + string.charAt(letter).toLowerCase();
			});
		}
65478
static function ToJavascript($string, $htmlEncode = true)
        {    
            if ($htmlEncode)
            {
                $string = self::ToHtml($string);
            }
            return '\'' . addcslashes($string, "'\r\n\\") . '\'';
        }
481103
function(string, color) {
      return "\u001B[" + {
       bold    : 1,
       black   : 30,
       red     : 31,
       green   : 32,
       yellow  : 33,
       blue    : 34,
       magenta : 35,
       cyan    : 36,
       white   : 37
      }[color] + 'm' + string + "\u001B[0m"
    }
564033
function escape (string) {
  return string
    .replace(/ /g, '\\ ')
    .replace(/\n/g, '')
    .replace(/\(/g, '\\(')
    .replace(/\)/g, '\\)');
}
708403
public function css($string)
    {
        if (!$string) {
            return $string;
        }

        $string = $this->toUtf8($string);
        if ($string === '' || ctype_digit($string)) {
            return $string;
        }

        $result = preg_replace_callback('/[^a-z0-9]/iSu', $this->cssMatcher, $string);
        return $this->fromUtf8($result);
    }
1018303
function(s) {
    return '"' + s.replace(/[\u0000-\u001f"\\\u007f-\uffff]/g, function (c) {
      switch (c) {
      case '\b':
        return '\\b';
      case '\f':
        return '\\f';
      case '\n':
        return '\\n';
      case '\r':
        return '\\r';
      case '\t':
        return '\\t';
      // IE doesn't support this
      /*
      case '\v':
        return '\\v';
      */
      case '"':
        return '\\"';
      case '\\':
        return '\\\\';
      default:
        return '\\u' + jscoverage_pad(c.charCodeAt(0).toString(16));
      }
    }) + '"';
  }
408268
function styleStringify (obj) {
  var key;
  var keyCount = 0;
  var i = 0;
  var str = '';

  for (key in obj) { keyCount++; }

  for (key in obj) {
    str += (key + ': ' + obj[key]);
    if (i < keyCount - 1) { str += '; '; }
    i++;
  }
  return str;
}
1172887
function format(string) {
        string = string.toLowerCase().replace(/-(.)?/g, function ($0, $1) {
            return '-' + $1.toUpperCase();
        });

        return string.charAt(0).toUpperCase()
            + string.substring(1);
    }
93275
function camelCase(text) {
    text = text || '';
    return text.replace(/(?:^\w|[A-Z]|\b\w)/g, (letter, index) => {
        return index === 0 ? letter.toLowerCase() : letter.toUpperCase();
    }).replace(/\s+/g, '');
}
1279245
def string_literal(string)
      Literal.new(Sass::Script::Value::String.new(string, :string))
    end
717153
function camelCase(s) {
    // Convert first character to lowercase
    return s.replace(/^\w/, function (match) {
        return match.toLowerCase();
    })
    .replace(/-\w/g, function (match) {
        return match.charAt(1).toUpperCase();
    });
}
917758
public function formatAnsi($string) {
        $styleStack = [];

        // match all tags like <tag> and </tag>
        $groups = $this->formatParser->parseFormat($string);

        foreach ($groups as $group) {
            $tag = $group[0]; // <tag> or </tag>
            $styleName = $group[1]; // tag
            $stylesString = $group[2]; // stuff like color=red

            // do not process unknown style tags
            if ($styleName !== 'style' && ! $this->hasStyle($styleName)) {
                continue;
            }

            // is this a closing tag?
            if (stripos($tag, '/') !== false) {
                // get previous style
                array_pop($styleStack);
                $styleCode = array_last($styleStack);

                if ( ! $styleCode) {
                    $styleCode = 0;
                }
            } else {
                if ($styleName === 'style') {
                    $style = new ConsoleStyle('style');
                } else {
                    $style = $this->getStyle($styleName);
                }

                if ($style instanceof IConsoleStyle) {
                    // clone style to prevent unwanted
                    // modification on future uses
                    $style = clone $style;
                    $style->parseStyle($stylesString);
                    $styleCode = $style->getStyleCode();
                }

                $styleStack[] = $styleCode;
            }

            // replace first matching tag with the escape sequence;
            $pattern = s('#%s#', preg_quote($tag));
            $escapeSequence = s("\e[%sm", $styleCode);

            $string = preg_replace($pattern, $escapeSequence, $string, 1);
        }

        $string = $this->formatParser->unescapeTags($string);

        return $string;
    }
733964
public static final String camelCase(String string) {

		StringBuilder sb = new StringBuilder();

		boolean upperFlag = false;

		for (int i = 0; i < string.length(); i++) {
			char ch = string.charAt(i);
			if (ch == '-')
				upperFlag = true;
			else if (upperFlag && Character.isLetter(ch)) {
				sb.append(Character.toUpperCase(ch));
				upperFlag = false;
			} else if (!upperFlag && Character.isLetter(ch))
				sb.append(ch);
			else if (ch == '_') // vendor extension
				sb.append(ch);
		}
		return sb.toString();
	}
712632
function camelToKebab( string ) {
	return string.replace( ptnCamel, ( all, predecessor, match ) => predecessor + "-" + match.toLocaleLowerCase() );
}
1368449
private function createStyleFromString(string $string)
    {
        if (isset($this->styles[$string])) {
            return $this->styles[$string];
        }

        if (!preg_match_all('/([^=]+)=([^;]+)(;|$)/', $string, $matches, PREG_SET_ORDER)) {
            return false;
        }

        $style = new OutputFormatterStyle();
        foreach ($matches as $match) {
            array_shift($match);
            $match[0] = strtolower($match[0]);

            if ('fg' == $match[0]) {
                $style->setForeground(strtolower($match[1]));
            } elseif ('bg' == $match[0]) {
                $style->setBackground(strtolower($match[1]));
            } elseif ('href' === $match[0]) {
                $style->setHref($match[1]);
            } elseif ('options' === $match[0]) {
                preg_match_all('([^,;]+)', strtolower($match[1]), $options);
                $options = array_shift($options);
                foreach ($options as $option) {
                    $style->setOption($option);
                }
            } else {
                return false;
            }
        }

        return $style;
    }
220999
function camelize(s) {
    return s.replace(STRING_CAMELIZE, function (match, separator, chr) {
        return chr.toUpperCase();
    }).replace(/^([A-Z])/, function (match) {
        return match.toLowerCase();
    });
}
255992
function showInvisibles(str) {
  let ret = '';
  for (let i = 0; i < str.length; i++) {
    switch (str[i]) {
      case ' ':
        ret += '·'; // Middle Dot, \u00B7
        break;
      case '\n':
        ret += '⏎'; // Return Symbol, \u23ce
        break;
      case '\t':
        ret += '↹'; // Left Arrow To Bar Over Right Arrow To Bar, \u21b9
        break;
      case '\r':
        ret += '␍'; // Carriage Return Symbol, \u240D
        break;
      default:
        ret += str[i];
        break;
    }
  }
  return ret;
}