Detect and Tag Code Block Languages

Python detected from an import line

The first line begins with import, the first pattern in the chain, so the block is tagged python.

Input:
```
import requests
resp = requests.get(url)
```

Output:
```python
import requests
resp = requests.get(url)
```

JavaScript from a const declaration

const matches the JavaScript pattern. Note: TypeScript is not a separate target, so a .ts snippet that opens with const is also tagged javascript.

Input:
```
const api = '/v1/users';
fetch(api).then(r => r.json());
```

Output:
```javascript
const api = '/v1/users';
fetch(api).then(r => r.json());
```

JSON detected from a leading brace

When the trimmed body starts with { or [, the block is tagged json. This rule sits near the end of the chain, so config that looks like another language can win first.

Input:
```
{
  "name": "jad",
  "version": "1.0.0"
}
```

Output:
```json
{
  "name": "jad",
  "version": "1.0.0"
}
```

Already-tagged block is preserved

A fence that already carries a hint is returned byte-for-byte, even if the content would have detected as something else.

Input:
```bash
npm run build
```

Output:
```bash
npm run build
```

Unrecognised snippet stays bare

A YAML block does not match any pattern, so it is left untagged — the tool never guesses a fallback like text.

Input:
```
name: build
on: [push]
```

Output:
```
name: build
on: [push]
```

There is no typescript target. A .ts snippet that opens with const, let, function, or import { matches the JavaScript pattern and is tagged javascript. If you need the typescript identifier for your renderer, change it by hand after the run.

const and var appear in both the JavaScript and Go patterns, and JavaScript is tested first. A Go file that opens with const ( is tagged javascript. Move a package or func line to the top, or correct the hint manually.

Detection reads the start of the block body. If the first line is a # comment, //, or blank, none of the keyword patterns match and the block stays untagged. Put a signature line (an import, a def, a SELECT) first to get a hit.

These languages are not in the nine-pattern set. Their blocks are never tagged automatically — add the hint yourself after running.

Only backtick fences (``` ) are scanned. A ~~~`-delimited block is skipped entirely. Convert tildes to backticks first if you want it tagged.

The tool only matches fenced blocks. A four-space-indented code block is treated as ordinary text and never receives a hint.

A block whose first character is { or [ is tagged json. A Rust or Go snippet that happens to open with a brace can be mislabelled json if its earlier patterns did not match. Review brace-first blocks.

Every tagged fence is returned unchanged, so a second pass produces identical output. The transform is idempotent and safe to wire into a pre-commit hook.

Free tier caps markdown input at 500,000 characters (and 1 MB / 1 file). A doc beyond that is rejected before processing — split it with md-splitter or upgrade for the 5,000,000-character Pro limit.