@engine262/engine262 0.0.1-07c72085c73f960bcf0aa06db807321f3b446518

package/src/parser/tokens.mts

@@ -0,0 +1,212 @@
+/** Coerces a property key into a numeric index */
+type ToIndex<T extends PropertyKey> =
+  T extends number ? ToIndex<`${T}`> :
+  T extends `${bigint}` ? T extends `${infer I extends number}` ? I : never :
+  never;
+
+type ReplaceType<T, U, V> = T extends U ? V : T;
+
+type TokenDefinition = readonly [name: string, value: string | null, precedence?: number];
+
+type TokenArrayToAssignTokenArray<A extends readonly TokenDefinition[]> = {
+  readonly [P in keyof A]: readonly [`ASSIGN_${A[P][0]}`, `${A[P][1]}`, A[P][2]];
+};
+
+type TokenArrayToEnumLike<A extends readonly TokenDefinition[]> = {
+  readonly [I in ToIndex<keyof A> as A[I][0]]: I;
+};
+
+type TokenArrayToElementArray<A extends readonly TokenDefinition[], I extends 0 | 1 | 2, V = undefined> = {
+  readonly [P in keyof A]: ReplaceType<A[P][I], undefined, V>;
+};
+
+type TokenArrayToKeywordsArray<A extends readonly TokenDefinition[]> = readonly {
+  readonly [I in ToIndex<keyof A>]: A[I][1] extends Lowercase<A[I][0]> ? A[I][1] : never;
+}[ToIndex<keyof A>][];
+
+type KeywordsArrayToEnumLike<A extends readonly string[]> = {
+  readonly [P in A[number]]: typeof Token[Uppercase<P> & keyof typeof Token];
+};
+
+const MaybeAssignTokens = [
+  // Logical
+  ['NULLISH', '??', 3],
+  ['OR', '||', 4],
+  ['AND', '&&', 5],
+
+  // Binop
+  ['BIT_OR', '|', 6],
+  ['BIT_XOR', '^', 7],
+  ['BIT_AND', '&', 8],
+  ['SHL', '<<', 11],
+  ['SAR', '>>', 11],
+  ['SHR', '>>>', 11],
+  ['MUL', '*', 13],
+  ['DIV', '/', 13],
+  ['MOD', '%', 13],
+  ['EXP', '**', 14],
+
+  // Unop
+  ['ADD', '+', 12],
+  ['SUB', '-', 12],
+] as const satisfies readonly TokenDefinition[];
+
+export const RawTokens = [
+  // BEGIN PropertyOrCall
+  // BEGIN Member
+  // BEGIN Template
+  ['TEMPLATE', '`'],
+  // END Template
+
+  // BEGIN Property
+  ['PERIOD', '.'],
+  ['LBRACK', '['],
+  // END Property
+  // END Member
+  ['OPTIONAL', '?.'],
+  ['LPAREN', '('],
+  // END PropertyOrCall
+  ['RPAREN', ')'],
+  ['RBRACK', ']'],
+  ['LBRACE', '{'],
+  ['COLON', ':'],
+  ['ELLIPSIS', '...'],
+  ['CONDITIONAL', '?'],
+  // BEGIN AutoSemicolon
+  ['SEMICOLON', ';'],
+  ['RBRACE', '}'],
+
+  ['EOS', 'EOS'],
+  // END AutoSemicolon
+
+  // BEGIN ArrowOrAssign
+  ['ARROW', '=>'],
+  // BEGIN Assign
+  ['ASSIGN', '=', 2],
+  ...MaybeAssignTokens.map((t) => [`ASSIGN_${t[0]}`, `${t[1]}=`, 2]) as readonly TokenDefinition[] as TokenArrayToAssignTokenArray<typeof MaybeAssignTokens>,
+  // END Assign
+  // END ArrowOrAssign
+
+  // Binary operators by precidence
+  ['COMMA', ',', 1],
+
+  ...MaybeAssignTokens,
+
+  ['NOT', '!'],
+  ['BIT_NOT', '~'],
+  ['DELETE', 'delete'],
+  ['TYPEOF', 'typeof'],
+  ['VOID', 'void'],
+
+  // BEGIN IsCountOp
+  ['INC', '++'],
+  ['DEC', '--'],
+  // END IsCountOp
+  // END IsUnaryOrCountOp
+
+  ['EQ', '==', 9],
+  ['EQ_STRICT', '===', 9],
+  ['NE', '!=', 9],
+  ['NE_STRICT', '!==', 9],
+  ['LT', '<', 10],
+  ['GT', '>', 10],
+  ['LTE', '<=', 10],
+  ['GTE', '>=', 10],
+  ['INSTANCEOF', 'instanceof', 10],
+  ['IN', 'in', 10],
+
+  ['BREAK', 'break'],
+  ['CASE', 'case'],
+  ['CATCH', 'catch'],
+  ['CONTINUE', 'continue'],
+  ['DEBUGGER', 'debugger'],
+  ['DEFAULT', 'default'],
+  // DELETE
+  ['DO', 'do'],
+  ['ELSE', 'else'],
+  ['FINALLY', 'finally'],
+  ['FOR', 'for'],
+  ['FUNCTION', 'function'],
+  ['IF', 'if'],
+  // IN
+  // INSTANCEOF
+  ['NEW', 'new'],
+  ['RETURN', 'return'],
+  ['SWITCH', 'switch'],
+  ['THROW', 'throw'],
+  ['TRY', 'try'],
+  // TYPEOF
+  ['VAR', 'var'],
+  // VOID
+  ['WHILE', 'while'],
+  ['WITH', 'with'],
+  ['THIS', 'this'],
+
+  ['NULL', 'null'],
+  ['TRUE', 'true'],
+  ['FALSE', 'false'],
+  ['NUMBER', null],
+  ['STRING', null],
+  ['BIGINT', null],
+
+  // BEGIN Callable
+  ['SUPER', 'super'],
+  // BEGIN AnyIdentifier
+  ['IDENTIFIER', null],
+  ['AWAIT', 'await'],
+  ['YIELD', 'yield'],
+  // END AnyIdentifier
+  // END Callable
+  ['CLASS', 'class'],
+  ['CONST', 'const'],
+  ['EXPORT', 'export'],
+  ['EXTENDS', 'extends'],
+  ['IMPORT', 'import'],
+  ['PRIVATE_IDENTIFIER', null],
+
+  ['ENUM', 'enum'],
+
+  ['ESCAPED_KEYWORD', null],
+] as const satisfies readonly TokenDefinition[];
+
+export const Token = RawTokens
+  .reduce((obj, [name], i) => {
+    obj[name] = i;
+    return obj;
+  }, Object.create(null)) as TokenArrayToEnumLike<typeof RawTokens>;
+
+export type Token = typeof Token[keyof typeof Token];
+
+export const TokenNames = RawTokens.map((r) => r[0]) as readonly string[] as TokenArrayToElementArray<typeof RawTokens, 0>;
+
+export const TokenValues = RawTokens.map((r) => r[1]) as readonly (string | null)[] as TokenArrayToElementArray<typeof RawTokens, 1>;
+
+export const TokenPrecedence = RawTokens.map((r) => (r[2] || 0)) as readonly number[] as TokenArrayToElementArray<typeof RawTokens, 2, 0>;
+
+const Keywords = RawTokens
+  .filter(([name, raw]) => name.toLowerCase() === raw)
+  .map(([, raw]) => raw!) as TokenArrayToKeywordsArray<typeof RawTokens>;
+
+export const KeywordLookup = Keywords
+  .reduce((obj, kw) => {
+    obj[kw] = Token[kw.toUpperCase() as Uppercase<typeof kw>];
+    return obj;
+  }, Object.create(null)) as KeywordsArrayToEnumLike<typeof Keywords>;
+
+const KeywordRaw: ReadonlySet<string> = new Set(Object.keys(KeywordLookup));
+const KeywordTokens: ReadonlySet<number> = new Set(Object.values(KeywordLookup));
+
+const isInRange = (t: number, l: number, h: number) => t >= l && t <= h;
+export const isAutomaticSemicolon = (t: number) => isInRange(t, Token.SEMICOLON, Token.EOS);
+export const isMember = (t: number) => isInRange(t, Token.TEMPLATE, Token.LBRACK);
+export const isPropertyOrCall = (t: number) => isInRange(t, Token.TEMPLATE, Token.LPAREN);
+export const isKeyword = (t: number): t is typeof KeywordLookup[keyof typeof KeywordLookup] => KeywordTokens.has(t);
+export const isKeywordRaw = (s: string): s is keyof typeof KeywordLookup => KeywordRaw.has(s);
+
+const ReservedWordsStrict: ReadonlySet<string> = new Set([
+  'implements', 'interface', 'let',
+  'package', 'private', 'protected',
+  'public', 'static', 'yield',
+]);
+
+export const isReservedWordStrict = (s: string) => ReservedWordsStrict.has(s);

