@engine262/engine262 0.0.1-01e9fa95a4e8a1c042efd00492309a2de4998fd0

package/src/static-semantics/LexicallyDeclaredNames.mts

@@ -0,0 +1,26 @@
+import type { ParseNode } from '../parser/ParseNode.mts';
+import type { JSStringValue } from '../value.mts';
+import {
+  TopLevelLexicallyDeclaredNames,
+} from './all.mts';
+
+export function LexicallyDeclaredNames(node: ParseNode): JSStringValue[] {
+  switch (node.type) {
+    case 'Script':
+      if (node.ScriptBody) {
+        return LexicallyDeclaredNames(node.ScriptBody);
+      }
+      return [];
+    case 'ScriptBody':
+      return TopLevelLexicallyDeclaredNames(node.StatementList);
+    case 'FunctionBody':
+    case 'GeneratorBody':
+    case 'AsyncBody':
+    case 'AsyncGeneratorBody':
+      return TopLevelLexicallyDeclaredNames(node.FunctionStatementList);
+    case 'ClassStaticBlockBody':
+      return TopLevelLexicallyDeclaredNames(node.ClassStaticBlockStatementList);
+    default:
+      return [];
+  }
+}

package/src/static-semantics/LexicallyScopedDeclarations.mts

@@ -0,0 +1,84 @@
+import { isArray } from '../utils/language.mts';
+import type { ParseNode } from '../parser/ParseNode.mts';
+import { TopLevelLexicallyScopedDeclarations, DeclarationPart } from './all.mts';
+
+export function LexicallyScopedDeclarations(node: ParseNode | readonly ParseNode[]): (ParseNode.Declaration | ParseNode.ExportDeclaration)[] {
+  if (isArray(node)) {
+    const declarations = [];
+    for (const item of node) {
+      declarations.push(...LexicallyScopedDeclarations(item));
+    }
+    return declarations;
+  }
+  switch (node.type) {
+    case 'LabelledStatement':
+      return LexicallyScopedDeclarations(node.LabelledItem);
+    case 'Script':
+      if (node.ScriptBody) {
+        return LexicallyScopedDeclarations(node.ScriptBody);
+      }
+      return [];
+    case 'ScriptBody':
+      return TopLevelLexicallyScopedDeclarations(node.StatementList);
+    case 'Module':
+      if (node.ModuleBody) {
+        return LexicallyScopedDeclarations(node.ModuleBody);
+      }
+      return [];
+    case 'ModuleBody':
+      return LexicallyScopedDeclarations(node.ModuleItemList);
+    case 'FunctionBody':
+    case 'GeneratorBody':
+    case 'AsyncBody':
+    case 'AsyncGeneratorBody':
+      return TopLevelLexicallyScopedDeclarations(node.FunctionStatementList);
+    case 'ClassStaticBlockBody':
+      return TopLevelLexicallyScopedDeclarations(node.ClassStaticBlockStatementList);
+    case 'ImportDeclaration':
+      return [];
+    case 'ClassDeclaration':
+    case 'LexicalDeclaration':
+    case 'UsingDeclaration':
+    case 'AwaitUsingDeclaration':
+    case 'FunctionDeclaration':
+    case 'GeneratorDeclaration':
+    case 'AsyncFunctionDeclaration':
+    case 'AsyncGeneratorDeclaration':
+      return [DeclarationPart(node)];
+    case 'CaseBlock': {
+      const names = [];
+      if (node.CaseClauses_a) {
+        names.push(...LexicallyScopedDeclarations(node.CaseClauses_a));
+      }
+      if (node.DefaultClause) {
+        names.push(...LexicallyScopedDeclarations(node.DefaultClause));
+      }
+      if (node.CaseClauses_b) {
+        names.push(...LexicallyScopedDeclarations(node.CaseClauses_b));
+      }
+      return names;
+    }
+    case 'CaseClause':
+    case 'DefaultClause':
+      if (node.StatementList) {
+        return LexicallyScopedDeclarations(node.StatementList);
+      }
+      return [];
+    case 'ExportDeclaration':
+      if (node.Declaration) {
+        return [DeclarationPart(node.Declaration)];
+      }
+      if (node.HoistableDeclaration) {
+        return [DeclarationPart(node.HoistableDeclaration)];
+      }
+      if (node.ClassDeclaration) {
+        return [node.ClassDeclaration];
+      }
+      if (node.AssignmentExpression) {
+        return [node];
+      }
+      return [];
+    default:
+      return [];
+  }
+}

