xbintsc 0.2.9 → 0.3.1

package/src/driver/toolchain.ts

@@ -13,8 +13,14 @@ export interface CommandResult {
   readonly stderr: string;
 }
 
+export interface RunOptions {
+  readonly cwd?: string;
+  /** Extra environment variables, merged over `process.env`. */
+  readonly env?: Record<string, string>;
+}
+
 export interface Runner {
-  run(command: string, args: readonly string[], options?: { cwd?: string }): CommandResult;
+  run(command: string, args: readonly string[], options?: RunOptions): CommandResult;
 }
 
 export const realRunner: Runner = {
@@ -24,6 +30,7 @@ export const realRunner: Runner = {
       encoding: "utf8",
       maxBuffer: 64 * 1024 * 1024,
     };
+    if (options.env) spawnOptions.env = Object.assign({}, process.env, options.env);
     const result = spawnSync(command, [...args], spawnOptions);
     return {
       status: result.status ?? (result.error ? 1 : 0),
@@ -68,17 +75,16 @@ export interface CompileIrOptions {
   readonly irPath: string;
   readonly objectPath: string;
   readonly optimize: string;
+  readonly env?: Record<string, string>;
 }
 
 /** Compile an LLVM IR file to a native object file. */
 export function compileIr(runner: Runner, options: CompileIrOptions): void {
-  const result = runner.run(options.clang, [
-    `-O${options.optimize}`,
-    "-c",
-    options.irPath,
-    "-o",
-    options.objectPath,
-  ]);
+  const result = runner.run(
+    options.clang,
+    [`-O${options.optimize}`, "-c", options.irPath, "-o", options.objectPath],
+    { env: options.env },
+  );
   if (result.status !== 0) throw new ToolchainError(`${options.clang} ${options.irPath}`, result.status, result.stderr);
 }
 
@@ -88,16 +94,28 @@ export interface LinkOptions {
   readonly outputPath: string;
   readonly linkerFlags: readonly string[];
   readonly optimize: string;
+  readonly env?: Record<string, string>;
 }
 
 export function link(runner: Runner, options: LinkOptions): void {
   const args = [`-O${options.optimize}`, ...options.objectPaths, "-o", options.outputPath, ...options.linkerFlags];
-  const result = runner.run(options.clang, args);
+  const result = runner.run(options.clang, args, { env: options.env });
   if (result.status !== 0) throw new ToolchainError(`${options.clang} link`, result.status, result.stderr);
 }
 
 /** Compile a C source to an object file (used for the runtime and extensions). */
-export function compileC(runner: Runner, clang: string, sourcePath: string, objectPath: string, includeDir: string): void {
-  const result = runner.run(clang, ["-O2", "-D_CRT_SECURE_NO_WARNINGS", "-c", sourcePath, "-o", objectPath, `-I${includeDir}`]);
+export function compileC(
+  runner: Runner,
+  clang: string,
+  sourcePath: string,
+  objectPath: string,
+  includeDir: string,
+  env?: Record<string, string>,
+): void {
+  const result = runner.run(
+    clang,
+    ["-O2", "-D_CRT_SECURE_NO_WARNINGS", "-c", sourcePath, "-o", objectPath, `-I${includeDir}`],
+    { env },
+  );
   if (result.status !== 0) throw new ToolchainError(`${clang} ${sourcePath}`, result.status, result.stderr);
 }

package/src/extensions/node/child_process/index.ts

@@ -1,7 +1,9 @@
 /**
  * Node's `child_process` module: `spawnSync(command, args, options)`, backed by
- * `runtime/ext_node/child_process`. Captures stdout/stderr as UTF-8 strings and
- * honours `options.cwd`, which is all the compiler's toolchain wrapper needs.
+ * `runtime/ext_node/child_process`. Captures stdout/stderr as UTF-8 strings,
+ * honours `options.cwd`, and supports `options.stdio: "inherit"` (hand the
+ * child the parent's stdout/stderr) — which is all the compiler's toolchain
+ * wrapper and `xbintsc run` need.
  */
 
 import type { NodeModule } from "../module.js";

package/src/extensions/node/events/index.ts

@@ -0,0 +1,27 @@
+/**
+ * Node's `events` module.
+ *
+ * Exposes the standalone `EventEmitter` class plus its statics. `EventEmitter`
+ * is provided both as a global constructor and as a named export, so
+ * `new EventEmitter()` and `import { EventEmitter } from "events"` both work.
+ * The implementation lives in `runtime/ext_node/events/events.c`.
+ */
+
+import type { NodeModule } from "../module.js";
+import { resolveFrom } from "../module.js";
+import type { ModuleExports } from "../../registry.js";
+
+const methods = ["listenerCount", "getEventListeners", "getMaxListeners", "setMaxListeners", "once"] as const;
+
+const exports: ModuleExports = {
+  EventEmitter: { symbol: "xt_event_emitter_ctor", isConstructor: true },
+  ...Object.fromEntries(methods.map((method) => [method, { namespace: "events", method }])),
+};
+
+export const eventsModule: NodeModule = {
+  name: "events",
+  namespace: "events",
+  runtimeSources: () => [resolveFrom(import.meta.url, "../../../../runtime/ext_node/events/events.c")],
+  builtins: () => ({}),
+  exports: () => exports,
+};

package/src/extensions/node/index.ts

@@ -25,6 +25,9 @@ import { httpModule } from "./http/index.js";
 import { urlModule } from "./url/index.js";
 import { cryptoModule } from "./crypto/index.js";
 import { childProcessModule } from "./child_process/index.js";
+import { eventsModule } from "./events/index.js";
+import { utilModule } from "./util/index.js";
+import { querystringModule } from "./querystring/index.js";
 
 /** Every Node module the extension currently provides. */
 const modules: readonly NodeModule[] = [
@@ -41,6 +44,9 @@ const modules: readonly NodeModule[] = [
   urlModule,
   cryptoModule,
   childProcessModule,
+  eventsModule,
+  utilModule,
+  querystringModule,
 ];
 
 export const nodeExtension: Extension = {

package/src/extensions/node/querystring/index.ts

@@ -0,0 +1,29 @@
+/**
+ * Node's `querystring` module.
+ *
+ * `parse` / `decode` and `stringify` / `encode` are the same functions under
+ * two names, alongside `escape` / `unescape`. Both named imports and namespace
+ * calls (`import qs from "querystring"`) are supported; the implementation
+ * lives in `runtime/ext_node/querystring/querystring.c`.
+ */
+
+import type { NodeModule } from "../module.js";
+import { resolveFrom } from "../module.js";
+import type { ModuleExports } from "../../registry.js";
+
+const exports: ModuleExports = {
+  parse: { symbol: "xt_querystring_parse" },
+  decode: { symbol: "xt_querystring_parse" },
+  stringify: { symbol: "xt_querystring_stringify" },
+  encode: { symbol: "xt_querystring_stringify" },
+  escape: { symbol: "xt_querystring_escape" },
+  unescape: { symbol: "xt_querystring_unescape" },
+};
+
+export const querystringModule: NodeModule = {
+  name: "querystring",
+  namespace: "querystring",
+  runtimeSources: () => [resolveFrom(import.meta.url, "../../../../runtime/ext_node/querystring/querystring.c")],
+  builtins: () => ({}),
+  exports: () => exports,
+};

package/src/extensions/node/util/index.ts

@@ -0,0 +1,48 @@
+/**
+ * Node's `util` module.
+ *
+ * Exposes the commonly used helpers (`format`, `inspect`, `isDeepStrictEqual`,
+ * `inherits`, `deprecate`, `promisify`) and the `isX` type predicates. Both
+ * `import { format } from "util"` and `import util from "util"` (namespace
+ * calls) are supported; the implementation lives in
+ * `runtime/ext_node/util/util.c`.
+ */
+
+import type { NodeModule } from "../module.js";
+import { resolveFrom } from "../module.js";
+import type { ModuleExports } from "../../registry.js";
+
+const symbols: Record<string, string> = {
+  format: "xt_util_format",
+  formatWithOptions: "xt_util_format_with_options",
+  inspect: "xt_util_inspect",
+  isDeepStrictEqual: "xt_util_is_deep_strict_equal",
+  inherits: "xt_util_inherits",
+  deprecate: "xt_util_deprecate",
+  promisify: "xt_util_promisify",
+  isString: "xt_util_is_string",
+  isNumber: "xt_util_is_number",
+  isBoolean: "xt_util_is_boolean",
+  isUndefined: "xt_util_is_undefined",
+  isNull: "xt_util_is_null",
+  isFunction: "xt_util_is_function",
+  isArray: "xt_util_is_array",
+  isObject: "xt_util_is_object",
+  isBuffer: "xt_util_is_buffer",
+  isDate: "xt_util_is_date",
+  isRegExp: "xt_util_is_regexp",
+  isPromise: "xt_util_is_promise",
+  isError: "xt_util_is_error",
+};
+
+const exports: ModuleExports = Object.fromEntries(
+  Object.entries(symbols).map(([name, symbol]) => [name, { symbol }]),
+);
+
+export const utilModule: NodeModule = {
+  name: "util",
+  namespace: "util",
+  runtimeSources: () => [resolveFrom(import.meta.url, "../../../../runtime/ext_node/util/util.c")],
+  builtins: () => ({}),
+  exports: () => exports,
+};

package/src/extensions/registry.ts

@@ -28,6 +28,12 @@ export interface ModuleExport {
   readonly returnVoid?: boolean;
   readonly namespace?: string;
   readonly method?: string;
+  /**
+   * Marks a runtime symbol as a constructor callable with `new` (it has the
+   * `(i32, i64*)` signature). Lets `import { EventEmitter } from "events"` be
+   * used as `new EventEmitter()`.
+   */
+  readonly isConstructor?: boolean;
 }
 
 export type ModuleExports = Readonly<Record<string, ModuleExport>>;

package/src/index.ts

@@ -25,6 +25,7 @@ export {
   XT_NULL,
   XT_TRUE,
   XT_FALSE,
+  XT_BIGINT,
   numberLiteral,
   booleanLiteral,
 } from "./codegen/values.js";

package/src/lexer/scanner/identifiers.ts

@@ -0,0 +1,37 @@
+/**
+ * Identifier scanning (identifiers, keywords and private `#name`s).
+ */
+
+import { DiagnosticCode } from "../../diagnostics/diagnostic.js";
+import { KEYWORDS, Token, TokenKind } from "../token.js";
+import { Char, isIdentifierPart } from "../char.js";
+import type { Scanner } from "../scanner.js";
+
+export interface IdentifierMethods {
+  scanIdentifier(this: Scanner, start: number, precededByLineBreak: boolean): Token;
+}
+
+export const identifierMethods: IdentifierMethods = {
+  scanIdentifier(this: Scanner, start: number, precededByLineBreak: boolean): Token {
+    this.pos++;
+    while (this.pos < this.text.length) {
+      const ch = this.text.charCodeAt(this.pos);
+      if (isIdentifierPart(ch)) {
+        this.pos++;
+      } else if (ch === Char.Backslash && this.text.charCodeAt(this.pos + 1) === Char.LowerU) {
+        this.pos += 2;
+        const hex = this.text.slice(this.pos, this.pos + 4);
+        this.pos += 4;
+        if (!/^[0-9a-fA-F]{4}$/.test(hex)) {
+          this.error(DiagnosticCode.InvalidEscape, "Invalid unicode escape in identifier", this.pos - 4, this.pos);
+        }
+      } else {
+        break;
+      }
+    }
+    const text = this.text.slice(start, this.pos);
+    const keyword = KEYWORDS.get(text);
+    const kind = keyword ?? TokenKind.Identifier;
+    return this.makeToken(kind, start, this.pos, text, precededByLineBreak);
+  },
+};

package/src/lexer/scanner/numbers.ts

@@ -0,0 +1,84 @@
+/**
+ * Numeric literal scanning: decimals, radix prefixes, exponents and BigInt.
+ */
+
+import { DiagnosticCode } from "../../diagnostics/diagnostic.js";
+import { Token, TokenKind } from "../token.js";
+import { Char, isDigit, isHexDigit } from "../char.js";
+import type { Scanner } from "../scanner.js";
+
+export interface NumberMethods {
+  scanNumber(this: Scanner, start: number, precededByLineBreak: boolean): Token;
+  finishNumber(this: Scanner, start: number, precededByLineBreak: boolean, isBigInt: boolean): Token;
+}
+
+export const numberMethods: NumberMethods = {
+  scanNumber(this: Scanner, start: number, precededByLineBreak: boolean): Token {
+    const text = this.text;
+    let isBigInt = false;
+    // Radix prefixes.
+    if (text.charCodeAt(this.pos) === Char.Zero) {
+      const next = text.charCodeAt(this.pos + 1);
+      if (next === Char.LowerX || next === Char.UpperX) {
+        this.pos += 2;
+        while (isHexDigit(text.charCodeAt(this.pos)) || text.charCodeAt(this.pos) === Char.Underscore) this.pos++;
+        isBigInt = text.charCodeAt(this.pos) === Char.LowerN;
+        if (isBigInt) this.pos++;
+        return this.finishNumber(start, precededByLineBreak, isBigInt);
+      }
+      if (next === Char.LowerO || next === Char.UpperO || next === Char.LowerB || next === Char.UpperB) {
+        this.pos += 2;
+        while (isDigit(text.charCodeAt(this.pos)) || text.charCodeAt(this.pos) === Char.Underscore) this.pos++;
+        isBigInt = text.charCodeAt(this.pos) === Char.LowerN;
+        if (isBigInt) this.pos++;
+        return this.finishNumber(start, precededByLineBreak, isBigInt);
+      }
+    }
+
+    while (isDigit(text.charCodeAt(this.pos)) || text.charCodeAt(this.pos) === Char.Underscore) this.pos++;
+    if (text.charCodeAt(this.pos) === Char.Dot) {
+      this.pos++;
+      while (isDigit(text.charCodeAt(this.pos)) || text.charCodeAt(this.pos) === Char.Underscore) this.pos++;
+    }
+    const e = text.charCodeAt(this.pos);
+    if (e === Char.LowerE || e === Char.UpperE) {
+      const save = this.pos;
+      this.pos++;
+      const sign = text.charCodeAt(this.pos);
+      if (sign === Char.Plus || sign === Char.Minus) this.pos++;
+      if (isDigit(text.charCodeAt(this.pos))) {
+        while (isDigit(text.charCodeAt(this.pos)) || text.charCodeAt(this.pos) === Char.Underscore) this.pos++;
+      } else {
+        // Not an exponent, roll back.
+        this.pos = save;
+      }
+    }
+    isBigInt = text.charCodeAt(this.pos) === Char.LowerN;
+    if (isBigInt) this.pos++;
+    return this.finishNumber(start, precededByLineBreak, isBigInt);
+  },
+
+  finishNumber(this: Scanner, start: number, precededByLineBreak: boolean, isBigInt: boolean): Token {
+    let raw = this.text.slice(start, this.pos);
+    const cleaned = raw.replace(/_/g, "");
+    if (isBigInt) {
+      raw = raw.slice(0, -1).replace(/_/g, "");
+      const parsed = Number(raw);
+      if (parsed !== parsed) {
+        this.error(DiagnosticCode.InvalidNumber, `Invalid BigInt literal '${raw}'`, start, this.pos);
+        return this.makeToken(TokenKind.BigIntLiteral, start, this.pos, raw, precededByLineBreak, 0);
+      }
+      return this.makeToken(TokenKind.BigIntLiteral, start, this.pos, raw, precededByLineBreak, parsed);
+    }
+    let value: number;
+    if (/^0[xX]/.test(cleaned)) value = parseInt(cleaned.slice(2), 16);
+    else if (/^0[oO]/.test(cleaned)) value = parseInt(cleaned.slice(2), 8);
+    else if (/^0[bB]/.test(cleaned)) value = parseInt(cleaned.slice(2), 2);
+    else value = Number(cleaned);
+    if (Number.isNaN(value)) {
+      this.error(DiagnosticCode.InvalidNumber, `Invalid numeric literal '${raw}'`, start, this.pos);
+      value = 0;
+    }
+    return this.makeToken(TokenKind.NumericLiteral, start, this.pos, raw, precededByLineBreak, value);
+  },
+};

package/src/lexer/scanner/punctuation.ts

@@ -0,0 +1,132 @@
+/**
+ * Punctuation and operator scanning (the operator dispatch table).
+ */
+
+import { DiagnosticCode } from "../../diagnostics/diagnostic.js";
+import { Token, TokenKind } from "../token.js";
+import { Char, isDigit } from "../char.js";
+import type { Scanner } from "../scanner.js";
+
+export interface PunctuationMethods {
+  scanPunctuation(this: Scanner, start: number, precededByLineBreak: boolean): Token;
+}
+
+export const punctuationMethods: PunctuationMethods = {
+  scanPunctuation(this: Scanner, start: number, precededByLineBreak: boolean): Token {
+    const text = this.text;
+    const ch = text.charCodeAt(this.pos);
+    const next = text.charCodeAt(this.pos + 1);
+    const third = text.charCodeAt(this.pos + 2);
+    const fourth = text.charCodeAt(this.pos + 3);
+
+    const emit = (kind: TokenKind, length: number): Token => {
+      this.pos += length;
+      return this.makeToken(kind, start, this.pos, text.slice(start, this.pos), precededByLineBreak);
+    };
+
+    switch (ch) {
+      case Char.OpenBrace:
+        return emit(TokenKind.OpenBrace, 1);
+      case Char.CloseBrace:
+        return emit(TokenKind.CloseBrace, 1);
+      case Char.OpenParen:
+        return emit(TokenKind.OpenParen, 1);
+      case Char.CloseParen:
+        return emit(TokenKind.CloseParen, 1);
+      case Char.OpenBracket:
+        return emit(TokenKind.OpenBracket, 1);
+      case Char.CloseBracket:
+        return emit(TokenKind.CloseBracket, 1);
+      case Char.Semicolon:
+        return emit(TokenKind.Semicolon, 1);
+      case Char.Comma:
+        return emit(TokenKind.Comma, 1);
+      case Char.At:
+        return emit(TokenKind.At, 1);
+      case Char.Tilde:
+        return emit(TokenKind.Tilde, 1);
+      case Char.Colon:
+        return emit(TokenKind.Colon, 1);
+      case Char.Dot:
+        if (next === Char.Dot && third === Char.Dot) return emit(TokenKind.DotDotDot, 3);
+        return emit(TokenKind.Dot, 1);
+      case Char.Question:
+        if (next === Char.Question) {
+          if (third === Char.Equals) return emit(TokenKind.QuestionQuestionEquals, 3);
+          return emit(TokenKind.QuestionQuestion, 2);
+        }
+        if (next === Char.Dot && !isDigit(third)) return emit(TokenKind.QuestionDot, 2);
+        return emit(TokenKind.Question, 1);
+      case Char.Equals:
+        if (next === Char.Equals && third === Char.Equals) return emit(TokenKind.EqualsEqualsEquals, 3);
+        if (next === Char.Equals) return emit(TokenKind.EqualsEquals, 2);
+        if (next === Char.GreaterThan) return emit(TokenKind.EqualsGreaterThan, 2);
+        return emit(TokenKind.Equals, 1);
+      case Char.Exclamation:
+        if (next === Char.Equals && third === Char.Equals) return emit(TokenKind.ExclamationEqualsEquals, 3);
+        if (next === Char.Equals) return emit(TokenKind.ExclamationEquals, 2);
+        return emit(TokenKind.Exclamation, 1);
+      case Char.Plus:
+        if (next === Char.Plus) return emit(TokenKind.PlusPlus, 2);
+        if (next === Char.Equals) return emit(TokenKind.PlusEquals, 2);
+        return emit(TokenKind.Plus, 1);
+      case Char.Minus:
+        if (next === Char.Minus) return emit(TokenKind.MinusMinus, 2);
+        if (next === Char.Equals) return emit(TokenKind.MinusEquals, 2);
+        return emit(TokenKind.Minus, 1);
+      case Char.Asterisk:
+        if (next === Char.Asterisk) {
+          if (third === Char.Equals) return emit(TokenKind.AsteriskAsteriskEquals, 3);
+          return emit(TokenKind.AsteriskAsterisk, 2);
+        }
+        if (next === Char.Equals) return emit(TokenKind.AsteriskEquals, 2);
+        return emit(TokenKind.Asterisk, 1);
+      case Char.Slash:
+        if (next === Char.Equals) return emit(TokenKind.SlashEquals, 2);
+        if (this.regexAllowed()) return this.scanRegex(start, precededByLineBreak);
+        return emit(TokenKind.Slash, 1);
+      case Char.Percent:
+        if (next === Char.Equals) return emit(TokenKind.PercentEquals, 2);
+        return emit(TokenKind.Percent, 1);
+      case Char.LessThan:
+        if (next === Char.LessThan) {
+          if (third === Char.Equals) return emit(TokenKind.LessThanLessThanEquals, 3);
+          return emit(TokenKind.LessThanLessThan, 2);
+        }
+        if (next === Char.Equals) return emit(TokenKind.LessThanEquals, 2);
+        return emit(TokenKind.LessThan, 1);
+      case Char.GreaterThan:
+        if (next === Char.GreaterThan) {
+          if (third === Char.GreaterThan) {
+            if (fourth === Char.Equals) return emit(TokenKind.GreaterThanGreaterThanGreaterThanEquals, 4);
+            return emit(TokenKind.GreaterThanGreaterThanGreaterThan, 3);
+          }
+          if (third === Char.Equals) return emit(TokenKind.GreaterThanGreaterThanEquals, 3);
+          return emit(TokenKind.GreaterThanGreaterThan, 2);
+        }
+        if (next === Char.Equals) return emit(TokenKind.GreaterThanEquals, 2);
+        return emit(TokenKind.GreaterThan, 1);
+      case Char.Ampersand:
+        if (next === Char.Ampersand) {
+          if (third === Char.Equals) return emit(TokenKind.AmpersandAmpersandEquals, 3);
+          return emit(TokenKind.AmpersandAmpersand, 2);
+        }
+        if (next === Char.Equals) return emit(TokenKind.AmpersandEquals, 2);
+        return emit(TokenKind.Ampersand, 1);
+      case Char.Bar:
+        if (next === Char.Bar) {
+          if (third === Char.Equals) return emit(TokenKind.BarBarEquals, 3);
+          return emit(TokenKind.BarBar, 2);
+        }
+        if (next === Char.Equals) return emit(TokenKind.BarEquals, 2);
+        return emit(TokenKind.Bar, 1);
+      case Char.Caret:
+        if (next === Char.Equals) return emit(TokenKind.CaretEquals, 2);
+        return emit(TokenKind.Caret, 1);
+      default:
+        this.pos++;
+        this.error(DiagnosticCode.InvalidCharacter, `Invalid character '${text[start]}'`, start, this.pos);
+        return this.makeToken(TokenKind.Identifier, start, this.pos, text[start] ?? "", precededByLineBreak);
+    }
+  },
+};

package/src/lexer/scanner/regex.ts

@@ -0,0 +1,79 @@
+/**
+ * Regular expression literal scanning and the disambiguation rule that decides
+ * whether a `/` is a regex or a division operator.
+ */
+
+import { DiagnosticCode } from "../../diagnostics/diagnostic.js";
+import { Token, TokenKind } from "../token.js";
+import { Char, isIdentifierPart } from "../char.js";
+import type { Scanner } from "../scanner.js";
+
+export interface RegexMethods {
+  regexAllowed(this: Scanner): boolean;
+  scanRegex(this: Scanner, start: number, precededByLineBreak: boolean): Token;
+}
+
+export const regexMethods: RegexMethods = {
+  /**
+   * True when a `/` in this position starts a regular expression rather than a
+   * division. The decision is made from the previous significant token.
+   */
+  regexAllowed(this: Scanner): boolean {
+    switch (this._token.kind) {
+      case TokenKind.Identifier:
+      case TokenKind.PrivateIdentifier:
+      case TokenKind.NumericLiteral:
+      case TokenKind.BigIntLiteral:
+      case TokenKind.StringLiteral:
+      case TokenKind.NoSubstitutionTemplateLiteral:
+      case TokenKind.TemplateTail:
+      case TokenKind.RegularExpressionLiteral:
+      case TokenKind.CloseParen:
+      case TokenKind.CloseBracket:
+      case TokenKind.TrueKeyword:
+      case TokenKind.FalseKeyword:
+      case TokenKind.NullKeyword:
+      case TokenKind.UndefinedKeyword:
+      case TokenKind.ThisKeyword:
+      case TokenKind.PlusPlus:
+      case TokenKind.MinusMinus:
+        return false;
+      default:
+        return true;
+    }
+  },
+
+  /** Scan a `/pattern/flags` literal, starting at the leading slash. */
+  scanRegex(this: Scanner, start: number, precededByLineBreak: boolean): Token {
+    this.pos++; // opening slash
+    let inClass = false;
+    for (;;) {
+      if (this.pos >= this.text.length) {
+        this.error(DiagnosticCode.InvalidCharacter, "Unterminated regular expression", start);
+        break;
+      }
+      const ch = this.text.charCodeAt(this.pos);
+      if (ch === Char.Backslash) {
+        this.pos += 2;
+        continue;
+      }
+      if (ch === Char.LineFeed || ch === Char.CarriageReturn) break;
+      if (ch === 91 /* [ */) inClass = true;
+      else if (ch === 93 /* ] */) inClass = false;
+      else if (ch === Char.Slash && !inClass) {
+        this.pos++;
+        break;
+      }
+      this.pos++;
+    }
+    // Flags.
+    while (this.pos < this.text.length && isIdentifierPart(this.text.charCodeAt(this.pos))) this.pos++;
+    return this.makeToken(
+      TokenKind.RegularExpressionLiteral,
+      start,
+      this.pos,
+      this.text.slice(start, this.pos),
+      precededByLineBreak,
+    );
+  },
+};