@engine262/engine262 0.0.1-01e9fa95a4e8a1c042efd00492309a2de4998fd0

package/src/intrinsics/URIHandling.mts

@@ -0,0 +1,277 @@
+import { JSStringValue, Value, type Arguments } from '../value.mts';
+import { CodePointAt, UTF16EncodeCodePoint } from '../static-semantics/all.mts';
+import { Q, type ValueEvaluator } from '../completion.mts';
+import {
+  Assert,
+  CreateBuiltinFunction,
+  Realm,
+  Throw,
+  ToString,
+} from '#self';
+import type { CodePoint } from '#self';
+
+function utf8Encode(codepoint: CodePoint) {
+  if (codepoint <= 0x7F) {
+    return [codepoint];
+  }
+  if (codepoint <= 0x07FF) {
+    return [
+      (((codepoint >> 6) & 0x1F) | 0xC0),
+      (((codepoint >> 0) & 0x3F) | 0x80),
+    ];
+  }
+  if (codepoint <= 0xFFFF) {
+    return [
+      (((codepoint >> 12) & 0x0F) | 0xE0),
+      (((codepoint >> 6) & 0x3F) | 0x80),
+      (((codepoint >> 0) & 0x3F) | 0x80),
+    ];
+  }
+  if (codepoint <= 0x10FFFF) {
+    return [
+      (((codepoint >> 18) & 0x07) | 0xF0),
+      (((codepoint >> 12) & 0x3F) | 0x80),
+      (((codepoint >> 6) & 0x3F) | 0x80),
+      (((codepoint >> 0) & 0x3F) | 0x80),
+    ];
+  }
+  return null;
+}
+
+/** https://encoding.spec.whatwg.org/#utf-8-decoder */
+function utf8Decode(bytes: readonly number[]): CodePoint | null {
+  let codepoint = 0;
+  let index = 0;
+  let bytes_seen = 0;
+  let bytes_needed = 0;
+  let lower_boundary = 0x80;
+  let upper_boundary = 0xBF;
+
+  while (true) {
+    // If byte is end-of-queue and UTF-8 bytes needed is not 0, then set UTF-8 bytes needed to 0 and return error.
+    // If byte is end-of-queue, then return finished.
+    if (!bytes.length) {
+      if (bytes_needed === 0) {
+        return null;
+      }
+      return codepoint as CodePoint;
+    }
+
+    const byte = bytes[index];
+    if (bytes_needed === 0) {
+      if (byte >= 0x00 && byte <= 0x7F) {
+        return byte as CodePoint;
+      } else if (byte >= 0xC2 && byte <= 0xDF) {
+        bytes_needed = 1;
+        codepoint = byte & 0x1F;
+      } else if (byte >= 0xE0 && byte <= 0xEF) {
+        if (byte === 0xE0) {
+          lower_boundary = 0xA0;
+        }
+        if (byte === 0xED) {
+          upper_boundary = 0x9F;
+        }
+        bytes_needed = 2;
+        codepoint = byte & 0xF;
+      } else if (byte >= 0xF0 && byte <= 0xF4) {
+        if (byte === 0xF0) {
+          lower_boundary = 0x90;
+        }
+        if (byte === 0xF4) {
+          upper_boundary = 0x8F;
+        }
+        bytes_needed = 3;
+        codepoint = byte & 0x7;
+      } else {
+        return null;
+      }
+      index += 1;
+      continue;
+    }
+
+    if (byte < lower_boundary || byte > upper_boundary) {
+      return null;
+    }
+
+    lower_boundary = 0x80;
+    upper_boundary = 0xBF;
+
+    codepoint = (codepoint << 6) | (byte & 0x3F);
+    bytes_seen += 1;
+    index += 1;
+
+    if (bytes_seen === bytes_needed) {
+      return codepoint as CodePoint;
+    }
+  }
+}
+
+/** https://tc39.es/ecma262/#sec-encode */
+function Encode(_string: JSStringValue, extraUnescaped: string) {
+  const string = _string.stringValue();
+  const len = string.length;
+  let R = '';
+  const alwaysUnescaped = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789_-.!~*\'()';
+  const unescapedSet = alwaysUnescaped + extraUnescaped;
+  let k = 0;
+  while (k < len) {
+    // Let C be the code unit at index k within string.
+    const C = string[k];
+    if (unescapedSet.includes(C)) {
+      k += 1;
+      R += C;
+    } else {
+      const cp = CodePointAt(string, k);
+      if (cp.IsUnpairedSurrogate) {
+        return Throw.URIError('URI malformed');
+      }
+      k += cp.CodeUnitCount;
+      // Let Octets be the List of octets resulting by applying the UTF-8 transformation to cp.[[CodePoint]].
+      const Octets = utf8Encode(cp.CodePoint)!;
+      Octets.forEach((octet) => {
+        const hex = octet.toString(16).toUpperCase().padStart(2, '0');
+        R = `${R}%${hex}`;
+      });
+    }
+  }
+  return Value(R);
+}
+
+/** https://tc39.es/ecma262/#sec-decode */
+function Decode(_string: JSStringValue, preserveEscapeSet: string) {
+  const string = _string.stringValue();
+  const len = string.length;
+  let R = '';
+  let k = 0;
+  while (k < len) {
+    // Let C be the code unit at index k within string.
+    const C = string[k];
+    let S = C;
+    if (C === '\u{0025}') {
+      if (k + 3 > len) {
+        return Throw.URIError('URI malformed');
+      }
+      const escape = string.substring(k, k + 3);
+      const B = ParseHexOctet(string, k + 1);
+      if (typeof B !== 'number') {
+        return Throw.URIError('URI malformed');
+      }
+      k += 2;
+      // Let n be the number of leading 1 bits in B.
+      const n = B.toString(2).padStart(8, '0').match(/^1+/)?.[0].length || 0;
+      if (n === 0) {
+        // Let asciiChar be the code unit whose numeric value is B.
+        const asciiChar = String.fromCharCode(B);
+        if (preserveEscapeSet.includes(asciiChar)) {
+          S = escape;
+        } else {
+          S = asciiChar;
+        }
+      } else {
+        if (n === 1 || n > 4) {
+          return Throw.URIError('URI malformed');
+        }
+        const Octets = [B];
+        let j = 1;
+        while (j < n) {
+          k += 1;
+          if (k + 3 > len) {
+            return Throw.URIError('URI malformed');
+          }
+          // If the code unit at index k within string is not U+0025 PERCENT SIGN (%),
+          if (string[k] !== '\u{0025}') {
+            return Throw.URIError('URI malformed');
+          }
+          const continuationByte = ParseHexOctet(string, k + 1);
+          if (typeof continuationByte !== 'number') {
+            return Throw.URIError('URI malformed');
+          }
+          Octets.push(continuationByte);
+          k += 2;
+          j += 1;
+        }
+        Assert(Octets.length === n);
+        // If Octets does not contain a valid UTF-8 encoding of a Unicode code point, ...
+        // Let V be the code point obtained by applying the UTF-8 transformation to Octets, that is, from a List of octets into a 21-bit value.
+        const V = utf8Decode(Octets);
+        if (V === null) {
+          return Throw.URIError('URI malformed');
+        }
+        S = UTF16EncodeCodePoint(V);
+      }
+    }
+    R += S;
+    k += 1;
+  }
+  return Value(R);
+}
+
+function ParseHexOctet(string: string, position: number): number | string[] {
+  const len = string.length;
+  Assert(position + 2 <= len);
+  const hexDigits = string.substring(position, position + 2);
+  // Let parseResult be ParseText(hexDigits, HexDigits[~Sep]).
+  // If parseResult is not a Parse Node, return parseResult.
+  if (!/^[0-9A-Fa-f]{2}$/.test(hexDigits)) {
+    return [];
+  }
+  const parseResult = parseInt(hexDigits, 16);
+  if (Number.isNaN(parseResult)) {
+    return [];
+  }
+  const n = parseResult;
+  // eslint-disable-next-line yoda
+  Assert(0 <= n && n <= 255);
+  return n;
+}
+
+/** https://tc39.es/ecma262/#sec-decodeuri-encodeduri */
+function* decodeURI([encodedURI = Value.undefined]: Arguments): ValueEvaluator {
+  // 1. Let uriString be ? ToString(encodedURI).
+  const uriString = Q(yield* ToString(encodedURI));
+  // 2. Let preserveEscapeSet be ";/?:@&=+$,#".
+  const preserveEscapeSet = ';/?:@&=+$,#';
+  // 3. Return ? Decode(uriString, reservedURISet).
+  return Q(Decode(uriString, preserveEscapeSet));
+}
+
+/** https://tc39.es/ecma262/#sec-decodeuricomponent-encodeduricomponent */
+function* decodeURIComponent([encodedURIComponent = Value.undefined]: Arguments): ValueEvaluator {
+  // 1. Let componentString be ? ToString(encodedURIComponent).
+  const componentString = Q(yield* ToString(encodedURIComponent));
+  // 2. Let preserveEscapeSet be the empty String.
+  const preserveEscapeSet = '';
+  // 3. Return ? Decode(componentString, reservedURIComponentSet).
+  return Q(Decode(componentString, preserveEscapeSet));
+}
+
+/** https://tc39.es/ecma262/#sec-encodeuri-uri */
+function* encodeURI([uri = Value.undefined]: Arguments): ValueEvaluator {
+  // 1. Let uriString be ? ToString(uri).
+  const uriString = Q(yield* ToString(uri));
+  // 2. Let extraUnescaped be ";/?:@&=+$,#".
+  const extraUnescaped = ';/?:@&=+$,#';
+  // 3. Return ? Encode(uriString, unescapedURISet).
+  return Q(Encode(uriString, extraUnescaped));
+}
+
+/** https://tc39.es/ecma262/#sec-encodeuricomponent-uricomponent */
+function* encodeURIComponent([uriComponent = Value.undefined]: Arguments): ValueEvaluator {
+  // 1. Let componentString be ? ToString(uriComponent).
+  const componentString = Q(yield* ToString(uriComponent));
+  // 2. Let extraUnescaped be the empty String.
+  const extraUnescaped = '';
+  // 3. Return ? Encode(componentString, unescapedURIComponentSet).
+  return Q(Encode(componentString, extraUnescaped));
+}
+
+export function bootstrapURIHandling(realmRec: Realm) {
+  ([
+    ['decodeURI', decodeURI, 1],
+    ['decodeURIComponent', decodeURIComponent, 1],
+    ['encodeURI', encodeURI, 1],
+    ['encodeURIComponent', encodeURIComponent, 1],
+  ] as const).forEach(([name, f, length]) => {
+    realmRec.Intrinsics[`%${name}%`] = CreateBuiltinFunction(f, length, Value(name), [], realmRec);
+  });
+}