package/src/static-semantics/ModuleRequests.mts

@@ -0,0 +1,185 @@
+import type { ParseNode } from '../parser/ParseNode.mts';
+import type { JSStringValue } from '../value.mts';
+import { OutOfRange, isArray, type Mutable } from '../utils/language.mts';
+import { StringValue } from './all.mts';
+import { MergeImportedNames, type LoadedModuleRequestRecord } from '#self';
+
+// https://tc39.es/proposal-deferred-reexports/
+export type ImportedNamesValue = 'all' | 'all-but-default' | readonly string[];
+
+// https://tc39.es/ecma262/#modulerequest-record
+export interface ModuleRequestRecord {
+  readonly Specifier: string;
+  readonly Attributes: readonly ImportAttributeRecord[];
+  readonly Phase: 'source' | 'defer' | 'evaluation';
+  readonly ImportedNames: ImportedNamesValue;
+}
+
+// https://tc39.es/ecma262/#importattribute-record
+export interface ImportAttributeRecord {
+  readonly Key: string;
+  readonly Value: string;
+}
+
+/** https://tc39.es/proposal-defer-import-eval/#sec-ModuleRequestsKeyEqual */
+export function ModuleRequestsKeyEqual(left: ModuleRequestRecord | LoadedModuleRequestRecord, right: ModuleRequestRecord | LoadedModuleRequestRecord) {
+  // 1. If left.[[Specifier]] is not right.[[Specifier]], return false.
+  if (left.Specifier !== right.Specifier) {
+    return false;
+  }
+  // 2. Let leftAttrs be left.[[Attributes]].
+  const leftAttrs = left.Attributes;
+  // 3. Let rightAttrs be right.[[Attributes]].
+  const rightAttrs = right.Attributes;
+  // 4. Let leftAttrsCount be the number of elements in leftAttrs.
+  const leftAttrsCount = leftAttrs.length;
+  // 5. Let rightAttrsCount be the number of elements in rightAttrs.
+  const rightAttrsCount = rightAttrs.length;
+  // 6. If leftAttrsCount ≠ rightAttrsCount, return false.
+  if (leftAttrsCount !== rightAttrsCount) {
+    return false;
+  }
+  // 7. For each ImportAttribute Record l of leftAttrs, do
+  for (const l of leftAttrs) {
+    // a. If rightAttrs does not contain an ImportAttribute Record r such that l.[[Key]] is r.[[Key]] and l.[[Value]] is r.[[Value]], return false.
+    if (!rightAttrs.some((r) => l.Key === r.Key && l.Value === r.Value)) {
+      return false;
+    }
+  }
+  // 8. Return true.
+  return true;
+}
+
+// https://tc39.es/ecma262/#sec-withclausetoattributes
+function WithClauseToAttributes(node: ParseNode.WithClause): ImportAttributeRecord[] {
+  const attributes: ImportAttributeRecord[] = [];
+  for (const attribute of node.WithEntries) {
+    attributes.push({
+      Key: StringValue(attribute.AttributeKey).value,
+      Value: StringValue(attribute.AttributeValue).value,
+    });
+  }
+  attributes.sort((a, b) => (a.Key < b.Key ? -1 : 1));
+  return attributes;
+}
+
+/** https://tc39.es/proposal-deferred-reexports/#sec-ImportedNames */
+export function ImportedNames(node: ParseNode.NamedImports | ParseNode.NamedExports): readonly string[];
+export function ImportedNames(node: ParseNode | readonly ParseNode[]): ImportedNamesValue;
+export function ImportedNames(node: ParseNode | readonly ParseNode[]): ImportedNamesValue {
+  if (isArray(node)) {
+    let importedNames: ImportedNamesValue = [];
+    for (const item of node) {
+      const additionalImportedNames = ImportedNames(item);
+      importedNames = MergeImportedNames(importedNames, additionalImportedNames);
+    }
+    return importedNames;
+  }
+  switch (node.type) {
+    case 'ImportClause':
+      if (node.ImportedDefaultBinding && node.NameSpaceImport) {
+        const names1 = ImportedNames(node.ImportedDefaultBinding);
+        const names2 = ImportedNames(node.NameSpaceImport);
+        return MergeImportedNames(names1, names2);
+      }
+      if (node.ImportedDefaultBinding && node.NamedImports) {
+        const names1 = ImportedNames(node.ImportedDefaultBinding);
+        const names2 = ImportedNames(node.NamedImports);
+        return MergeImportedNames(names1, names2);
+      }
+      if (node.ImportedDefaultBinding) {
+        return ImportedNames(node.ImportedDefaultBinding);
+      }
+      if (node.NameSpaceImport) {
+        return ImportedNames(node.NameSpaceImport);
+      }
+      if (node.NamedImports) {
+        return ImportedNames(node.NamedImports);
+      }
+      throw OutOfRange.nonExhaustive(node);
+    case 'ImportedDefaultBinding':
+      return ['default'];
+    case 'NameSpaceImport':
+      if (node.NamedImports) {
+        return ImportedNames(node.NamedImports);
+      }
+      return 'all';
+    case 'NamedImports':
+      return ImportedNames(node.ImportsList);
+    case 'ImportSpecifier':
+      return [StringValue(node.ModuleExportName ?? node.ImportedBinding).stringValue()];
+    case 'ExportFromClause':
+      if (node.ModuleExportName) {
+        return 'all';
+      }
+      return 'all-but-default';
+    case 'NamedExports':
+      return ImportedNames(node.ExportsList);
+    case 'ExportSpecifier':
+      return [StringValue(node.localName).stringValue()];
+    default:
+      throw OutOfRange.nonExhaustive(node);
+  }
+}
+
+/** https://tc39.es/proposal-deferred-reexports/#sec-ExportFromDeclarationModuleRequest */
+export function ExportFromDeclarationModuleRequest(node: ParseNode.ExportDeclaration_NamedFrom): ModuleRequestRecord {
+  const importedNames = ImportedNames(node.ExportFromClause);
+  const specifier = StringValue(node.FromClause);
+  const attributes = node.WithClause ? WithClauseToAttributes(node.WithClause) : [];
+  return {
+    Specifier: specifier.value, Attributes: attributes, Phase: 'evaluation', ImportedNames: importedNames,
+  };
+}
+
+export function ModuleRequests(node: ParseNode): ModuleRequestRecord[] {
+  switch (node.type) {
+    case 'Module':
+      if (node.ModuleBody) {
+        return ModuleRequests(node.ModuleBody);
+      }
+      return [];
+    case 'ModuleBody': {
+      const requests: ModuleRequestRecord[] = [];
+      for (const item of node.ModuleItemList) {
+        const additionalRequests = ModuleRequests(item);
+        for (const mr of additionalRequests) {
+          const existing = requests.find((r) => ModuleRequestsKeyEqual(r, mr) && r.Phase === mr.Phase);
+          if (existing) {
+            (existing as Mutable<ModuleRequestRecord>).ImportedNames = MergeImportedNames(existing.ImportedNames, mr.ImportedNames);
+          } else {
+            requests.push(mr);
+          }
+        }
+      }
+      return requests;
+    }
+    case 'ImportDeclaration': {
+      let specifier: JSStringValue;
+      if (node.FromClause) {
+        specifier = StringValue(node.FromClause);
+      } else if (node.ModuleSpecifier) {
+        specifier = StringValue(node.ModuleSpecifier);
+      } else {
+        throw new Error('Unreachable: all imports must have either an ImportClause or a ModuleSpecifier');
+      }
+      const importedNames = node.ImportClause ? ImportedNames(node.ImportClause) : [];
+      const attributes = node.WithClause ? WithClauseToAttributes(node.WithClause) : [];
+      return [{
+        Specifier: specifier.value, Attributes: attributes, Phase: node.Phase, ImportedNames: importedNames,
+      }];
+    }
+    case 'ExportDeclaration':
+      if (node.FromClause) {
+        const fromNode = node as ParseNode.ExportDeclaration_NamedFrom;
+        // `export defer ... from "m"` is tracked via [[OptionalIndirectExportEntries]]
+        if (fromNode.Phase === 'defer') {
+          return [];
+        }
+        return [ExportFromDeclarationModuleRequest(fromNode)];
+      }
+      return [];
+    default:
+      return [];
+  }
+}

