@engine262/engine262 0.0.1-01e9fa95a4e8a1c042efd00492309a2de4998fd0

package/src/static-semantics/ExportEntries.mts

@@ -0,0 +1,183 @@
+import { JSStringValue, NullValue, Value } from '../value.mts';
+import { OutOfRange, isArray } from '../utils/language.mts';
+import type { ParseNode } from '../parser/ParseNode.mts';
+import {
+  BoundNames, ExportFromDeclarationModuleRequest, ExportEntriesForModule, type ModuleRequestRecord,
+} from './all.mts';
+
+export function ExportEntries(node: ParseNode | readonly ParseNode[]): ExportEntry[] {
+  if (isArray(node)) {
+    const entries: ExportEntry[] = [];
+    node.forEach((n) => {
+      entries.push(...ExportEntries(n));
+    });
+    return entries;
+  }
+  switch (node.type) {
+    case 'Module':
+      if (!node.ModuleBody) {
+        return [];
+      }
+      return ExportEntries(node.ModuleBody);
+    case 'ModuleBody':
+      return ExportEntries(node.ModuleItemList);
+    case 'ExportDeclaration':
+      switch (true) {
+        case !!node.ExportFromClause && !!node.FromClause: {
+          const fromNode = node as ParseNode.ExportDeclaration_NamedFrom;
+          // ExportDeclaration : `export` `defer` ExportFromClause FromClause WithClause? `;`
+          // 1. Return a new empty List.
+          // (https://tc39.es/proposal-deferred-reexports/#sec-static-semantics-exportentries)
+          // The corresponding entries are produced by OptionalIndirectExportEntries instead.
+          if (fromNode.Phase === 'defer') {
+            return [];
+          }
+          // ExportDeclaration : `export` ExportFromClause FromClause WithClause? `;`
+          // 1. Let module be the sole element of ModuleRequests of FromClause.
+          // 2. Return ExportEntriesForModule of ExportFromClause with argument module.
+          const module = ExportFromDeclarationModuleRequest(fromNode);
+          return ExportEntriesForModule(fromNode.ExportFromClause, module);
+        }
+        case !!node.NamedExports: {
+          // `export` NamedExports `;`
+          // 1. Return ExportEntriesForModule(NamedExports, null).
+          return ExportEntriesForModule(node.NamedExports, Value.null);
+        }
+        case !!node.VariableStatement: {
+          // `export` VariableStatement
+          // 1. Let entries be a new empty List.
+          const entries = [];
+          // 2. Let names be the BoundNames of VariableStatement.
+          const names = BoundNames(node.VariableStatement);
+          // 3. For each name in names, do
+          for (const name of names) {
+            // a. Append the ExportEntry Record { [[ModuleRequest]]: null, [[ImportName]]: null, [[LocalName]]: name, [[ExportName]]: name } to entries.
+            entries.push({
+              ModuleRequest: Value.null,
+              ImportName: Value.null,
+              LocalName: name,
+              ExportName: name,
+            });
+          }
+          // 4. Return entries.
+          return entries;
+        }
+        case !!node.Declaration: {
+          // `export` Declaration
+          // 1. Let entries be a new empty List.
+          const entries: ExportEntry[] = [];
+          // 2. Let names be the BoundNames of Declaration.
+          const names = BoundNames(node.Declaration);
+          // 3. For each name in names, do
+          for (const name of names) {
+            // a. Append the ExportEntry Record { [[ModuleRequest]]: null, [[ImportName]]: null, [[LocalName]]: name, [[ExportName]]: name } to entries.
+            entries.push({
+              ModuleRequest: Value.null,
+              ImportName: Value.null,
+              LocalName: name,
+              ExportName: name,
+            });
+          }
+          // 4. Return entries.
+          return entries;
+        }
+        case node.default && !!node.HoistableDeclaration: {
+          // `export` `default` HoistableDeclaration
+          // 1. Let names be BoundNames of HoistableDeclaration.
+          const names = BoundNames(node.HoistableDeclaration);
+          // 2. Let localName be the sole element of names.
+          const localName = names[0];
+          // 3. Return a new List containing the ExportEntry Record { [[ModuleRequest]]: null, [[ImportName]]: null, [[LocalName]]: localName, [[ExportName]]: "default" }.
+          return [{
+            ModuleRequest: Value.null,
+            ImportName: Value.null,
+            LocalName: localName,
+            ExportName: Value('default'),
+          }];
+        }
+        case node.default && !!node.ClassDeclaration: {
+          // `export` `default` ClassDeclaration
+          // 1. Let names be BoundNames of ClassDeclaration.
+          const names = BoundNames(node.ClassDeclaration);
+          // 2. Let localName be the sole element of names.
+          const localName = names[0];
+          // 3. Return a new List containing the ExportEntry Record { [[ModuleRequest]]: null, [[ImportName]]: null, [[LocalName]]: localName, [[ExportName]]: "default" }.
+          return [{
+            ModuleRequest: Value.null,
+            ImportName: Value.null,
+            LocalName: localName,
+            ExportName: Value('default'),
+          }];
+        }
+        case node.default && !!node.AssignmentExpression: {
+          // `export` `default` AssignmentExpression `;`
+          // 1. Let entry be the ExportEntry Record { [[ModuleRequest]]: null, [[ImportName]]: null, [[LocalName]]: "*default*", [[ExportName]]: "default" }.
+          const entry = {
+            ModuleRequest: Value.null,
+            ImportName: Value.null,
+            LocalName: Value('*default*'),
+            ExportName: Value('default'),
+          };
+          // 2. Return a new List containing entry.
+          return [entry];
+        }
+        default:
+          throw OutOfRange.exhaustive(node);
+      }
+    default:
+      return [];
+  }
+}
+
+export interface ExportEntry {
+  readonly ModuleRequest: ModuleRequestRecord | NullValue;
+  readonly ImportName: JSStringValue | NullValue | 'namespace' | 'filtered-namespace' | 'source' | 'all-but-default';
+  readonly LocalName: JSStringValue | NullValue;
+  readonly ExportName: JSStringValue | NullValue;
+  readonly NamespaceNamesFilter?: readonly string[];
+}
+
+/** https://tc39.es/proposal-deferred-reexports/#sec-static-semantics-optionalindirectexportentries */
+export function OptionalIndirectExportEntries(node: ParseNode | readonly ParseNode[]): ExportEntry[] {
+  if (isArray(node)) {
+    // ModuleItemList : ModuleItemList ModuleItem
+    //   1. Let entries1 be OptionalIndirectExportEntries of ModuleItemList.
+    //   2. Let entries2 be OptionalIndirectExportEntries of ModuleItem.
+    //   3. Return the list-concatenation of entries1 and entries2.
+    const entries: ExportEntry[] = [];
+    node.forEach((n) => {
+      entries.push(...OptionalIndirectExportEntries(n));
+    });
+    return entries;
+  }
+  switch (node.type) {
+    case 'Module':
+      // Module : [empty]
+      //   1. Return a new empty List.
+      if (!node.ModuleBody) {
+        return [];
+      }
+      return OptionalIndirectExportEntries(node.ModuleBody);
+    case 'ModuleBody':
+      return OptionalIndirectExportEntries(node.ModuleItemList);
+    case 'ExportDeclaration': {
+      // Only `ExportDeclaration : export defer ExportFromClause FromClause WithClause? ;`
+      // produces optional indirect entries; every other ExportDeclaration production
+      // (and ImportDeclaration / StatementListItem) returns a new empty List.
+      if (!node.FromClause) {
+        return [];
+      }
+      const fromNode = node as ParseNode.ExportDeclaration_NamedFrom;
+      if (fromNode.Phase !== 'defer') {
+        return [];
+      }
+      // 1. If WithClause is present, let request be ExportFromDeclarationModuleRequest(ExportFromClause, FromClause, WithClause).
+      // 2. Else, let request be ExportFromDeclarationModuleRequest(ExportFromClause, FromClause).
+      const request = ExportFromDeclarationModuleRequest(fromNode);
+      // 3. Return ExportEntriesForModule of ExportFromClause with argument request.
+      return ExportEntriesForModule(fromNode.ExportFromClause, request);
+    }
+    default:
+      return [];
+  }
+}

