Implement a Capitalize Utility Type in TypeScript

This challenge asks you to create a TypeScript utility type that transforms the first letter of a string literal type to uppercase, while keeping the rest of the string as is. This is a common pattern for creating more descriptive string literal types, such as FirstName or CompanyName, where you might want to enforce a specific casing convention.

Problem Description

Your task is to define a generic TypeScript utility type named Capitalize<T>. This type should accept a string literal type T as its input.

Requirements:

• If T is an empty string, Capitalize<T> should also be an empty string.
• If T starts with a lowercase letter, Capitalize<T> should return a new string literal type where the first letter is uppercase and the rest of the string remains unchanged.
• If T already starts with an uppercase letter or any non-alphabetic character, Capitalize<T> should return T unchanged.

Expected Behavior:

The Capitalize<T> type should be a conditional type that inspects the structure of the input string T and applies the transformation accordingly. You will need to leverage TypeScript's template literal types and intrinsic string manipulation types.

Edge Cases:

• Empty string input.
• Strings starting with uppercase letters.
• Strings starting with numbers or symbols.

Examples

Example 1:

Input: "hello"
Output: "Hello"
Explanation: The first letter 'h' is converted to 'H'.

Example 2:

Input: "world"
Output: "World"
Explanation: The first letter 'w' is converted to 'W'.

Example 3:

Input: "TypeScript"
Output: "TypeScript"
Explanation: The string already starts with an uppercase letter, so it remains unchanged.

Example 4:

Input: ""
Output: ""
Explanation: An empty string input results in an empty string output.

Example 5:

Input: "1st place"
Output: "1st place"
Explanation: The string starts with a number, so it remains unchanged.

Constraints

• The solution must be implemented solely using TypeScript's type system.
• No runtime JavaScript code is required; this is a purely type-level programming exercise.
• The solution should be efficient and not lead to excessive type inference or computation time for typical string literal types.

Notes

Consider how you can pattern match on the beginning of a string literal type. TypeScript's intrinsic string manipulation types (like Uppercase, Lowercase, Capitalize, Uncapitalize) can be very useful here, but the challenge is to implement one of them from scratch to understand the underlying principles. You might find it helpful to think about how to extract the first character and the rest of the string separately.