Case Converter

Different contexts expect text in different case conventions, and manually retyping a phrase into camelCase or CONSTANT_CASE is both tedious and error-prone. Developers rename things between naming conventions constantly — a database column in snake_case needs to become a JavaScript variable in camelCase, a class name needs PascalCase, an environment variable needs CONSTANT_CASE — while writers and editors more often need Title Case for headings or Sentence case for cleaning up text that was typed in all caps. This tool computes all ten conversions from a single input simultaneously, so you can see and copy whichever one you actually need without re-running a conversion for each format. The five simple, character-level conversions — UPPERCASE, lowercase, Title Case, Sentence case and aLtErNaTiNg CaSe — work directly on the text as typed, including its existing spacing and punctuation. UPPERCASE and lowercase are straightforward. Title Case capitalizes the first letter of every whitespace-separated word and lowercases the rest (this tool intentionally does not implement the more elaborate style-guide rule of keeping short connector words like "of" or "the" lowercase — every word is capitalized the same simple way, which is predictable and covers the common case well). Sentence case lowercases everything and then capitalizes only the first letter of the whole text and the first letter following each `.`, `!` or `?`, mimicking normal sentence capitalization. aLtErNaTiNg CaSe toggles the case of every letter in sequence, skipping over spaces and punctuation without breaking the alternating rhythm — so a space in the middle of the phrase does not reset the pattern back to lowercase. The five programmatic-case conversions — camelCase, PascalCase, snake_case, kebab-case and CONSTANT_CASE — are different in kind: they all first break the input into individual words using a single shared `splitWords()` helper, then reassemble those words with different casing and different separators. Getting the word-splitting step right is the crux of making these conversions actually useful on realistic input, because text pasted into a case converter rarely arrives as clean, single-style words. `splitWords()` handles three separate cases in sequence: it treats existing hyphens and underscores as word separators (so "example-text" or "my_variable" split the same way spaces do), it inserts a boundary wherever a lowercase letter or digit is immediately followed by an uppercase letter (so "helloWorld" splits into "hello" and "World"), and it inserts a boundary between a run of uppercase letters and a following capitalized word (so an acronym like "HTTPServer" splits into "HTTP" and "Server" rather than "H", "T", "T", "P", "Server"). This means a mixed input like "helloWorld example-text" or "my_HTTPRequest-handler" splits sensibly into clean words before being reassembled, instead of producing a mangled result the way a naive single-rule splitter would. Once split, camelCase lowercases the first word entirely and capitalizes the first letter of every subsequent word, joining them with no separator; PascalCase capitalizes every word's first letter and joins with no separator; snake_case lowercases every word and joins with underscores; kebab-case lowercases every word and joins with hyphens; and CONSTANT_CASE (also known as SCREAMING_SNAKE_CASE) uppercases every word and joins with underscores. Because all five share the same `splitWords()` word list, they always agree with each other about where one word ends and the next begins — converting the same input to snake_case and then to camelCase will always represent the identical word boundaries, just formatted differently.