package/src/static-semantics/ExportEntriesForModule.mts

@@ -0,0 +1,79 @@
+import { NullValue, Value } from '../value.mts';
+import { OutOfRange, isArray } from '../utils/language.mts';
+import type { ParseNode } from '../parser/ParseNode.mts';
+import { ImportedNames, StringValue, type ExportEntry, type ModuleRequestRecord } from './all.mts';
+
+export function ExportEntriesForModule(node: ParseNode | readonly ParseNode[], module: ModuleRequestRecord | NullValue): ExportEntry[] {
+  if (isArray(node)) {
+    const specs: ExportEntry[] = [];
+    node.forEach((n) => {
+      specs.push(...ExportEntriesForModule(n, module));
+    });
+    return specs;
+  }
+  switch (node.type) {
+    case 'ExportFromClause':
+      if (node.ModuleExportName) {
+        // 1. Let exportName be the StringValue of ModuleExportName.
+        const exportName = StringValue(node.ModuleExportName);
+        // 2. Let entry be the ExportEntry Record { [[ModuleRequest]]: module, [[ImportName]]: ~namespace~, [[LocalName]]: null, [[ExportName]]: exportName, [[NamespaceNamesFilter]]: empty }.
+        //    (proposal-deferred-reexports renamed ~all~ to ~namespace~ for star-as exports.)
+        const entry: ExportEntry = {
+          ModuleRequest: module,
+          ImportName: 'namespace',
+          LocalName: Value.null,
+          ExportName: exportName,
+          NamespaceNamesFilter: [],
+        };
+        // 3. Return a new List containing entry.
+        return [entry];
+      } else {
+        // 1. Let entry be the ExportEntry Record { [[ModuleRequest]]: module, [[ImportName]]: ~all-but-default~, [[LocalName]]: null, [[ExportName]]: null, [[NamespaceNamesFilter]]: empty }.
+        const entry: ExportEntry = {
+          ModuleRequest: module,
+          ImportName: 'all-but-default',
+          LocalName: Value.null,
+          ExportName: Value.null,
+          NamespaceNamesFilter: [],
+        };
+        // 2. Return a new List containing entry.
+        return [entry];
+      }
+    case 'ExportSpecifier': {
+      const sourceName = StringValue(node.localName);
+      const exportName = StringValue(node.exportName);
+      let localName;
+      let importName;
+      if (module === Value.null) {
+        localName = sourceName;
+        importName = Value.null;
+      } else { // 4. Else,
+        localName = Value.null;
+        importName = sourceName;
+      }
+      return [{
+        ModuleRequest: module,
+        ImportName: importName,
+        LocalName: localName,
+        ExportName: exportName,
+        NamespaceNamesFilter: [],
+      }];
+    }
+    case 'NamedExports':
+      if (node.NamespaceExportName) {
+        const exportName = StringValue(node.NamespaceExportName);
+        const importedNames = ImportedNames(node);
+        const entry: ExportEntry = {
+          ModuleRequest: module,
+          ImportName: 'filtered-namespace',
+          LocalName: Value.null,
+          ExportName: exportName,
+          NamespaceNamesFilter: importedNames,
+        };
+        return [entry];
+      }
+      return ExportEntriesForModule(node.ExportsList, module);
+    default:
+      throw OutOfRange.nonExhaustive(node);
+  }
+}

