diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index a278bc3..04497d8 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -11,7 +11,7 @@ jobs:
     runs-on: ubuntu-latest
     strategy:
       matrix:
-        node-version: [18, 20, 22]
+        node-version: [18, 20, 22, 24]
 
     steps:
       - uses: actions/checkout@v4
@@ -36,6 +36,15 @@ jobs:
         if: matrix.node-version != 18
         run: npm run test:coverage
 
+      - name: CLI smoke test
+        run: |
+          node bin/capstring.js --version
+          test "$(echo 'hello world' | node bin/capstring.js title)" = "Hello World"
+          test "$(node bin/capstring.js kebab 'XMLHttpRequest')" = "xml-http-request"
+
+      - name: Verify package contents
+        run: npm pack --dry-run
+
       - name: Upload coverage
         uses: codecov/codecov-action@v4
         if: matrix.node-version == 20
diff --git a/.npmignore b/.npmignore
deleted file mode 100644
index d3e0ac2..0000000
--- a/.npmignore
+++ /dev/null
@@ -1,42 +0,0 @@
-# Tests
-test
-tests
-testing
-
-# Services
-.codeclimate.yml
-.travis.yml
-codecov.yml
-.gitignore
-
-# Logs
-logs
-*.log
-npm-debug.log*
-
-# Runtime data
-pids
-*.pid
-*.seed
-
-# Coverage directory used by tools like istanbul
-coverage
-
-# Grunt intermediate storage (http://gruntjs.com/creating-plugins#storing-task-files)
-.grunt
-
-# node-waf configuration
-.lock-wscript
-
-# Compiled binary addons (http://nodejs.org/api/addons.html)
-build/Release
-
-# Dependency directories
-node_modules
-jspm_packages
-
-# Optional npm cache directory
-.npm
-
-# Optional REPL history
-.node_repl_history
diff --git a/AGENTS.md b/AGENTS.md
index add67be..008728a 100644
--- a/AGENTS.md
+++ b/AGENTS.md
@@ -2,57 +2,66 @@
 
 ## Overview
 
-`capstring` is a lightweight JavaScript library for text capitalization and transformation. Zero dependencies, 24+ styles.
+`capstring` is a lightweight JavaScript library for text capitalization and transformation.
+Zero dependencies, 37 styles, Unicode and emoji safe, ships a CLI and TypeScript types.
 
 ## Quick Start
 
 ```javascript
-import capstring from 'capstring';
+import capstring, { capstringAll } from 'capstring';
 
-capstring('hello world', 'title');    // 'Hello World'
-capstring('hello world', 'camel');    // 'helloWorld'
-capstring('hello world', 'kebab');    // 'hello-world'
-capstring('hello world', 'constant'); // 'HELLO_WORLD'
+capstring('hello world', 'title');     // 'Hello World'
+capstring('XMLHttpRequest', 'kebab');  // 'xml-http-request'
+capstring('Crème Brûlée', 'slug');     // 'creme-brulee'
+capstringAll('hi').upper;              // 'HI'
 ```
 
-## API
+```bash
+npx capstring kebab "Hello World"      # hello-world
+echo hi | npx capstring --all          # every style
+```
 
-### Main Function
+## API
 
 ```javascript
-capstring(str, style)
+capstring(str, style = 'same', { strict = false } = {})
 ```
 
 - `str` - String to transform
 - `style` - Style name (default: 'same')
-- Returns: Transformed string, or `false` if input invalid
-
-### Helper Functions
+- `strict` - Throw `TypeError` / `RangeError` instead of returning `false` / the input
+- Returns: Transformed string; `''` for empty input; `false` if `str` is not a string
 
 ```javascript
-import { getStyles, isValidStyle, STYLES } from 'capstring';
+import { capstringAll, getStyles, isValidStyle, STYLES, CATEGORIES } from 'capstring';
 
-getStyles();           // ['same', 'none', 'proper', ...]
-isValidStyle('kebab'); // true
-STYLES;                // Frozen array of all style names
+capstringAll('hi');     // { same: 'hi', none: '', ... } in STYLES order
+getStyles();            // fresh copy of STYLES
+isValidStyle('kebab');  // true
+STYLES;                 // frozen array of all 37 style names
+CATEGORIES;             // frozen { case, code, fun, encoding, art }
 ```
 
-## All 24 Styles
+## All 37 Styles
 
 | Category | Styles |
 |----------|--------|
-| Case | same, none, proper, title, sentence, upper, lower, swap |
-| Code | camel, pascal, snake, kebab, slug, constant, python, dot, path |
-| Fun | leet, reverse, sponge, mock, alternate, crazy, random |
+| case | same, none, proper, title, sentence, upper, lower, swap |
+| code | camel, pascal, snake, kebab, slug, constant, python, dot, path, train, hashtag, acronym |
+| fun | reverse, sponge, mock, alternate, crazy, random, clap, piglatin |
+| encoding | leet, rot13, morse, binary |
+| art | flip, smallcaps, bubble, wide, strike |
+
+## Files
+
+- `index.js` - the whole library. Must stay browser-safe: no `node:` imports, no `process`.
+- `cli.js` - CLI logic as `main(argv, io)`; `bin/capstring.js` is the executable shim.
+- `index.d.ts` - hand-written types. `test/types.test.js` fails if the `Style` union drifts from `STYLES`.
 
 ## Testing
 
 ```bash
 npm test              # Run tests
 npm run lint          # Run linter
-npm run test:coverage # Coverage report
+npm run test:coverage # Coverage report (100% thresholds enforced)
 ```