package/src/static-semantics/NonConstructorElements.mts

@@ -0,0 +1,15 @@
+import type { ParseNode } from '../parser/ParseNode.mts';
+import { PropName } from './all.mts';
+
+/** https://tc39.es/ecma262/#sec-static-semantics-nonconstructorelements */
+// ClassElementList :
+//   ClassElement
+//   ClassElementList ClassElement
+export function NonConstructorElements(ClassElementList: ParseNode.ClassElementList) {
+  return ClassElementList.filter((ClassElement) => {
+    if (ClassElement.static === false && PropName(ClassElement) === 'constructor') {
+      return false;
+    }
+    return true;
+  });
+}

package/src/static-semantics/NumericValue.mts

@@ -0,0 +1,7 @@
+/** https://tc39.es/ecma262/#sec-numericvalue */
+import type { ParseNode } from '../parser/ParseNode.mts';
+import { Value } from '../value.mts';
+
+export function NumericValue(node: ParseNode.NumericLiteral) {
+  return Value(node.value);
+}

package/src/static-semantics/PrivateBoundIdentifiers.mts

@@ -0,0 +1,23 @@
+import { isArray } from '../utils/language.mts';
+import type { ParseNode } from '../parser/ParseNode.mts';
+import type { JSStringValue } from '../value.mts';
+import { StringValue } from './all.mts';
+
+/** https://tc39.es/ecma262/#sec-static-semantics-privateboundidentifiers */
+export function PrivateBoundIdentifiers(node: ParseNode | readonly ParseNode[]): JSStringValue[] {
+  if (isArray(node)) {
+    return node.flatMap((n) => PrivateBoundIdentifiers(n));
+  }
+  switch (node.type) {
+    case 'PrivateIdentifier':
+      return [StringValue(node)];
+    case 'MethodDefinition':
+    case 'GeneratorMethod':
+    case 'AsyncMethod':
+    case 'AsyncGeneratorMethod':
+    case 'FieldDefinition':
+      return PrivateBoundIdentifiers(node.ClassElementName);
+    default:
+      return [];
+  }
+}