package/src/intrinsics/WeakMap.mts

@@ -0,0 +1,56 @@
+import {
+  UndefinedValue,
+  Value,
+  type Arguments,
+  type FunctionCallContext,
+} from '../value.mts';
+import {
+  Q,
+} from '../completion.mts';
+import type { Mutable } from '../utils/language.mts';
+import { AddEntriesFromIterable } from './Map.mts';
+import { bootstrapConstructor } from './bootstrap.mts';
+import {
+  Get,
+  IsCallable,
+  OrdinaryCreateFromConstructor,
+  Realm,
+  Throw,
+  type FunctionObject,
+  type OrdinaryObject,
+} from '#self';
+
+export interface WeakMapObject extends OrdinaryObject {
+  readonly WeakMapData: { Key: Value | undefined; Value: Value | undefined; }[];
+}
+export function isWeakMapObject(object: object): object is WeakMapObject {
+  return 'WeakMapData' in object;
+}
+/** https://tc39.es/ecma262/#sec-weakmap-constructor */
+function* WeakMapConstructor(this: FunctionObject, [iterable = Value.undefined]: Arguments, { NewTarget }: FunctionCallContext) {
+  // 1. If NewTarget is undefined, throw a TypeError exception.
+  if (NewTarget instanceof UndefinedValue) {
+    return Throw.TypeError('WeakMap cannot be invoked without new');
+  }
+  // 2. Let map be ? OrdinaryCreateFromConstructor(NewTarget, "%WeakMap.prototype%", « [[WeakMapData]] »).
+  const map = Q(yield* OrdinaryCreateFromConstructor(NewTarget, '%WeakMap.prototype%', ['WeakMapData'])) as Mutable<WeakMapObject>;
+  // 3. Set map.[[WeakMapData]] to a new empty List.
+  map.WeakMapData = [];
+  // 4. If iterable is either undefined or null, return map.
+  if (iterable === Value.undefined || iterable === Value.null) {
+    return map;
+  }
+  // 5. Let adder be ? Get(map, "set").
+  const adder = Q(yield* Get(map, Value('set')));
+  if (!IsCallable(adder)) {
+    return Throw.TypeError('"set" property ($1) of object $2 is not a function', adder, map);
+  }
+  // 6. Return ? AddEntriesFromIterable(map, iterable, adder).
+  return Q(yield* AddEntriesFromIterable(map, iterable, adder));
+}
+
+export function bootstrapWeakMap(realmRec: Realm) {
+  const c = bootstrapConstructor(realmRec, WeakMapConstructor, 'WeakMap', 0, realmRec.Intrinsics['%WeakMap.prototype%'], []);
+
+  realmRec.Intrinsics['%WeakMap%'] = c;
+}