package/src/static-semantics/FlagText.mts

@@ -0,0 +1,7 @@
+import type { ParseNode } from '../parser/ParseNode.mts';
+
+/** https://tc39.es/ecma262/#sec-static-semantics-flagtext */
+//   RegularExpressionLiteral :: `/` RegularExpressionBody `/` RegularExpressionFlags
+export function FlagText(RegularExpressionLiteral: ParseNode.RegularExpressionLiteral) {
+  return RegularExpressionLiteral.RegularExpressionFlags;
+}

package/src/static-semantics/HasInitializer.mts

@@ -0,0 +1,5 @@
+import type { ParseNode } from '../parser/ParseNode.mts';
+
+export function HasInitializer(node: ParseNode): node is ParseNode & { readonly Initializer: ParseNode.Initializer; } {
+  return 'Initializer' in node && !!node.Initializer;
+}

package/src/static-semantics/HasName.mts

@@ -0,0 +1,8 @@
+import type { ParseNode } from '../parser/ParseNode.mts';
+
+export function HasName(node: ParseNode): boolean {
+  if (node.type === 'ParenthesizedExpression') {
+    return HasName(node.Expression);
+  }
+  return 'BindingIdentifier' in node && !!node.BindingIdentifier;
+}

package/src/static-semantics/ImportEntries.mts

