import re

def sanitize_unicode(input_string, keep_ascii_only=True):
    """
    Remove emojis and non-ASCII characters from strings.
    
    Args:
        input_string (str): The string to sanitize
        keep_ascii_only (bool): If True, keep only ASCII characters.
                                If False, keep letters/numbers but remove emojis/symbols.
    
    Returns:
        str: Sanitized string safe for codebases and config files
    """
    
    # Pattern to match most emojis and pictographs
    emoji_pattern = re.compile(
        "["
        "\U0001F600-\U0001F64F"  # emoticons
        "\U0001F300-\U0001F5FF"  # symbols & pictographs
        "\U0001F680-\U0001F6FF"  # transport & map symbols
        "\U0001F1E0-\U0001F1FF"  # flags (iOS)
        "\U00002702-\U000027B0"  # dingbats
        "\U000024C2-\U0001F251"  # enclosed characters
        "]+",
        flags=re.UNICODE
    )
    
    # Remove emojis
    clean_string = emoji_pattern.sub(r'', input_string)
    
    if keep_ascii_only:
        # Keep only ASCII characters (codes 0-127)
        clean_string = clean_string.encode('ascii', 'ignore').decode('ascii')
    else:
        # Alternative: Keep letters, numbers, basic punctuation
        clean_string = re.sub(r'[^\w\s.,!?;:\-()\[\]{}]', '', clean_string)
    
    return clean_string.strip()


# Example usage:
if __name__ == "__main__":
    dirty_code = "print('Hello World! 😂🚀')  # This will break in production"
    clean_code = sanitize_unicode(dirty_code)
    print(f"Original: {dirty_code}")
    print(f"Sanitized: {clean_code}")
    # Output: print('Hello World! ')  # This will break in production

The Problem: When Your Codebase Catches Feelings

Let's be honest: we've all done it. You're deep in a heated Slack debate about whether tabs or spaces are morally superior, and you paste a code snippet to prove your point. "Look," you type, "this function is clearly broken 😂." That laughing-crying face? It's not just commentary. It's a stowaway. It hitchhikes into your IDE when you copy-paste the "fixed" version back into your editor. Suddenly, your Python function has more emotional range than a Netflix teen drama, and your linter is too polite to mention it.

This isn't just about aesthetics. This is about production outages that start with a single 🚀 emoji in a deployment script. The problem exists because our communication tools have evolved faster than our development discipline. We live in a world where GitHub comments support emoji reactions, commit messages have become performance art, and our brains have been rewired to append 👍 to every semi-coherent thought. The boundary between "expressive communication" and "executable code" has blurred like a developer's vision at 3 AM during crunch week.

The absurdity reaches its peak when you consider the debugging process. Your tests pass locally (because your terminal font hides the emoji), CI passes (because the runner uses a different encoding), but production crashes with "SyntaxError: invalid character." You check the logs, search Stack Overflow, question your life choices, and finally—after eliminating every other possibility—you notice the tiny, colorful culprit: a single 🐛 emoji that was supposed to be metaphorical but became literal. The time wasted isn't just about fixing the error; it's about the existential crisis that follows when you realize a smiley face outsmarted you.

The Solution: A Digital Condom for Your Codebase

Enter the Emoji Syntax Sanitizer—the tool your codebase desperately needs but is too embarrassed to ask for. Think of it as a bouncer at the club of your repository, checking IDs and turning away any Unicode characters that look suspiciously like they belong in a text message rather than a ternary operator.

At its core, the tool does something beautifully simple: it scans your source files for non-ASCII emojis and replaces them with safe, boring, predictable ASCII equivalents. That 😅 that snuck into your error handling? It becomes // TODO: fix this. That 🚀 in your deployment script? It becomes # DEPLOY. The tool operates on the principle that while emotions have no place in production code, TODO comments are always welcome.

Despite the humorous premise, this tool solves a genuine problem. It's the digital equivalent of checking your fly before leaving the bathroom—a small, preventative measure that saves you from catastrophic embarrassment later. In an era where we copy-paste from chat apps more often than we write original code, having a safety net against invisible syntax errors isn't just convenient; it's professional hygiene.

How to Use It: Sanitizing Your Code in Three Easy Steps

Installation is as straightforward as the problem is absurd. With Node.js installed, you can add the sanitizer to your project:

npm install emoji-syntax-sanitizer --save-dev

Basic usage involves pointing it at your source directory:

npx sanitize-emoji ./src

The magic happens in the main scanning function. Here's a simplified look at how it identifies those pesky emojis (check out the full source code for the complete implementation):

function containsEmoji(str) {
  const emojiRegex = /[\u{1F300}-\u{1F5FF}\u{1F600}-\u{1F64F}\u{1F680}-\u{1F6FF}\u{2600}-\u{26FF}\u{2700}-\u{27BF}]/gu;
  return emojiRegex.test(str);
}

function sanitizeFile(content) {
  return content.replace(emojiRegex, (match) => {
    return `// TODO: removed emoji ${match}`;
  });
}

This isn't just pattern matching—it's an intervention for your code's emotional baggage.

Key Features That Will Make You Feel Less Ashamed

• Comprehensive Emoji Detection: Scans source files for non-ASCII emojis across the entire Unicode emoji range, because 🦄 deserves to be caught just as much as 😭.
• Safe ASCII Replacement: Transforms emotional outbursts into professional commentary (😅 → // TODO: fix this, 🔥 → // HOTFIX, etc.).
• Shame Report Generation: Produces a beautifully formatted report of offending files, perfect for passive-aggressively sharing in your team chat.
• Optional Git Pre-commit Hook Integration: Prevent emotional contamination before it even reaches staging, because prevention is cheaper than therapy.
• Configurable Replacement Dictionary: Customize what each emoji becomes, because sometimes 🐛 should be "FIXME: actual bug" rather than just "BUG."

Conclusion: Clean Code Starts With Unicode Hygiene

In the grand tradition of developer tools, the Emoji Syntax Sanitizer exists because we've created a problem that previous generations of programmers couldn't have imagined. Our ancestors worried about memory allocation and pointer arithmetic; we worry about whether the crying-laughing face will break our Kubernetes deployment. Progress!

The benefits extend beyond preventing syntax errors. You'll sleep better knowing your production environment won't crash because someone got too enthusiastic in Slack. Your code reviews will focus on logic rather than emotional expression. And most importantly, you'll never again have to explain to your manager why the outage was caused by a single 😬 in the authentication middleware.

Try it out today: https://github.com/BoopyCode/emoji-syntax-sanitizer

Remember: just because your code can express emotions doesn't mean it should. Leave the 😍 for DMs and the 🚀 for marketing copy. Your production server will thank you.