package/src/static-semantics/PropName.mts

@@ -0,0 +1,23 @@
+import type { ParseNode } from '../parser/ParseNode.mts';
+
+export function PropName(node: ParseNode): string | undefined {
+  switch (node.type) {
+    case 'IdentifierName':
+      return node.name;
+    case 'StringLiteral':
+      return node.value;
+    case 'MethodDefinition':
+    case 'GeneratorMethod':
+    case 'AsyncGeneratorMethod':
+    case 'AsyncMethod':
+    case 'FieldDefinition':
+      return PropName(node.ClassElementName);
+    case 'PropertyDefinition':
+      if (node.PropertyName) {
+        return PropName(node.PropertyName);
+      }
+      break;
+    default:
+  }
+  return undefined;
+}

package/src/static-semantics/StringToCodePoints.mts

@@ -0,0 +1,22 @@
+import { CodePointAt } from './all.mts';
+
+/** https://tc39.es/ecma262/#sec-stringtocodepoints */
+export function StringToCodePoints(string: string) {
+  // 1. Let codePoints be a new empty List.
+  const codePoints = [];
+  // 2. Let size be the length of string.
+  const size = string.length;
+  // 3. Let position be 0.
+  let position = 0;
+  // 4. Repeat, while position < size,
+  while (position < size) {
+    // a. Let cp be ! CodePointAt(string, position).
+    const cp = CodePointAt(string, position);
+    // b. Append cp.[[CodePoint]] to codePoints.
+    codePoints.push(cp.CodePoint);
+    // c. Set position to position + cp.[[CodeUnitCount]].
+    position += cp.CodeUnitCount;
+  }
+  // 5. Return codePoints.
+  return codePoints;
+}