package/src/intrinsics/WeakMapPrototype.mts

@@ -0,0 +1,203 @@
+import {
+  Value,
+  type Arguments,
+  type FunctionCallContext,
+} from '../value.mts';
+import { Q, type ValueCompletion, type ValueEvaluator } from '../completion.mts';
+import { bootstrapPrototype } from './bootstrap.mts';
+import type { WeakMapObject } from './WeakMap.mts';
+import {
+  surroundingAgent,
+  Call,
+  IsCallable,
+  SameValue,
+  RequireInternalSlot,
+  CanBeHeldWeakly,
+  Realm,
+  Throw,
+} from '#self';
+
+/** https://tc39.es/ecma262/#sec-weakmap.prototype.delete */
+function WeakMapProto_delete([key = Value.undefined]: Arguments, { thisValue }: FunctionCallContext): ValueCompletion {
+  // 1. Let M be the this value.
+  const M = thisValue as WeakMapObject;
+  // 2. Perform ? RequireInternalSlot(M, [[WeakMapData]]).
+  Q(RequireInternalSlot(M, 'WeakMapData'));
+  // 3. If CanBeHeldWeakly(key) is false, return false.
+  if (!CanBeHeldWeakly(key)) {
+    return Value.false;
+  }
+  // 4. For each Record { [[Key]], [[Value]] } p that is an element of entries, do
+  const entries = M.WeakMapData;
+  for (let i = 0; i < entries.length; i += 1) {
+    const p = entries[i];
+    // a. If p.[[Key]] is not empty and SameValue(p.[[Key]], key) is true, then
+    if (p.Key !== undefined && SameValue(p.Key, key)) {
+      // i. Set p.[[Key]] to empty.
+      Q(surroundingAgent.debugger_tryTouchDuringPreview(M));
+      p.Key = undefined;
+      // ii. Set p.[[Value]] to empty.
+      p.Value = undefined;
+      // iii. return true.
+      return Value.true;
+    }
+  }
+  // 5. Return false.
+  return Value.false;
+}
+
+/** https://tc39.es/ecma262/#sec-weakmap.prototype.get */
+function WeakMapProto_get([key = Value.undefined]: Arguments, { thisValue }: FunctionCallContext): ValueCompletion {
+  // 1. Let m be the this value.
+  const M = thisValue as WeakMapObject;
+  // 2. Perform ? RequireInternalSlot(M, [[WeakMapData]]).
+  Q(RequireInternalSlot(M, 'WeakMapData'));
+  // 3. If CanBeHeldWeakly(key) is false, return false.
+  if (!CanBeHeldWeakly(key)) {
+    return Value.undefined;
+  }
+  // 4. For each Record { [[Key]], [[Value]] } p of M.[[WeakMapData]], do
+  const entries = M.WeakMapData;
+  for (const p of entries) {
+    // a. If p.[[Key]] is not empty and SameValue(p.[[Key]], key) is true, return p.[[Value]].
+    if (p.Key !== undefined && SameValue(p.Key, key)) {
+      return p.Value!;
+    }
+  }
+  // 6. Return undefined.
+  return Value.undefined;
+}
+
+/** https://tc39.es/ecma262/#sec-weakmap.prototype.getorinsert */
+function WeakMapProto_getOrInsert([key = Value.undefined, value = Value.undefined]: Arguments, { thisValue }: FunctionCallContext): ValueCompletion {
+  // 1. Let m be the this value.
+  const M = thisValue as WeakMapObject;
+  // 2. Perform ? RequireInternalSlot(M, [[WeakMapData]]).
+  Q(RequireInternalSlot(M, 'WeakMapData'));
+  // 3. If CanBeHeldWeakly(key) is false, throw a TypeError exception.
+  if (!CanBeHeldWeakly(key)) {
+    return Throw.TypeError('$1 cannot be used as a WeakMap key', key);
+  }
+  // 4. For each Record { [[Key]], [[Value]] } p of M.[[WeakMapData]], do
+  const entries = M.WeakMapData;
+  for (const p of entries) {
+    // a. If p.[[Key]] is not empty and SameValue(p.[[Key]], key) is true, return p.[[Value]].
+    if (p.Key !== undefined && SameValue(p.Key, key)) {
+      return p.Value!;
+    }
+  }
+  // 5. Let p be the Record { [[Key]]: key, [[Value]]: value }.
+  const p = { Key: key, Value: value };
+  // 6. Append p to M.[[WeakMapData]].
+  entries.push(p);
+  // 7. Return value.
+  return value;
+}
+
+/** https://tc39.es/ecma262/#sec-weakmap.prototype.getorinsertcomputed */
+function* WeakMapProto_getOrInsertComputed([key = Value.undefined, callbackfn = Value.undefined]: Arguments, { thisValue }: FunctionCallContext): ValueEvaluator {
+  // 1. Let m be the this value.
+  const M = thisValue as WeakMapObject;
+  // 2. Perform ? RequireInternalSlot(M, [[WeakMapData]]).
+  Q(RequireInternalSlot(M, 'WeakMapData'));
+  // 3. If CanBeHeldWeakly(key) is false, throw a TypeError exception.
+  if (!CanBeHeldWeakly(key)) {
+    return Throw.TypeError('$1 cannot be weakly referenced', key);
+  }
+  // 4. If IsCallable(callbackfn) is false, throw a TypeError exception.
+  if (!IsCallable(callbackfn)) {
+    return Throw.TypeError('callbackfn ($1) is not a function', callbackfn);
+  }
+  // 5. For each Record { [[Key]], [[Value]] } p of M.[[WeakMapData]], do
+  const entries = M.WeakMapData;
+  for (const p of entries) {
+    // a. If p.[[Key]] is not empty and SameValue(p.[[Key]], key) is true, return p.[[Value]].
+    if (p.Key !== undefined && SameValue(p.Key, key)) {
+      return p.Value!;
+    }
+  }
+  // 6. Let value be ? Call(callbackfn, undefined, « key »).
+  const value = Q(yield* Call(callbackfn, Value.undefined, [key]));
+  // 7. NOTE: The Map may have been modified during execution of callbackfn.
+  // 8. For each Record { [[Key]], [[Value]] } p of M.[[WeakMapData]], do
+  for (const p of entries) {
+    // a. If p.[[Key]] is not empty and SameValue(p.[[Key]], key) is true, then
+    if (p.Key !== undefined && SameValue(p.Key, key)) {
+      // i. Set p.[[Value]] to value.
+      p.Value = value;
+      // ii. Return value.
+      return value;
+    }
+  }
+  // 9. Let p be the Record { [[Key]]: key, [[Value]]: value }.
+  const p = { Key: key, Value: value };
+  // 10. Append p to M.[[WeakMapData]].
+  entries.push(p);
+  // 11. Return value.
+  return value;
+}
+
+/** https://tc39.es/ecma262/#sec-weakmap.prototype.has */
+function WeakMapProto_has([key = Value.undefined]: Arguments, { thisValue }: FunctionCallContext): ValueCompletion {
+  // 1. Let M be the this value.
+  const M = thisValue as WeakMapObject;
+  // 2. Perform ? RequireInternalSlot(M, [[WeakMapData]]).
+  Q(RequireInternalSlot(M, 'WeakMapData'));
+  // 3. If CanBeHeldWeakly(key) is false, return false.
+  if (!CanBeHeldWeakly(key)) {
+    return Value.false;
+  }
+  // 4. For each Record { [[Key]], [[Value]] } p of M.[[WeakMapData]], do
+  const entries = M.WeakMapData;
+  for (const p of entries) {
+    // a. If p.[[Key]] is not empty and SameValue(p.[[Key]], key) is true, return true.
+    if (p.Key !== undefined && SameValue(p.Key, key)) {
+      return Value.true;
+    }
+  }
+  // 6. Return false.
+  return Value.false;
+}
+
+/** https://tc39.es/ecma262/#sec-weakmap.prototype.set */
+function WeakMapProto_set([key = Value.undefined, value = Value.undefined]: Arguments, { thisValue }: FunctionCallContext): ValueCompletion {
+  // 1. Let M be the this value.
+  const M = thisValue as WeakMapObject;
+  // 2. Perform ? RequireInternalSlot(M, [[WeakMapData]]).
+  Q(RequireInternalSlot(M, 'WeakMapData'));
+  // 3. If CanBeHeldWeakly(key) is false, throw a TypeError exception.
+  if (!CanBeHeldWeakly(key)) {
+    return Throw.TypeError('$1 cannot be weakly referenced', key);
+  }
+  // 4. For each Record { [[Key]], [[Value]] } p that is an element of entries, do
+  const entries = M.WeakMapData;
+  for (const p of entries) {
+    // a. If p.[[Key]] is not empty and SameValue(p.[[Key]], key) is true, then
+    if (p.Key !== undefined && SameValue(p.Key, key)) {
+      // i. Set p.[[Value]] to value.
+      Q(surroundingAgent.debugger_tryTouchDuringPreview(M));
+      p.Value = value;
+      // ii. Return M.
+      return M;
+    }
+  }
+  // 5. Let p be the Record { [[Key]]: key, [[Value]]: value }.
+  const p = { Key: key, Value: value };
+  // 7. Append p as the last element of entries.
+  entries.push(p);
+  // 7. Return M.
+  return M;
+}
+
+export function bootstrapWeakMapPrototype(realmRec: Realm) {
+  const proto = bootstrapPrototype(realmRec, [
+    ['delete', WeakMapProto_delete, 1],
+    ['get', WeakMapProto_get, 1],
+    ['getOrInsert', WeakMapProto_getOrInsert, 2],
+    ['getOrInsertComputed', WeakMapProto_getOrInsertComputed, 2],
+    ['has', WeakMapProto_has, 1],
+    ['set', WeakMapProto_set, 2],
+  ], realmRec.Intrinsics['%Object.prototype%'], 'WeakMap');
+
+  realmRec.Intrinsics['%WeakMap.prototype%'] = proto;
+}

