### Install and Build Packages with pnpm

Source: https://github.com/jamesmoss/emojitron/blob/main/README.md

This bash script demonstrates the basic commands for setting up and building the monorepo using pnpm. It covers dependency installation, building all packages, running tests, and performing type checks.

```bash
pnpm install

pnpm build

pnpm test

pnpm typecheck
```

--------------------------------

### Manipulate Emoji Size and Create Patterns with TypeScript

Source: https://github.com/jamesmoss/emojitron/blob/main/README.md

Shows how to utilize the `@emoji-toolkit/size` package for controlling emoji dimensions and arranging them into visual patterns. Examples include scaling emojis to be larger, creating rectangular grids, progress bars, and pyramid structures.

```typescript
import { makeLarge, createGrid, createProgressBar, createPyramid } from "@emoji-toolkit/size";

// Scale emojis
makeLarge("⭐"); // "⭐⭐⭐"

// Create shapes
createGrid("🟦", 3, 3);
// 🟦🟦🟦
// 🟦🟦🟦
// 🟦🟦🟦

createProgressBar("🟢", "⚪", 0.7, 10); // "🟢🟢🟢🟢🟢🟢🟢⚪⚪⚪"

createPyramid("🔺", 3);
//   🔺
//  🔺🔺🔺
// 🔺🔺🔺🔺🔺
```

--------------------------------

### Monorepo Development Scripts with pnpm

Source: https://github.com/jamesmoss/emojitron/blob/main/README.md

This section outlines the essential pnpm scripts used for developing and maintaining the Emoji Toolkit monorepo. These scripts facilitate common development tasks such as building, running in watch mode, testing, linting, and cleaning build artifacts.

```bash
pnpm build      # Build all packages
pnpm dev        # Watch mode for development
pnpm test       # Run all tests
pnpm lint       # Type check all packages
pnpm clean      # Clean build outputs
```

--------------------------------

### Combine Emojis into ZWJ Sequences and Patterns with TypeScript

Source: https://github.com/jamesmoss/emojitron/blob/main/README.md

Demonstrates the functionality of the `@emoji-toolkit/combiner` package for creating complex emoji sequences, particularly Zero-Width Joiner (ZWJ) combinations. It also includes utilities for generating preset sequences and creative patterns like waves and mirrors.

```typescript
import { createFamily, getPresetSequence, wave, mirror } from "@emoji-toolkit/combiner";

// Create ZWJ combinations
createFamily("👨", "👩", "👧"); // "👨‍👩‍👧"

// Use presets
getPresetSequence("moon"); // "🌑🌒🌓🌔🌕🌖🌗🌘"

// Creative patterns
wave("🌊", 3); // "🌊 🌊🌊 🌊🌊🌊 🌊🌊 🌊"
mirror(["🔴", "🟡", "🟢"]); // "🔴🟡🟢🟡🔴"
```

--------------------------------

### Combine Emojis and Create Patterns with @emoji-toolkit/combiner

Source: https://context7.com/jamesmoss/emojitron/llms.txt

Demonstrates how to combine emojis using Zero-Width Joiner (ZWJ) to create families, professions, and preset sequences. It also includes functions for generating wave, mirror, and alternating patterns, as well as creating bullet lists.

```typescript
import { createFamily, createProfession, wave, mirror, alternate, getPresetSequence, bulletList } from "@emoji-toolkit/combiner";

// Create family combinations using ZWJ
const family = createFamily("👨", "👩", "👧", "👦");
// Returns: "👨‍👩‍👧‍👦" (renders as single family emoji)

// Create profession emojis
const developer = createProfession("👨", "💻"); // Returns: "👨‍💻"
const scientist = createProfession("👩", "🔬"); // Returns: "👩‍🔬"
const artist = createProfession("👩", "🎨"); // Returns: "👩‍🎨"

// Get preset emoji sequences
const moonPhases = getPresetSequence("moon");
// Returns: "🌑🌒🌓🌔🌕🌖🌗🌘"

const loveSequence = getPresetSequence("love");
// Returns: "💕💖💗💓💞"

// Create wave pattern (crescendo and decrescendo)
const wavePattern = wave("🌊", 3);
// Returns: "🌊 🌊🌊 🌊🌊🌊 🌊🌊 🌊"

// Create mirror pattern
const mirrored = mirror(["🔴", "🟡", "🟢"]);
// Returns: "🔴🟡🟢🟡🔴"

// Create alternating pattern
const checkered = alternate("⬛", "⬜", 8);
// Returns: "⬛⬜⬛⬜⬛⬜⬛⬜"

// Create bullet list
const list = bulletList("✨", ["First item", "Second item", "Third item"]);
// Returns:
// ✨ First item
// ✨ Second item
// ✨ Third item

```