package/src/parser/unicode.d.ts

@@ -0,0 +1,20 @@
+declare module '@unicode/unicode-16.0.0/Binary_Property/ID_Start/regex.js' {
+    let regex: RegExp;
+    export default regex;
+}
+declare module '@unicode/unicode-16.0.0/Binary_Property/ID_Continue/regex.js' {
+    let regex: RegExp;
+    export default regex;
+}
+declare module '@unicode/unicode-16.0.0/General_Category/Space_Separator/regex.js' {
+    let regex: RegExp;
+    export default regex;
+}
+declare module '@unicode/unicode-16.0.0/Case_Folding/C/symbols.js' {
+    let data: Map<string, string>;
+    export default data;
+}
+declare module '@unicode/unicode-16.0.0/Case_Folding/S/symbols.js' {
+    let data: Map<string, string>;
+    export default data;
+}

package/src/runtime-semantics/AdditiveExpression.mts

@@ -0,0 +1,29 @@
+import { Q } from '../completion.mts';
+import type { ExpressionEvaluator } from '../evaluator.mts';
+import { OutOfRange } from '../helpers.mts';
+import type { ParseNode } from '../parser/ParseNode.mts';
+import { EvaluateStringOrNumericBinaryExpression } from './all.mts';
+
+/** https://tc39.es/ecma262/#sec-addition-operator-plus-runtime-semantics-evaluation */
+//   AdditiveExpression : AdditiveExpression + MultiplicativeExpression
+function* Evaluate_AdditiveExpression_Plus({ AdditiveExpression, MultiplicativeExpression }: ParseNode.AdditiveExpression): ExpressionEvaluator {
+  // 1. Return ? EvaluateStringOrNumericBinaryExpression(AdditiveExpression, +, MultiplicativeExpression).
+  return Q(yield* EvaluateStringOrNumericBinaryExpression(AdditiveExpression, '+', MultiplicativeExpression));
+}
+
+/** https://tc39.es/ecma262/#sec-subtraction-operator-minus-runtime-semantics-evaluation */
+function* Evaluate_AdditiveExpression_Minus({ AdditiveExpression, MultiplicativeExpression }: ParseNode.AdditiveExpression): ExpressionEvaluator {
+  // 1. Return ? EvaluateStringOrNumericBinaryExpression(AdditiveExpression, -, MultiplicativeExpression).
+  return Q(yield* EvaluateStringOrNumericBinaryExpression(AdditiveExpression, '-', MultiplicativeExpression));
+}
+
+export function* Evaluate_AdditiveExpression(AdditiveExpression: ParseNode.AdditiveExpression) {
+  switch (AdditiveExpression.operator) {
+    case '+':
+      return yield* Evaluate_AdditiveExpression_Plus(AdditiveExpression);
+    case '-':
+      return yield* Evaluate_AdditiveExpression_Minus(AdditiveExpression);
+    default:
+      throw new OutOfRange('Evaluate_AdditiveExpression', AdditiveExpression);
+  }
+}