package/src/intrinsics/WeakRef.mts

@@ -0,0 +1,43 @@
+import {
+  ObjectValue,
+  SymbolValue,
+  UndefinedValue, Value, type Arguments, type FunctionCallContext,
+} from '../value.mts';
+import { Q } from '../completion.mts';
+import type { Mutable } from '../utils/language.mts';
+import { bootstrapConstructor } from './bootstrap.mts';
+import {
+  AddToKeptObjects, CanBeHeldWeakly, OrdinaryCreateFromConstructor, Realm, Throw, type FunctionObject, type OrdinaryObject,
+} from '#self';
+
+export interface WeakRefObject extends OrdinaryObject {
+  WeakRefTarget: ObjectValue | SymbolValue | undefined;
+}
+export function isWeakRef(object: object): object is WeakRefObject {
+  return 'WeakRefTarget' in object && !('HeldValue' in object);
+}
+/** https://tc39.es/ecma262/#sec-weak-ref-target */
+function* WeakRefConstructor(this: FunctionObject, [target = Value.undefined]: Arguments, { NewTarget }: FunctionCallContext) {
+  // 1. If NewTarget is undefined, throw a TypeError exception.
+  if (NewTarget instanceof UndefinedValue) {
+    return Throw.TypeError('WeakRef cannot be invoked without new');
+  }
+  // 2. If CanBeHeldWeakly(target) is false, throw a TypeError exception.
+  if (!CanBeHeldWeakly(target)) {
+    return Throw.TypeError('$1 cannot be weakly referenced', target);
+  }
+  // 3. Let weakRef be ? OrdinaryCreateFromConstructor(NewTarget, "%WeakRefPrototype%", « [[WeakRefTarget]] »).
+  const weakRef = Q(yield* OrdinaryCreateFromConstructor(NewTarget, '%WeakRef.prototype%', ['WeakRefTarget'])) as Mutable<WeakRefObject>;
+  // 4. Perform ! AddToKeptObjects(target).
+  AddToKeptObjects(target);
+  // 5. Set weakRef.[[WeakRefTarget]] to target.
+  weakRef.WeakRefTarget = target;
+  // 6. Return weakRef
+  return weakRef;
+}
+
+export function bootstrapWeakRef(realmRec: Realm) {
+  const weakRefConstructor = bootstrapConstructor(realmRec, WeakRefConstructor, 'WeakRef', 1, realmRec.Intrinsics['%WeakRef.prototype%'], []);
+
+  realmRec.Intrinsics['%WeakRef%'] = weakRefConstructor;
+}