--------------------------------

### Apply Color Themes and Skin Tones with TypeScript

Source: https://github.com/jamesmoss/emojitron/blob/main/README.md

Illustrates the usage of the `@emoji-toolkit/colorizer` package for modifying emoji appearance. This includes applying various skin tone modifiers and applying color themes, such as making specific emojis green or colorizing heart emojis.

```typescript
import { applySkinTone, makeGreen, colorizeHearts } from "@emoji-toolkit/colorizer";

// Apply skin tones
applySkinTone("👋", "dark"); // "👋🏿"

// Color themes
makeGreen("I ❤️ coding"); // Replaces hearts with green emojis
colorizeHearts("Love 💙 nature", "green"); // "Love 💚 nature"
```

--------------------------------

### Generate Random Emojis and Passwords with TypeScript

Source: https://github.com/jamesmoss/emojitron/blob/main/README.md

Explains how to use the `@emoji-toolkit/randomizer` package for generating random emojis, selecting emojis from specific categories, shuffling arrays of emojis, and creating emoji-based passwords. This package is useful for adding an element of randomness to applications.

```typescript
import { randomEmoji, randomFromCategory, shuffle, emojiPassword } from "@emoji-toolkit/randomizer";

// Random emojis
randomEmoji(); // "🎉" (random)
randomFromCategory("animals"); // "🐶" (random animal)

// Shuffle
shuffle(["🍎", "🍊", "🍋"]); // ["🍊", "🍎", "🍋"] (random order)

// Generate emoji password
emojiPassword(4); // "🌟🐸🎨🚀"
```

--------------------------------

### Explore Emoji Collections and Options

Source: https://context7.com/jamesmoss/emojitron/llms.txt

Query available options and explore emoji collections using utilities from @emoji-toolkit/randomizer, @emoji-toolkit/colorizer, @emoji-toolkit/mood, @emoji-toolkit/size, and @emoji-toolkit/combiner. These functions help retrieve categories, emojis within categories, color themes, mood types, size options, and preset sequences.

```typescript
import { getAvailableCategories, getEmojisInCategory } from "@emoji-toolkit/randomizer";
import { getAvailableThemes } from "@emoji-toolkit/colorizer";
import { getAvailableMoods, getEmojisForMood } from "@emoji-toolkit/mood";
import { getAvailableSizes } from "@emoji-toolkit/size";
import { getAvailablePresets } from "@emoji-toolkit/combiner";

// Get all available emoji categories
const categories = getAvailableCategories();
// Returns: ["smileys", "people", "animals", "food", "travel", "activities", "objects", "symbols", "nature"]

// Get all emojis in a category
const animals = getEmojisInCategory("animals");
// Returns: ["🐶", "🐱", "🐭", "🐹", "🐰", "🦊", "🐻", ...]

// Get available color themes
const themes = getAvailableThemes();
// Returns: ["green", "blue", "red", "yellow", "purple", "pink"]

// Get available mood types
const moods = getAvailableMoods();
// Returns: ["happy", "sad", "angry", "calm", "surprised", "neutral"]

// Get emojis for a specific mood
const angryEmojis = getEmojisForMood("angry");
// Returns: ["😠", "😡", "🤬", "👿", "💢", "😤", "🔥", "💀"]

// Get available size options
const sizes = getAvailableSizes();
// Returns: ["tiny", "small", "medium", "large", "huge", "giant"]

// Get available preset sequences
const presets = getAvailablePresets();
// Returns: ["love", "weather", "moon", "time", "growth", "fire", "ocean", "space", "food", "celebration"]
```

--------------------------------

