rbuckton

• Intl.StringInfo
  • .charCodes(s) - Returns an Iterable that yields each code unit within the string s.
  • .codePoints(s) - Returns an Iterable that yields each code point within the string s (essentially just yield* s).
  • .graphemeClusters(s) - Returns an Iterable that yields each grapheme cluster substring within the string s.
  • .codePointCount(s) - Counts the number of code points within the string s.
  • .graphemeClusterCount(s) - Counts the number of grapheme clusters within the string s.
  • .nthCodePoint(s, n) - Gets the n-th code point (as a number) within the string s.
  • .nthGraphemeCluster(s, n) - Gets the n-th grapheme cluster (as a substring) within the string s.
  • .codePointSize(codePoint) - Gets the size, in code units, of the provided code point.
• .getUnicodeCategory(s, i) - Gets the unicode category for the code point at the specified index i in string s.

rbuckton

ECMAScript Regular Expression Language Additions

This is a strawperson for the addition of multiple Regular Expression features popular in various languages and parsers. The primary influences for this proposal come from prior art in the following languages and regular expression engines:

• Perl
• .NET
• Oniguruma (docs)

rbuckton

Range Types (T[X:Y]) for TypeScript

A Range Type is a type that produces a new tuple or array type that derives from T by dropping the excess ordered elements of T outside of the range starting at offset X (inclusive) through offset Y (exclusive).

A Range Type is denoted using a : operator in what would otherwise be an Indexed Access Type:

type T = [1, 2, 3][0:2];

rbuckton

Proposal: Inverse Offset Types (^N) for TypeScript

This proposal adds an Inverse Offset Type to the TypeScript type-space. An Inverse Offset Type is a type notation used to indicate that Type should be considered as an offset from the end of an Array Type or Tuple Type.

An Inverse Offset Type is denoted using a "hat" operator (^) preceding a type:

type T = ^0;

rbuckton

Purpose:

• Primarily for developer tooling, such as for "rename" refactoring.

Syntax:

nameof IdentifierName

Examples:

rbuckton

Syntax:

// classes
class C {
  #x = 1;
  get x() => this.#x;
  set x(value) => this.#x = value;
  toString() => `C(${this.#x})`;
  static create() => new C();
}

rbuckton

// Symbols:
//  @@geti          - An inverted-get. When present on an object used in an element access, calls this method rather than coercing 
//                    the object to a String.
//                    ex: `a[b]` --> `b[@@geti](a)`
//  @@seti          - An inverted-set. When present on an object used in an element access assignment, calls this method rather 
//                    than coercing the object to a String.
//                    ex: `a[b] = 1` --> `b[@@seti](a, 1)`
//  @@indexedGet    - Gets a value from an object in relation to a given `Index` instance.
//  @@indexedSet    - Sets a value on an object in relation to a given `Index` instance.
//  @@slice         - Gets values from an object in relation to a given `Interval` instance.

rbuckton

export {};

/** A non-existent symbol used to define the types of events defined on an object */
declare const kEvents: unique symbol;

/** Gets the events defined on an object. */
type Events<T> = T extends { readonly [kEvents]: infer Events } ? Events : {};

/** Get the names of events defined on an object. */
type EventNames<T> = keyof Events<T>;

rbuckton

Symbol.asyncDispose = Symbol.for("Symbol.asyncDispose");
function __asyncUsing(obj) {
    let state = obj !== null && obj !== undefined ? 0 : 2;
    return {
        [Symbol.asyncIterator]() { return this; },
        async next() {
            if (state) return this.return();
            state = 1;
            return { value: obj };
        },

rbuckton

//
// Lexical Grammar
//

SourceCharacter::
  > Any unicode code point

WhiteSpace::
  <TAB>
  <VT>