package/src/intrinsics/WeakRefPrototype.mts

@@ -0,0 +1,23 @@
+import { Q, X } from '../completion.mts';
+import { bootstrapPrototype } from './bootstrap.mts';
+import type { WeakRefObject } from './WeakRef.mts';
+import { Realm, RequireInternalSlot, WeakRefDeref } from '#self';
+import type { Arguments, ValueCompletion, FunctionCallContext } from '#self';
+
+/** https://tc39.es/ecma262/#sec-weak-ref.prototype.deref */
+function WeakRefProto_deref(_args: Arguments, { thisValue }: FunctionCallContext): ValueCompletion {
+  // 1. Let weakRef be the this value.
+  const weakRef = thisValue as WeakRefObject;
+  // 2. Perform ? RequireInternalSlot(weakRef, [[WeakRefTarget]]).
+  Q(RequireInternalSlot(weakRef, 'WeakRefTarget'));
+  // 3. Return ! WeakRefDeref(weakRef).
+  return X(WeakRefDeref(weakRef));
+}
+
+export function bootstrapWeakRefPrototype(realmRec: Realm) {
+  const proto = bootstrapPrototype(realmRec, [
+    ['deref', WeakRefProto_deref, 0],
+  ], realmRec.Intrinsics['%Object.prototype%'], 'WeakRef');
+
+  realmRec.Intrinsics['%WeakRef.prototype%'] = proto;
+}