### Transform Emoji Moods with TypeScript

Source: https://github.com/jamesmoss/emojitron/blob/main/README.md

Demonstrates how to use the `@emoji-toolkit/mood` package to detect and transform the emotional state of emojis within text. It includes functions for making emojis sad, transforming moods to a specified state, and detecting the inherent mood of an emoji.

```typescript
import { makeHappySad, transformMood, detectMood } from "@emoji-toolkit/mood";

// Detect emoji mood
detectMood("😀"); // "happy"
detectMood("😢"); // "sad"

// Transform moods
makeHappySad("Hello 😀 World! 😊"); // "Hello 😢 World! 😭"
transformMood("😠", "calm"); // "😌"
```

--------------------------------

### Scale Emojis and Create Patterns (TypeScript)

Source: https://context7.com/jamesmoss/emojitron/llms.txt

This functionality allows scaling emojis to different sizes (large, huge, tiny) and creating various visual patterns such as grids, pyramids, and progress bars. It involves repeating emojis with separators and can be used for generating visual representations in text-based applications. The relevant package is `@emoji-toolkit/size`.

```typescript
import { makeLarge, createGrid, createProgressBar, createPyramid, scaleEmoji } from "@emoji-toolkit/size";

// Scale emojis to different sizes
const large = makeLarge("⭐"); // Returns: "⭐⭐⭐"
const huge = makeHuge("🔥"); // Returns: "🔥 🔥 🔥 🔥"
const tiny = makeTiny("💎"); // Returns: "·💎·"

// Create a grid pattern
const grid = createGrid("🟦", 3, 4);
// Returns:
// 🟦🟦🟦🟦
// 🟦🟦🟦🟦
// 🟦🟦🟦🟦

// Create a pyramid
const pyramid = createPyramid("🔺", 4);
// Returns:
//    🔺
//   🔺🔺🔺
//  🔺🔺🔺🔺🔺
// 🔺🔺🔺🔺🔺🔺🔺

// Create a progress bar
const progress = createProgressBar("🟢", "⚪", 0.7, 10);
// Returns: "🟢🟢🟢🟢🟢🟢🟢⚪⚪⚪"

const loading = createProgressBar("█", "░", 0.35, 20);
// Returns: "███████░░░░░░░░░░░░░"

// Repeat emoji with separator
const repeated = repeatEmoji("⭐", 5, " ");
// Returns: "⭐ ⭐ ⭐ ⭐ ⭐"
```

--------------------------------

### Analyze Emoji Sequences with @emoji-toolkit/combiner

Source: https://context7.com/jamesmoss/emojitron/llms.txt

This snippet focuses on analyzing emoji sequences, specifically Zero-Width Joiner (ZWJ) combinations. It includes functions to determine if an emoji is a ZWJ sequence, split a sequence into its component emojis, and decompose known ZWJ combinations. It also allows retrieval of all known ZWJ combinations.

```typescript
import { splitZWJ, isZWJSequence, decomposeZWJ, getKnownZWJCombinations } from "@emoji-toolkit/combiner";

// Check if emoji is a ZWJ sequence
const isSequence = isZWJSequence("👨‍💻"); // Returns: true
const isNotSequence = isZWJSequence("😀"); // Returns: false

// Split ZWJ sequence into components
const components = splitZWJ("👨‍👩‍👧");
// Returns: ["👨", "👩", "👧"]

// Decompose known ZWJ combinations
const familyParts = decomposeZWJ("👨‍👩‍👧‍👦");
// Returns: ["👨", "👩", "👧", "👦"]

const rainbowFlag = decomposeZWJ("🏳️‍🌈");
// Returns: ["🏳️", "🌈"]

const unknownEmoji = decomposeZWJ("😀");
// Returns: null (not a ZWJ sequence)

// Get all known ZWJ combinations
const allCombinations = getKnownZWJCombinations();
// Returns object mapping combined emojis to their components:
// {
//   "👨‍👩‍👧": ["👨", "👩", "👧"],
//   "👨‍💻": ["👨", "💻"],
//   "🏳️‍🌈": ["🏳️", "🌈"],
//   ...
// }

```

--------------------------------

### Replace Emojis with Color Themes (TypeScript)

