@engine262/engine262 0.0.1-07c72085c73f960bcf0aa06db807321f3b446518

package/src/intrinsics/URIHandling.mts

@@ -0,0 +1,321 @@
+import { surroundingAgent } from '../engine.mts';
+import { JSStringValue, Value, type Arguments } from '../value.mts';
+import {
+  Assert,
+  CreateBuiltinFunction,
+  Realm,
+  ToString,
+} from '../abstract-ops/all.mts';
+import { CodePointAt } from '../static-semantics/all.mts';
+import { isHexDigit } from '../parser/Lexer.mts';
+import { Q, X, type ExpressionCompletion } from '../completion.mts';
+
+function utf8Encode(utf: number) {
+  if (utf <= 0x7F) {
+    return [utf];
+  }
+  if (utf <= 0x07FF) {
+    return [
+      (((utf >> 6) & 0x1F) | 0xC0),
+      (((utf >> 0) & 0x3F) | 0x80),
+    ];
+  }
+  if (utf <= 0xFFFF) {
+    return [
+      (((utf >> 12) & 0x0F) | 0xE0),
+      (((utf >> 6) & 0x3F) | 0x80),
+      (((utf >> 0) & 0x3F) | 0x80),
+    ];
+  }
+  if (utf <= 0x10FFFF) {
+    return [
+      (((utf >> 18) & 0x07) | 0xF0),
+      (((utf >> 12) & 0x3F) | 0x80),
+      (((utf >> 6) & 0x3F) | 0x80),
+      (((utf >> 0) & 0x3F) | 0x80),
+    ];
+  }
+  return null;
+}
+
+function utf8Decode(octets: readonly number[]) {
+  const b0 = octets[0];
+  if (b0 <= 0x7F) {
+    return b0;
+  }
+  if (b0 < 0xC2 || b0 > 0xF4) {
+    return null;
+  }
+  const b1 = octets[1];
+
+  switch (b0) {
+    case 0xE0:
+      if (b1 < 0xA0 || b1 > 0xBF) {
+        return null;
+      }
+      break;
+    case 0xED:
+      if (b1 < 0x80 || b1 > 0x9F) {
+        return null;
+      }
+      break;
+    case 0xF0:
+      if (b1 < 0x90 || b1 > 0xBF) {
+        return null;
+      }
+      break;
+    case 0xF4:
+      if (b1 < 0x80 || b1 > 0x8F) {
+        return null;
+      }
+      break;
+    default:
+      if (b1 < 0x80 || b1 > 0xBF) {
+        return null;
+      }
+      break;
+  }
+
+  if (b0 <= 0xDF) {
+    return ((b0 & 0x1F) << 6)
+      | (b0 & 0x3F);
+  }
+
+  const b2 = octets[2];
+  if (b2 < 0x80 || b2 > 0xBF) {
+    return null;
+  }
+  if (b0 <= 0xEF) {
+    return ((b0 & 0x0F) << 12)
+      | ((b1 & 0x3F) << 6)
+      | (b2 & 0x3F);
+  }
+
+  const b3 = octets[3];
+  if (b3 < 0x80 || b3 > 0xBF) {
+    return null;
+  }
+
+  return ((b0 & 0x07) << 18)
+    | ((b1 & 0x3F) << 12)
+    | ((b2 & 0x3F) << 6)
+    | (b3 & 0x3F);
+}
+
+const uriReserved = ';/?:@&=+$,';
+const uriAlpha = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ';
+const uriMark = '-_.!~*\'()';
+const DecimalDigit = '0123456789';
+const uriUnescaped = uriAlpha + DecimalDigit + uriMark;
+
+/** https://tc39.es/ecma262/#sec-encode */
+function Encode(_string: JSStringValue, unescapedSet: string) {
+  const string = _string.stringValue();
+  // 1. Let strLen be the number of code units in string.
+  const strLen = string.length;
+  // 2. Let R be the empty String.
+  let R = '';
+  // 3. Let k be 0.
+  let k = 0;
+  // 4. Repeat,
+  while (true) {
+    // a. If k equals strLen, return R.
+    if (k === strLen) {
+      return Value(R);
+    }
+    // b. Let C be the code unit at index k within string.
+    const C = string[k];
+    // c. If C is in unescapedSet, then
+    if (unescapedSet.includes(C)) {
+      // i. Set k to k + 1.
+      k += 1;
+      // ii. Set R to the string-concatenation of the previous value of R and C.
+      R = `${R}${C}`;
+    } else { // d. Else,
+      // i. Let cp be ! CodePointAt(string, k).
+      const cp = X(CodePointAt(string, k));
+      // ii. If cp.[[IsUnpairedSurrogate]] is true, throw a URIError exception.
+      if (cp.IsUnpairedSurrogate) {
+        return surroundingAgent.Throw('URIError', 'URIMalformed');
+      }
+      // iii. Set k to k + cp.[[CodeUnitCount]].
+      k += cp.CodeUnitCount;
+      // iv. Let Octets be the List of octets resulting by applying the UTF-8 transformation to cp.[[CodePoint]].
+      const Octets = utf8Encode(cp.CodePoint)!;
+      // v. For each element octet of Octets in List order, do
+      Octets.forEach((octet) => {
+        // 1. Set R to the string-concatenation of:
+        //   * the previous value of R
+        //   * "%"
+        //   * the String representation of octet, formatted as a two-digit uppercase hexadecimal number, padded to the left with a zero if necessary
+        R = `${R}%${octet.toString(16).toUpperCase().padStart(2, '0')}`;
+      });
+    }
+  }
+}
+
+/** https://tc39.es/ecma262/#sec-decode */
+function Decode(_string: JSStringValue, reservedSet: string) {
+  const string = _string.stringValue();
+  // 1. Let strLen be the number of code units in string.
+  const strLen = string.length;
+  // 2. Let R be the empty String.
+  let R = '';
+  // 3. Let k be 0.
+  let k = 0;
+  // 4. Repeat,
+  while (true) {
+    // a. If k equals strLen, return R.
+    if (k === strLen) {
+      return Value(R);
+    }
+    // b. Let C be the code unit at index k within string.
+    const C = string[k];
+    let S;
+    // c. If C is not the code unit 0x0025 (PERCENT SIGN), then
+    if (C !== '\u{0025}') {
+      S = C;
+    } else { // d. Else,
+      // i. Let start be k.
+      const start = k;
+      // ii. If k + 2 is greater than or equal to strLen, throw a URIError exception.
+      if (k + 2 >= strLen) {
+        return surroundingAgent.Throw('URIError', 'URIMalformed');
+      }
+      // iii. If the code units at index (k + 1) and (k + 2) within string do not represent hexadecimal digits, throw a URIError exception.
+      if (!isHexDigit(string[k + 1]) || !isHexDigit(string[k + 2])) {
+        return surroundingAgent.Throw('URIError', 'URIMalformed');
+      }
+      // iv. Let B be the 8-bit value represented by the two hexadecimal digits at index (k + 1) and (k + 2).
+      const B = Number.parseInt(string.slice(k + 1, k + 3), 16);
+      // v. Set k to k + 2.
+      k += 2;
+      // vi. If the most significant bit in B is 0, then
+      if ((B & 0b10000000) === 0) {
+        // 1. Let C be the code unit whose value is B.
+        const innerC = String.fromCharCode(B);
+        // 2. If C is not in reservedSet, then
+        if (!reservedSet.includes(C)) {
+          // a. Let S be the String value containing only the code unit C.
+          S = innerC;
+        } else { // 3. Else,
+          // a. Let S be the substring of string from index start to index k inclusive.
+          S = string.slice(start, k + 1);
+        }
+      } else { // vii. Else,
+        // 1. Assert: the most significant bit in B is 1.
+        Assert(!!(B & 0b10000000));
+        // 2. Let n be the smallest nonnegative integer such that (B << n) & 0x80 is equal to 0.
+        let n = 0;
+        while (((B << n) & 0x80) !== 0) {
+          n += 1;
+          if (n > 4) {
+            break;
+          }
+        }
+        // 3. If n equals 1 or n is greater than 4, throw a URIError exception.
+        if (n === 1 || n > 4) {
+          return surroundingAgent.Throw('URIError', 'URIMalformed');
+        }
+        // 4. Let Octets be a List of 8-bit integers of size n.
+        const Octets = [];
+        // 5. Set Octets[0] to B.
+        Octets[0] = B;
+        // 6. If k + (3 × (n - 1)) is greater than or equal to strLen, throw a URIError exception.
+        if (k + (3 * (n - 1)) >= strLen) {
+          return surroundingAgent.Throw('URIError', 'URIMalformed');
+        }
+        // 7. Let j be 1.
+        let j = 1;
+        // 8. Repeat, while j < n,
+        while (j < n) {
+          // a. Set k to k + 1.
+          k += 1;
+          // b. If the code unit at index k within string is not the code unit 0x0025 (PERCENT SIGN), throw a URIError exception.
+          if (string[k] !== '\u{0025}') {
+            return surroundingAgent.Throw('URIError', 'URIMalformed');
+          }
+          // c. If the code units at index (k + 1) and (k + 2) within string do not represent hexadecimal digits, throw a URIError exception.
+          if (!isHexDigit(string[k + 1]) || !isHexDigit(string[k + 2])) {
+            return surroundingAgent.Throw('URIError', 'URIMalformed');
+          }
+          // d. Let B be the 8-bit value represented by the two hexadecimal digits at index (k + 1) and (k + 2).
+          const innerB = Number.parseInt(string.slice(k + 1, k + 3), 16);
+          // e. If the two most significant bits in B are not 10, throw a URIError exception.
+          if (innerB >> 6 !== 0b10) {
+            return surroundingAgent.Throw('URIError', 'URIMalformed');
+          }
+          // f. Set k to k + 2.
+          k += 2;
+          // g. Set Octets[j] to B.
+          Octets[j] = innerB;
+          // h. Set j to j + 1.
+          j += 1;
+        }
+        // 9. If Octets does not contain a valid UTF-8 encoding of a Unicode code point, throw a URIError exception.
+        // 10. Let V be the value 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 surroundingAgent.Throw('URIError', 'URIMalformed');
+        }
+        // 11. Let S be the String value whose code units are, in order, the elements in UTF16Encoding(V).
+        S = String.fromCodePoint(V);
+      }
+    }
+    // e. Set R to the string-concatenation of the previous value of R and S.
+    R = `${R}${S}`;
+    // f. Set k to k + 1.
+    k += 1;
+  }
+}
+
+/** https://tc39.es/ecma262/#sec-decodeuri-encodeduri */
+function decodeURI([encodedURI = Value.undefined]: Arguments): ExpressionCompletion {
+  // 1. Let uriString be ? ToString(encodedURI).
+  const uriString = Q(ToString(encodedURI));
+  // 2. Let reservedURISet be a String containing one instance of each code unit valid in uriReserved plus "#".
+  const reservedURISet = `${uriReserved}#`;
+  // 3. Return ? Decode(uriString, reservedURISet).
+  return Q(Decode(uriString, reservedURISet));
+}
+
+/** https://tc39.es/ecma262/#sec-decodeuricomponent-encodeduricomponent */
+function decodeURIComponent([encodedURIComponent = Value.undefined]: Arguments): ExpressionCompletion {
+  // 1. Let componentString be ? ToString(encodedURIComponent).
+  const componentString = Q(ToString(encodedURIComponent));
+  // 2. Let reservedURIComponentSet be the empty String.
+  const reservedURIComponentSet = '';
+  // 3. Return ? Decode(componentString, reservedURIComponentSet).
+  return Q(Decode(componentString, reservedURIComponentSet));
+}
+
+/** https://tc39.es/ecma262/#sec-encodeuri-uri */
+function encodeURI([uri = Value.undefined]: Arguments): ExpressionCompletion {
+  // 1. Let uriString be ? ToString(uri).
+  const uriString = Q(ToString(uri));
+  // 2. Let unescapedURISet be a String containing one instance of each code unit valid in uriReserved and uriUnescaped plus "#".
+  const unescapedURISet = `${uriReserved}${uriUnescaped}#`;
+  // 3. Return ? Encode(uriString, unescapedURISet).
+  return Q(Encode(uriString, unescapedURISet));
+}
+
+/** https://tc39.es/ecma262/#sec-encodeuricomponent-uricomponent */
+function encodeURIComponent([uriComponent = Value.undefined]: Arguments): ExpressionCompletion {
+  // 1. Let componentString be ? ToString(uriComponent).
+  const componentString = Q(ToString(uriComponent));
+  // 2. Let unescapedURIComponentSet be a String containing one instance of each code unit valid in uriUnescaped.
+  const unescapedURIComponentSet = uriUnescaped;
+  // 3. Return ? Encode(componentString, unescapedURIComponentSet).
+  return Q(Encode(componentString, unescapedURIComponentSet));
+}
+
+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 { surroundingAgent } from '../engine.mts';
+import {
+  Get,
+  IsCallable,
+  OrdinaryCreateFromConstructor,
+  Realm,
+  type FunctionObject,
+  type OrdinaryObject,
+} from '../abstract-ops/all.mts';
+import {
+  UndefinedValue,
+  Value,
+  type Arguments,
+  type FunctionCallContext,
+} from '../value.mts';
+import {
+  Q,
+} from '../completion.mts';
+import type { Mutable } from '../helpers.mts';
+import { AddEntriesFromIterable } from './Map.mts';
+import { bootstrapConstructor } from './bootstrap.mts';
+
+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 surroundingAgent.Throw('TypeError', 'ConstructorNonCallable', this);
+  }
+  // 2. Let map be ? OrdinaryCreateFromConstructor(NewTarget, "%WeakMap.prototype%", « [[WeakMapData]] »).
+  const map = Q(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(Get(map, Value('set')));
+  if (IsCallable(adder) === Value.false) {
+    return surroundingAgent.Throw('TypeError', 'NotAFunction', adder);
+  }
+  // 6. Return ? AddEntriesFromIterable(map, iterable, adder).
+  return Q(AddEntriesFromIterable(map, iterable, adder as FunctionObject));
+}
+
+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,129 @@
+import { surroundingAgent } from '../engine.mts';
+import {
+  SameValue,
+  RequireInternalSlot,
+  CanBeHeldWeakly,
+  Realm,
+} from '../abstract-ops/all.mts';
+import {
+  Value,
+  type Arguments,
+  type FunctionCallContext,
+} from '../value.mts';
+import { Q, type ExpressionCompletion } from '../completion.mts';
+import { bootstrapPrototype } from './bootstrap.mts';
+import type { WeakMapObject } from './WeakMap.mts';
+
+/** https://tc39.es/ecma262/#sec-weakmap.prototype.delete */
+function WeakMapProto_delete([key = Value.undefined]: Arguments, { thisValue }: FunctionCallContext): ExpressionCompletion {
+  // 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) === Value.false) {
+    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) === Value.true) {
+      // 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): ExpressionCompletion {
+  // 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) === Value.false) {
+    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) === Value.true) {
+      return p.Value!;
+    }
+  }
+  // 6. Return undefined.
+  return Value.undefined;
+}
+
+/** https://tc39.es/ecma262/#sec-weakmap.prototype.has */
+function WeakMapProto_has([key = Value.undefined]: Arguments, { thisValue }: FunctionCallContext): ExpressionCompletion {
+  // 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) === Value.false) {
+    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) === Value.true) {
+      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): ExpressionCompletion {
+  // 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) === Value.false) {
+    return surroundingAgent.Throw('TypeError', 'WeakCollectionNotObject', 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) === Value.true) {
+      // 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],
+    ['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,42 @@
+import { surroundingAgent } from '../engine.mts';
+import {
+  UndefinedValue, Value, type Arguments, type FunctionCallContext,
+} from '../value.mts';
+import {
+  AddToKeptObjects, CanBeHeldWeakly, OrdinaryCreateFromConstructor, Realm, type FunctionObject, type OrdinaryObject,
+} from '../abstract-ops/all.mts';
+import { Q, X } from '../completion.mts';
+import type { Mutable } from '../helpers.mts';
+import { bootstrapConstructor } from './bootstrap.mts';
+
+export interface WeakRefObject extends OrdinaryObject {
+  WeakRefTarget: Value | 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 surroundingAgent.Throw('TypeError', 'ConstructorNonCallable', this);
+  }
+  // 2. If CanBeHeldWeakly(target) is false, throw a TypeError exception.
+  if (CanBeHeldWeakly(target) === Value.false) {
+    return surroundingAgent.Throw('TypeError', 'NotAWeakKey', target);
+  }
+  // 3. Let weakRef be ? OrdinaryCreateFromConstructor(NewTarget, "%WeakRefPrototype%", « [[WeakRefTarget]] »).
+  const weakRef = Q(OrdinaryCreateFromConstructor(NewTarget, '%WeakRef.prototype%', ['WeakRefTarget'])) as Mutable<WeakRefObject>;
+  // 4. Perform ! AddToKeptObjects(target).
+  X(AddToKeptObjects(target));
+  // 5. Set weakRef.[[WeakRefTarget]] to target.
+  weakRef.WeakRefTarget = target;
+  // 6. Return weakRef
+  return weakRef;
+}
+
+export function bootstrapWeakRef(realmRec: Realm) {
+  const bigintConstructor = bootstrapConstructor(realmRec, WeakRefConstructor, 'WeakRef', 1, realmRec.Intrinsics['%WeakRef.prototype%'], []);
+
+  realmRec.Intrinsics['%WeakRef%'] = bigintConstructor;
+}

package/src/intrinsics/WeakRefPrototype.mts

@@ -0,0 +1,23 @@
+import { Realm, RequireInternalSlot, WeakRefDeref } from '../abstract-ops/all.mts';
+import { Q, X } from '../completion.mts';
+import { bootstrapPrototype } from './bootstrap.mts';
+import type { WeakRefObject } from './WeakRef.mts';
+import type { Arguments, ExpressionCompletion, FunctionCallContext } from '#self';
+
+/** https://tc39.es/ecma262/#sec-weak-ref.prototype.deref */
+function WeakRefProto_deref(_args: Arguments, { thisValue }: FunctionCallContext): ExpressionCompletion {
+  // 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 { surroundingAgent } from '../engine.mts';
+import {
+  UndefinedValue, Value, type Arguments, type FunctionCallContext,
+} from '../value.mts';
+import {
+  IsCallable,
+  OrdinaryCreateFromConstructor,
+  Call,
+  Get,
+  GetIterator,
+  type OrdinaryObject,
+  Realm,
+  type FunctionObject,
+  IteratorStepValue,
+} from '../abstract-ops/all.mts';
+import { IfAbruptCloseIterator, Q } from '../completion.mts';
+import type { Mutable } from '../helpers.mts';
+import { bootstrapConstructor } from './bootstrap.mts';
+
+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 surroundingAgent.Throw('TypeError', 'ConstructorNonCallable', this);
+  }
+  // 2. Let set be ? OrdinaryCreateFromConstructor(NewTarget, "%WeakSet.prototype%", « [[WeakSetData]] »).
+  const set = Q(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(Get(set, Value('add')));
+  // 6. If IsCallable(adder) is false, throw a TypeError exception.
+  if (IsCallable(adder) === Value.false) {
+    return surroundingAgent.Throw('TypeError', 'NotAFunction', adder);
+  }
+  // 7. Let iteratorRecord be ? GetIterator(iterable).
+  const iteratorRecord = Q(GetIterator(iterable, 'sync'));
+  // 8. Repeat,
+  while (true) {
+    // a. Let next be ? IteratorStep(iteratorRecord).
+    const next = Q(IteratorStepValue(iteratorRecord));
+    // b. If next is false, return set.
+    if (next === 'done') {
+      return set;
+    }
+    // d. Let status be Call(adder, set, « next »).
+    const status = 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;
+}