@@ -0,0 +1,49 @@
+import type { ParseNode } from '../parser/ParseNode.mts';
+import type { JSStringValue } from '../value.mts';
+import {
+  BoundNames,
+  ImportEntriesForModule, ModuleRequests, type ModuleRequestRecord,
+} from './all.mts';
+
+export function ImportEntries(node: ParseNode): ImportEntry[] {
+  switch (node.type) {
+    case 'Module':
+      if (node.ModuleBody) {
+        return ImportEntries(node.ModuleBody);
+      }
+      return [];
+    case 'ModuleBody': {
+      const entries: ImportEntry[] = [];
+      for (const item of node.ModuleItemList) {
+        entries.push(...ImportEntries(item));
+      }
+      return entries;
+    }
+    case 'ImportDeclaration':
+      if (node.ImportedBinding) {
+        const module = ModuleRequests(node)[0];
+        const localName = BoundNames(node.ImportedBinding)[0];
+        return [{
+          ModuleRequest: module,
+          ImportName: 'source',
+          LocalName: localName,
+        }];
+      }
+      if (node.FromClause) {
+        // 1. Let module be the sole element of ModuleRequests of FromClause.
+        const module = ModuleRequests(node)[0];
+        // 2. Return ImportEntriesForModule of ImportClause with argument module.
+        return ImportEntriesForModule(node.ImportClause!, module);
+      }
+      return [];
+    default:
+      return [];
+  }
+}
+
+export interface ImportEntry {
+  readonly ModuleRequest: ModuleRequestRecord;
+  readonly ImportName: JSStringValue | 'namespace' | 'filtered-namespace-object' | 'source';
+  readonly LocalName: JSStringValue;
+  readonly NamespaceNamesFilter?: readonly string[];
+}

package/src/static-semantics/ImportEntriesForModule.mts