Source: https://context7.com/jamesmoss/emojitron/llms.txt

This function enables replacing emojis, particularly hearts, with alternatives from predefined color themes. It provides quick color transformations for text (e.g., making text green or blue), fetching random emojis associated with a specific color theme, and retrieving all emojis belonging to a particular theme. The functionality is part of the `@emoji-toolkit/colorizer` package.

```typescript
import { colorizeHearts, makeGreen, makeBlue, getColoredEmoji, getEmojisForTheme } from "@emoji-toolkit/colorizer";

// Replace heart emojis with a specific color theme
const greenHearts = colorizeHearts("I ❤️ nature 💙 and forests 💛", "green");
// Returns: "I 💚 nature 🌲 and forests 🥒" (random green emojis)

// Quick color transformations
const greenText = makeGreen("Love ❤️ coding"); // Converts to green theme
const blueText = makeBlue("Ocean 💙 waves ❤️"); // Converts to blue theme

// Get a random emoji from a color theme
const greenEmoji = getColoredEmoji("green"); // Returns random: 💚, 🥒, 🥦, etc.
const redEmoji = getColoredEmoji("red"); // Returns random: ❤️, 🔴, 🍎, etc.

// Get all emojis for a theme
const purpleEmojis = getEmojisForTheme("purple");
// Returns: ["💜", "🍇", "🍆", "🔮", "☂️", "🟣", "🟪", "👾", "🦄", "🌸", "🎵", "🪻"]
```

--------------------------------

### Generate Random Emojis with @emoji-toolkit/randomizer

Source: https://context7.com/jamesmoss/emojitron/llms.txt

Provides functions for generating random emojis, either completely random, from specific categories, or as unique sequences. It also includes utilities for shuffling emojis in arrays or within text, creating emoji passwords, and performing weighted random selections. Dice rolling and coin flipping are also supported.

```typescript
import { randomEmoji, randomFromCategory, shuffle, emojiPassword, weightedRandom, randomEmojis, shuffleEmojisInText, rollDice, flipCoin } from "@emoji-toolkit/randomizer";

// Get a completely random emoji
const random = randomEmoji(); // Returns random emoji from all categories

// Get random emoji from specific category
const randomAnimal = randomFromCategory("animals"); // Returns: "🐶", "🐱", etc.
const randomFood = randomFromCategory("food"); // Returns: "🍕", "🍔", etc.
const randomSmiley = randomFromCategory("smileys"); // Returns: "😀", "😂", etc.

// Generate multiple random emojis
const multipleRandom = randomEmojis(5, false); // Returns 5 random (may repeat)
const uniqueRandom = randomEmojis(5, true); // Returns 5 unique emojis

// Shuffle an array of emojis
const original = ["🍎", "🍊", "🍋", "🍇", "🍓"];
const shuffled = shuffle(original); // Returns shuffled order: ["🍋", "🍎", "🍇", "🍓", "🍊"]

// Shuffle emojis within text (preserves text, moves emojis)
const text = "Hello 😀 world 🌍 how are you 👋";
const shuffledText = shuffleEmojisInText(text);
// Returns: "Hello 🌍 world 👋 how are you 😀" (example)

// Generate emoji password
const password = emojiPassword(6); // Returns: "🌟🐸🎨🚀🍕💡"

// Weighted random selection
const weighted = weightedRandom({
  "🎯": 10,  // 50% chance
  "⭐": 6,   // 30% chance
  "💫": 4    // 20% chance
});

// Roll dice and flip coin
const diceRoll = rollDice(); // Returns one of: "⚀", "⚁", "⚂", "⚃", "⚄", "⚅"
const coinFlip = flipCoin("👍", "👎"); // Returns: "👍" or "👎"

```

--------------------------------

### Apply and Analyze Skin Tones (TypeScript)

Source: https://context7.com/jamesmoss/emojitron/llms.txt

This function allows applying specific skin tone modifiers to person emojis and removing existing ones. It can also identify the skin tone of an emoji or apply a chosen skin tone to all compatible emojis within a given text. The primary package for these operations is `@emoji-toolkit/colorizer`. Input emojis can be single characters or strings containing multiple emojis.

