// Variables
let firstName = 'John';
let userAge = 30;
let isLoggedIn = true;

// Functions
function getUserData() { }
function calculateTotalPrice() { }
function sendEmailNotification() { }

// Object properties
const user = {
  userId: 123,
  userName: 'john_doe',
  emailAddress: '[email protected]',
  phoneNumber: '555-0123'
};

// Classes
class UserProfile { }
class DatabaseConnection { }
class HttpClient { }

// React components
function NavigationMenu() { }
const UserProfileCard = () => { };

// Constructors
const currentDate = new Date();
const userMap = new Map();

// Types (TypeScript)
interface UserData { }
type ApiResponse = { };

# Variables
first_name = 'John'
user_age = 30
is_logged_in = True

# Functions
def get_user_data():
    pass

def calculate_total_price():
    pass

# Database columns
user_profiles = {
    'user_id': 123,
    'user_name': 'john_doe',
    'email_address': '[email protected]',
    'created_at': '2024-01-01'
}

/* CSS classes */
.user-profile { }
.nav-menu-item { }
.btn-primary { }
.card-header-title { }

/* CSS IDs */
#main-content { }
#user-profile-section { }

/* URLs */
https://example.com/user-profile
https://example.com/blog/case-converter-guide

/* File names */
user-profile.component.ts
date-utils.js
main-styles.css

// Constants
const API_KEY = 'abc123';
const MAX_RETRIES = 3;
const DATABASE_URL = 'postgresql://localhost';

// Environment variables
process.env.NODE_ENV
process.env.API_KEY
process.env.DATABASE_URL

// C preprocessor macros
#define MAX_BUFFER_SIZE 1024
#define PI 3.14159

# Unix commands
ls
cd
mkdir
rm

# Python modules
import datetime
import json
from collections import defaultdict

# File names
readme.md
package.json
dockerfile

The Quick Brown Fox Jumps Over the Lazy Dog
Getting Started With React and TypeScript
A Guide to Modern JavaScript Development
How to Build Scalable Web Applications

# Note: Articles, conjunctions, and short prepositions are lowercase
# unless they're the first or last word

This is a sentence case example
Enter your email address
Submit your application
Delete this item
Create new account

// Java packages
package com.example.myapp;
package com.company.project.utils;

// Configuration paths
app.database.host
app.cache.redis.url
logging.level.com.example

// Property access
user.profile.settings.notifications
config.api.endpoints.users

class CaseConverter {
  // Convert to camelCase
  static toCamelCase(str) {
    return str
      .replace(/(?:^\w|[A-Z]|\b\w)/g, (letter, index) =>
        index === 0 ? letter.toLowerCase() : letter.toUpperCase()
      )
      .replace(/\s+|[-_]+/g, '');
  }

  // Convert to PascalCase
  static toPascalCase(str) {
    return str
      .replace(/(?:^\w|[A-Z]|\b\w)/g, letter => letter.toUpperCase())
      .replace(/\s+|[-_]+/g, '');
  }

  // Convert to snake_case
  static toSnakeCase(str) {
    return str
      .replace(/([A-Z])/g, '_$1')
      .replace(/\s+|-+/g, '_')
      .toLowerCase()
      .replace(/^_/, '');
  }

  // Convert to kebab-case
  static toKebabCase(str) {
    return str
      .replace(/([A-Z])/g, '-$1')
      .replace(/\s+|_+/g, '-')
      .toLowerCase()
      .replace(/^-/, '');
  }

  // Convert to SCREAMING_SNAKE_CASE
  static toScreamingSnakeCase(str) {
    return this.toSnakeCase(str).toUpperCase();
  }

  // Convert to Title Case
  static toTitleCase(str) {
    const smallWords = /^(a|an|and|as|at|but|by|for|if|in|nor|of|on|or|so|the|to|up|yet)$/i;

    return str
      .toLowerCase()
      .split(' ')
      .map((word, index, array) => {
        if (index === 0 || index === array.length - 1) {
          return word.charAt(0).toUpperCase() + word.slice(1);
        }
        if (smallWords.test(word)) {
          return word;
        }
        return word.charAt(0).toUpperCase() + word.slice(1);
      })
      .join(' ');
  }

  // Convert to Sentence case
  static toSentenceCase(str) {
    return str.charAt(0).toUpperCase() + str.slice(1).toLowerCase();
  }

