AI code generator

A function wordFrequencies(text) that returns an object mapping each lowercase word to how many times it appears, ignoring punctuation.

```javascript
function wordFrequencies(text) {
  const frequencies = Object.create(null);
  const words = String(text).toLowerCase().match(/[\p{L}\p{N}]+/gu) || [];

  for (const word of words) {
    frequencies[word] = (frequencies[word] || 0) + 1;
  }

  return frequencies;
}
```

It counts lowercase sequences of letters and numbers, ignoring punctuation; empty input returns an empty object.
Example: `wordFrequencies("Hello, hello!")` returns `{ hello: 2 }`.

A function that reads a CSV file of orders (date, customer, amount) and returns the total amount per customer, highest first.

```python
import csv
from collections import defaultdict
from decimal import Decimal, InvalidOperation
from pathlib import Path


def total_amount_per_customer(csv_path: str | Path) -> list[tuple[str, Decimal]]:
    """Return (customer, total) pairs, sorted by total descending."""
    totals: dict[str, Decimal] = defaultdict(Decimal)

    with open(csv_path, "r", newline="", encoding="utf-8-sig") as file:
        reader = csv.DictReader(file)
        required = {"date", "customer", "amount"}
        if reader.fieldnames is None or not required.issubset(reader.fieldnames):
            raise ValueError("CSV must contain date, customer, and amount columns")

        for row in reader:
            customer = (row.get("customer") or "").strip()
            raw_amount = (row.get("amount") or "").strip()
            if not customer or not raw_amount:
                continue
            try:
                totals[customer] += Decimal(raw_amount)
            except InvalidOperation as exc:
                raise ValueError(f"Invalid amount: {raw_amount!r}") from exc

    return sorted(totals.items(), key=lambda item: (-item[1], item[0]))
```

It reads the named CSV columns, skips rows with a blank customer or amount, and sorts totals highest first (customer name breaks ties).
Example: `total_amount_per_customer("orders.csv")` returns entries such as `[("Ada", Decimal("25.50"))]`.

A debounce(fn, ms) function: calls fn only after ms milliseconds have passed without another call, with the latest arguments.

```typescript
function debounce<T extends (...args: any[]) => void>(
  fn: T,
  ms: number
): (...args: Parameters<T>) => void {
  let timer: ReturnType<typeof setTimeout> | undefined;

  return (...args: Parameters<T>): void => {
    if (timer !== undefined) clearTimeout(timer);
    timer = setTimeout(() => fn(...args), Math.max(0, ms));
  };
}

// Example:
const debouncedLog = debounce((message: string) => console.log(message), 300);
debouncedLog("first");
debouncedLog("latest"); // Calls fn with "latest" after 300 ms without another call.
```

Each call resets the timer, so `fn` runs with the latest arguments only after calls stop for `ms` milliseconds.