```typescript
import { applySkinTone, removeSkinTone, getSkinTone, applyAllSkinTones } from "@emoji-toolkit/colorizer";

// Apply skin tone to a single emoji
const darkSkinWave = applySkinTone("👋", "dark"); // Returns: "👋🏿"
const mediumSkinTone = applySkinTone("👍", "medium"); // Returns: "👍🏽"
const unsupported = applySkinTone("🚀", "dark"); // Returns: "🚀" (unchanged)

// Remove skin tone modifiers
const baseEmoji = removeSkinTone("👋🏿"); // Returns: "👋"

// Check what skin tone an emoji has
const tone = getSkinTone("👋🏿"); // Returns: "dark"
const noTone = getSkinTone("👋"); // Returns: null

// Apply skin tone to all compatible emojis in text
const text = "Hello 👋 nice to meet you 🤝 let's high five 🙌";
const tonedText = applyAllSkinTones(text, "medium-dark");
// Returns: "Hello 👋🏾 nice to meet you 🤝🏾 let's high five 🙌🏾"
```

--------------------------------

### Transform Emojis in Text

Source: https://context7.com/jamesmoss/emojitron/llms.txt

Apply advanced text transformations to emojis while preserving surrounding content using functions from @emoji-toolkit/mood, @emoji-toolkit/randomizer, and @emoji-toolkit/size. These utilities allow for mood transformation, random emoji selection (global or category-specific), and scaling of emojis within text.

```typescript
import { transformAllMoods } from "@emoji-toolkit/mood";
import { randomizeEmojis } from "@emoji-toolkit/randomizer";
import { scaleAllEmojis } from "@emoji-toolkit/size";

// Transform all emojis in text to a specific mood
const happyText = "Great day 😀 but feeling stressed 😰 and angry 😠";
const calmVersion = transformAllMoods(happyText, "calm");
// Returns: "Great day 😌 but feeling stressed 😇 and angry 🧘"

// Randomize all emojis in text
const original = "I love 🍕 and 🍔 for lunch";
const randomized = randomizeEmojis(original);
// Returns: "I love 🎨 and 🚀 for lunch" (completely random emojis)

const categoryRandomized = randomizeEmojis(original, "food");
// Returns: "I love 🍣 and 🌮 for lunch" (random food emojis only)

// Scale all emojis in text
const textWithEmojis = "Great work 👍 keep it up 🎯 amazing 🌟";
const largeVersion = scaleAllEmojis(textWithEmojis, "large");
// Returns: "Great work 👍👍👍 keep it up 🎯🎯🎯 amazing 🌟🌟🌟"
```

--------------------------------

### Transform Emoji Moods (TypeScript)

Source: https://context7.com/jamesmoss/emojitron/llms.txt

This function transforms emoji moods between different states like happy, sad, angry, and calm. It can detect the current mood of an emoji, transform single emojis, or modify all emojis of a certain mood within a text. It also allows fetching a random emoji for a specified mood. Dependencies include the `@emoji-toolkit/mood` package.

```typescript
import { detectMood, transformMood, makeHappySad, makeAngryCool, getEmojiForMood } from "@emoji-toolkit/mood";

// Detect the current mood of an emoji
const mood = detectMood("😀"); // Returns: "happy"
const sadMood = detectMood("😢"); // Returns: "sad"
const unknownMood = detectMood("🚀"); // Returns: null

// Transform a single emoji to a different mood
const calmEmoji = transformMood("😠", "calm"); // Returns: "😌"
const happyEmoji = transformMood("😢", "happy"); // Returns: "😀" (or similar)

// Transform all happy emojis to sad in text
const sadText = makeHappySad("Hello 😀 World! 😊 Great day! 😁");
// Returns: "Hello 😢 World! 😭 Great day! 😢"

// Calm down angry text
const calmText = makeAngryCool("I'm so mad 😠😡🤬");
// Returns: "I'm so mad 😌😇🧘"

// Get a random emoji for a specific mood
const randomHappy = getEmojiForMood("happy"); // Returns random from: 😀, 😃, 😄, etc.
```

=== COMPLETE CONTENT === This response contains all available snippets from this library. No additional content exists. Do not make further requests.