Specifying JavaScript.

TC39

Ecma International's TC39 is a group of JavaScript developers, implementers, academics, and more, collaborating with the community to maintain and evolve the definition of JavaScript.

We are part of

Contribute

TC39 welcomes contributions from the JavaScript community, whether it is feedback on existing proposals, improved documentation, testing, implementations, or even language feature ideas. See our contributor guide for details.

To participate in TC39 meetings as a member, join Ecma.

Specs

We develop the JavaScript (formally, ECMAScript) specification on GitHub and meet every two months to discuss proposals. To learn more about the process, please take a look at the five stages for new language feature proposals. See our meeting agendas and minutes to learn more.

State of Proposals

Current Candidates for the Specification

This section features proposals that are in Stage 3 of our process, which means they are close to completion.

How to read the proposals list

Each proposal has links out to other resources. The tags identify the following attributes. Below you will find a table with example tags and their meanings. All tags have hover text if you need help getting oriented.

Types of tags and what they mean

Last Presented:
December 2018
Available Tests:
Tests
Specification Text:
Specification

Legacy RegExp features in JavaScript

2017
Tests

Author: Claude Pache | Champions: Mark Miller, Claude Pache

This is a specification draft for the legacy (deprecated) RegExp features in JavaScript, i.e., static properties of the constructor like RegExp.$1 as well as the RegExp.prototype.compile method.

Hashbang Grammar

Author: Bradley Farias | Champion Bradley Farias

This proposal is to match de-facto usage in some CLI JS hosts that allow for Shebangs / Hashbang. Such hosts strip the hashbang in order to generate valid JS source texts before passing to JS engines currently. This would unify and standardize how that is done.

Show Example

#!/usr/bin/env node
// in the Module Goal
export {};
console.log(1);

`Atomics.waitAsync`

Author: Lars Hansen | Champions: Shu-yu Guo, Lars Hansen

A proposal for an “asynchronous atomic wait” for ECMAScript, primarily for use in agents that are not allowed to block.

Import Assertions

Authors: Myles Borins, Sven Sauleau, Dan Clark, Daniel Ehrenberg | Champions: Myles Borins, Sven Sauleau, Dan Clark, Daniel Ehrenberg

A proposal for syntax to import ES modules with assertions.

Show Example

new Worker("foo.wasm", { type: "module", assert: { type: "webassembly" } });

JSON Modules

Authors: Sven Sauleau, Daniel Ehrenberg, Myles Borins, Dan Clark | Champions: Sven Sauleau, Daniel Ehrenberg, Myles Borins, Dan Clark

Proposal to import JSON files as modules.

Show Example

import json from "./foo.json" assert { type: "json" };

Temporal

Authors: Maggie Pint, Matt Johnson, Philipp Dunkel | Champions: Maggie Pint, Matt Johnson, Philipp Dunkel

Date has been a long-standing pain point in ECMAScript. This proposes Temporal, a global Object that acts as a top-level namespace (like Math), that brings a modern date/time API to the ECMAScript language. For a detailed breakdown of motivations, see the proposal readme.

Show Example

// See the repo for detailed examples. // small example from the cook book
const date = Temporal.now.plainDateISO(); // Gets the current date
date.toString(); // returns the date in ISO 8601 date format
// If you additionally want the time
Temporal.now.plainDateTimeISO().toString(); // date and time in ISO 8601 format

In-Place Resizable and Growable ArrayBuffers

Author: Shu-yu Guo | Champion Shu-yu Guo

ArrayBuffers have enabled in-memory handling of binary data and have enjoyed great success. This proposal extends the ArrayBuffer constructors to take an additional maximum length that allows in-place growth and shrinking of buffers. Similarly, SharedArrayBuffer is extended to take an additional maximum length that allows in-place growth. The transfer method is also re-introduced here as a standard way to detach ArrayBuffers, perform zero-copy moves, and to "fix" resizable ArrayBuffer instances to ArrayBuffer instances.

Show Example

// Resizable ArrayBuffer

let rab = new ArrayBuffer(1024, { maximumByteLength: 1024 ** 2 });
assert(rab.byteLength === 1024);
assert(rab.maximumByteLength === 1024 ** 2);
assert(rab.resizable);
rab.resize(rab.byteLength * 2);
assert(rab.byteLength === 1024 * 2);

// Transfer the first 1024 bytes.
let ab = rab.transfer(1024);

// rab is now detached
assert(rab.byteLength === 0);
assert(rab.maximumByteLength === 0);

// The contents are moved to ab.
assert(!ab.resizable);
assert(ab.byteLength === 1024);

Array.prototype.findLast and Array.prototype.findLastIndex

Author: Wenlu Wang | Champions: Wenlu Wang, Daniel Rosenwasser

Proposal for finding the first match from the end of the array for both elements and indices.

Show Example

const array = [{ value: 1 }, { value: 2 }, { value: 3 }, { value: 4 }];
array.find(n => n.value % 2 === 1); // { value: 1 }
array.findIndex(n => n.value % 2 === 1); // 0

ShadowRealm API

Authors: Caridy Patiño, Jean-Francois Paradis | Champions: Dave Herman, Mark Miller, Caridy Patiño, Leo Balter

ShadowRealms are a distinct global environment, with its own global object containing its own intrinsics and built-ins (standard objects that are not bound to global variables, like the initial value of Object.prototype)..

Show Example

const red = new ShadowRealm();

// realms can import modules that will execute within it's own environment.
// When the module is resolved, it captured the binding value, or creates a new
// wrapped function that is connected to the callable binding.
const redAdd = await red.importValue('./inside-code.js', 'add');

// redAdd is a wrapped function exotic object that chains it's call to the
// respective imported binding.
let result = redAdd(2, 3);

Array Grouping

2021
Specification

Author: Justin Ridgewell | Champion Justin Ridgewell

A proposal to make grouping of array items easier.

Show Example

const array = [1, 2, 3, 4, 5];

// groupBy groups items by arbitrary key.
// In this case, we're grouping by even/odd keys
array.groupBy((num, index, array) => {
  return num % 2 === 0 ? 'even': 'odd';
});

// =>  { odd: [1, 3, 5], even: [2, 4] }

// groupByToMap returns items in a Map, and is useful for grouping using
// an object key.
const odd  = { odd: true };
const even = { even: true };
array.groupByToMap((num, index, array) => {
  return num % 2 === 0 ? even: odd;
});

// =>  Map { {odd: true}: [1, 3, 5], {even: true}: [2, 4] }

See proposals in all stages