package/src/static-semantics/StringValue.mts

@@ -0,0 +1,19 @@
+import { Value } from '../value.mts';
+import { OutOfRange } from '../utils/language.mts';
+import type { ParseNode } from '../parser/ParseNode.mts';
+
+export function StringValue(node: ParseNode) {
+  switch (node.type) {
+    case 'IdentifierName':
+    case 'BindingIdentifier':
+    case 'IdentifierReference':
+    case 'LabelIdentifier':
+      return Value(node.name);
+    case 'PrivateIdentifier':
+      return Value(`#${node.name}`);
+    case 'StringLiteral':
+      return Value(node.value);
+    default:
+      throw OutOfRange.nonExhaustive(node);
+  }
+}

package/src/static-semantics/TemplateStrings.mts

@@ -0,0 +1,109 @@
+import { Value } from '../value.mts';
+import { isHexDigit, isDecimalDigit, isLineTerminator } from '../parser/Lexer.mts';
+import type { ParseNode } from '../parser/ParseNode.mts';
+
+/** https://tc39.es/ecma262/#sec-static-semantics-tv */
+export function TV(s: string) {
+  let buffer = '';
+  for (let i = 0; i < s.length; i += 1) {
+    if (s[i] === '\\') {
+      i += 1;
+      switch (s[i]) {
+        case '$':
+          buffer += '$';
+          break;
+        case '\\':
+          buffer += '\\';
+          break;
+        case '`':
+          buffer += '`';
+          break;
+        case '\'':
+          buffer += '\'';
+          break;
+        case '"':
+          buffer += '"';
+          break;
+        case 'b':
+          buffer += '\b';
+          break;
+        case 'f':
+          buffer += '\f';
+          break;
+        case 'n':
+          buffer += '\n';
+          break;
+        case 'r':
+          buffer += '\r';
+          break;
+        case 't':
+          buffer += '\t';
+          break;
+        case 'v':
+          buffer += '\v';
+          break;
+        case 'x':
+          i += 1;
+          if (isHexDigit(s[i]) && isHexDigit(s[i + 1])) {
+            const n = Number.parseInt(s.slice(i, i + 2), 16);
+            i += 1;
+            buffer += String.fromCharCode(n);
+          } else {
+            return undefined;
+          }
+          break;
+        case 'u':
+          i += 1;
+          if (s[i] === '{') {
+            i += 1;
+            const start = i;
+            do {
+              i += 1;
+            } while (isHexDigit(s[i]));
+            if (s[i] !== '}') {
+              return undefined;
+            }
+            const n = Number.parseInt(s.slice(start, i), 16);
+            if (n > 0x10FFFF) {
+              return undefined;
+            }
+            buffer += String.fromCodePoint(n);
+          } else if (isHexDigit(s[i]) && isHexDigit(s[i + 1])
+                     && isHexDigit(s[i + 2]) && isHexDigit(s[i + 3])) {
+            const n = Number.parseInt(s.slice(i, i + 4), 16);
+            i += 3;
+            buffer += String.fromCodePoint(n);
+          } else {
+            return undefined;
+          }
+          break;
+        case '0':
+          if (isDecimalDigit(s[i + 1])) {
+            return undefined;
+          }
+          return '\u{0000}';
+        default:
+          if (isLineTerminator(s)) {
+            return '';
+          }
+          return undefined;
+      }
+    } else {
+      buffer += s[i];
+    }
+  }
+  return buffer;
+}
+
+export function TemplateStrings(node: ParseNode.TemplateLiteral, raw: boolean) {
+  if (raw) {
+    return node.TemplateSpanList.map((s) => Value(s));
+  }
+  return node.TemplateSpanList.map((v) => {
+    const tv = TV(v);
+    if (tv === undefined) {
+      return Value.undefined;
+    }
+    return Value(tv);
+  });
+}