package/src/runtime-semantics/ApplyStringOrNumericBinaryOperator.mts

@@ -0,0 +1,78 @@
+import { surroundingAgent } from '../engine.mts';
+import {
+  Type, JSStringValue, Value,
+  NumberValue,
+  BigIntValue,
+} from '../value.mts';
+import {
+  Assert, ToNumeric, ToPrimitive, ToString,
+} from '../abstract-ops/all.mts';
+import { Q } from '../completion.mts';
+
+export type BinaryOperator = '+' | '-' | '*' | '/' | '%' | '**' | '<<' | '>>' | '>>>' | '&' | '^' | '|';
+/** https://tc39.es/ecma262/#sec-applystringornumericbinaryoperator */
+export function ApplyStringOrNumericBinaryOperator(lval: Value, opText: BinaryOperator, rval: Value) {
+  // 1. If opText is +, then
+  if (opText === '+') {
+    // a. Let lprim be ? ToPrimitive(lval).
+    const lprim = Q(ToPrimitive(lval));
+    // b. Let rprim be ? ToPrimitive(rval).
+    const rprim = Q(ToPrimitive(rval));
+    // c. If Type(lprim) is String or Type(rprim) is String, then
+    if (lprim instanceof JSStringValue || rprim instanceof JSStringValue) {
+      // i. Let lstr be ? ToString(lprim).
+      const lstr = Q(ToString(lprim));
+      // ii. Let rstr be ? ToString(rprim).
+      const rstr = Q(ToString(rprim));
+      // iii. Return the string-concatenation of lstr and rstr.
+      return Value(lstr.stringValue() + rstr.stringValue());
+    }
+    // d. Set lval to lprim.
+    lval = lprim;
+    // e. Set rval to rprim.
+    rval = rprim;
+  }
+  // 2. NOTE: At this point, it must be a numeric operation.
+  // 3. Let lnum be ? ToNumeric(lval).
+  const lnum = Q(ToNumeric(lval));
+  // 4. Let rnum be ? ToNumeric(rval).
+  const rnum = Q(ToNumeric(rval));
+  // 5. If Type(lnum) is different from Type(rnum), throw a TypeError exception.
+  if (Type(lnum) !== Type(rnum)) {
+    return surroundingAgent.Throw('TypeError', 'CannotMixBigInts');
+  }
+  if (lnum instanceof BigIntValue) {
+    const operations = {
+      '**': BigIntValue.exponentiate,
+      '*': BigIntValue.multiply,
+      '/': BigIntValue.divide,
+      '%': BigIntValue.remainder,
+      '+': BigIntValue.add,
+      '-': BigIntValue.subtract,
+      '<<': BigIntValue.leftShift,
+      '>>': BigIntValue.signedRightShift,
+      '>>>': BigIntValue.unsignedRightShift,
+      '&': BigIntValue.bitwiseAND,
+      '^': BigIntValue.bitwiseXOR,
+      '|': BigIntValue.bitwiseOR,
+    };
+    return Q(operations[opText](lnum, rnum as BigIntValue));
+  } else {
+    Assert(lnum instanceof NumberValue);
+    const operations = {
+      '**': NumberValue.exponentiate,
+      '*': NumberValue.multiply,
+      '/': NumberValue.divide,
+      '%': NumberValue.remainder,
+      '+': NumberValue.add,
+      '-': NumberValue.subtract,
+      '<<': NumberValue.leftShift,
+      '>>': NumberValue.signedRightShift,
+      '>>>': NumberValue.unsignedRightShift,
+      '&': NumberValue.bitwiseAND,
+      '^': NumberValue.bitwiseXOR,
+      '|': NumberValue.bitwiseOR,
+    };
+    return Q(operations[opText](lnum, rnum as NumberValue));
+  }
+}

