Modern JavaScript built-ins you can use in 2026: a browser support checklist

Many front-end projects still ship helper libraries and polyfills for things the browser now does natively: grouping arrays, set operations, Base64 encoding, escaping strings for regular expressions. Each extra dependency adds bytes to download, code to audit and versions to update. At the same time, a few eye-catching new features are not ready everywhere, and using them without checking breaks the site for part of your audience.

This guide is a practical checklist for October 2026. It lists modern JavaScript built-ins, the first Chrome, Firefox and Safari versions that support them according to MDN's browser compatibility data (version 8.1.4, published 1 October 2026), and a short example of each. Use it to decide what you can delete from your bundle, and what still needs a fallback.

The versions below refer to desktop browsers; Safari on iOS has the same version numbers for every feature listed here. Edge uses the same version numbers as Chrome.

How to read "supported" in 2026

The web.dev Baseline project gives a shared vocabulary. A feature is Baseline newly available when it is supported by all the core browsers: Chrome (desktop and Android), Edge, Firefox (desktop and Android) and Safari (macOS and iOS). It becomes Baseline widely available 30 months after that date, when "the feature can be used by most sites without worrying about support".

Your own analytics matter more than any general rule. A business tool used on managed office laptops can adopt newer features faster than a consumer site with many older phones. A simple policy is: use widely available features freely, use newly available features when your analytics show the older versions are rare, and feature-detect everything else.

Safe to use: features from the last few years

Non-mutating array methods

const prices = [499, 99, 1299];

const sorted = prices.toSorted((a, b) => a - b); // [99, 499, 1299]
const updated = prices.with(1, 149);              // [499, 149, 1299]
console.log(prices);                              // unchanged: [499, 99, 1299]

These matter in React and other state-driven UIs, where mutating an array in place causes missed re-renders.

Grouping

const orders = [
  { id: 1, status: 'paid' },
  { id: 2, status: 'pending' },
  { id: 3, status: 'paid' },
];

const byStatus = Object.groupBy(orders, (o) => o.status);
// { paid: [{id: 1,…}, {id: 3,…}], pending: [{id: 2,…}] }

Object.groupBy() returns an object with a null prototype, so call Object.keys() on it rather than methods such as hasOwnProperty. Use Map.groupBy() when keys are not strings.

Set operations

const required = new Set(['read', 'write']);
const granted = new Set(['read', 'comment']);

required.difference(granted);   // Set {'write'}: what is missing
required.isSubsetOf(granted);   // false
required.union(granted);        // Set {'read', 'write', 'comment'}

The full set is union, intersection, difference, symmetricDifference, isSubsetOf, isSupersetOf and isDisjointFrom. Remember that browser-side permission checks are for display only; the server must still enforce access.

Newer, now in all three engines

Features in the upper rows have been in every engine for longer. The lower rows, which need Safari 26.x or Chrome 145 and later, are recent: check your traffic before relying on them without a fallback.

Iterator helpers: lazy pipelines without arrays

function* naturals() {
  let n = 1;
  while (true) yield n++;
}

const firstFiveEvenSquares = naturals()
  .filter((n) => n % 2 === 0)
  .map((n) => n * n)
  .take(5)
  .toArray(); // [4, 16, 36, 64, 100]

Unlike array methods, iterator helpers process one value at a time, so the infinite generator above is safe. They also work on the iterators returned by map.entries(), set.values() and DOM collections' iterators, avoiding temporary arrays.

Base64 without btoa() surprises

const bytes = new TextEncoder().encode('नमस्ते');  // UTF-8 bytes
const encoded = bytes.toBase64();                 // works for any bytes
const decoded = new TextDecoder().decode(Uint8Array.fromBase64(encoded));

const hex = new Uint8Array([255, 16]).toHex();    // "ff10"

The old btoa() throws on characters outside Latin-1, which regularly breaks Hindi, Tamil or emoji text. The Uint8Array methods operate on bytes, so encode text with TextEncoder first.

Escaping user input in regular expressions

const term = 'C++ (beta)';
const re = new RegExp(RegExp.escape(term), 'i');
re.test('Learning c++ (BETA) today'); // true

This replaces the hand-written escaping helpers found in many search features, which often miss a character.

Upserts on Map

const counts = new Map();
for (const word of ['js', 'ts', 'js']) {
  counts.set(word, counts.getOrInsert(word, 0) + 1);
}
// Map {'js' => 2, 'ts' => 1}

const cache = new Map();
const user = cache.getOrInsertComputed(42, (id) => ({ id, loadedAt: Date.now() }));

Safer error handling with Promise.try() and Error.isError()

function loadSettings(source) {
  // Wraps both synchronous throws and async rejections in one promise
  return Promise.try(() => source.read());
}

loadSettings(storage).catch((err) => {
  // true for real Error objects, including ones from other realms such as iframes
  if (Error.isError(err)) {
    reportError(err);
  } else {
    reportError(new Error('Non-error thrown', { cause: err }));
  }
});

Promise.try() removes the classic bug where a function that throws synchronously escapes a .catch() handler. Error.isError() is more reliable than instanceof Error when errors cross frames or workers. Together with the cause option they make error reporting more consistent.

Not ready everywhere: feature-detect or wait

For APIs (functions and objects), feature detection is simple:

if (typeof globalThis.Temporal === 'undefined') {
  await import('temporal-polyfill/global');
}

const zip = typeof Iterator.zip === 'function'
  ? Iterator.zip
  : null; // fall back to your own helper

Syntax is different. A using declaration is a parse error in a browser that does not understand it, so the whole script fails, not just one line. Either compile it away with your build tool or wait until all your target browsers support it. Check your transpiler's documentation for which proposals it can transform.

A checklist for cleaning up your bundle

1. Export a browser and version report from your analytics for the last 90 days, including iOS versions.
2. Set your build target (for example a Browserslist query or your bundler's target option) to match that audience, and keep it in version control.
3. Search your dependencies and code for helpers the platform now covers: groupBy, deep set utilities, Base64 helpers, regex-escape functions, "deferred" promise helpers, last() helpers.
4. Replace them one module at a time and remove the dependency when the last import is gone.
5. Check that your polyfill service or core-js configuration only includes what your targets need.
6. For anything in the "not ready" table, add feature detection and a tested fallback, or hold it back.
7. Set a review date. Browser support changes every few weeks; repeat the audit each quarter.
8. Run your test suite in at least one Chromium, one Firefox and one WebKit browser before each release, so a missing method fails in CI rather than for a customer.

TypeScript note

Type definitions lag behind or lead browsers. TypeScript 6.0 added an es2025 target and library, including types for RegExp.escape, Temporal and the Map upsert methods. If the compiler says a method does not exist, check your lib setting before adding a polyfill: the problem may be types, not runtime support.

Summary

A large set of once-missing built-ins now works in Chrome, Firefox and Safari: immutable array methods, grouping, Set operations, iterator helpers, Promise.try(), byte-level Base64 and RegExp.escape(). They let you remove dependencies and write clearer code. Temporal, explicit resource management with using and Iterator.zip() are still missing from Safari, so treat them as progressive enhancements or wait. Check MDN's compatibility tables and your own analytics before each decision.