package/src/static-semantics/TopLevelLexicallyDeclaredNames.mts

@@ -0,0 +1,23 @@
+import { isArray } from '../utils/language.mts';
+import type { ParseNode } from '../parser/ParseNode.mts';
+import type { JSStringValue } from '../value.mts';
+import { BoundNames } from './all.mts';
+
+export function TopLevelLexicallyDeclaredNames(node: ParseNode | readonly ParseNode[]): JSStringValue[] {
+  if (isArray(node)) {
+    const names = [];
+    for (const StatementListItem of node) {
+      names.push(...TopLevelLexicallyDeclaredNames(StatementListItem));
+    }
+    return names;
+  }
+  switch (node.type) {
+    case 'ClassDeclaration':
+    case 'LexicalDeclaration':
+    case 'UsingDeclaration':
+    case 'AwaitUsingDeclaration':
+      return BoundNames(node);
+    default:
+      return [];
+  }
+}

package/src/static-semantics/TopLevelLexicallyScopedDeclarations.mts

@@ -0,0 +1,27 @@
+import { isArray } from '../utils/language.mts';
+import type { ParseNode } from '../parser/ParseNode.mts';
+
+export function TopLevelLexicallyScopedDeclarations(node: ParseNode | readonly ParseNode[]): LexicallyScopedDeclaration[] {
+  if (isArray(node)) {
+    const declarations = [];
+    for (const item of node) {
+      declarations.push(...TopLevelLexicallyScopedDeclarations(item));
+    }
+    return declarations;
+  }
+  switch (node.type) {
+    case 'ClassDeclaration':
+    case 'LexicalDeclaration':
+    case 'UsingDeclaration':
+    case 'AwaitUsingDeclaration':
+      return [node];
+    default:
+      return [];
+  }
+}
+
+export type LexicallyScopedDeclaration =
+  | ParseNode.ClassDeclaration
+  | ParseNode.LexicalDeclaration
+  | ParseNode.UsingDeclaration
+  | ParseNode.AwaitUsingDeclaration;

package/src/static-semantics/TopLevelVarDeclaredNames.mts

@@ -0,0 +1,28 @@
+import { isArray } from '../utils/language.mts';
+import type { ParseNode } from '../parser/ParseNode.mts';
+import type { JSStringValue } from '../value.mts';
+import { BoundNames, VarDeclaredNames } from './all.mts';
+
+export function TopLevelVarDeclaredNames(node: ParseNode | readonly ParseNode[]): JSStringValue[] {
+  if (isArray(node)) {
+    const names = [];
+    for (const item of node) {
+      names.push(...TopLevelVarDeclaredNames(item));
+    }
+    return names;
+  }
+  switch (node.type) {
+    case 'ClassDeclaration':
+    case 'LexicalDeclaration':
+    case 'UsingDeclaration':
+    case 'AwaitUsingDeclaration':
+      return [];
+    case 'FunctionDeclaration':
+    case 'GeneratorDeclaration':
+    case 'AsyncFunctionDeclaration':
+    case 'AsyncGeneratorDeclaration':
+      return BoundNames(node);
+    default:
+      return VarDeclaredNames(node);
+  }
+}