package/src/runtime-semantics/ArgumentListEvaluation.mts

@@ -0,0 +1,178 @@
+import { surroundingAgent } from '../engine.mts';
+import {
+  Value, Descriptor, type Arguments,
+} from '../value.mts';
+import { Evaluate, type Evaluator } from '../evaluator.mts';
+import { Q, X, type PlainCompletion } from '../completion.mts';
+import { OutOfRange, isArray } from '../helpers.mts';
+import {
+  Assert,
+  ArrayCreate,
+  SetIntegrityLevel,
+  ToString,
+  GetIterator,
+  GetValue,
+  F,
+  IteratorStepValue,
+} from '../abstract-ops/all.mts';
+import { TemplateStrings } from '../static-semantics/all.mts';
+import type { ParseNode } from '../parser/ParseNode.mts';
+
+/** https://tc39.es/ecma262/#sec-gettemplateobjec */
+function GetTemplateObject(templateLiteral: ParseNode.TemplateLiteral) {
+  // 1. Let realm be the current Realm Record.
+  const realm = surroundingAgent.currentRealmRecord;
+  // 2. Let templateRegistry be realm.[[TemplateMap]].
+  const templateRegistry = realm.TemplateMap;
+  // 3. For each element e of templateRegistry, do
+  for (const e of templateRegistry) {
+    // a. If e.[[Site]] is the same Parse Node as templateLiteral, then
+    if (e.Site === templateLiteral) {
+      // b. Return e.[[Array]].
+      return e.Array;
+    }
+  }
+  // 4. Let rawStrings be TemplateStrings of templateLiteral with argument true.
+  const rawStrings = TemplateStrings(templateLiteral, true);
+  // 5. Let cookedStrings be TemplateStrings of templateLiteral with argument false.
+  const cookedStrings = TemplateStrings(templateLiteral, false);
+  // 6. Let count be the number of elements in the List cookedStrings.
+  const count = cookedStrings.length;
+  // 7. Assert: count ≤ 232 - 1.
+  Assert(count < (2 ** 32) - 1);
+  // 8. Let template be ! ArrayCreate(count).
+  const template = X(ArrayCreate(count));
+  // 9. Let template be ! ArrayCreate(count).
+  const rawObj = X(ArrayCreate(count));
+  // 10. Let index be 0.
+  let index = 0;
+  // 11. Repeat, while index < count
+  while (index < count) {
+    // a. Let prop be ! ToString(𝔽(index)).
+    const prop = X(ToString(F(index)));
+    // b. Let cookedValue be the String value cookedStrings[index].
+    const cookedValue = cookedStrings[index];
+    // c. Call template.[[DefineOwnProperty]](prop, PropertyDescriptor { [[Value]]: cookedValue, [[Writable]]: false, [[Enumerable]]: true, [[Configurable]]: false }).
+    X(template.DefineOwnProperty(prop, Descriptor({
+      Value: cookedValue,
+      Writable: Value.false,
+      Enumerable: Value.true,
+      Configurable: Value.false,
+    })));
+    // d. Let rawValue be the String value rawStrings[index].
+    const rawValue = rawStrings[index];
+    // e. Call rawObj.[[DefineOwnProperty]](prop, PropertyDescriptor { [[Value]]: rawValue, [[Writable]]: false, [[Enumerable]]: true, [[Configurable]]: false }).
+    X(rawObj.DefineOwnProperty(prop, Descriptor({
+      Value: rawValue,
+      Writable: Value.false,
+      Enumerable: Value.true,
+      Configurable: Value.false,
+    })));
+    // f. Call rawObj.[[DefineOwnProperty]](prop, PropertyDescriptor { [[Value]]: rawValue, [[Writable]]: false, [[Enumerable]]: true, [[Configurable]]: false }).
+    index += 1;
+  }
+  // 12. Perform SetIntegrityLevel(rawObj, frozen).
+  X(SetIntegrityLevel(rawObj, 'frozen'));
+  // 13. Perform SetIntegrityLevel(rawObj, frozen).
+  X(template.DefineOwnProperty(Value('raw'), Descriptor({
+    Value: rawObj,
+    Writable: Value.false,
+    Enumerable: Value.false,
+    Configurable: Value.false,
+  })));
+  // 14. Perform SetIntegrityLevel(template, frozen).
+  X(SetIntegrityLevel(template, 'frozen'));
+  // 15. Append the Record { [[Site]]: templateLiteral, [[Array]]: template } to templateRegistry.
+  templateRegistry.push({ Site: templateLiteral, Array: template });
+  // 16. Return template.
+  return template;
+}
+
+/** https://tc39.es/ecma262/#sec-template-literals-runtime-semantics-argumentlistevaluation */
+//   TemplateLiteral : NoSubstitutionTemplate
+//
+// https://github.com/tc39/ecma262/pull/1402
+//   TemplateLiteral : SubstitutionTemplate
+function* ArgumentListEvaluation_TemplateLiteral(TemplateLiteral: ParseNode.TemplateLiteral): Evaluator<PlainCompletion<Arguments>> {
+  switch (true) {
+    case TemplateLiteral.TemplateSpanList.length === 1: {
+      const templateLiteral = TemplateLiteral;
+      const siteObj = GetTemplateObject(templateLiteral);
+      return [siteObj] as Arguments;
+    }
+
+    case TemplateLiteral.TemplateSpanList.length > 1: {
+      const templateLiteral = TemplateLiteral;
+      const siteObj = GetTemplateObject(templateLiteral);
+      const restSub = [];
+      for (const Expression of TemplateLiteral.ExpressionList) {
+        const subRef = yield* Evaluate(Expression);
+        const subValue = Q(GetValue(subRef));
+        restSub.push(subValue);
+      }
+      return [siteObj, ...restSub] as Arguments;
+    }
+
+    default:
+      throw new OutOfRange('ArgumentListEvaluation_TemplateLiteral', TemplateLiteral);
+  }
+}
+
+/** https://tc39.es/ecma262/#sec-argument-lists-runtime-semantics-argumentlistevaluation */
+//   Arguments : `(` `)`
+//   ArgumentList :
+//     AssignmentExpression
+//     `...` AssignmentExpression
+//     ArgumentList `,` AssignmentExpression
+//     ArgumentList `,` `...` AssignmentExpression
+//
+// (implicit)
+//   Arguments :
+//     `(` ArgumentList `)`
+//     `(` ArgumentList `,` `)`
+function* ArgumentListEvaluation_Arguments(Arguments: ParseNode.Arguments): Evaluator<PlainCompletion<Arguments>> {
+  const precedingArgs = [];
+  for (const element of Arguments) {
+    if (element.type === 'AssignmentRestElement') {
+      const { AssignmentExpression } = element;
+      // 2. Let spreadRef be the result of evaluating AssignmentExpression.
+      const spreadRef = yield* Evaluate(AssignmentExpression);
+      // 3. Let spreadObj be ? GetValue(spreadRef).
+      const spreadObj = Q(GetValue(spreadRef));
+      // 4. Let iteratorRecord be ? GetIterator(spreadObj).
+      const iteratorRecord = Q(GetIterator(spreadObj, 'sync'));
+      // 5. Repeat,
+      while (true) {
+        // a. Let next be ? IteratorStepValue(iteratorRecord).
+        const next = Q(IteratorStepValue(iteratorRecord));
+        // b. If next is false, return list.
+        if (next === 'done') {
+          break;
+        }
+        // d. Append next as the last element of list.
+        precedingArgs.push(next);
+      }
+    } else {
+      const AssignmentExpression = element;
+      // 2. Let ref be the result of evaluating AssignmentExpression.
+      const ref = yield* Evaluate(AssignmentExpression);
+      // 3. Let arg be ? GetValue(ref).
+      const arg = Q(GetValue(ref));
+      // 4. Append arg to the end of precedingArgs.
+      precedingArgs.push(arg);
+      // 5. Return precedingArgs.
+    }
+  }
+  return precedingArgs as Arguments;
+}
+
+export function ArgumentListEvaluation(ArgumentsOrTemplateLiteral: ParseNode | ParseNode.Arguments) {
+  switch (true) {
+    case isArray(ArgumentsOrTemplateLiteral):
+      return ArgumentListEvaluation_Arguments(ArgumentsOrTemplateLiteral);
+    case ('type' in ArgumentsOrTemplateLiteral && ArgumentsOrTemplateLiteral.type === 'TemplateLiteral'):
+      return ArgumentListEvaluation_TemplateLiteral(ArgumentsOrTemplateLiteral);
+    default:
+      throw new OutOfRange('ArgumentListEvaluation', ArgumentsOrTemplateLiteral);
+  }
+}

