Regular Expressions 101

Positive Lookbehind(?<=^|[\n;](?:[\t ]*(?:\w+ )?)?)

1st Alternative^

^start of string

2nd Alternative[\n;](?:[\t ]*(?:\w+ )?)?

Character Class[\n;]

\na line-feed (newline) character (ASCII 10)

;the literal ; (59₁₀ / 73₈ / 3B₁₆)

Non-Capturing Group(?:[\t ]*(?:\w+ )?)?

?repeats the group contents below at most once:

Character Class[\t ]*

*matches any number of characters from the set below:

\ta tab character (ASCII 9)

the literal (32₁₀ / 40₈ / 20₁₆)

Non-Capturing Group(?:\w+ )?

?repeats the group contents below at most once:

\w+any word character, repeated at least once

the literal (32₁₀ / 40₈ / 20₁₆)

exportthe literal text export (case sensitive)

\s*any whitespace character, repeated any number of times

Group modifiers(?<modifiers>(?:\s*declare|\s*abstract|\s*async)+)?

?repeats the group contents below at most once:

Non-Capturing Group(?:\s*declare|\s*abstract|\s*async)+

+repeats the group contents below at least once:

1st Alternative\s*declare

\s*any whitespace character, repeated any number of times

declarethe literal text declare (case sensitive)

2nd Alternative\s*abstract

\s*any whitespace character, repeated any number of times

abstractthe literal text abstract (case sensitive)

3rd Alternative\s*async

\s*any whitespace character, repeated any number of times

asyncthe literal text async (case sensitive)

\s*any whitespace character, repeated any number of times

Group declaration(?<declaration>class|const +enum|const|enum|function\*?|interface|let|namespace|type(?! *\{)|var)

1st Alternativeclass

classthe literal text class (case sensitive)

2nd Alternativeconst +enum

constthe literal text const (case sensitive)

+the literal (32₁₀ / 40₈ / 20₁₆) , repeated at least once

enumthe literal text enum (case sensitive)

3rd Alternativeconst

constthe literal text const (case sensitive)

4th Alternativeenum

enumthe literal text enum (case sensitive)

5th Alternativefunction\*?

functionthe literal text function (case sensitive)

\*?optionally matches the literal * (42₁₀ / 52₈ / 2A₁₆)

6th Alternativeinterface

interfacethe literal text interface (case sensitive)

7th Alternativelet

letthe literal text let (case sensitive)

8th Alternativenamespace

namespacethe literal text namespace (case sensitive)

9th Alternativetype(?! *\{)

typethe literal text type (case sensitive)

Negative Lookahead(?! *\{)

*the literal (32₁₀ / 40₈ / 20₁₆) , repeated any number of times

\{the literal { (123₁₀ / 173₈ / 7B₁₆)

10th Alternativevar

varthe literal text var (case sensitive)

\s+any whitespace character, repeated at least once

Group exports(?<exports>(?:[$_\p{ID_Start}][$\u200C\u200D\p{ID_Continue}]*(?=[\s=:;/({])(?!.*?,))|(?:[\w\t\n\r .,:$'"=-]+)|(?:[{[][\w\t\n\r .,:$'"-]+[}\]]))

1st Alternative(?:[$_\p{ID_Start}][$\u200C\u200D\p{ID_Continue}]*(?=[\s=:;/({])(?!.*?,))

2nd Alternative(?:[\w\t\n\r .,:$'"=-]+)

3rd Alternative(?:[{[][\w\t\n\r .,:$'"-]+[}\]])

Non-Capturing Group(?:\s*=\s*[$_\p{ID_Start}][$\u200C\u200D\p{ID_Continue}]*)?

Global pattern flags

g modifier: global. Finds all matches instead of stopping after the first

u modifier: unicode. Enables Unicode-aware matching and escape syntax

Detailed match information will be displayed here automatically.

26 tokens

Regular Expression

(?<=^|[\n;](?:[\t ]*(?:\w+ )?)?)export\s*(?<modifiers>(?:\s*declare|\s*abstract|\s*async)+)?\s*(?<declaration>class|const +enum|const|enum|function\*?|interface|let|namespace|type(?! *\{)|var)\s+(?<exports>(?:[$_\p{ID_Start}][$\u200C\u200D\p{ID_Continue}]*(?=[\s=:;/({])(?!.*?,))|(?:[\w\t\n\r .,:$'"=-]+)|(?:[{[][\w\t\n\r .,:$'"-]+[}\]]))(?:\s*=\s*[$_\p{ID_Start}][$\u200C\u200D\p{ID_Continue}]*)?

New

export const CJS_SYNTAX_REGEX: RegExp = /pattern/gm;export const IGNORE_PATTERNS: string[] = [];
export declare const RESOLVE_EXTENSIONS: string[]
export enum Snack{}
export const enum Snack {}
export interface User {}
export class House {}
export declare abstract class House extends Building {}
export abstract class House {}
export async function run() {}
export async function* run() {}
export function foo() {}
export function* foo() {}
export const $foo = 42
export const $foo= 42
export namespace Foo {}
export type Foo = 'foo'
export let name1, name2/*, … */; // also var
export const name1 = 1, name2 = 2/*, … */; // also var, let
export function functionName() { /* … */ }
export class ClassName { /* … */ }
export function* generatorFunctionName() { /* … */ }
export const { name1, name2: bar } = o;
export const [ name1, name2 ] = array;

declare module 'module-name' {
  export declare abstract class Building {}
  export declare class House extends Building {}
}

"export const $foo = 42"

export default async function functionName() { /* … */ }
export default function functionName() { /* … */ }
export default function* generatorName() { /* … */ }
export default async function* generatorNameAsync() { /* … */ }
export default class ClassName { /* … */ }
export default abstract class ClassName { /* … */ }

export default function () { /* … */ }
export default async function () { /* … */ }
export default function* () { /* … */ }
export default async function* () { /* … */ }
export default class { /* … */ }

export default async () => {}
export default async arg => {}
export default () => {}
export default arg => {}
export default (arg) => {}

export default foo
export default foo;
export default 1 + 1;

// export const CJS_SYNTAX_REGEX

/**
 * Resolvable file extensions.
 *
 * @example
 *	  export const CJS_SYNTAX_REGEX
 */

export type Foo = 'foo'

Substitution