package/src/static-semantics/TopLevelVarScopedDeclarations.mts

@@ -0,0 +1,36 @@
+import { isArray } from '../utils/language.mts';
+import type { ParseNode } from '../parser/ParseNode.mts';
+import { DeclarationPart, VarScopedDeclarations } from './all.mts';
+
+export function TopLevelVarScopedDeclarations(node: ParseNode | readonly ParseNode[]): VarScopedDeclaration[] {
+  if (isArray(node)) {
+    const declarations = [];
+    for (const item of node) {
+      declarations.push(...TopLevelVarScopedDeclarations(item));
+    }
+    return declarations;
+  }
+  switch (node.type) {
+    case 'ClassDeclaration':
+    case 'LexicalDeclaration':
+    case 'UsingDeclaration':
+    case 'AwaitUsingDeclaration':
+      return [];
+    case 'FunctionDeclaration':
+    case 'GeneratorDeclaration':
+    case 'AsyncFunctionDeclaration':
+    case 'AsyncGeneratorDeclaration':
+      return [DeclarationPart(node)];
+    default:
+      return VarScopedDeclarations(node);
+  }
+}
+
+export type VarScopedDeclaration =
+  | ParseNode.ForBinding
+  | ParseNode.VariableDeclaration
+  | ParseNode.FunctionDeclaration
+  | ParseNode.GeneratorDeclaration
+  | ParseNode.AsyncFunctionDeclaration
+  | ParseNode.AsyncGeneratorDeclaration
+  | ParseNode.BindingIdentifier;

package/src/static-semantics/UTF16EncodeCodePoint.mts

@@ -0,0 +1,19 @@
+import { modulo } from '../abstract-ops/math.mts';
+import { Assert } from '#self';
+import type { CodePoint } from '#self';
+
+/** https://tc39.es/ecma262/#sec-utf16encodecodepoint */
+export function UTF16EncodeCodePoint(cp: CodePoint) {
+  // 1. Assert: 0 ≤ cp ≤ 0x10FFFF.
+  Assert(cp >= 0 && cp <= 0x10FFFF);
+  // 2. If cp ≤ 0xFFFF, return the String value consisting of the code unit whose value is cp.
+  if (cp <= 0xFFFF) {
+    return String.fromCodePoint(cp);
+  }
+  // 3. Let cu1 be the code unit whose value is floor((cp - 0x10000) / 0x400) + 0xD800.
+  const cu1 = Math.floor((cp - 0x10000) / 0x400) + 0xD800;
+  // 4. Let cu2 be the code unit whose value is ((cp - 0x10000) modulo 0x400) + 0xDC00.
+  const cu2 = modulo(cp - 0x10000, 0x400) + 0xDC00;
+  // 5. Return the string-concatenation of cu1 and cu2.
+  return String.fromCodePoint(cu1, cu2);
+}

package/src/static-semantics/UTF16SurrogatePairToCodePoint.mts

@@ -0,0 +1,12 @@
+import { Assert } from '#self';
+import { isLeadingSurrogate, isTrailingSurrogate, type CodePoint } from '#self';
+
+/** https://tc39.es/ecma262/#sec-utf16decodesurrogatepair */
+export function UTF16SurrogatePairToCodePoint(lead: number, trail: number): CodePoint {
+  // 1. Assert: lead is a leading surrogate and trail is a trailing surrogate.
+  Assert(isLeadingSurrogate(lead) && isTrailingSurrogate(trail));
+  // 2. Let cp be (lead - 0xD800) × 0x400 + (trail - 0xDC00) + 0x10000.
+  const cp = (lead - 0xD800) * 0x400 + (trail - 0xDC00) + 0x10000;
+  // 3. Return the code point cp.
+  return cp as CodePoint;
+}