@@ -0,0 +1,110 @@
+import { Value } from '../value.mts';
+import { OutOfRange } from '../utils/language.mts';
+import type { ParseNode } from '../parser/ParseNode.mts';
+import {
+  BoundNames, ImportedNames, StringValue, type ImportEntry, type ModuleRequestRecord,
+} from './all.mts';
+
+export function ImportEntriesForModule(node: ParseNode, module: ModuleRequestRecord): ImportEntry[] {
+  switch (node.type) {
+    case 'ImportClause':
+      switch (true) {
+        case !!node.ImportedDefaultBinding && !!node.NameSpaceImport: {
+          // 1. Let entries be ImportEntriesForModule of ImportedDefaultBinding with argument module.
+          const entries = ImportEntriesForModule(node.ImportedDefaultBinding, module);
+          // 2. Append to entries the elements of the ImportEntriesForModule of NameSpaceImport with argument module.
+          entries.push(...ImportEntriesForModule(node.NameSpaceImport, module));
+          // 3. Return entries.
+          return entries;
+        }
+        case !!node.ImportedDefaultBinding && !!node.NamedImports: {
+          // 1. Let entries be ImportEntriesForModule of ImportedDefaultBinding with argument module.
+          const entries = ImportEntriesForModule(node.ImportedDefaultBinding, module);
+          // 2. Append to entries the elements of the ImportEntriesForModule of NamedImports with argument module.
+          entries.push(...ImportEntriesForModule(node.NamedImports, module));
+          // 3. Return entries.
+          return entries;
+        }
+        case !!node.ImportedDefaultBinding:
+          return ImportEntriesForModule(node.ImportedDefaultBinding, module);
+        case !!node.NameSpaceImport:
+          return ImportEntriesForModule(node.NameSpaceImport, module);
+        case !!node.NamedImports:
+          return ImportEntriesForModule(node.NamedImports, module);
+        default:
+          throw OutOfRange.nonExhaustive(node);
+      }
+    case 'ImportedDefaultBinding': {
+      // 1. Let localName be the sole element of BoundNames of ImportedBinding.
+      const localName = BoundNames(node.ImportedBinding)[0];
+      // 2. Let defaultEntry be the ImportEntry Record { [[ModuleRequest]]: module, [[ImportName]]: "default", [[LocalName]]: localName }.
+      const defaultEntry: ImportEntry = {
+        ModuleRequest: module,
+        ImportName: Value('default'),
+        LocalName: localName,
+      };
+      // 3. Return a new List containing defaultEntry.
+      return [defaultEntry];
+    }
+    case 'NameSpaceImport': {
+      // 1. Let localName be the StringValue of ImportedBinding.
+      const localName = StringValue(node.ImportedBinding);
+      if (node.NamedImports) {
+        const importedNames = ImportedNames(node.NamedImports);
+        const entry: ImportEntry = {
+          ModuleRequest: module,
+          ImportName: 'filtered-namespace-object',
+          LocalName: localName,
+          NamespaceNamesFilter: importedNames,
+        };
+        return [entry];
+      }
+      // 2. Let entry be the ImportEntry Record { [[ModuleRequest]]: module, [[ImportName]]: ~namespace~, [[LocalName]]: localName, [[NamespaceNamesFilter]]: empty }.
+      const entry: ImportEntry = {
+        ModuleRequest: module,
+        ImportName: 'namespace',
+        LocalName: localName,
+        NamespaceNamesFilter: [],
+      };
+      // 3. Return a new List containing entry.
+      return [entry];
+    }
+    case 'NamedImports': {
+      const specs: ImportEntry[] = [];
+      node.ImportsList.forEach((n) => {
+        specs.push(...ImportEntriesForModule(n, module));
+      });
+      return specs;
+    }
+    case 'ImportSpecifier':
+      if (node.ModuleExportName) {
+        // 1. Let importName be the StringValue of ModuleExportName.
+        const importName = StringValue(node.ModuleExportName);
+        // 2. Let localName be the StringValue of ImportedBinding.
+        const localName = StringValue(node.ImportedBinding);
+        // 3. Let entry be the ImportEntry Record { [[ModuleRequest]]: module, [[ImportName]]: importName, [[LocalName]]: localName }.
+        const entry: ImportEntry = {
+          ModuleRequest: module,
+          ImportName: importName,
+          LocalName: localName,
+          NamespaceNamesFilter: [],
+        };
+        // 4. Return a new List containing entry.
+        return [entry];
+      } else {
+        // 1. Let localName be the sole element of BoundNames of ImportedBinding.
+        const localName = BoundNames(node.ImportedBinding)[0];
+        // 2. Let entry be the ImportEntry Record { [[ModuleRequest]]: module, [[ImportName]]: localName, [[LocalName]]: localName }.
+        const entry: ImportEntry = {
+          ModuleRequest: module,
+          ImportName: localName,
+          LocalName: localName,
+          NamespaceNamesFilter: [],
+        };
+        // 3. Return a new List containing entry.
+        return [entry];
+      }
+    default:
+      throw OutOfRange.nonExhaustive(node);
+  }
+}

package/src/static-semantics/ImportedLocalNames.mts

@@ -0,0 +1,14 @@
+import type { ImportEntry } from './ImportEntries.mts';
+
+/** https://tc39.es/ecma262/#sec-importedlocalnames */
+export function ImportedLocalNames(importEntries: readonly ImportEntry[]) {
+  // 1. Let localNames be a new empty List.
+  const localNames = [];
+  // 2. For each ImportEntry Record i in importEntries, do
+  for (const i of importEntries) {
+    // a. Append i.[[LocalName]] to localNames.
+    localNames.push(i.LocalName);
+  }
+  // 3. Return localNames.
+  return localNames;
+}