-
-## Related
-
-- **cAPIta** - REST API for capstring (https://github.com/brianfunk/cAPIta)
diff --git a/CHANGELOG.md b/CHANGELOG.md
index e48c5aa..58704a4 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -5,6 +5,43 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [1.1.0] - 2026-10-02
+
+### Added
+
+- **8 new styles** (37 total): `smallcaps`, `bubble`, `wide`, `strike`, `clap`, `morse`, `binary`, `piglatin`
+- **CLI**: `npx capstring <style> [text]`, `--all`, `--list`, `--json`, `--help`, `--version`; reads stdin when no text is given
+- **TypeScript declarations** (`index.d.ts`) with a `Style` union type for autocomplete
+- `capstringAll(str)` - every style at once, keyed by style name
+- `CATEGORIES` - frozen style groupings (`case`, `code`, `fun`, `encoding`, `art`)
+- `{ strict: true }` option - throw `TypeError` / `RangeError` instead of returning `false` / the input
+- Smart tokenizer for code styles: splits on camelCase boundaries, `_`, `-`, `.`, `/` and punctuation (`XMLHttpRequest` → `xml-http-request`)
+- `files` whitelist, `sideEffects: false`, `./package.json` export, `prepublishOnly` gate
+- 100% coverage thresholds enforced; Node 24 added to CI; CLI smoke test in CI
+
+### Behavior changes
+
+- Empty string input now returns `''` instead of `false` (non-string input still returns `false`)
+- `slug` is now a real slugifier: diacritics folded, punctuation removed, ASCII only (`Crème Brûlée & Co.` → `creme-brulee-co`). It no longer equals `kebab`, which keeps Unicode letters
+- All code styles tokenize camelCase and separator input (`helloWorld` → `hello_world`, was `helloworld`)
+- `title` is Unicode aware (`élan vital` → `Élan Vital`, was `éLan Vital`); `_` now breaks words
+- `sentence` capitalizes after `.`, `!`, `?` (`hello. world` → `Hello. World`)
+- `leet` uses the conventional ASCII map and preserves case (`hello WORLD` → `h3110 W0R1D`, was `h3££0 w0r£d`)
+- `alternate` counts Unicode letters, not just a-z
+- `hashtag` of text with no words returns `''` instead of `#`
+- `crazy` output may differ from 1.0.0 for text containing emoji (now seeded per code point)
+
+### Fixed
+
+- `reverse` and `flip` no longer corrupt emoji, flags, or combining accents (grapheme-cluster aware)
+- All styles iterate code points instead of UTF-16 code units
+- `@eslint/js` declared as a devDependency
+
+### Docs
+
+- Style count corrected everywhere (README, AGENTS.md, package.json)
+- README regrouped into Case / Code / Fun / Encodings / Unicode Art with behavior notes
+
 ## [1.0.0] - 2026-02-01
 
 ### Breaking Changes
diff --git a/CLAUDE.md b/CLAUDE.md
index 91fc7cd..3cdba10 100644
--- a/CLAUDE.md
+++ b/CLAUDE.md
@@ -2,7 +2,7 @@
 
 ## Project Context
 
-capstring is a lightweight JavaScript library for text capitalization and transformation. It supports 29 different styles including case transformations, code conventions, and fun styles.
+capstring is a lightweight JavaScript library for text capitalization and transformation. It supports 37 styles including case transformations, code conventions, encodings, and fun Unicode styles. Serious and robust, even though it's for fun.
 
 ## Development Commands
 
@@ -22,26 +22,33 @@ npm run test:coverage  # Run tests with coverage report
 
 ## Architecture
 
-Single-file library with a main function and helper exports:
-- `capstring(str, style)` - Main transformation function
-- `getStyles()` - Returns array of all style names
-- `isValidStyle(style)` - Validates a style name
-- `STYLES` - Frozen array constant of all styles
+Single-file library plus a thin CLI:
+- `index.js` - the whole library. **Must stay browser-safe**: no `node:` imports, no `process`.
+  - `capstring(str, style, { strict })` - Main transformation function
+  - `capstringAll(str, options)` - Every style at once
+  - `getStyles()`, `isValidStyle(style)`, `STYLES`, `CATEGORIES`
+- `cli.js` - `main(argv, io)` with injected I/O so it is unit-testable; `bin/capstring.js` is the shim
+- `index.d.ts` - hand-written types; `test/types.test.js` enforces that the `Style` union matches `STYLES`
 
-## Supported Styles (29 total)
+## Supported Styles (37 total)
 
 **Case:** same, none, proper, title, sentence, upper, lower, swap
-**Code:** camel, pascal, snake, kebab, slug, constant, python, dot, path, train
-**Fun:** leet, reverse, sponge, mock, alternate, crazy, random
-**New:** hashtag, acronym, rot13, flip
+**Code:** camel, pascal, snake, kebab, slug, constant, python, dot, path, train, hashtag, acronym
+**Fun:** reverse, sponge, mock, alternate, crazy, random, clap, piglatin
+**Encoding:** leet, rot13, morse, binary
+**Art:** flip, smallcaps, bubble, wide, strike
+
+Never remove a style name; `proper` and `python` are kept as aliases on purpose.
 
 ## When Making Changes
 
 1. Ensure all tests pass: `npm test`
-2. Maintain 100% coverage: `npm run test:coverage`
+2. Maintain 100% coverage (thresholds enforced): `npm run test:coverage`
 3. Run linter: `npm run lint`
-4. Update CHANGELOG.md for any user-facing changes
-5. Preserve the ASCII art header
+4. Update CHANGELOG.md for any user-facing changes; behavior changes get their own section
+5. Adding a style: add to `STYLES` **and** one `CATEGORIES` group **and** the `Style` union in `index.d.ts`, plus README table
+6. Preserve the ASCII art header
+7. Verify `npm pack --dry-run` still lists only the intended files
 
 ## Related Projects
 
diff --git a/README.md b/README.md
index 3af8281..7de8839 100644
--- a/README.md
+++ b/README.md
@@ -9,16 +9,20 @@
 
 # capstring
 
-> CaPiTaLiZe StRiNgS in 29 ways!
+> CaPiTaLiZe StRiNgS in 37 ways!
 
-A lightweight, zero-dependency library for text capitalization and transformation. Perfect for formatting strings for code, URLs, display, or fun!
+A small, serious, zero-dependency library for turning text into any case, code convention, or
+ridiculous fun style. Unicode and emoji safe. Ships a CLI and TypeScript types.
 
 ## Features
 
-- **29 transformation styles** - More than any other library!
-- **Zero dependencies** - Lightweight and fast
-- **ESM native** - Modern JavaScript modules
-- **98% test coverage** - Thoroughly tested
+- **37 transformation styles** - case, code conventions, encodings, and Unicode art
+- **Zero dependencies** - one 17 kB file, browser-safe
+- **Unicode aware** - `Élan Vital`, `crème-brûlée`, emoji and flags survive every style
+- **Smart tokenizer** - `XMLHttpRequest` becomes `xml-http-request`, `hello_world` becomes `helloWorld`
+- **CLI** - `npx capstring kebab "Hello World"`
+- **TypeScript types** - autocomplete for every style name
+- **100% test coverage**
 
 ## Installation
 
@@ -31,126 +35,166 @@ npm install capstring
 ```javascript
 import capstring from 'capstring';
 
-capstring('hello world', 'title');     // 'Hello World'
-capstring('hello world', 'camel');     // 'helloWorld'
-capstring('hello world', 'kebab');     // 'hello-world'
-capstring('hello world', 'constant');  // 'HELLO_WORLD'
-capstring('hello world', 'leet');      // 'h3££0 w0r£d'
-capstring('hello world', 'hashtag');   // '#HelloWorld'
+capstring('hello world', 'title');        // 'Hello World'
+capstring('XMLHttpRequest', 'kebab');     // 'xml-http-request'
+capstring('Crème Brûlée & Co.', 'slug');  // 'creme-brulee-co'
+capstring('hello world', 'constant');     // 'HELLO_WORLD'
+capstring('hello world', 'sponge');       // 'HeLlO WoRlD'
+capstring('hello world', 'flip');         // 'plɹoʍ ollǝɥ'
+capstring('hello world', 'hashtag');      // '#HelloWorld'
 ```
 
-## All 29 Styles
+## CLI
 
-### Case Styles
+```bash
+npx capstring kebab "Hello World"          # hello-world
+echo "hello world" | npx capstring title   # Hello World
+npx capstring --all "hello world"          # every style, one per line
+npx capstring --list                       # style names
+npx capstring snake --json "Hello World"   # {"input":"Hello World","style":"snake","output":"hello_world"}
+```
+
+Exit code `2` means a usage error (unknown style or option, missing text).
+
+## All 37 Styles
+
+### Case
 
 | Style | Input | Output |
 |-------|-------|--------|
 | `same` | Hello World | Hello World |
 | `none` | Hello World | *(empty)* |
-| `proper` | Hello World | Hello World |
-| `title` | hello world | Hello World |
-| `sentence` | hello world | Hello world |
+| `proper` | Hello World | Hello World *(alias of same)* |
+| `title` | élan vital | Élan Vital |
+| `sentence` | hello. world! | Hello. World! |
 | `upper` | hello world | HELLO WORLD |
 | `lower` | HELLO WORLD | hello world |
 | `swap` | Hello World | hELLO wORLD |
 
-### Code Styles
+### Code
 
 | Style | Input | Output |
 |-------|-------|--------|
 | `camel` | hello world | helloWorld |
 | `pascal` | hello world | HelloWorld |
 | `snake` | hello world | hello_world |
-| `kebab` | hello world | hello-world |
-| `slug` | hello world | hello-world |
+| `kebab` | Crème Brûlée | crème-brûlée |
+| `slug` | Crème Brûlée & Co. | creme-brulee-co |
 | `constant` | hello world | HELLO_WORLD |
-| `python` | hello world | HELLO_WORLD |
+| `python` | hello world | HELLO_WORLD *(alias of constant)* |
 | `dot` | hello world | hello.world |
 | `path` | hello world | hello/world |
 | `train` | hello world | Hello-World |
+| `hashtag` | hello world | #HelloWorld |
+| `acronym` | as soon as possible | ASAP |
+
+All code styles share one tokenizer: words split on whitespace, `_`, `-`, `.`, `/`, punctuation,
+and camelCase boundaries (`XMLHttpRequest` → `xml`, `http`, `request`). Letters stay attached to
+digits (`utf8`, `mp3`). Apostrophes are dropped (`don't` → `dont`).
 
-### Fun Styles
+### Fun
 
 | Style | Input | Output |
 |-------|-------|--------|
-| `leet` | hello world | h3££0 w0r£d |
 | `reverse` | hello world | dlrow olleh |
 | `sponge` | hello world | HeLlO WoRlD |
 | `mock` | hello world | hElLo wOrLd |
-| `alternate` | hello world | hElLo WoRlD |
-| `crazy` | hello world | *(deterministic random)* |
-| `random` | hello world | *(random case)* |
+| `alternate` | hello world | hElLo WoRlD *(letters only)* |
+| `crazy` | hello world | *(deterministic pseudo-random case)* |
+| `random` | hello world | *(random case, different every call)* |
+| `clap` | hello world | hello 👏 world |
+| `piglatin` | hello world | ellohay orldway |
 
-### New Styles
+### Encodings
 
 | Style | Input | Output |
 |-------|-------|--------|
-| `hashtag` | hello world | #HelloWorld |
-| `acronym` | as soon as possible | ASAP |
+| `leet` | hello world | h3110 w0r1d |
 | `rot13` | hello | uryyb |
+| `morse` | SOS 1 | ... --- ... / .---- |
+| `binary` | hi | 01101000 01101001 |
+
+### Unicode Art
+
+| Style | Input | Output |
+|-------|-------|--------|
 | `flip` | hello | ollǝɥ |
+| `smallcaps` | hello | ʜᴇʟʟᴏ |
+| `bubble` | hello | ⓗⓔⓛⓛⓞ |
+| `wide` | hello | ｈｅｌｌｏ |
+| `strike` | hello | h̶e̶l̶l̶o̶ |
 
 ## API
 
-### `capstring(str, style)`
-
-Transform a string to the specified style.
+### `capstring(str, style = 'same', options?)`
 
 ```javascript
 import capstring from 'capstring';
 
 capstring('hello world', 'title');  // 'Hello World'
 capstring('hello world');           // 'hello world' (default: same)
-capstring(123);                     // false (invalid input)
+capstring('');                      // ''
+capstring(123);                     // false (not a string)
+capstring('hello', 'nope');         // 'hello' (unknown style returns input)
+
+// Strict mode throws instead
+capstring(123, 'title', { strict: true });    // TypeError
+capstring('hi', 'nope', { strict: true });    // RangeError
 ```
 
-### `getStyles()`
+### `capstringAll(str, options?)`
 
-Get an array of all supported style names.
+Every style at once, keyed by style name in `STYLES` order.
 
 ```javascript
-import { getStyles } from 'capstring';
+import { capstringAll } from 'capstring';
 
-getStyles();  // ['same', 'none', 'proper', 'title', ...]
+const all = capstringAll('hello world');
+all.kebab;   // 'hello-world'
+all.morse;   // '.... . .-.. .-.. --- / .-- --- .-. .-.. -..'
 ```
 
-### `isValidStyle(style)`
-
-Check if a style is supported.
+### `getStyles()`, `isValidStyle(style)`, `STYLES`, `CATEGORIES`
 
 ```javascript
-import { isValidStyle } from 'capstring';
+import { getStyles, isValidStyle, STYLES, CATEGORIES } from 'capstring';
 
+getStyles();              // ['same', 'none', 'proper', ...] (fresh copy)
 isValidStyle('kebab');    // true
-isValidStyle('invalid');  // false
+STYLES.length;            // 37 (frozen)
+CATEGORIES.art;           // ['flip', 'smallcaps', 'bubble', 'wide', 'strike'] (frozen)
 ```
 
-### `STYLES`
+### TypeScript
 
-Frozen array of all style names.
+```typescript
+import capstring, { type Style } from 'capstring';
 
-```javascript
-import { STYLES } from 'capstring';
-
-STYLES.length;  // 29
+const style: Style = 'kebab';   // autocompletes all 37 names
+capstring('Hello', style);      // string
 ```
 
-## REST API
-
-Looking for an API? Check out [cAPIta](https://github.com/brianfunk/cAPIta) - a full REST API powered by capstring!
+## Behavior notes
 
-```bash
-curl https://your-api.com/title/hello%20world
-# {"input":"hello world","output":"Hello World","cap":"title"}
-```
+- **Unicode**: every style iterates code points, and `reverse` / `flip` iterate grapheme clusters, so
+  emoji, flags, and combining accents stay intact. Requires `Intl.Segmenter` (Node 16+, all modern browsers).
+- **`title`** capitalizes every word, including small words like "of" and "the". Hyphens and
+  underscores break words (`stop-me` → `Stop-Me`). Apostrophes stay inside words (`don't` → `Don't`).
+- **`sentence`** capitalizes after `.`, `!`, `?` followed by whitespace. `3.14 is pi` is left alone.
+- **`slug`** is ASCII only: diacritics are folded (`é` → `e`, `ß` → `ss`), everything else becomes a
+  hyphen. Scripts with no ASCII folding (CJK, Cyrillic) produce an empty slug. Use `kebab` to keep
+  Unicode letters.
+- **`piglatin`** and **`morse`** only understand Latin letters; other characters pass through
+  (`piglatin`) or are dropped (`morse`).
+- **`random`** is the only non-deterministic style.
 
 ## Development
 
 ```bash
-npm install        # Install dependencies
-npm test           # Run tests
-npm run lint       # Run linter
-npm run test:coverage  # Test with coverage
+npm install            # Install dependencies
+npm test               # Run tests
+npm run lint           # Run linter
+npm run test:coverage  # Test with coverage (100% required)
 ```
 
 ## Contributing
@@ -163,7 +207,7 @@ This project uses [Semantic Versioning 2.0](http://semver.org/spec/v2.0.0.html).
 
 ## Requirements
 
-- Node.js 18+
+- Node.js 18+ (or any modern browser)
 - ES modules (`import`/`export`)
 
 ## License
diff --git a/bin/capstring.js b/bin/capstring.js
new file mode 100755
index 0000000..0691879
--- /dev/null
+++ b/bin/capstring.js
@@ -0,0 +1,16 @@
+#!/usr/bin/env node
+import { main } from '../cli.js';
+
+const readStdin = async () => {
+  process.stdin.setEncoding('utf8');
+  let data = '';
+  for await (const chunk of process.stdin) data += chunk;
+  return data;
+};
+
+process.exitCode = await main(process.argv.slice(2), {
+  readStdin,
+  isTTY: Boolean(process.stdin.isTTY),
+  stdout: (s) => process.stdout.write(s),
+  stderr: (s) => process.stderr.write(s)
+});
diff --git a/cli.js b/cli.js
new file mode 100644
index 0000000..adf59b7
--- /dev/null
+++ b/cli.js
@@ -0,0 +1,140 @@
+/*
+   ___      ___    _____   ___ _  _
+  / __|__ _| _ \__|_   _| |_ _| \| |__ _
+ | (__/ _` |  _(_-< | || '_| || .` / _` |
+  \___\__,_|_| /__/ |_||_||___|_|\_\__, |
+                                   |___/
+*/
+
+/**
+ * capstring command-line interface.
+ *
+ * The entry point is `main(argv, io)`, which is pure apart from the injected `io`
+ * so it can be tested in-process. `bin/capstring.js` wires it to the real process.
+ * @module capstring/cli
+ */
+
+import { readFileSync } from 'node:fs';
+import capstring, { capstringAll, STYLES, isValidStyle } from './index.js';
+
+const { version: VERSION } = JSON.parse(readFileSync(new URL('./package.json', import.meta.url), 'utf8'));
+
+const USAGE = `capstring ${VERSION} - CaPiTaLiZe StRiNgS in ${STYLES.length} ways!
+
+Usage:
+  capstring <style> [text...]     Transform text (reads stdin when no text is given)
+  capstring --all [text...]       Print every style
+  capstring --list                List style names
+
+Options:
+  -a, --all        Print every style
+  -l, --list       List style names, one per line
+      --json       JSON output
+  -h, --help       Show this help
+  -v, --version    Show version
+  --               End of options
+
+Examples:
+  capstring kebab "Hello World"          # hello-world
+  echo "hello world" | capstring title   # Hello World
+  capstring --all hi
+`;
+
+/**
+ * @typedef {Object} CliIO
+ * @property {() => Promise<string>} readStdin - Read all of stdin
+ * @property {boolean} isTTY - Whether stdin is an interactive terminal
+ * @property {(s: string) => void} stdout - Write to stdout
+ * @property {(s: string) => void} stderr - Write to stderr
+ */
+
+/**
+ * Parse CLI arguments
+ * @param {string[]} argv - Arguments (without node and script path)
+ * @returns {{ all: boolean, list: boolean, json: boolean, help: boolean, version: boolean, style: string|null, text: string[], unknown: string|null }} Parsed flags
+ */
+const parseArgs = (argv) => {
+  const out = { all: false, list: false, json: false, help: false, version: false, style: null, text: [], unknown: null };
+  let optionsDone = false;
+  for (const arg of argv) {
+    if (!optionsDone && arg === '--') {
+      optionsDone = true;
+    } else if (!optionsDone && arg.startsWith('-') && arg.length > 1) {
+      if (arg === '-a' || arg === '--all') out.all = true;
+      else if (arg === '-l' || arg === '--list') out.list = true;
+      else if (arg === '--json') out.json = true;
+      else if (arg === '-h' || arg === '--help') out.help = true;
+      else if (arg === '-v' || arg === '--version') out.version = true;
+      else out.unknown = out.unknown ?? arg;
+    } else if (out.style === null && !out.all) {
+      out.style = arg;
+    } else {
+      out.text.push(arg);
+    }
+  }
+  return out;
+};
+
+/**
+ * Run the CLI
+ * @param {string[]} argv - Arguments (without node and script path)
+ * @param {CliIO} io - Process I/O
+ * @returns {Promise<number>} Exit code (0 ok, 2 usage error)
+ */
+export const main = async (argv, io) => {
+  const args = parseArgs(argv);
+
+  if (args.help) {
+    io.stdout(USAGE);
+    return 0;
+  }
+  if (args.version) {
+    io.stdout(`${VERSION}\n`);
+    return 0;
+  }
+  if (args.unknown) {
+    io.stderr(`capstring: unknown option "${args.unknown}"\n\n${USAGE}`);
+    return 2;
+  }
+  if (args.list) {
+    io.stdout(args.json ? `${JSON.stringify(STYLES)}\n` : `${STYLES.join('\n')}\n`);
+    return 0;
+  }
+  if (!args.all && args.style === null) {
+    io.stderr(USAGE);
+    return 2;
+  }
+  if (!args.all && !isValidStyle(args.style)) {
+    io.stderr(`capstring: unknown style "${args.style}". Run 'capstring --list' to see all styles.\n`);
+    return 2;
+  }
+
+  let text;
+  if (args.text.length > 0) {
+    text = args.text.join(' ');
+  } else if (io.isTTY) {
+    io.stderr(USAGE);
+    return 2;
+  } else {
+    text = (await io.readStdin()).replace(/\r?\n$/, '');
+  }
+
+  if (args.all) {
+    const results = capstringAll(text);
+    if (args.json) {
+      io.stdout(`${JSON.stringify(results, null, 2)}\n`);
+    } else {
+      const width = Math.max(...STYLES.map((s) => s.length));
+      // One row per style, so line breaks inside a result are shown escaped
+      const oneLine = (v) => v.replace(/\r/g, '\\r').replace(/\n/g, '\\n').replace(/\u2028/g, '\\u2028').replace(/\u2029/g, '\\u2029');
+      io.stdout(STYLES.map((s) => `${s.padEnd(width)}  ${oneLine(results[s])}`).join('\n') + '\n');
+    }
+    return 0;
+  }
+
+  const output = capstring(text, args.style);
+  io.stdout(args.json ? `${JSON.stringify({ input: text, style: args.style, output })}\n` : `${output}\n`);
+  return 0;
+};
+
+export default main;
diff --git a/eslint.config.js b/eslint.config.js
index 657257f..1c3e6b7 100644
--- a/eslint.config.js
+++ b/eslint.config.js
@@ -4,11 +4,14 @@ export default [
   js.configs.recommended,
   {
     languageOptions: {
-      ecmaVersion: 2022,
+      ecmaVersion: 2023,
       sourceType: 'module',
       globals: {
         console: 'readonly',
-        process: 'readonly'
+        process: 'readonly',
+        Intl: 'readonly',
+        TextEncoder: 'readonly',
+        URL: 'readonly'
       }
     },
     rules: {
diff --git a/index.d.ts b/index.d.ts
new file mode 100644
index 0000000..48f1391
--- /dev/null
+++ b/index.d.ts
@@ -0,0 +1,57 @@
+/**
+ * capstring - CaPiTaLiZe StRiNgS in 37 ways!
+ */
+
+/** Every supported style name. */
+export type Style =
+  // Case
+  | 'same' | 'none' | 'proper' | 'title' | 'sentence' | 'upper' | 'lower' | 'swap'
+  // Code
+  | 'camel' | 'pascal' | 'snake' | 'kebab' | 'slug' | 'constant' | 'python' | 'dot' | 'path' | 'train'
+  // Fun
+  | 'leet' | 'reverse' | 'sponge' | 'mock' | 'alternate' | 'crazy' | 'random'
+  // Added in 1.0.0
+  | 'hashtag' | 'acronym' | 'rot13' | 'flip'
+  // Added in 1.1.0
+  | 'smallcaps' | 'bubble' | 'wide' | 'strike' | 'clap' | 'morse' | 'binary' | 'piglatin';
+
+/** Style category names. */
+export type Category = 'case' | 'code' | 'fun' | 'encoding' | 'art';
+
+export interface CapstringOptions {
+  /**
+   * Throw `TypeError` for non-string input and `RangeError` for an unknown style,
+   * instead of returning `false` / the input unchanged. Default `false`.
+   */
+  strict?: boolean;
+}
+
+/** All supported styles, frozen, in canonical order. */
+export const STYLES: readonly Style[];
+
+/** Styles grouped by category. Every style appears in exactly one category. */
+export const CATEGORIES: Readonly<Record<Category, readonly Style[]>>;
+
+/**
+ * Transform a string to the given style.
+ *
+ * @example
+ * capstring('hello world', 'title') // 'Hello World'
+ * capstring('XMLHttpRequest', 'kebab') // 'xml-http-request'
+ */
+export function capstring(str: string, style?: Style | (string & {}), options?: CapstringOptions): string;
+export function capstring(str: unknown, style?: Style | (string & {}), options?: CapstringOptions): string | false;
+
+/**
+ * Transform a string into every style at once, keyed by style name in `STYLES` order.
+ */
+export function capstringAll(str: string, options?: CapstringOptions): Record<Style, string>;
+export function capstringAll(str: unknown, options?: CapstringOptions): Record<Style, string> | false;
+
+/** A fresh copy of `STYLES`. */
+export function getStyles(): Style[];
+
+/** Whether `style` is a supported style name. */
+export function isValidStyle(style: unknown): style is Style;
+
+export default capstring;
diff --git a/index.js b/index.js
index b5c0621..e6b980a 100644
--- a/index.js
+++ b/index.js
@@ -7,11 +7,28 @@
 */
 
 /**
- * capstring - CaPiTaLiZe StRiNgS in 29 ways!
+ * capstring - CaPiTaLiZe StRiNgS in 37 ways!
+ *
+ * Zero dependencies, browser-safe (no Node-only imports), Unicode and emoji aware.
  * @module capstring
  */
 
-/** All supported capitalization styles */
+/**
+ * Style groupings. Every style appears in exactly one category.
+ * @type {Readonly<Record<string, readonly string[]>>}
+ */
+const CATEGORIES = Object.freeze({
+  case: Object.freeze(['same', 'none', 'proper', 'title', 'sentence', 'upper', 'lower', 'swap']),
+  code: Object.freeze(['camel', 'pascal', 'snake', 'kebab', 'slug', 'constant', 'python', 'dot', 'path', 'train', 'hashtag', 'acronym']),
+  fun: Object.freeze(['reverse', 'sponge', 'mock', 'alternate', 'crazy', 'random', 'clap', 'piglatin']),
+  encoding: Object.freeze(['leet', 'rot13', 'morse', 'binary']),
+  art: Object.freeze(['flip', 'smallcaps', 'bubble', 'wide', 'strike'])
+});
+
+/**
+ * All supported styles, in canonical order (original 29 first, then additions).
+ * @type {readonly string[]}
+ */
 const STYLES = Object.freeze([
   // Case styles
   'same', 'none', 'proper', 'title', 'sentence', 'upper', 'lower', 'swap',
@@ -19,10 +36,14 @@ const STYLES = Object.freeze([
   'camel', 'pascal', 'snake', 'kebab', 'slug', 'constant', 'python', 'dot', 'path', 'train',
   // Fun styles
   'leet', 'reverse', 'sponge', 'mock', 'alternate', 'crazy', 'random',
-  // New styles
-  'hashtag', 'acronym', 'rot13', 'flip'
+  // Added in 1.0.0
+  'hashtag', 'acronym', 'rot13', 'flip',
+  // Added in 1.1.0
+  'smallcaps', 'bubble', 'wide', 'strike', 'clap', 'morse', 'binary', 'piglatin'
 ]);
 
+// ========== Character tables ==========
+
 /** Upside-down character mapping */
 const FLIP_MAP = {
   'a': 'ɐ', 'b': 'q', 'c': 'ɔ', 'd': 'p', 'e': 'ǝ', 'f': 'ɟ', 'g': 'ƃ',
@@ -40,225 +61,463 @@ const FLIP_MAP = {
   '<': '>', '>': '<', '&': '⅋', '_': '‾'
 };
 
+/** Conventional leetspeak substitutions (ASCII only, case preserved) */
+const LEET_MAP = {
+  'a': '4', 'b': '8', 'e': '3', 'g': '9', 'i': '1', 'l': '1', 'o': '0', 's': '5', 't': '7', 'z': '2'
+};
+
+/** Unicode small capitals for a-z */
+const SMALLCAPS = Array.from('ᴀʙᴄᴅᴇꜰɢʜɪᴊᴋʟᴍɴᴏᴘǫʀꜱᴛᴜᴠᴡxʏᴢ');
+const ALPHABET = 'abcdefghijklmnopqrstuvwxyz';
+
+/** International Morse code */
+const MORSE_MAP = {
+  'a': '.-', 'b': '-...', 'c': '-.-.', 'd': '-..', 'e': '.', 'f': '..-.', 'g': '--.',
+  'h': '....', 'i': '..', 'j': '.---', 'k': '-.-', 'l': '.-..', 'm': '--', 'n': '-.',
+  'o': '---', 'p': '.--.', 'q': '--.-', 'r': '.-.', 's': '...', 't': '-', 'u': '..-',
+  'v': '...-', 'w': '.--', 'x': '-..-', 'y': '-.--', 'z': '--..',
+  '0': '-----', '1': '.----', '2': '..---', '3': '...--', '4': '....-',
+  '5': '.....', '6': '-....', '7': '--...', '8': '---..', '9': '----.',
+  '.': '.-.-.-', ',': '--..--', '?': '..--..', "'": '.----.', '!': '-.-.--', '/': '-..-.',
+  '(': '-.--.', ')': '-.--.-', '&': '.-...', ':': '---...', ';': '-.-.-.', '=': '-...-',
+  '+': '.-.-.', '-': '-....-', '_': '..--.-', '"': '.-..-.', '$': '...-..-', '@': '.--.-.'
+};
+
+/** Latin letters with no Unicode decomposition, folded for slugs */
+const SLUG_FOLD = {
+  'ß': 'ss', 'æ': 'ae', 'œ': 'oe', 'ø': 'o', 'đ': 'd', 'ł': 'l', 'þ': 'th', 'ð': 'd'
+};
+
+// ========== Helpers ==========
+
+/** Grapheme segmenter (created once). Available in Node 16+ and all modern browsers. */
+const SEGMENTER = new Intl.Segmenter(undefined, { granularity: 'grapheme' });
+
+/**
+ * Split a string into Unicode code points (emoji-safe, unlike `split('')`)
+ * @param {string} str - Input string
+ * @returns {string[]} Code points
+ */
+const chars = (str) => Array.from(str);
+
+/**
+ * Split a string into grapheme clusters (keeps combined accents, ZWJ emoji, flags intact)
+ * @param {string} str - Input string
+ * @returns {string[]} Grapheme clusters
+ */
+const graphemes = (str) => Array.from(SEGMENTER.segment(str), (s) => s.segment);
+
+/**
+ * Test whether a single character is a Unicode letter
+ * @param {string} ch - A single code point
+ * @returns {boolean} True if `ch` is a letter in any script
+ */
+const isLetter = (ch) => /\p{L}/u.test(ch);
+
+/**
+ * Uppercase the first code point of a word, leave the rest as-is
+ * @param {string} word - Input word
+ * @returns {string} Capitalized word
+ */
+const capitalize = (word) => {
+  const [first = '', ...rest] = chars(word);
+  return first.toUpperCase() + rest.join('');
+};
+
+/**
+ * Tokenize a string into lowercase words for the code styles.
+ *
+ * Rules, in order:
+ * 1. Apostrophes are removed (`don't` -> `dont`).
+ * 2. A boundary is inserted between a lowercase letter or digit and an uppercase letter
+ *    (`helloWorld`, `version2Beta`), and between an uppercase run and a capitalized word
+ *    (`XMLHttp` -> `XML Http`).
+ * 3. Any run of characters that is not a letter, digit, or combining mark becomes a single
+ *    separator (whitespace, `_`, `-`, `.`, `/`, punctuation, emoji). Input is NFC-normalized
+ *    first so decomposed accents stay attached to their letters.
+ * 4. Letters are not split from digits (`utf8`, `mp3` stay intact).
+ *
+ * @param {string} str - Input string
+ * @returns {string[]} Lowercase words (empty when the input has no letters or digits)
+ *
+ * @example
+ * toWords('XMLHttpRequest') // ['xml', 'http', 'request']
+ * toWords('__private_var__') // ['private', 'var']
+ */
+const toWords = (str) => str
+  .normalize('NFC')
+  .replace(/[0-9#*]\uFE0F?\u20E3/gu, ' ') // keycap emoji (1️⃣, #️⃣) are emoji, not digits
+  .replace(/['’]/gu, '')
+  .replace(/([\p{Ll}\p{N}])(\p{Lu})/gu, '$1 $2')
+  .replace(/(\p{Lu})(\p{Lu}\p{Ll})/gu, '$1 $2')
+  .replace(/(^|[^\p{L}\p{N}\p{M}])\p{M}+/gu, '$1') // drop marks orphaned by a removed base (❤️ -> U+FE0F)
+  .replace(/[^\p{L}\p{N}\p{M}]+/gu, ' ')
+  .trim()
+  .split(' ')
+  .filter(Boolean)
+  .map((w) => w.toLowerCase());
+
+/**
+ * Build a URL slug: tokenize like the other code styles (so camelCase splits), fold
+ * diacritics, lowercase, keep only `a-z0-9`, single hyphens.
+ * Scripts that cannot be folded to ASCII (e.g. CJK, Cyrillic) are dropped.
+ * @param {string} str - Input string
+ * @returns {string} Slug (may be empty)
+ */
+const slugify = (str) => toWords(str)
+  .join(' ')
+  .normalize('NFKD')
+  .replace(/\p{M}/gu, '')
+  .toLowerCase()
+  .replace(/[ßæœøđłþð]/g, (ch) => SLUG_FOLD[ch])
+  .replace(/[^a-z0-9]+/g, '-')
+  .replace(/^-+|-+$/g, '');
+
+/**
+ * Alternate the case of letters, starting with the given case
+ * @param {string} str - Input string
+ * @param {boolean} upperFirst - Whether position 0 is uppercase
+ * @returns {string} Alternating-case string
+ */
+const alternateByPosition = (str, upperFirst) => chars(str).map((ch, i) =>
+  (i % 2 === 0) === upperFirst ? ch.toUpperCase() : ch.toLowerCase()
+).join('');
+
 /**
  * Apply ROT13 cipher to a string
  * @param {string} str - Input string
  * @returns {string} ROT13 encoded string
  */
-const rot13 = (str) => {
-  return str.replace(/[a-zA-Z]/g, (char) => {
-    const code = char.charCodeAt(0);
-    const base = code < 97 ? 65 : 97;
-    return String.fromCharCode(((code - base + 13) % 26) + base);
-  });
-};
+const rot13 = (str) => str.replace(/[a-zA-Z]/g, (char) => {
+  const code = char.charCodeAt(0);
+  const base = code < 97 ? 65 : 97;
+  return String.fromCharCode(((code - base + 13) % 26) + base);
+});
 
 /**
- * Flip text upside down
+ * Flip text upside down (reversed, grapheme-safe)
  * @param {string} str - Input string
  * @returns {string} Flipped string
  */
-const flipText = (str) => {
-  return str.split('').reverse().map(char => FLIP_MAP[char] || char).join('');
+const flipText = (str) => graphemes(str).reverse().map((g) => FLIP_MAP[g] || g).join('');
+
+/**
+ * Shift single-code-point graphemes by a code point offset, used by bubble and fullwidth styles.
+ * Multi-code-point graphemes (keycap emoji like 1️⃣, flags, ZWJ sequences) pass through whole.
+ * @param {string} str - Input string
+ * @param {(cp: number) => number|undefined} shift - Returns the new code point, or undefined to keep
+ * @returns {string} Transformed string
+ */
+const mapCodePoints = (str, shift) => graphemes(str).map((g) => {
+  if (chars(g).length !== 1) return g;
+  const mapped = shift(g.codePointAt(0));
+  return mapped === undefined ? g : String.fromCodePoint(mapped);
+}).join('');
+
+/**
+ * Enclosed alphanumerics: Ⓐ-Ⓩ ⓐ-ⓩ ① -⑨ ⓪
+ * @param {number} cp - Code point
+ * @returns {number|undefined} Bubble code point
+ */
+const toBubble = (cp) => {
+  if (cp >= 97 && cp <= 122) return 0x24D0 + (cp - 97);
+  if (cp >= 65 && cp <= 90) return 0x24B6 + (cp - 65);
+  if (cp >= 49 && cp <= 57) return 0x2460 + (cp - 49);
+  if (cp === 48) return 0x24EA;
+  return undefined;
+};
+
+/**
+ * Fullwidth forms: ! through ~ shift by 0xFEE0, space becomes ideographic space
+ * @param {number} cp - Code point
+ * @returns {number|undefined} Fullwidth code point
+ */
+const toWide = (cp) => {
+  if (cp === 32) return 0x3000;
+  if (cp >= 0x21 && cp <= 0x7E) return cp + 0xFEE0;
+  return undefined;
 };
 
+/**
+ * Convert one English word to Pig Latin, preserving an initial capital
+ * @param {string} word - A run of ASCII letters
+ * @returns {string} Pig Latin word
+ */
+const pigLatinWord = (word) => {
+  const lower = word.toLowerCase();
+  const wasCapitalized = word[0] !== lower[0];
+  let result;
+  if (/^[aeiou]/.test(lower)) {
+    result = lower + 'way';
+  } else {
+    // Leading consonant cluster: `qu` moves as a unit; `y` is a vowel unless it leads the word
+    const cluster = /^([^aeiouy]*qu|[^aeiouy]+|[^aeiou]+)/.exec(lower)[0];
+    result = lower.slice(cluster.length) + cluster + 'ay';
+  }
+  return wasCapitalized ? capitalize(result) : result;
+};
+
+/**
+ * Encode a string as space-separated 8-bit binary of its UTF-8 bytes
+ * @param {string} str - Input string
+ * @returns {string} Binary string
+ */
+const toBinary = (str) => Array.from(new TextEncoder().encode(str), (b) => b.toString(2).padStart(8, '0')).join(' ');
+
+/**
+ * Encode a string as International Morse code. Letters are separated by a space,
+ * words by ` / `. Characters with no Morse equivalent are dropped.
+ * @param {string} str - Input string
+ * @returns {string} Morse string
+ */
+const toMorse = (str) => str.toLowerCase().trim().split(/\s+/).map((word) =>
+  chars(word).map((ch) => MORSE_MAP[ch]).filter(Boolean).join(' ')
+).filter(Boolean).join(' / ');
+
+// ========== Main ==========
+
+/**
+ * Build the TypeError thrown in strict mode for non-string input
+ * @param {*} value - The offending value
+ * @returns {TypeError} Error to throw
+ */
+const notAString = (value) => new TypeError(`capstring: expected a string, got ${value === null ? 'null' : typeof value}`);
+
+/**
+ * @typedef {Object} CapstringOptions
+ * @property {boolean} [strict=false] - Throw `TypeError` for non-string input and
+ *   `RangeError` for an unknown style instead of returning `false` / the input unchanged.
+ */
+
 /**
  * Transform a string to the specified capitalization style
  * @param {string} str - The string to transform
- * @param {string} [style='same'] - The capitalization style
- * @returns {string|false} The transformed string, or false if input is invalid
+ * @param {string} [style='same'] - The capitalization style (see {@link STYLES})
+ * @param {CapstringOptions} [options] - Options
+ * @returns {string|false} The transformed string, or `false` if the input is not a string
  *
  * @example
  * capstring('hello world', 'title') // 'Hello World'
- * capstring('hello world', 'kebab') // 'hello-world'
- * capstring('hello world', 'camel') // 'helloWorld'
+ * capstring('XMLHttpRequest', 'kebab') // 'xml-http-request'
+ * capstring('Crème Brûlée & Co.', 'slug') // 'creme-brulee-co'
  */
-const capstring = (str, style = 'same') => {
-  // Validate input
-  if (!str) return false;
-  if (typeof str !== 'string') return false;
+const capstring = (str, style = 'same', { strict = false } = {}) => {
+  if (typeof str !== 'string') {
+    if (strict) throw notAString(str);
+    return false;
+  }
+  if (!STYLES.includes(style)) {
+    if (strict) throw new RangeError(`capstring: unknown style "${style}". Use getStyles() to list valid styles.`);
+    return str;
+  }
+  if (str === '') return '';
 
-  // Normalize words (split on any whitespace, filter empty)
-  const words = str.toLowerCase().split(/\s+/).filter(w => w);
+  // Only the code styles tokenize, so do it lazily (capstringAll calls this 37 times per string)
+  let tokens;
+  const words = () => (tokens ??= toWords(str));
 
   switch (style) {
     // ========== Case Styles ==========
 
     case 'same':
-      // Return unchanged
+    case 'proper':
+      // Return unchanged (proper is a historical alias)
       return str;
 
     case 'none':
       // Return empty string
       return '';
 
-    case 'proper':
-      // Return unchanged (alias for same)
-      return str;
-
     case 'title':
-      // Title Case - capitalize first letter of each word
-      return str.replace(/\w([^-\s]*)/g, (txt) =>
-        txt.charAt(0).toUpperCase() + txt.substring(1).toLowerCase()
+      // Title Case - capitalize each word; hyphens and underscores break words
+      return str.replace(/[\p{L}\p{N}][\p{L}\p{N}\p{M}'’]*/gu, (word) =>
+        capitalize(word.toLowerCase())
       );
 
     case 'sentence':
-      // Sentence case - capitalize first letter only
-      return str.charAt(0).toUpperCase() + str.substring(1).toLowerCase();
+      // Sentence case - capitalize the first letter and the first letter after . ! ? (quotes and brackets, ASCII or typographic, may sit in between)
+      return str.toLowerCase().replace(/(^["'“‘«([]*|[.!?]+["'”’»)\]]*\s+["'“‘«([]*)(\p{L})/gu, (_, lead, letter) =>
+        lead + letter.toUpperCase()
+      );
 
     case 'upper':
-      // UPPERCASE
       return str.toUpperCase();
 
     case 'lower':
-      // lowercase
       return str.toLowerCase();
 
     case 'swap':
       // sWAP cASE - invert each character's case
-      return str.split('').map(char => {
-        if (char === char.toUpperCase()) return char.toLowerCase();
-        if (char === char.toLowerCase()) return char.toUpperCase();
-        return char;
+      return chars(str).map((ch) => {
+        const upper = ch.toUpperCase();
+        return ch === upper ? ch.toLowerCase() : upper;
       }).join('');
 
     // ========== Code Styles ==========
 
     case 'camel':
-      // camelCase - first word lowercase, rest capitalized, no spaces
-      return words.map((word, i) =>
-        i === 0 ? word : word.charAt(0).toUpperCase() + word.slice(1)
-      ).join('');
+      // camelCase
+      return words().map((word, i) => (i === 0 ? word : capitalize(word))).join('');
 
     case 'pascal':
-      // PascalCase - all words capitalized, no spaces
-      return words.map(word =>
-        word.charAt(0).toUpperCase() + word.slice(1)
-      ).join('');
+      // PascalCase
+      return words().map(capitalize).join('');
 
     case 'snake':
       // snake_case
-      return words.join('_');
+      return words().join('_');
 
     case 'kebab':
+      // kebab-case (Unicode letters preserved)
+      return words().join('-');
+
     case 'slug':
-      // kebab-case (URL-friendly)
-      return words.join('-');
+      // url-slug (ASCII only, diacritics folded)
+      return slugify(str);
 
     case 'constant':
     case 'python':
-      // CONSTANT_CASE / PYTHON_CASE (SCREAMING_SNAKE_CASE)
-      // Both now use normalized words for consistency
-      return words.join('_').toUpperCase();
+      // CONSTANT_CASE (python is a historical alias)
+      return words().join('_').toUpperCase();
 
     case 'dot':
       // dot.case
-      return words.join('.');
+      return words().join('.');
 
     case 'path':
       // path/case
-      return words.join('/');
+      return words().join('/');
 
     case 'train':
-      // Train-Case (like title but with dashes)
-      return words.map(word =>
-        word.charAt(0).toUpperCase() + word.slice(1)
-      ).join('-');
+      // Train-Case
+      return words().map(capitalize).join('-');
 
-    // ========== Fun Styles ==========
+    case 'hashtag':
+      // #HashTag
+      return words().length ? '#' + words().map(capitalize).join('') : '';
 
-    case 'leet':
-      // l33t sp34k
-      return str.toLowerCase()
-        .replace(/i/g, '1')
-        .replace(/e/g, '3')
-        .replace(/o/g, '0')
-        .replace(/l/g, '£')
-        .replace(/f/g, 'ƒ')
-        .replace(/s/g, '$')
-        .replace(/n/g, 'И');
+    case 'acronym':
+      // ASAP - first letter of each word, uppercase
+      return words().map((word) => chars(word)[0]).join('').toUpperCase();
+
+    // ========== Fun Styles ==========
 
     case 'reverse':
-      // esreveR
-      return str.split('').reverse().join('');
+      // esreveR (grapheme-safe)
+      return graphemes(str).reverse().join('');
 
     case 'sponge':
-      // SpOnGeBoB tExT - starts uppercase, alternates
-      return str.split('').map((char, i) =>
-        i % 2 === 0 ? char.toUpperCase() : char.toLowerCase()
-      ).join('');
+      // SpOnGeBoB - starts uppercase, alternates by position
+      return alternateByPosition(str, true);
 
     case 'mock':
-      // mOcKiNg TeXt - starts lowercase, alternates (opposite of sponge)
-      return str.split('').map((char, i) =>
-        i % 2 === 0 ? char.toLowerCase() : char.toUpperCase()
-      ).join('');
+      // mOcKiNg - starts lowercase, alternates by position
+      return alternateByPosition(str, false);
 
     case 'alternate': {
-      // aLtErNaTe - alternates only on letters, ignoring spaces
+      // aLtErNaTe - alternates on letters only, ignoring spaces and punctuation
       let letterIndex = 0;
-      return str.split('').map(char => {
-        if (/[a-zA-Z]/.test(char)) {
-          const result = letterIndex % 2 === 0 ? char.toLowerCase() : char.toUpperCase();
-          letterIndex++;
-          return result;
-        }
-        return char;
+      return chars(str).map((ch) => {
+        if (!isLetter(ch)) return ch;
+        return letterIndex++ % 2 === 0 ? ch.toLowerCase() : ch.toUpperCase();
       }).join('');
     }
 
     case 'crazy':
-      // cRaZy CaSe - pseudo-random based on char code (deterministic but looks random)
-      return str.split('').map((char, i) => {
-        const seed = (char.charCodeAt(0) * (i + 1)) % 3;
-        return seed === 0 ? char.toLowerCase() : char.toUpperCase();
-      }).join('');
+      // cRaZy - deterministic pseudo-random case seeded by code point and position
+      return chars(str).map((ch, i) => (
+        (ch.codePointAt(0) * (i + 1)) % 3 === 0 ? ch.toLowerCase() : ch.toUpperCase()
+      )).join('');
 
     case 'random':
-      // RaNdOm CaSe (actually random)
-      return str.split('').map(char =>
-        Math.random() > 0.5 ? char.toLowerCase() : char.toUpperCase()
-      ).join('');
+      // RaNdOm - actually random, different on every call
+      return chars(str).map((ch) => (Math.random() > 0.5 ? ch.toLowerCase() : ch.toUpperCase())).join('');
 
-    // ========== New Styles ==========
+    case 'clap':
+      // hello 👏 world
+      return str.trim().split(/\s+/).join(' 👏 ');
 
-    case 'hashtag':
-      // #HelloWorld - PascalCase with hash prefix
-      return '#' + words.map(word =>
-        word.charAt(0).toUpperCase() + word.slice(1)
-      ).join('');
+    case 'piglatin':
+      // Igpay Atinlay - English words only, everything else untouched
+      return str.replace(/[A-Za-z]+/g, pigLatinWord);
 
-    case 'acronym':
-      // ASAP - first letter of each word, uppercase
-      return words.map(word => word.charAt(0).toUpperCase()).join('');
+    // ========== Encodings ==========
+
+    case 'leet':
+      // 1337 - conventional ASCII substitutions, case preserved
+      return chars(str).map((ch) => LEET_MAP[ch.toLowerCase()] ?? ch).join('');
 
     case 'rot13':
-      // ROT13 cipher
       return rot13(str);
 
+    case 'morse':
+      return toMorse(str);
+
+    case 'binary':
+      return toBinary(str);
+
+    // ========== Unicode Art ==========
+
     case 'flip':
-      // ʇxǝʇ uʍop ǝpᴉsdn - upside down text
+      // ʇxǝʇ uʍop ǝpᴉsdn
       return flipText(str);
 
+    case 'smallcaps':
+      // sᴍᴀʟʟ ᴄᴀᴘs
+      return chars(str).map((ch) => {
+        const idx = ALPHABET.indexOf(ch.toLowerCase());
+        return idx === -1 ? ch : SMALLCAPS[idx];
+      }).join('');
+
+    case 'bubble':
+      // ⓑⓤⓑⓑⓛⓔ
+      return mapCodePoints(str, toBubble);
+
+    case 'wide':
+      // ｗｉｄｅ
+      return mapCodePoints(str, toWide);
+
+    case 'strike':
+      // s̶t̶r̶i̶k̶e̶
+      return graphemes(str).map((g) => (/^\s+$/u.test(g) ? g : g + '\u0336')).join('');
+
+    /* c8 ignore next 2 -- unreachable: style validated above */
     default:
-      // Unknown style - return unchanged
       return str;
   }
 };
 
+/**
+ * Transform a string into every style at once
+ * @param {string} str - The string to transform
+ * @param {CapstringOptions} [options] - Options
+ * @returns {Record<string, string>|false} Map of style name to output, in {@link STYLES} order,
+ *   or `false` if the input is not a string
+ *
+ * @example
+ * capstringAll('hi').kebab // 'hi'
+ */
+const capstringAll = (str, options = {}) => {
+  if (typeof str !== 'string') {
+    if (options.strict) throw notAString(str);
+    return false;
+  }
+  return Object.fromEntries(STYLES.map((s) => [s, capstring(str, s, options)]));
+};
+
 /**
  * Get list of all supported styles
- * @returns {string[]} Array of style names
+ * @returns {string[]} A fresh copy of the style names
  */
 const getStyles = () => [...STYLES];
 
 /**
  * Check if a style is supported
- * @param {string} style - The style to check
+ * @param {*} style - The style to check
  * @returns {boolean} True if style is supported
  */
 const isValidStyle = (style) => STYLES.includes(style);
 
 // ESM exports
 export default capstring;
-export { capstring, getStyles, isValidStyle, STYLES };
+export { capstring, capstringAll, getStyles, isValidStyle, STYLES, CATEGORIES };
diff --git a/package-lock.json b/package-lock.json
index c2437bc..8cbd083 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -1,14 +1,18 @@
 {
   "name": "capstring",
-  "version": "1.0.0",
+  "version": "1.1.0",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "capstring",
-      "version": "1.0.0",
+      "version": "1.1.0",
       "license": "MIT",
+      "bin": {
+        "capstring": "bin/capstring.js"
+      },
       "devDependencies": {
+        "@eslint/js": "^9.17.0",
         "@vitest/coverage-v8": "^4.0.18",
         "eslint": "^9.17.0",
         "vitest": "^4.0.18"
diff --git a/package.json b/package.json
index 42f87ad..e76dd0f 100644
--- a/package.json
+++ b/package.json
@@ -1,20 +1,36 @@
 {
   "name": "capstring",
-  "version": "1.0.0",
-  "description": "CaPiTaLiZe StRiNgS in 24+ ways!",
+  "version": "1.1.0",
+  "description": "CaPiTaLiZe StRiNgS in 37 ways! Case conversion, code conventions, and fun text styles. Zero deps, Unicode safe.",
   "type": "module",
   "main": "index.js",
+  "types": "./index.d.ts",
+  "bin": {
+    "capstring": "./bin/capstring.js"
+  },
   "exports": {
     ".": {
-      "import": "./index.js"
-    }
+      "types": "./index.d.ts",
+      "import": "./index.js",
+      "default": "./index.js"
+    },
+    "./package.json": "./package.json"
   },
+  "files": [
+    "index.js",
+    "index.d.ts",
+    "cli.js",
+    "bin/",
+    "CHANGELOG.md"
+  ],
+  "sideEffects": false,
   "scripts": {
     "test": "vitest run",
     "test:watch": "vitest",
     "test:coverage": "vitest run --coverage",
     "lint": "eslint . --format stylish",
-    "lint:report": "eslint . --format html -o coverage/lint-report.html"
+    "lint:report": "eslint . --format html -o coverage/lint-report.html",
+    "prepublishOnly": "npm run lint && npm run test:coverage"
   },
   "repository": {
     "type": "git",
@@ -33,18 +49,40 @@
     "kebab",
     "title",
     "transform",
-    "text"
+    "text",
+    "slug",
+    "slugify",
+    "title-case",
+    "sentence-case",
+    "constant-case",
+    "leet",
+    "sponge",
+    "mock",
+    "upside-down",
+    "flip",
+    "rot13",
+    "morse",
+    "binary",
+    "bubble",
+    "fullwidth",
+    "small-caps",
+    "strikethrough",
+    "pig-latin",
+    "cli",
+    "typescript",
+    "unicode"
   ],
   "author": "Brian Funk",
   "license": "MIT",
   "bugs": {
     "url": "https://github.com/brianfunk/capstring/issues"
   },
-  "homepage": "https://github.com/brianfunk/capstring#readme",
+  "homepage": "https://capstring.netlify.app",
   "engines": {
     "node": ">=18.0.0"
   },
   "devDependencies": {
+    "@eslint/js": "^9.17.0",
     "@vitest/coverage-v8": "^4.0.18",
     "eslint": "^9.17.0",
     "vitest": "^4.0.18"
diff --git a/test/cli.test.js b/test/cli.test.js
new file mode 100644
index 0000000..5309b4e
--- /dev/null
+++ b/test/cli.test.js
@@ -0,0 +1,153 @@
+import { describe, it, expect } from 'vitest';
+import { execFileSync, spawnSync } from 'node:child_process';
+import { readFileSync } from 'node:fs';
+import { fileURLToPath } from 'node:url';
+import { main } from '../cli.js';
+import { STYLES } from '../index.js';
+
+const BIN = fileURLToPath(new URL('../bin/capstring.js', import.meta.url));
+const { version } = JSON.parse(readFileSync(new URL('../package.json', import.meta.url), 'utf8'));
+
+/**
+ * Run the CLI in-process with fake I/O
+ * @param {string[]} argv - Arguments
+ * @param {{ stdin?: string, isTTY?: boolean }} [opts] - Fake stdin content and TTY flag
+ */
+const run = async (argv, { stdin = '', isTTY = false } = {}) => {
+  let out = '';
+  let err = '';
+  const code = await main(argv, {
+    readStdin: async () => stdin,
+    isTTY,
+    stdout: (s) => { out += s; },
+    stderr: (s) => { err += s; }
+  });
+  return { code, out, err };
+};
+
+describe('cli main()', () => {
+  it('--help / -h prints usage to stdout, exit 0', async () => {
+    for (const flag of ['--help', '-h']) {
+      const r = await run([flag]);
+      expect(r.code).toBe(0);
+      expect(r.out).toContain('Usage:');
+      expect(r.err).toBe('');
+    }
+  });
+
+  it('--version / -v prints package version', async () => {
+    expect((await run(['--version'])).out).toBe(`${version}\n`);
+    expect((await run(['-v'])).out).toBe(`${version}\n`);
+  });
+
+  it('--list / -l prints every style', async () => {
+    const r = await run(['--list']);
+    expect(r.code).toBe(0);
+    expect(r.out.trim().split('\n')).toEqual([...STYLES]);
+    expect((await run(['-l'])).out).toBe(r.out);
+  });
+
+  it('--list --json prints a JSON array', async () => {
+    const r = await run(['--list', '--json']);
+    expect(JSON.parse(r.out)).toEqual([...STYLES]);
+  });
+
+  it('transforms text arguments joined by one space', async () => {
+    const r = await run(['title', 'hello', 'world']);
+    expect(r.code).toBe(0);
+    expect(r.out).toBe('Hello World\n');
+  });
+
+  it('--json with a style prints an object', async () => {
+    const r = await run(['kebab', '--json', 'Hello World']);
+    expect(JSON.parse(r.out)).toEqual({ input: 'Hello World', style: 'kebab', output: 'hello-world' });
+  });
+
+  it('--all / -a prints one line per style', async () => {
+    const r = await run(['--all', 'hi']);
+    expect(r.code).toBe(0);
+    const lines = r.out.trimEnd().split('\n');
+    expect(lines).toHaveLength(STYLES.length);
+    expect(lines[0]).toMatch(/^same\s+hi$/);
+    expect(lines.find((l) => l.startsWith('none'))).toMatch(/^none\s*$/);
+    const short = await run(['-a', 'hi']);
+    expect(short.out.split('\n')).toHaveLength(r.out.split('\n').length);
+  });
+
+  it('--all keeps one row per style for multiline input', async () => {
+    const r = await run(['--all'], { stdin: 'a\nb\n' });
+    expect(r.out.trimEnd().split('\n')).toHaveLength(STYLES.length);
+    expect(r.out).toMatch(/^same\s+a\\nb$/m);
+    const ls = await run(['--all'], { stdin: 'a\u2028b\u2029c' });
+    expect(ls.out.trimEnd().split('\n')).toHaveLength(STYLES.length);
+    expect(ls.out).toMatch(/^same\s+a\\u2028b\\u2029c$/m);
+  });
+
+  it('--all --json prints an object keyed by style', async () => {
+    const r = await run(['--all', '--json', 'hi']);
+    const obj = JSON.parse(r.out);
+    expect(Object.keys(obj)).toEqual([...STYLES]);
+    expect(obj.upper).toBe('HI');
+  });
+
+  it('-- ends option parsing', async () => {
+    const r = await run(['upper', '--', '--not-a-flag']);
+    expect(r.code).toBe(0);
+    expect(r.out).toBe('--NOT-A-FLAG\n');
+  });
+
+  it('a lone dash is treated as text', async () => {
+    expect((await run(['upper', '-'])).out).toBe('-\n');
+  });
+
+  it('reads stdin when no text is given, stripping one trailing newline', async () => {
+    expect((await run(['title'], { stdin: 'hello world\n' })).out).toBe('Hello World\n');
+    expect((await run(['title'], { stdin: 'hello\r\n' })).out).toBe('Hello\n');
+    expect((await run(['upper'], { stdin: 'a\n\n' })).out).toBe('A\n\n');
+    expect((await run(['upper'], { stdin: '' })).out).toBe('\n');
+  });
+
+  it('unknown style exits 2 with a hint', async () => {
+    const r = await run(['nope', 'x']);
+    expect(r.code).toBe(2);
+    expect(r.out).toBe('');
+    expect(r.err).toContain('unknown style "nope"');
+    expect(r.err).toContain('--list');
+  });
+
+  it('unknown option exits 2 with usage', async () => {
+    const r = await run(['--wat', 'upper', 'x']);
+    expect(r.code).toBe(2);
+    expect(r.err).toContain('unknown option "--wat"');
+    expect(r.err).toContain('Usage:');
+  });
+
+  it('no arguments exits 2 with usage', async () => {
+    const r = await run([]);
+    expect(r.code).toBe(2);
+    expect(r.err).toContain('Usage:');
+  });
+
+  it('no text on a TTY exits 2 with usage', async () => {
+    const r = await run(['upper'], { isTTY: true });
+    expect(r.code).toBe(2);
+    expect(r.err).toContain('Usage:');
+  });
+});
+
+describe('bin/capstring.js', () => {
+  it('runs with arguments', () => {
+    expect(execFileSync(process.execPath, [BIN, 'upper', 'hi'], { encoding: 'utf8' })).toBe('HI\n');
+  });
+
+  it('reads piped stdin', () => {
+    const out = execFileSync(process.execPath, [BIN, 'title'], { input: 'hello world\n', encoding: 'utf8' });
+    expect(out).toBe('Hello World\n');
+  });
+
+  it('exits 2 for an unknown style', () => {
+    const r = spawnSync(process.execPath, [BIN, 'nope', 'x'], { encoding: 'utf8' });
+    expect(r.status).toBe(2);
+    expect(r.stderr).toContain('unknown style');
+  });
+});
diff --git a/test/index.test.js b/test/index.test.js
index cf22409..c8d55e3 100644
--- a/test/index.test.js
+++ b/test/index.test.js
@@ -6,8 +6,8 @@
                                    |___/
 */
 
-import { describe, it, expect } from 'vitest';
-import capstring, { getStyles, isValidStyle, STYLES } from '../index.js';
+import { describe, it, expect, vi, afterEach } from 'vitest';
+import capstring, { capstringAll, getStyles, isValidStyle, STYLES, CATEGORIES } from '../index.js';
 
 describe('capstring', () => {
   describe('input validation', () => {
@@ -23,13 +23,30 @@ describe('capstring', () => {
       expect(capstring([])).toBe(false);
     });
 
-    it('returns false for empty string', () => {
-      expect(capstring('')).toBe(false);
+    it('returns empty string for empty string, in every style', () => {
+      for (const style of STYLES) {
+        expect(capstring('', style)).toBe('');
+      }
     });
 
     it('returns unchanged for unknown style', () => {
       expect(capstring('hello world', 'unknown')).toBe('hello world');
     });
+
+    it('strict: throws TypeError for non-string input', () => {
+      expect(() => capstring(123, 'same', { strict: true })).toThrow(TypeError);
+      expect(() => capstring(null, 'same', { strict: true })).toThrow(/got null/);
+    });
+
+    it('strict: throws RangeError for unknown style', () => {
+      expect(() => capstring('hi', 'nope', { strict: true })).toThrow(RangeError);
+      expect(() => capstring('hi', 'nope', { strict: true })).toThrow(/unknown style "nope"/);
+    });
+
+    it('strict: false and empty options behave like default', () => {
+      expect(capstring('hi', 'nope', { strict: false })).toBe('hi');
+      expect(capstring('hi', 'upper', {})).toBe('HI');
+    });
   });
 
   describe('case styles', () => {
@@ -49,6 +66,15 @@ describe('capstring', () => {
     it('title - Title Case', () => {
       expect(capstring('hello world', 'title')).toBe('Hello World');
       expect(capstring('HELLO WORLD', 'title')).toBe('Hello World');
+      expect(capstring("don't stop-me now", 'title')).toBe("Don't Stop-Me Now");
+      expect(capstring('hello_world', 'title')).toBe('Hello_World');
+      expect(capstring('3d printing', 'title')).toBe('3d Printing');
+      expect(capstring('"quoted" text', 'title')).toBe('"Quoted" Text');
+    });
+
+    it('title - Unicode letters', () => {
+      expect(capstring('élan vital über', 'title')).toBe('Élan Vital Über');
+      expect(capstring('привет мир', 'title')).toBe('Привет Мир');
     });
 
     it('sentence - Sentence case', () => {
@@ -56,6 +82,20 @@ describe('capstring', () => {
       expect(capstring('HELLO WORLD', 'sentence')).toBe('Hello world');
     });
 
+    it('sentence - capitalizes after . ! ?', () => {
+      expect(capstring('hello. world! how? ok', 'sentence')).toBe('Hello. World! How? Ok');
+      expect(capstring('hello!  double space', 'sentence')).toBe('Hello!  Double space');
+      expect(capstring('wait... really', 'sentence')).toBe('Wait... Really');
+      expect(capstring('"hello." she said', 'sentence')).toBe('"Hello." She said');
+      expect(capstring('hello. "world" (yes)! [ok]', 'sentence')).toBe('Hello. "World" (yes)! [Ok]');
+      expect(capstring('“hello.” she said. ‘yes’ «ok»', 'sentence')).toBe('“Hello.” She said. ‘Yes’ «ok»');
+    });
+
+    it('sentence - leaves decimals and abbreviations without spaces alone', () => {
+      expect(capstring('3.14 is pi', 'sentence')).toBe('3.14 is pi');
+      expect(capstring('see e.g.this', 'sentence')).toBe('See e.g.this');
+    });
+
     it('upper - UPPERCASE', () => {
       expect(capstring('hello world', 'upper')).toBe('HELLO WORLD');
     });
@@ -64,48 +104,94 @@ describe('capstring', () => {
       expect(capstring('HELLO WORLD', 'lower')).toBe('hello world');
     });
 
-    it('swap - sWAP cASE', () => {
+    it('swap - inverts case', () => {
       expect(capstring('Hello World', 'swap')).toBe('hELLO wORLD');
-      expect(capstring('HELLO world', 'swap')).toBe('hello WORLD');
+      expect(capstring('ÀbÇ 😀 1', 'swap')).toBe('àBç 😀 1');
+    });
+  });
+
+  describe('word tokenizer (via code styles)', () => {
+    const cases = [
+      ['hello world', 'hello world'],
+      ['  hello   world  ', 'hello world'],
+      ['helloWorld', 'hello world'],
+      ['HelloWorld', 'hello world'],
+      ['hello_world', 'hello world'],
+      ['hello-world', 'hello world'],
+      ['hello.world', 'hello world'],
+      ['hello/world', 'hello world'],
+      ['__private_var__', 'private var'],
+      ['XMLHttpRequest', 'xml http request'],
+      ['getHTTPResponse2XX', 'get http response2 xx'],
+      ['utf8 string', 'utf8 string'],
+      ['iPhone12 pro', 'i phone12 pro'],
+      ['version 2.0 beta', 'version 2 0 beta'],
+      ["don't stop", 'dont stop'],
+      ['Crème Brûlée', 'crème brûlée'],
+      ['Cre\u0300me Bru\u0302le\u0301e', 'crème brûlée'], // NFD input, marks stay attached
+      ['ПриветМир', 'привет мир'],
+      ['😀 hi!!', 'hi'],
+      ['❤️ hi ☕️', 'hi'], // variation selectors leave with their emoji
+      ['❤️', ''],
+      ['1️⃣ go #️⃣', 'go'] // keycap emoji are separators, not digits
+    ];
+
+    it.each(cases)('%j tokenizes to %j', (input, words) => {
+      expect(capstring(input, 'snake')).toBe(words.replace(/ /g, '_'));
+    });
+
+    it('no letters or digits yields empty output for every code style', () => {
+      for (const style of CATEGORIES.code) {
+        expect(capstring('!!! ???', style)).toBe('');
+      }
     });
   });
 
   describe('code styles', () => {
     it('camel - camelCase', () => {
       expect(capstring('hello world', 'camel')).toBe('helloWorld');
-      expect(capstring('HELLO WORLD', 'camel')).toBe('helloWorld');
+      expect(capstring('Hello World Foo', 'camel')).toBe('helloWorldFoo');
+      expect(capstring('XMLHttpRequest hello_world', 'camel')).toBe('xmlHttpRequestHelloWorld');
     });
 
     it('pascal - PascalCase', () => {
       expect(capstring('hello world', 'pascal')).toBe('HelloWorld');
+      expect(capstring('XMLHttpRequest', 'pascal')).toBe('XmlHttpRequest');
     });
 
     it('snake - snake_case', () => {
       expect(capstring('hello world', 'snake')).toBe('hello_world');
+      expect(capstring('Hello World', 'snake')).toBe('hello_world');
     });
 
-    it('kebab - kebab-case', () => {
+    it('kebab - kebab-case, Unicode preserved', () => {
       expect(capstring('hello world', 'kebab')).toBe('hello-world');
+      expect(capstring('helloWorld', 'kebab')).toBe('hello-world');
+      expect(capstring('Crème Brûlée', 'kebab')).toBe('crème-brûlée');
     });
 
-    it('slug - slug-case (alias for kebab)', () => {
+    it('slug - real URL slug', () => {
       expect(capstring('hello world', 'slug')).toBe('hello-world');
+      expect(capstring('Crème Brûlée & Co.', 'slug')).toBe('creme-brulee-co');
+      expect(capstring('  --Hello__World--  ', 'slug')).toBe('hello-world');
+      expect(capstring('straße', 'slug')).toBe('strasse');
+      expect(capstring('file Æsir Øre', 'slug')).toBe('file-aesir-ore');
+      expect(capstring('日本語', 'slug')).toBe('');
+      expect(capstring('helloWorld', 'slug')).toBe('hello-world');
+      expect(capstring('XMLHttpRequest v2', 'slug')).toBe('xml-http-request-v2');
+      expect(capstring("don't", 'slug')).toBe('dont');
+      expect(capstring('Cre\u0300me', 'slug')).toBe('creme');
     });
 
     it('constant - CONSTANT_CASE', () => {
       expect(capstring('hello world', 'constant')).toBe('HELLO_WORLD');
+      expect(capstring('helloWorld', 'constant')).toBe('HELLO_WORLD');
     });
 
-    it('python - PYTHON_CASE', () => {
+    it('python - alias for constant', () => {
       expect(capstring('hello world', 'python')).toBe('HELLO_WORLD');
     });
 
-    it('python and constant handle multiple spaces consistently', () => {
-      // Both should normalize whitespace
-      expect(capstring('hello  world', 'python')).toBe('HELLO_WORLD');
-      expect(capstring('hello  world', 'constant')).toBe('HELLO_WORLD');
-    });
-
     it('dot - dot.case', () => {
       expect(capstring('hello world', 'dot')).toBe('hello.world');
     });
@@ -116,121 +202,194 @@ describe('capstring', () => {
 
     it('train - Train-Case', () => {
       expect(capstring('hello world', 'train')).toBe('Hello-World');
-      expect(capstring('foo bar baz', 'train')).toBe('Foo-Bar-Baz');
+    });
+
+    it('hashtag - #HashTag', () => {
+      expect(capstring('hello world', 'hashtag')).toBe('#HelloWorld');
+      expect(capstring('!!!', 'hashtag')).toBe('');
+    });
+
+    it('acronym - first letters uppercase', () => {
+      expect(capstring('as soon as possible', 'acronym')).toBe('ASAP');
+      expect(capstring('XMLHttpRequest', 'acronym')).toBe('XHR');
+      expect(capstring('élan vital', 'acronym')).toBe('ÉV');
     });
   });
 
   describe('fun styles', () => {
-    it('leet - l33t sp34k', () => {
-      expect(capstring('hello WORLD of Interwebs', 'leet')).toBe('h3££0 w0r£d 0ƒ 1Иt3rw3b$');
+    afterEach(() => {
+      vi.restoreAllMocks();
     });
 
-    it('reverse - esreveR', () => {
-      expect(capstring('Hello World', 'reverse')).toBe('dlroW olleH');
+    it('reverse - reverses graphemes', () => {
+      expect(capstring('hello world', 'reverse')).toBe('dlrow olleh');
+      expect(capstring('héllo 😀 wörld', 'reverse')).toBe('dlröw 😀 olléh');
+      expect(capstring('éa', 'reverse')).toBe('aé'); // decomposed accent stays attached
+      expect(capstring('a👨‍👩‍👧b', 'reverse')).toBe('b👨‍👩‍👧a');
+      expect(capstring('🇺🇸🇫🇷', 'reverse')).toBe('🇫🇷🇺🇸');
     });
 
-    it('sponge - SpOnGeBoB TeXt (starts uppercase)', () => {
-      // Alternates on every character including spaces
+    it('sponge - starts uppercase', () => {
       expect(capstring('hello world', 'sponge')).toBe('HeLlO WoRlD');
+      expect(capstring('a😀b', 'sponge')).toBe('A😀B'); // emoji counts as one position
     });
 
-    it('mock - mOcKiNg TeXt (starts lowercase)', () => {
-      // Alternates on every character including spaces
+    it('mock - starts lowercase', () => {
       expect(capstring('hello world', 'mock')).toBe('hElLo wOrLd');
     });
 
-    it('alternate - aLtErNaTiNg (only letters alternate)', () => {
-      // Only counts letters, not spaces
-      const result = capstring('hello world', 'alternate');
-      expect(result).toBe('hElLo WoRlD');
+    it('alternate - letters only, Unicode aware', () => {
+      expect(capstring('hello world', 'alternate')).toBe('hElLo WoRlD');
+      expect(capstring('àbç déf', 'alternate')).toBe('àBç DéF');
+      expect(capstring('a 😀 b', 'alternate')).toBe('a 😀 B');
     });
 
-    it('crazy - cRaZy CaSe (deterministic pseudo-random)', () => {
-      const result1 = capstring('hello world', 'crazy');
-      const result2 = capstring('hello world', 'crazy');
-      // Same input should produce same output (deterministic)
-      expect(result1).toBe(result2);
-      expect(result1.toLowerCase()).toBe('hello world');
+    it('crazy - deterministic', () => {
+      const a = capstring('hello world', 'crazy');
+      const b = capstring('hello world', 'crazy');
+      expect(a).toBe(b);
+      expect(a.toLowerCase()).toBe('hello world');
+      expect(a).not.toBe('hello world');
+      expect(capstring('a😀b', 'crazy').replace(/[^a-z😀]/giu, '').toLowerCase()).toBe('a😀b');
     });
 
-    it('random - returns a string (random case)', () => {
-      const result = capstring('hello world', 'random');
-      expect(typeof result).toBe('string');
-      expect(result.toLowerCase()).toBe('hello world');
+    it('random - uses Math.random for each code point', () => {
+      vi.spyOn(Math, 'random').mockReturnValueOnce(0.9).mockReturnValueOnce(0.1).mockReturnValue(0.9);
+      expect(capstring('ab😀', 'random')).toBe('aB😀');
+      expect(Math.random).toHaveBeenCalledTimes(3);
     });
-  });
 
-  describe('new styles', () => {
-    it('hashtag - #HelloWorld', () => {
-      expect(capstring('hello world', 'hashtag')).toBe('#HelloWorld');
-      expect(capstring('foo bar baz', 'hashtag')).toBe('#FooBarBaz');
+    it('clap - claps between words', () => {
+      expect(capstring('hello world', 'clap')).toBe('hello 👏 world');
+      expect(capstring('  Hello   big  World ', 'clap')).toBe('Hello 👏 big 👏 World');
+      expect(capstring('single', 'clap')).toBe('single');
     });
 
-    it('acronym - first letter of each word', () => {
-      expect(capstring('as soon as possible', 'acronym')).toBe('ASAP');
-      expect(capstring('hello world', 'acronym')).toBe('HW');
-      expect(capstring('frequently asked questions', 'acronym')).toBe('FAQ');
+    it('piglatin - English rules', () => {
+      expect(capstring('hello world', 'piglatin')).toBe('ellohay orldway');
+      expect(capstring('Hello world, quick!', 'piglatin')).toBe('Ellohay orldway, ickquay!');
+      expect(capstring('apple', 'piglatin')).toBe('appleway');
+      expect(capstring('string', 'piglatin')).toBe('ingstray');
+      expect(capstring('shh', 'piglatin')).toBe('shhay');
+      expect(capstring('yes my rhythm', 'piglatin')).toBe('esyay ymay ythmrhay');
+      expect(capstring('squeal Square squid', 'piglatin')).toBe('ealsquay Aresquay idsquay');
+      expect(capstring('123 日本', 'piglatin')).toBe('123 日本');
+    });
+  });
+
+  describe('encodings', () => {
+    it('leet - conventional ASCII map, case preserved', () => {
+      expect(capstring('hello world', 'leet')).toBe('h3110 w0r1d');
+      expect(capstring('hello WORLD', 'leet')).toBe('h3110 W0R1D');
+      expect(capstring('abegilostz', 'leet')).toBe('4839110572');
+      expect(capstring('xyz 😀', 'leet')).toBe('xy2 😀');
     });
 
     it('rot13 - ROT13 cipher', () => {
       expect(capstring('hello', 'rot13')).toBe('uryyb');
-      expect(capstring('uryyb', 'rot13')).toBe('hello'); // ROT13 is self-inverse
       expect(capstring('Hello World', 'rot13')).toBe('Uryyb Jbeyq');
+      expect(capstring(capstring('Hello World', 'rot13'), 'rot13')).toBe('Hello World');
     });
 
-    it('flip - upside down text', () => {
-      expect(capstring('hello', 'flip')).toBe('ollǝɥ');
-      expect(capstring('Hello!', 'flip')).toBe('¡ollǝH');
+    it('morse - International Morse', () => {
+      expect(capstring('SOS 1', 'morse')).toBe('... --- ... / .----');
+      expect(capstring('hi!', 'morse')).toBe('.... .. -.-.--');
+      expect(capstring('a 日 b', 'morse')).toBe('.- / -...'); // unmapped word dropped
+      expect(capstring('日', 'morse')).toBe('');
     });
-  });
-});
 
-describe('getStyles', () => {
-  it('returns an array of style names', () => {
-    const styles = getStyles();
-    expect(Array.isArray(styles)).toBe(true);
-    expect(styles.length).toBeGreaterThan(25);
+    it('binary - UTF-8 bytes', () => {
+      expect(capstring('A', 'binary')).toBe('01000001');
+      expect(capstring('hi', 'binary')).toBe('01101000 01101001');
+      expect(capstring('é', 'binary')).toBe('11000011 10101001');
+      expect(capstring('😀', 'binary').split(' ')).toHaveLength(4);
+    });
   });
 
-  it('includes common styles', () => {
-    const styles = getStyles();
-    expect(styles).toContain('title');
-    expect(styles).toContain('camel');
-    expect(styles).toContain('kebab');
-    expect(styles).toContain('snake');
-  });
+  describe('unicode art', () => {
+    it('flip - upside down', () => {
+      expect(capstring('hello', 'flip')).toBe('ollǝɥ');
+      expect(capstring('Hello World!', 'flip')).toBe('¡plɹoM ollǝH');
+      expect(capstring('héllo 😀', 'flip')).toBe('😀 olléɥ');
+      expect(capstring('(a)', 'flip')).toBe('(ɐ)');
+    });
 
-  it('includes new styles', () => {
-    const styles = getStyles();
-    expect(styles).toContain('train');
-    expect(styles).toContain('hashtag');
-    expect(styles).toContain('acronym');
-    expect(styles).toContain('rot13');
-    expect(styles).toContain('flip');
-  });
-});
+    it('smallcaps', () => {
+      expect(capstring('Hello', 'smallcaps')).toBe('ʜᴇʟʟᴏ');
+      expect(capstring('abcdefghijklmnopqrstuvwxyz', 'smallcaps')).toBe('ᴀʙᴄᴅᴇꜰɢʜɪᴊᴋʟᴍɴᴏᴘǫʀꜱᴛᴜᴠᴡxʏᴢ');
+      expect(capstring('A1 Ü 😀', 'smallcaps')).toBe('ᴀ1 Ü 😀');
+    });
 
-describe('isValidStyle', () => {
-  it('returns true for valid styles', () => {
-    expect(isValidStyle('title')).toBe(true);
-    expect(isValidStyle('camel')).toBe(true);
-    expect(isValidStyle('kebab')).toBe(true);
-    expect(isValidStyle('hashtag')).toBe(true);
-  });
+    it('bubble', () => {
+      expect(capstring('Hi 5', 'bubble')).toBe('Ⓗⓘ ⑤');
+      expect(capstring('az AZ 09', 'bubble')).toBe('ⓐⓩ ⒶⓏ ⓪⑨');
+      expect(capstring('!Ü😀', 'bubble')).toBe('!Ü😀');
+      expect(capstring('1️⃣ a', 'bubble')).toBe('1️⃣ ⓐ'); // keycap stays whole
+    });
 
-  it('returns false for invalid styles', () => {
-    expect(isValidStyle('invalid')).toBe(false);
-    expect(isValidStyle('')).toBe(false);
-    expect(isValidStyle(null)).toBe(false);
+    it('wide - fullwidth', () => {
+      expect(capstring('Hi!', 'wide')).toBe('Ｈｉ！');
+      expect(capstring('a b', 'wide')).toBe('ａ　ｂ');
+      expect(capstring('~Ü😀', 'wide')).toBe('～Ü😀');
+      expect(capstring('#️⃣!', 'wide')).toBe('#️⃣！');
+    });
+
+    it('strike', () => {
+      expect(capstring('hi', 'strike')).toBe('h̶i̶');
+      expect(capstring('a b', 'strike')).toBe('a̶ b̶');
+      expect(capstring('😀', 'strike')).toBe('😀̶');
+      expect(capstring('👨‍👩‍👧🇺🇸', 'strike')).toBe('👨‍👩‍👧\u0336🇺🇸\u0336'); // ZWJ family and flag stay whole
+      expect(capstring('e\u0301', 'strike')).toBe('e\u0301\u0336');
+      expect(capstring('a\r\nb', 'strike')).toBe('a\u0336\r\nb\u0336');
+    });
   });
-});
 
-describe('STYLES constant', () => {
-  it('is a frozen array', () => {
-    expect(Object.isFrozen(STYLES)).toBe(true);
+  describe('capstringAll', () => {
+    it('returns every style in STYLES order', () => {
+      const all = capstringAll('hello world');
+      expect(Object.keys(all)).toEqual([...STYLES]);
+      expect(all.title).toBe('Hello World');
+      expect(all.none).toBe('');
+      for (const value of Object.values(all)) expect(typeof value).toBe('string');
+    });
+
+    it('returns false for non-string input', () => {
+      expect(capstringAll(42)).toBe(false);
+    });
+
+    it('strict: throws for non-string input', () => {
+      expect(() => capstringAll(42, { strict: true })).toThrow(TypeError);
+      expect(() => capstringAll(null, { strict: true })).toThrow(/got null/);
+    });
   });
 
-  it('contains all 29 styles', () => {
-    expect(STYLES.length).toBe(29);
+  describe('helpers', () => {
+    it('STYLES has 37 entries and is frozen', () => {
+      expect(STYLES).toHaveLength(37);
+      expect(Object.isFrozen(STYLES)).toBe(true);
+    });
+
+    it('CATEGORIES covers every style exactly once', () => {
+      const flat = Object.values(CATEGORIES).flat();
+      expect(flat).toHaveLength(STYLES.length);
+      expect(new Set(flat).size).toBe(STYLES.length);
+      expect([...flat].sort()).toEqual([...STYLES].sort());
+      expect(Object.isFrozen(CATEGORIES)).toBe(true);
+      expect(Object.isFrozen(CATEGORIES.case)).toBe(true);
+    });
+
+    it('getStyles returns a copy of STYLES', () => {
+      const styles = getStyles();
+      expect(styles).toEqual([...STYLES]);
+      styles.push('mutated');
+      expect(STYLES).not.toContain('mutated');
+    });
+
+    it('isValidStyle', () => {
+      expect(isValidStyle('kebab')).toBe(true);
+      expect(isValidStyle('piglatin')).toBe(true);
+      expect(isValidStyle('invalid')).toBe(false);
+      expect(isValidStyle(undefined)).toBe(false);
+    });
   });
 });
diff --git a/test/types.test.js b/test/types.test.js
new file mode 100644
index 0000000..4c78074
--- /dev/null
+++ b/test/types.test.js
@@ -0,0 +1,32 @@
+import { describe, it, expect } from 'vitest';
+import { readFileSync } from 'node:fs';
+import { STYLES, CATEGORIES } from '../index.js';
+
+const dts = readFileSync(new URL('../index.d.ts', import.meta.url), 'utf8');
+
+/**
+ * Extract the quoted members of a `type X = | 'a' | 'b'` union from the .d.ts
+ * @param {string} name - Type name
+ * @returns {string[]} Members
+ */
+const unionMembers = (name) => {
+  const match = new RegExp(`export type ${name} =([\\s\\S]*?);`).exec(dts);
+  return Array.from(match[1].matchAll(/'([^']+)'/g), (m) => m[1]);
+};
+
+describe('index.d.ts', () => {
+  it('Style union matches STYLES exactly, in order', () => {
+    expect(unionMembers('Style')).toEqual([...STYLES]);
+  });
+
+  it('Category union matches CATEGORIES keys', () => {
+    expect(unionMembers('Category')).toEqual(Object.keys(CATEGORIES));
+  });
+
+  it('declares every runtime export', () => {
+    for (const name of ['STYLES', 'CATEGORIES', 'capstring', 'capstringAll', 'getStyles', 'isValidStyle']) {
+      expect(dts).toMatch(new RegExp(`export (const|function) ${name}\\b`));
+    }
+    expect(dts).toContain('export default capstring');
+  });
+});
diff --git a/vitest.config.js b/vitest.config.js
index 588e4ef..0090f71 100644
--- a/vitest.config.js
+++ b/vitest.config.js
@@ -4,8 +4,10 @@ export default defineConfig({
   test: {
     coverage: {
       provider: 'v8',
+      include: ['index.js', 'cli.js'],
+      exclude: ['bin/**'],
       reporter: ['text', 'html', 'lcov'],
-      exclude: ['test/**', 'vitest.config.js', 'eslint.config.js', 'coverage/**']
+      thresholds: { lines: 100, functions: 100, branches: 100, statements: 100 }
     }
   }
 });