  // Convert to dot.notation
  static toDotNotation(str) {
    return str
      .replace(/([A-Z])/g, '.$1')
      .replace(/\s+|[-_]+/g, '.')
      .toLowerCase()
      .replace(/^\./, '');
  }
}

const input = 'hello world example';

console.log(CaseConverter.toCamelCase(input));
// "helloWorldExample"

console.log(CaseConverter.toPascalCase(input));
// "HelloWorldExample"

console.log(CaseConverter.toSnakeCase(input));
// "hello_world_example"

console.log(CaseConverter.toKebabCase(input));
// "hello-world-example"

console.log(CaseConverter.toScreamingSnakeCase(input));
// "HELLO_WORLD_EXAMPLE"

console.log(CaseConverter.toTitleCase(input));
// "Hello World Example"

console.log(CaseConverter.toSentenceCase(input));
// "Hello world example"

console.log(CaseConverter.toDotNotation(input));
// "hello.world.example"

// Using template literals and modern JS
const toCamelCase = (str) =>
  str
    .toLowerCase()
    .replace(/[^a-zA-Z0-9]+(.)/g, (_, chr) => chr.toUpperCase());

const toKebabCase = (str) =>
  str
    .replace(/([a-z])([A-Z])/g, '$1-$2')
    .replace(/[\s_]+/g, '-')
    .toLowerCase();

const toSnakeCase = (str) =>
  str
    .replace(/([a-z])([A-Z])/g, '$1_$2')
    .replace(/[\s-]+/g, '_')
    .toLowerCase();

// Chaining conversions
const transform = (str) => ({
  value: str,
  toCamel() {
    this.value = toCamelCase(this.value);
    return this;
  },
  toKebab() {
    this.value = toKebabCase(this.value);
    return this;
  },
  toString() {
    return this.value;
  }
});

// Usage
const result = transform('Hello World')
  .toCamel()
  .toString();
// "helloWorld"

import re

class CaseConverter:
    @staticmethod
    def to_camel_case(text):
        """Convert to camelCase"""
        words = re.sub(r'[^a-zA-Z0-9]', ' ', text).split()
        if not words:
            return ''
        return words[0].lower() + ''.join(w.capitalize() for w in words[1:])

    @staticmethod
    def to_pascal_case(text):
        """Convert to PascalCase"""
        words = re.sub(r'[^a-zA-Z0-9]', ' ', text).split()
        return ''.join(w.capitalize() for w in words)

    @staticmethod
    def to_snake_case(text):
        """Convert to snake_case"""
        # Insert underscore before capital letters
        s1 = re.sub('(.)([A-Z][a-z]+)', r'\1_\2', text)
        # Insert underscore before capital letter sequences
        s2 = re.sub('([a-z0-9])([A-Z])', r'\1_\2', s1)
        # Replace spaces and hyphens with underscores
        s3 = re.sub(r'[\s-]+', '_', s2)
        return s3.lower()

    @staticmethod
    def to_kebab_case(text):
        """Convert to kebab-case"""
        s1 = re.sub('(.)([A-Z][a-z]+)', r'\1-\2', text)
        s2 = re.sub('([a-z0-9])([A-Z])', r'\1-\2', s1)
        s3 = re.sub(r'[\s_]+', '-', s2)
        return s3.lower()

    @staticmethod
    def to_screaming_snake_case(text):
        """Convert to SCREAMING_SNAKE_CASE"""
        return CaseConverter.to_snake_case(text).upper()

    @staticmethod
    def to_title_case(text):
        """Convert to Title Case"""
        return text.title()

    @staticmethod
    def to_sentence_case(text):
        """Convert to Sentence case"""
        return text.capitalize()

# Usage
converter = CaseConverter()
text = "hello world example"

print(converter.to_camel_case(text))         # helloWorldExample
print(converter.to_pascal_case(text))        # HelloWorldExample
print(converter.to_snake_case(text))         # hello_world_example
print(converter.to_kebab_case(text))         # hello-world-example
print(converter.to_screaming_snake_case(text))  # HELLO_WORLD_EXAMPLE

# Using the inflection library
import inflection

text = "hello world example"

print(inflection.camelize(text, False))      # helloWorldExample
print(inflection.camelize(text))             # HelloWorldExample
print(inflection.underscore(text))           # hello_world_example
print(inflection.dasherize(text))            # hello-world-example
print(inflection.titleize(text))             # Hello World Example