package/src/runtime-semantics/ArrayLiteral.mts

@@ -0,0 +1,97 @@
+import { ObjectValue, Value } from '../value.mts';
+import {
+  Set,
+  ArrayCreate,
+  GetValue,
+  GetIterator,
+  ToString,
+  CreateDataPropertyOrThrow,
+  F,
+  IteratorStepValue,
+} from '../abstract-ops/all.mts';
+import { Evaluate, type Evaluator, type ExpressionEvaluator } from '../evaluator.mts';
+import {
+  ReturnIfAbrupt, Q, X, type PlainCompletion,
+} from '../completion.mts';
+import type { ParseNode } from '../parser/ParseNode.mts';
+
+/** https://tc39.es/ecma262/#sec-runtime-semantics-arrayaccumulation */
+//  Elision :
+//    `,`
+//    Elision `,`
+//  ElementList :
+//    Elision? AssignmentExpression
+//    Elision? SpreadElement
+//    ElementList `,` Elision? AssignmentExpression
+//    ElementList : ElementList `,` Elision SpreadElement
+//  SpreadElement :
+//    `...` AssignmentExpression
+function* ArrayAccumulation(ElementList: ParseNode.ElementList, array: ObjectValue, nextIndex: number): Evaluator<PlainCompletion<number>> {
+  let postIndex = nextIndex;
+  for (const element of ElementList) {
+    switch (element.type) {
+      case 'Elision':
+        postIndex += 1;
+        Q(Set(array, Value('length'), F(postIndex), Value.true));
+        break;
+      case 'SpreadElement':
+        postIndex = Q(yield* ArrayAccumulation_SpreadElement(element, array, postIndex));
+        break;
+      default:
+        postIndex = Q(yield* ArrayAccumulation_AssignmentExpression(element, array, postIndex));
+        break;
+    }
+  }
+  return postIndex;
+}
+
+// SpreadElement : `...` AssignmentExpression
+function* ArrayAccumulation_SpreadElement({ AssignmentExpression }: ParseNode.SpreadElement, array: ObjectValue, nextIndex: number): Evaluator<PlainCompletion<number>> {
+  // 1. Let spreadRef be the result of evaluating AssignmentExpression.
+  const spreadRef = yield* Evaluate(AssignmentExpression);
+  // 2. Let spreadObj be ? GetValue(spreadRef).
+  const spreadObj = Q(GetValue(spreadRef));
+  // 3. Let iteratorRecord be ? GetIterator(spreadObj).
+  const iteratorRecord = Q(GetIterator(spreadObj, 'sync'));
+  // 4. Repeat,
+  while (true) {
+    // a. Let next be ? IteratorStep(iteratorRecord).
+    const next = Q(IteratorStepValue(iteratorRecord));
+    // b. If next is done, return nextIndex.
+    if (next === 'done') {
+      return nextIndex;
+    }
+    // d. Perform ! CreateDataPropertyOrThrow(array, ! ToString(𝔽(nextIndex)), next).
+    X(CreateDataPropertyOrThrow(array, X(ToString(F(nextIndex))), next));
+    // e. Set nextIndex to nextIndex + 1.
+    nextIndex += 1;
+  }
+}
+
+
+function* ArrayAccumulation_AssignmentExpression(AssignmentExpression: ParseNode.AssignmentExpressionOrHigher, array: ObjectValue, nextIndex: number): Evaluator<PlainCompletion<number>> {
+  // 2. Let initResult be the result of evaluating AssignmentExpression.
+  const initResult = yield* Evaluate(AssignmentExpression);
+  // 3. Let initValue be ? GetValue(initResult).
+  const initValue = Q(GetValue(initResult));
+  // 4. Let created be ! CreateDataPropertyOrThrow(array, ! ToString(𝔽(nextIndex)), initValue).
+  X(CreateDataPropertyOrThrow(array, X(ToString(F(nextIndex))), initValue));
+  // 5. Return nextIndex + 1.
+  return nextIndex + 1;
+}
+
+/** https://tc39.es/ecma262/#sec-array-initializer-runtime-semantics-evaluation */
+//  ArrayLiteral :
+//    `[` Elision `]`
+//    `[` ElementList `]`
+//    `[` ElementList `,` Elision `]`
+export function* Evaluate_ArrayLiteral({ ElementList }: ParseNode.ArrayLiteral): ExpressionEvaluator {
+  // 1. Let array be ! ArrayCreate(0).
+  const array = X(ArrayCreate(0));
+  // 2. Let len be the result of performing ArrayAccumulation for ElementList with arguments array and 0.
+  const len = yield* ArrayAccumulation(ElementList, array, 0);
+  // 3. ReturnIfAbrupt(len).
+  ReturnIfAbrupt(len);
+  // 4. Return array.
+  return array;
+}

package/src/runtime-semantics/ArrowFunction.mts

@@ -0,0 +1,8 @@
+import type { ParseNode } from '../parser/ParseNode.mts';
+import { InstantiateArrowFunctionExpression } from './all.mts';
+
+/** https://tc39.es/ecma262/#sec-arrow-function-definitions-runtime-semantics-evaluation */
+export function Evaluate_ArrowFunction(ArrowFunction: ParseNode.ArrowFunction) {
+  // 1. Return InstantiateArrowFunctionExpression of ArrowFunction.
+  return InstantiateArrowFunctionExpression(ArrowFunction);
+}