The code

export function isCJK(s: string): boolean {
  for (const ch of s) {
    const c = ch.codePointAt(0)!
    if ((c >= 0x4E00 && c <= 0x9FFF) ||
        (c >= 0x3400 && c <= 0x4DBF) ||
        (c >= 0x20000 && c <= 0x2A6DF) ||
        (c >= 0x2A700 && c <= 0x2B73F) ||
        (c >= 0x2B740 && c <= 0x2B81F) ||
        (c >= 0x2B820 && c <= 0x2CEAF) ||
        (c >= 0x2CEB0 && c <= 0x2EBEF) ||
        (c >= 0x30000 && c <= 0x3134F) ||
        (c >= 0xF900 && c <= 0xFAFF) ||
        (c >= 0x2F800 && c <= 0x2FA1F) ||
        (c >= 0x3000 && c <= 0x303F) ||
        (c >= 0x3040 && c <= 0x309F) ||
        (c >= 0x30A0 && c <= 0x30FF) ||
        (c >= 0xAC00 && c <= 0xD7AF) ||
        (c >= 0xFF00 && c <= 0xFFEF)) {
      return true
    }
  }
  return false
}

My spider sense tingling

Hunch is good, benchmark is better

function bench(name, fn, iterations = 1_000_000) {
  for (let i = 0; i < 10_000; i++) fn(); // warmup
  const start = performance.now();
  for (let i = 0; i < iterations; i++) fn();
  const elapsed = performance.now() - start;
  const opsPerSec = ((iterations / elapsed) * 1000).toFixed(0);
  console.log(`${name}: ${elapsed.toFixed(2)} ms (${opsPerSec} ops/sec)`);
}

// to call:
bench("isCJKRegex       ", () => isCJKRegex(input));

The new AI normal

100% vibe coding

• early exit
• replace 15 linear checks with binary search

look at is_cjk.js. come up with 2 ideas for how to speed up isCJK(). Implement those as separate functions and write a javascript micro-benchmark that compares those 2 new implementations against isCJK

Two ideas:

1. Pre-compiled regex — push the entire check into the native regex engine, avoiding JS-level for…of iteration and codePointAt() overhead.
2. Typed array bitmap for BMP — for BMP characters (the vast majority of real text), a Uint8Array bitmap gives O(1) lookup with a single array access. Fall back to range checks only for supplementary plane characters.

Human assisted coding

You’re benchmarking what?

run the tests using bun

Continuing collaboration with AI

don’t benchmark bitmap, it uses too much memory; write a variant of isCJK that does an early false exit if char is less than smallest

now implement a variant that does inline bisect / binary search

// Flat array: [lo0, hi0, lo1, hi1, ...] sorted by lo
const cjkRanges = new Uint32Array([
  0x3000, 0x303f,
  0x3040, 0x309f,
  ...

implement a variant isCJBisect that doesn’t use array but unrolls binary search logic into if statements

function inCJKUnrolled(c) {
  if (c < 0x3000) return false;
  if (c < 0xff00) {
    if (c < 0x3400) {
      if (c < 0x3040) {
        return c <= 0x303f;
      } else if (c > 0x309f) {
        return c >= 0x30a0 && c <= 0x30ff;
      }
      return true;
  // ... more gnarly code

The for…of + codePointAt iterator overhead remains the bottleneck shared by all non-regex variants on long strings.

write variant of isCJKEarly which replaces for of with a faster loop

isCJKEarlyFast crushes everything across the board on both runtimes

Replacing for…of + codePointAt() with charCodeAt() + index loop eliminates the iterator overhead, which was the main bottleneck. The early c < 0x3000 bail then skips all range checks for ASCII/latin characters cheaply. Only regex still wins on Node’s long latin miss case thanks to V8’s native string scanning.

Pressing on

export function isCJKUnrolled(s) {
  for (const ch of s) {
    if (inCJKUnrolled(ch.codePointAt(0))) return true;
  }
  return false;
}

inline inCJKUnrolled into isCJKUnrolled

Done. Inlining didn’t help — it actually got slightly slower in most cases (the engine was already inlining the small function). No change in rankings; EarlyFast remains the winner.

also write original with for of replaced by standard for loop and bench all and give results as markdown table

Bun

Node

Conclusions

Programming expert knowledge

• importance of warmup phase when benchmarking JIT compilers
• for .. of is slower than for (let i = 0; i < n; i++)
• regex matching in JavaScript engines is fast
• subtlety of surrogate pairs in JavaScript strings
• using bitmaps to speed up range lookups

Resources