# With PascalCase
pascal = "UserProfileData"
print(inflection.underscore(pascal))         # user_profile_data
print(inflection.dasherize(pascal))          # user-profile-data

# Install: pip install inflection

<?php
class CaseConverter
{
    public static function toCamelCase($str)
    {
        $str = str_replace(['-', '_'], ' ', $str);
        $str = ucwords($str);
        $str = str_replace(' ', '', $str);
        return lcfirst($str);
    }

    public static function toPascalCase($str)
    {
        $str = str_replace(['-', '_'], ' ', $str);
        $str = ucwords($str);
        return str_replace(' ', '', $str);
    }

    public static function toSnakeCase($str)
    {
        $str = preg_replace('/([a-z])([A-Z])/', '$1_$2', $str);
        $str = str_replace([' ', '-'], '_', $str);
        return strtolower($str);
    }

    public static function toKebabCase($str)
    {
        $str = preg_replace('/([a-z])([A-Z])/', '$1-$2', $str);
        $str = str_replace([' ', '_'], '-', $str);
        return strtolower($str);
    }
}

// Usage
echo CaseConverter::toCamelCase('hello world');    // helloWorld
echo CaseConverter::toSnakeCase('helloWorld');     // hello_world
?>

public class CaseConverter {
    public static String toCamelCase(String str) {
        String[] words = str.split("[\\s_-]+");
        StringBuilder result = new StringBuilder(words[0].toLowerCase());

        for (int i = 1; i < words.length; i++) {
            result.append(capitalize(words[i]));
        }

        return result.toString();
    }

    public static String toPascalCase(String str) {
        String[] words = str.split("[\\s_-]+");
        StringBuilder result = new StringBuilder();

        for (String word : words) {
            result.append(capitalize(word));
        }

        return result.toString();
    }

    public static String toSnakeCase(String str) {
        return str.replaceAll("([a-z])([A-Z])", "$1_$2")
                  .replaceAll("[\\s-]+", "_")
                  .toLowerCase();
    }

    public static String toKebabCase(String str) {
        return str.replaceAll("([a-z])([A-Z])", "$1-$2")
                  .replaceAll("[\\s_]+", "-")
                  .toLowerCase();
    }

    private static String capitalize(String str) {
        if (str == null || str.isEmpty()) return str;
        return str.substring(0, 1).toUpperCase() + str.substring(1).toLowerCase();
    }
}

using System;
using System.Text.RegularExpressions;
using System.Linq;

public class CaseConverter
{
    public static string ToCamelCase(string str)
    {
        var words = Regex.Split(str, @"[\s_-]+");
        return words[0].ToLower() +
               string.Concat(words.Skip(1).Select(Capitalize));
    }

    public static string ToPascalCase(string str)
    {
        var words = Regex.Split(str, @"[\s_-]+");
        return string.Concat(words.Select(Capitalize));
    }

    public static string ToSnakeCase(string str)
    {
        return Regex.Replace(str, @"([a-z])([A-Z])", "$1_$2")
                    .Replace(" ", "_")
                    .Replace("-", "_")
                    .ToLower();
    }

    public static string ToKebabCase(string str)
    {
        return Regex.Replace(str, @"([a-z])([A-Z])", "$1-$2")
                    .Replace(" ", "-")
                    .Replace("_", "-")
                    .ToLower();
    }

    private static string Capitalize(string str)
    {
        if (string.IsNullOrEmpty(str)) return str;
        return char.ToUpper(str[0]) + str.Substring(1).ToLower();
    }
}

class CaseConverter
  def self.to_camel_case(str)
    str.split(/[\s_-]+/).map.with_index do |word, index|
      index == 0 ? word.downcase : word.capitalize
    end.join
  end

  def self.to_pascal_case(str)
    str.split(/[\s_-]+/).map(&:capitalize).join
  end

  def self.to_snake_case(str)
    str.gsub(/([a-z\d])([A-Z])/, '\1_\2')
       .gsub(/[\s-]+/, '_')
       .downcase
  end

  def self.to_kebab_case(str)
    str.gsub(/([a-z\d])([A-Z])/, '\1-\2')
       .gsub(/[\s_]+/, '-')
       .downcase
  end

  def self.to_screaming_snake_case(str)
    to_snake_case(str).upcase
  end
end

# Usage
puts CaseConverter.to_camel_case('hello world')    # helloWorld
puts CaseConverter.to_snake_case('HelloWorld')     # hello_world