package/src/static-semantics/IsAnonymousFunctionDefinition.mts

@@ -0,0 +1,18 @@
+import type { ParseNode } from '../parser/ParseNode.mts';
+import { IsFunctionDefinition, HasName } from './all.mts';
+
+/** https://tc39.es/ecma262/#sec-isanonymousfunctiondefinition */
+export function IsAnonymousFunctionDefinition(expr: ParseNode) {
+  // 1. If IsFunctionDefinition of expr is false, return false.
+  if (!IsFunctionDefinition(expr)) {
+    return false;
+  }
+  // 1. Let hasName be HasName of expr.
+  const hasName = HasName(expr);
+  // 1. If hasName is true, return false.
+  if (hasName) {
+    return false;
+  }
+  // 1. Return true.
+  return true;
+}

package/src/static-semantics/IsAwaitUsingDeclaration.mts

@@ -0,0 +1,12 @@
+import type { ParseNode } from '../parser/ParseNode.mts';
+
+export function IsAwaitUsingDeclaration(node: ParseNode) {
+  switch (node.type) {
+    case 'AwaitUsingDeclaration':
+      return true;
+    case 'ForDeclaration':
+      return node.production === 'AwaitUsing';
+    default:
+      return false;
+  }
+}

package/src/static-semantics/IsComputedPropertyKey.mts

@@ -0,0 +1,7 @@
+import type { ParseNode } from '../parser/ParseNode.mts';
+
+export function IsComputedPropertyKey(node: ParseNode.PropertyNameLike): node is ParseNode.PropertyName {
+  return node.type !== 'IdentifierName'
+    && node.type !== 'StringLiteral'
+    && node.type !== 'NumericLiteral';
+}

package/src/static-semantics/IsConstantDeclaration.mts

@@ -0,0 +1,11 @@
+import type { ParseNode } from '../parser/ParseNode.mts';
+
+export function IsConstantDeclaration(node: ParseNode | ParseNode.LetOrConst) {
+  return node === 'const'
+    || (typeof node === 'object' && (
+      ('LetOrConst' in node && node.LetOrConst === 'const')
+      || node.type === 'UsingDeclaration'
+      || node.type === 'AwaitUsingDeclaration'
+      || (node.type === 'ForDeclaration' && node.production !== 'LetOrConst')
+    ));
+}

package/src/static-semantics/IsDestructuring.mts

@@ -0,0 +1,21 @@
+import type { ParseNode } from '../parser/ParseNode.mts';
+
+export type DestructuringParseNode = ParseNode.ObjectBindingPattern | ParseNode.ArrayBindingPattern | ParseNode.ObjectLiteral | ParseNode.ArrayLiteral | ParseNode.ForDeclaration | ParseNode.ForBinding;
+export function IsDestructuring(node: ParseNode): boolean {
+  switch (node.type) {
+    case 'ObjectBindingPattern':
+    case 'ArrayBindingPattern':
+    case 'ObjectLiteral':
+    case 'ArrayLiteral':
+      return true;
+    case 'ForDeclaration':
+      return node.production === 'LetOrConst' && IsDestructuring(node.ForBinding);
+    case 'ForBinding':
+      if (node.BindingIdentifier) {
+        return false;
+      }
+      return true;
+    default:
+      return false;
+  }
+}

package/src/static-semantics/IsFunctionDefinition.mts

@@ -0,0 +1,15 @@
+import type { ParseNode } from '../parser/ParseNode.mts';
+
+export type FunctionDeclaration = ParseNode.FunctionExpression | ParseNode.GeneratorExpression | ParseNode.AsyncFunctionExpression | ParseNode.AsyncGeneratorExpression | ParseNode.ClassExpression | ParseNode.ArrowFunction | ParseNode.AsyncArrowFunction | ParseNode.ParenthesizedExpression & { readonly Expression: FunctionDeclaration };
+export function IsFunctionDefinition(node: ParseNode): node is FunctionDeclaration {
+  if (node.type === 'ParenthesizedExpression') {
+    return IsFunctionDefinition(node.Expression);
+  }
+  return node.type === 'FunctionExpression'
+    || node.type === 'GeneratorExpression'
+    || node.type === 'AsyncGeneratorExpression'
+    || node.type === 'AsyncFunctionExpression'
+    || node.type === 'ClassExpression'
+    || node.type === 'ArrowFunction'
+    || node.type === 'AsyncArrowFunction';
+}

