Traverse and transform objects by visiting every node on a recursive walk. A TypeScript rewrite of traverse with 0 dependencies, prototype-pollution hardening, ~5× the throughput and ~6× less allocation with the functional API (up to ~10× / ~11× peaks on core walks).

📖 Full docs, security audit & live benchmarks: neotraverse.puruvj.dev

Utility-first: the default export is named functions (sideEffects: false), pay for what you use, not a monolithic class.

• 🤌 ~2–6 KB brotli (tree-shaken; ~2 KB for one walk like forEach, ~5.8 KB for every helper)
• 🚥 Zero dependencies, no polyfills
• 🎹 TypeScript: throw away @types/traverse
• 🛡️ Safe on untrusted input (prototype-pollution & injection hardened)
• ⚡ ~5× faster and ~6× leaner than traverse with the functional API (up to ~10× / ~11×); ~3× speed and ~2× less memory on the legacy drop-in build
• 🛸 ESM-first, with a legacy ES2015 CJS/ESM build
• 🛟 neotraverse/safe: an opt-in, stack-safe iterative core that walks 200,000-deep trees recursion can't, with a lazy visit iterator and copy-on-write transform (Node 22+)

Geometric-mean speedup versus the original traverse across the full operation × shape matrix:

Core traversal ops (forEach / map / clone / reduce / paths / nodes) on the functional build land at ~3–10× throughput and ~6× less heap on average vs traverse (peaks: clone · small ~9.9× speed, forEach · wide ~11× memory). See the full table or the interactive benchmarks page. Reproduce with pnpm bench.

npm install neotraverse

Measured with esbuild + brotli from published ESM (bench/bundle-sizes.json; pnpm bundle-size):

// the default export: tree-shakeable functions, `ctx` argument (recommended)
import { forEach } from 'neotraverse';

forEach({ a: 1, b: 2, c: [3, 4] }, (ctx, x) => {
  if (typeof x === 'number') ctx.update(x * 10);
});

// classic `traverse`-compatible API (drop-in for the original `traverse`)
import traverse from 'neotraverse/legacy';

traverse({ a: 1, b: 2, c: [3, 4] }).forEach(function (x) {
  if (typeof x === 'number') this.update(x * 10);
});

// the deprecated 0.x `Traverse` class lives here, removed in v2
import { Traverse } from 'neotraverse/modern';

A second, opt-in entry point for input that is deep, untrusted, huge, or only partially consumed. The default neotraverse walk is recursive (fast, but it overflows the call stack on deep enough input). neotraverse/safe runs on an iterative engine, so it traverses arbitrarily deep trees that crash a recursive walker (measured: the default overflows past ~2,000 levels; /safe handles 200,000+). It is also lazy and copy-on-write.

import { visit, transform } from 'neotraverse/safe';

// lazy iteration: stop early, never materialize the rest
const first5 = visit(huge)
  .filter((v) => typeof v.value === 'string')
  .take(5)
  .toArray();

// copy-on-write: shares untouched subtrees, returns the input by identity on a no-op
const redacted = transform(doc, {
  '**.{password,token}': (v, { replace }) => replace('***')
});

It ships a twelve-export surface: visit, transform / transformAsync, get / set / has, clone, equal, merge, diff, patch, resolveRefs.

The honest trade-off: on a full eager scan /safe runs at roughly 0.8× the default (still ~4× faster than traverse), and materializing a whole tree costs a little more memory. It wins on stack safety, on early-exit memory (~6× less peak on a filter().take() chain), and on copy-on-write edits. Requires Node 22+ / evergreen browsers (it uses native ES2025 iterator helpers). See the /safe guide.

⚠️ 1.0 breaking changes: the default export (neotraverse) is now the functional API, not the classic traverse default. Move classic drop-in imports to neotraverse/legacy, and import { Traverse } to neotraverse/modern. The legacy build also targets ES2015 (was ES5); only environments needing literal ES5 (e.g. IE11) are affected.

neotraverse is safe to run on untrusted data:

• No prototype pollution: set(path, value) refuses __proto__ / constructor / prototype keys.
• No prototype injection: clone() / map() of hostile JSON like {"__proto__":{"isAdmin":true}} keep their real prototype; result.isAdmin is undefined.
• Prototype preservation intact: legitimate instanceof still works after a clone.
• No prototype-chain disclosure: get() / has() follow only own properties.

import { clone } from 'neotraverse';

const evil = JSON.parse('{"user":"bob","__proto__":{"isAdmin":true}}');
clone(evil).isAdmin; // undefined
({}).isAdmin; // undefined, global prototype untouched

Read the full story in the 1.0 release post.

Bound recursion on deeply-nested hostile input with maxDepth (throws a catchable RangeError; unlimited by default):

clone(untrusted, { maxDepth: 1000 });

The hardening and DoS guards apply to the functional API. The neotraverse/legacy drop-in is intentionally kept behaviour-compatible with the original traverse and does not receive them — run untrusted data through the functional API.

Differences from traverse: drop-in vs functional, what's new, which build to use.

-import traverse from 'traverse';
+import traverse from 'neotraverse/legacy';

npm install neotraverse && npm uninstall traverse @types/traverse

The legacy API is identical to traverse. For new code, prefer the functional default export.

Functional (neotraverse, recommended): forEach, map, clone, reduce, find, filter, some, every, paths, nodes, get, set, has, entries, values, walk, breadthFirst, mapBfs, forEachAsync, mapAsync, plus findPaths, filterPaths, getPath, setPath, hasPath, parsePath, parseDotPath, parseJsonPointer, pointerPath, parseGlob, count, size, getType, groupBy, skipWhere, deleteWhere, prune, pruneDeep, sanitize, deepEqual, merge, dereference, toJSON, freeze, diff, patch, select. Options are always the last argument.

Deprecated class (neotraverse/modern): the Traverse class (.get/.has/.set/.map/.forEach/.reduce/.paths/.nodes/.clone) is deprecated and removed in v2 — use the functions above.

Classic (neotraverse/legacy): .map(fn) · .forEach(fn) · .reduce(fn, acc) · .paths() · .nodes() · .clone() · .get(path) · .set(path, value) · .has(path) on a traversal instance (this-bound context).

Options: { immutable?, includeSymbols?, maxDepth?, signal? } (signal is async-only on modern).

Each callback gets a context (ctx in modern, this in classic) with node, path, parent, key, isRoot, isLeaf, isFirst, isLast, level, circular, and the mutators update(), remove(), delete(), before(), after(), pre(), post(), stop(), block().

👉 Full API reference, examples, and context docs: neotraverse.puruvj.dev/guide.

neotraverse vs traverse, ops/sec (and ×speedup). Generated by bench/run.ts via tinybench; see bench/results.json.

get / has / set are micro-ops (20M+ ops/s); all three builds are within noise of each other and of traverse. The legacy class stores its state in plain instance fields (not #private, which would downlevel to WeakMaps at ES2015), so these stay native-fast on the drop-in too.

MIT, Puru Vijay.