package/src/intrinsics/WeakSet.mts

@@ -0,0 +1,66 @@
+import {
+  UndefinedValue, Value, type Arguments, type FunctionCallContext,
+} from '../value.mts';
+import { IfAbruptCloseIterator, Q } from '../completion.mts';
+import type { Mutable } from '../utils/language.mts';
+import { bootstrapConstructor } from './bootstrap.mts';
+import {
+  IsCallable,
+  OrdinaryCreateFromConstructor,
+  Call,
+  Get,
+  GetIterator,
+  type OrdinaryObject,
+  Realm,
+  Throw,
+  type FunctionObject,
+  IteratorStepValue,
+} from '#self';
+
+export interface WeakSetObject extends OrdinaryObject {
+  readonly WeakSetData: (Value | undefined)[];
+}
+export function isWeakSetObject(object: object): object is WeakSetObject {
+  return 'WeakSetData' in object;
+}
+/** https://tc39.es/ecma262/#sec-weakset-iterable */
+function* WeakSetConstructor(this: FunctionObject, [iterable = Value.undefined]: Arguments, { NewTarget }: FunctionCallContext) {
+  // 1. If NewTarget is undefined, throw a TypeError exception.
+  if (NewTarget instanceof UndefinedValue) {
+    return Throw.TypeError('WeakSet cannot be invoked without new');
+  }
+  // 2. Let set be ? OrdinaryCreateFromConstructor(NewTarget, "%WeakSet.prototype%", « [[WeakSetData]] »).
+  const set = Q(yield* OrdinaryCreateFromConstructor(NewTarget, '%WeakSet.prototype%', ['WeakSetData'])) as Mutable<WeakSetObject>;
+  // 3. Set set.[[WeakSetData]] to a new empty List.
+  set.WeakSetData = [];
+  // 4. If iterable is either undefined or null, return set.
+  if (iterable === Value.undefined || iterable === Value.null) {
+    return set;
+  }
+  // 5. Let adder be ? Get(set, "add").
+  const adder = Q(yield* Get(set, Value('add')));
+  // 6. If IsCallable(adder) is false, throw a TypeError exception.
+  if (!IsCallable(adder)) {
+    return Throw.TypeError('"add" property ($1) of object $2 is not a function', adder, set);
+  }
+  // 7. Let iteratorRecord be ? GetIterator(iterable).
+  const iteratorRecord = Q(yield* GetIterator(iterable, 'sync'));
+  // 8. Repeat,
+  while (true) {
+    // a. Let next be ? IteratorStep(iteratorRecord).
+    const next = Q(yield* IteratorStepValue(iteratorRecord));
+    // b. If next is false, return set.
+    if (next === 'done') {
+      return set;
+    }
+    // d. Let status be Call(adder, set, « next »).
+    const status = yield* Call(adder, set, [next]);
+    // e. IfAbruptCloseIterator(status, iteratorRecord).
+    IfAbruptCloseIterator(status, iteratorRecord);
+  }
+}
+
+export function bootstrapWeakSet(realmRec: Realm) {
+  const c = bootstrapConstructor(realmRec, WeakSetConstructor, 'WeakSet', 0, realmRec.Intrinsics['%WeakSet.prototype%'], []);
+  realmRec.Intrinsics['%WeakSet%'] = c;
+}