package/src/static-semantics/IsIdentifierRef.mts

@@ -0,0 +1,5 @@
+import type { ParseNode } from '../parser/ParseNode.mts';
+
+export function IsIdentifierRef(node: ParseNode): node is ParseNode.IdentifierReference {
+  return node.type === 'IdentifierReference';
+}

package/src/static-semantics/IsInTailPosition.mts

@@ -0,0 +1,5 @@
+import type { ParseNode } from '../parser/ParseNode.mts';
+
+export function IsInTailPosition(_node: ParseNode): boolean {
+  return false;
+}

package/src/static-semantics/IsSimpleParameterList.mts

@@ -0,0 +1,23 @@
+import { OutOfRange, isArray } from '../utils/language.mts';
+import type { ParseNode } from '../parser/ParseNode.mts';
+
+export function IsSimpleParameterList(node: ParseNode | readonly ParseNode[]) {
+  if (isArray(node)) {
+    for (const n of node) {
+      if (!IsSimpleParameterList(n)) {
+        return false;
+      }
+    }
+    return true;
+  }
+  switch (node.type) {
+    case 'SingleNameBinding':
+      return node.Initializer === null;
+    case 'BindingElement':
+      return false;
+    case 'BindingRestElement':
+      return false;
+    default:
+      throw OutOfRange.nonExhaustive(node);
+  }
+}

package/src/static-semantics/IsStatic.mts

@@ -0,0 +1,10 @@
+import type { ParseNode } from '../parser/ParseNode.mts';
+
+/** https://tc39.es/ecma262/#sec-static-semantics-isstatic */
+// ClassElement :
+//   MethodDefinition
+//   `static` MethodDefinition
+//   `;`
+export function IsStatic(ClassElement: ParseNode.ClassElement) {
+  return ClassElement.static;
+}

package/src/static-semantics/IsStrict.mts

@@ -0,0 +1,7 @@
+import type { ParseNode } from '../parser/ParseNode.mts';
+
+/** https://tc39.es/ecma262/#sec-static-semantics-isstrict */
+export function IsStrict({ ScriptBody }: ParseNode.Script) {
+  // 1. If ScriptBody is present and the Directive Prologue of ScriptBody contains a Use Strict Directive, return true; otherwise, return false.
+  return ScriptBody!.strict;
+}

package/src/static-semantics/IsStringWellFormedUnicode.mts

@@ -0,0 +1,24 @@
+import { X } from '../completion.mts';
+import type { JSStringValue } from '../value.mts';
+import { CodePointAt } from './all.mts';
+
+export function IsStringWellFormedUnicode(string_: JSStringValue) {
+  const string = string_.stringValue();
+  // 1. Let _strLen_ be the number of code units in string.
+  const strLen = string.length;
+  // 2. Let k be 0.
+  let k = 0;
+  // 3. Repeat, while k ≠ strLen,
+  while (k !== strLen) {
+    // a. Let cp be ! CodePointAt(string, k).
+    const cp = X(CodePointAt(string, k));
+    // b. If cp.[[IsUnpairedSurrogate]] is true, return false.
+    if (cp.IsUnpairedSurrogate) {
+      return false;
+    }
+    // c. Set k to k + cp.[[CodeUnitCount]].
+    k += cp.CodeUnitCount;
+  }
+  // 4. Return true.
+  return true;
+}

package/src/static-semantics/IsUsingDeclaration.mts

@@ -0,0 +1,12 @@
+import type { ParseNode } from '../parser/ParseNode.mts';
+
+export function IsUsingDeclaration(node: ParseNode) {
+  switch (node.type) {
+    case 'UsingDeclaration':
+      return true;
+    case 'ForDeclaration':
+      return node.production === 'Using';
+    default:
+      return false;
+  }
+}