@engine262/engine262 0.0.1-01e9fa95a4e8a1c042efd00492309a2de4998fd0

package/src/execution-context/Realm.mts

@@ -0,0 +1,378 @@
+import { AddRestrictedFunctionProperties, type Intrinsics } from '../abstract-ops/realms.mts';
+import { bootstrapAggregateError } from '../intrinsics/AggregateError.mts';
+import { bootstrapAggregateErrorPrototype } from '../intrinsics/AggregateErrorPrototype.mts';
+import { bootstrapAbstractModuleSource } from '../intrinsics/AbstractModuleSource.mts';
+import { bootstrapArray } from '../intrinsics/Array.mts';
+import { bootstrapArrayBuffer } from '../intrinsics/ArrayBuffer.mts';
+import { bootstrapArrayBufferPrototype } from '../intrinsics/ArrayBufferPrototype.mts';
+import { bootstrapArrayIteratorPrototype } from '../intrinsics/ArrayIteratorPrototype.mts';
+import { bootstrapArrayPrototype } from '../intrinsics/ArrayPrototype.mts';
+import { bootstrapAsyncFromSyncIteratorPrototype } from '../intrinsics/AsyncFromSyncIteratorPrototype.mts';
+import { bootstrapAsyncFunction } from '../intrinsics/AsyncFunction.mts';
+import { bootstrapAsyncFunctionPrototype } from '../intrinsics/AsyncFunctionPrototype.mts';
+import { bootstrapAsyncGeneratorFunction } from '../intrinsics/AsyncGeneratorFunction.mts';
+import { bootstrapAsyncGeneratorFunctionPrototype } from '../intrinsics/AsyncGeneratorFunctionPrototype.mts';
+import { bootstrapAsyncGeneratorFunctionPrototypePrototype } from '../intrinsics/AsyncGeneratorFunctionPrototypePrototype.mts';
+import { bootstrapAsyncIteratorPrototype } from '../intrinsics/AsyncIteratorPrototype.mts';
+import { bootstrapAsyncDisposableStack } from '../intrinsics/AsyncDisposableStack.mts';
+import { bootstrapAsyncDisposableStackPrototype } from '../intrinsics/AsyncDisposableStackPrototype.mts';
+import { bootstrapBigInt } from '../intrinsics/BigInt.mts';
+import { bootstrapBigIntPrototype } from '../intrinsics/BigIntPrototype.mts';
+import { bootstrapBoolean } from '../intrinsics/Boolean.mts';
+import { bootstrapBooleanPrototype } from '../intrinsics/BooleanPrototype.mts';
+import { bootstrapDataView } from '../intrinsics/DataView.mts';
+import { bootstrapDataViewPrototype } from '../intrinsics/DataViewPrototype.mts';
+import { bootstrapDate } from '../intrinsics/Date.mts';
+import { bootstrapDatePrototype } from '../intrinsics/DatePrototype.mts';
+import { bootstrapDisposableStack } from '../intrinsics/DisposableStack.mts';
+import { bootstrapDisposableStackPrototype } from '../intrinsics/DisposableStackPrototype.mts';
+import { bootstrapError } from '../intrinsics/Error.mts';
+import { bootstrapErrorPrototype } from '../intrinsics/ErrorPrototype.mts';
+import { bootstrapEval } from '../intrinsics/eval.mts';
+import { bootstrapFinalizationRegistry } from '../intrinsics/FinalizationRegistry.mts';
+import { bootstrapFinalizationRegistryPrototype } from '../intrinsics/FinalizationRegistryPrototype.mts';
+import { bootstrapForInIteratorPrototype } from '../intrinsics/ForInIteratorPrototype.mts';
+import { bootstrapFunction } from '../intrinsics/Function.mts';
+import { bootstrapFunctionPrototype } from '../intrinsics/FunctionPrototype.mts';
+import { bootstrapGeneratorFunction } from '../intrinsics/GeneratorFunction.mts';
+import { bootstrapGeneratorFunctionPrototype } from '../intrinsics/GeneratorFunctionPrototype.mts';
+import { bootstrapGeneratorFunctionPrototypePrototype } from '../intrinsics/GeneratorFunctionPrototypePrototype.mts';
+import { bootstrapIsFinite } from '../intrinsics/isFinite.mts';
+import { bootstrapIsNaN } from '../intrinsics/isNaN.mts';
+import { bootstrapIterator } from '../intrinsics/Iterator.mts';
+import { bootstrapIteratorHelperPrototype } from '../intrinsics/IteratorHelperPrototype.mts';
+import { bootstrapIteratorPrototype } from '../intrinsics/IteratorPrototype.mts';
+import { bootstrapJSON } from '../intrinsics/JSON.mts';
+import { bootstrapMap } from '../intrinsics/Map.mts';
+import { bootstrapMapIteratorPrototype } from '../intrinsics/MapIteratorPrototype.mts';
+import { bootstrapMapPrototype } from '../intrinsics/MapPrototype.mts';
+import { bootstrapMath } from '../intrinsics/Math.mts';
+import { bootstrapNativeError } from '../intrinsics/NativeError.mts';
+import { bootstrapNumber } from '../intrinsics/Number.mts';
+import { bootstrapNumberPrototype } from '../intrinsics/NumberPrototype.mts';
+import { bootstrapObject } from '../intrinsics/Object.mts';
+import { makeObjectPrototype, bootstrapObjectPrototype } from '../intrinsics/ObjectPrototype.mts';
+import { bootstrapParseFloat } from '../intrinsics/parseFloat.mts';
+import { bootstrapParseInt } from '../intrinsics/parseInt.mts';
+import { bootstrapPromise } from '../intrinsics/Promise.mts';
+import { bootstrapPromisePrototype } from '../intrinsics/PromisePrototype.mts';
+import { bootstrapProxy } from '../intrinsics/Proxy.mts';
+import { bootstrapReflect } from '../intrinsics/Reflect.mts';
+import { bootstrapRegExp } from '../intrinsics/RegExp.mts';
+import { bootstrapRegExpPrototype } from '../intrinsics/RegExpPrototype.mts';
+import { bootstrapRegExpStringIteratorPrototype } from '../intrinsics/RegExpStringIteratorPrototype.mts';
+import { bootstrapSet } from '../intrinsics/Set.mts';
+import { bootstrapSetIteratorPrototype } from '../intrinsics/SetIteratorPrototype.mts';
+import { bootstrapSetPrototype } from '../intrinsics/SetPrototype.mts';
+import { bootstrapShadowRealm } from '../intrinsics/ShadowRealm.mts';
+import { bootstrapShadowRealmPrototype } from '../intrinsics/ShadowRealmPrototype.mts';
+import { bootstrapString } from '../intrinsics/String.mts';
+import { bootstrapStringIteratorPrototype } from '../intrinsics/StringIteratorPrototype.mts';
+import { bootstrapStringPrototype } from '../intrinsics/StringPrototype.mts';
+import { bootstrapSymbol } from '../intrinsics/Symbol.mts';
+import { bootstrapSymbolPrototype } from '../intrinsics/SymbolPrototype.mts';
+import { bootstrapSuppressedError } from '../intrinsics/SuppressedError.mts';
+import { bootstrapSuppressedErrorPrototype } from '../intrinsics/SuppressedErrorPrototype.mts';
+import { bootstrapThrowTypeError } from '../intrinsics/ThrowTypeError.mts';
+import { bootstrapTypedArray } from '../intrinsics/TypedArray.mts';
+import { bootstrapUint8Array } from '../intrinsics/TypedArray_Uint8Array.mts';
+import { bootstrapTypedArrayConstructors } from '../intrinsics/TypedArrayConstructors.mts';
+import { bootstrapTypedArrayPrototype } from '../intrinsics/TypedArrayPrototype.mts';
+import { bootstrapTypedArrayPrototypes } from '../intrinsics/TypedArrayPrototypes.mts';
+import { bootstrapURIHandling } from '../intrinsics/URIHandling.mts';
+import { bootstrapWeakMap } from '../intrinsics/WeakMap.mts';
+import { bootstrapWeakMapPrototype } from '../intrinsics/WeakMapPrototype.mts';
+import { bootstrapWeakRef } from '../intrinsics/WeakRef.mts';
+import { bootstrapWeakRefPrototype } from '../intrinsics/WeakRefPrototype.mts';
+import { bootstrapWeakSet } from '../intrinsics/WeakSet.mts';
+import { bootstrapWeakSetPrototype } from '../intrinsics/WeakSetPrototype.mts';
+import { bootstrapWrapForValidIteratorPrototype } from '../intrinsics/WrapForValidIteratorPrototype.mts';
+import { bootstrapTemporal } from '../intrinsics/Temporal/Temporal.mts';
+import {
+  type ObjectValue, type GlobalEnvironmentRecord, type ParseNode, type LoadedModuleRequestRecord, type ManagedRealmHostDefined, type GCMarker,
+  ManagedRealm,
+  type Mutable,
+  DefinePropertyOrThrow,
+  Descriptor,
+  F as toNumberValue,
+  Value,
+  X,
+} from '#self';
+
+/** https://tc39.es/ecma262/#sec-code-realms */
+export abstract class Realm {
+  abstract readonly AgentSignifier: unknown;
+
+  abstract readonly Intrinsics: Intrinsics;
+
+  abstract readonly GlobalObject: ObjectValue;
+
+  abstract readonly GlobalEnv: GlobalEnvironmentRecord;
+
+  abstract readonly TemplateMap: { Site: ParseNode.TemplateLiteral; Array: ObjectValue; }[];
+
+  readonly LoadedModules: LoadedModuleRequestRecord[] = [];
+
+  abstract readonly HostDefined: ManagedRealmHostDefined;
+
+  // NON-SPEC
+  abstract randomState: undefined | BigUint64Array;
+
+  mark(m: GCMarker) {
+    m(this.GlobalObject);
+    m(this.GlobalEnv);
+    for (const v of Object.values(this.Intrinsics)) {
+      m(v);
+    }
+    for (const v of Object.values(this.TemplateMap)) {
+      m(v);
+    }
+    for (const v of this.LoadedModules) {
+      m(v.Module);
+    }
+  }
+}
+
+/** https://tc39.es/ecma262/pr/3728/#sec-makerealm */
+export function MakeRealm(...args: ConstructorParameters<typeof ManagedRealm>) {
+  return new ManagedRealm(...args).topContext;
+}
+
+/** https://tc39.es/ecma262/#sec-createintrinsics */
+export function CreateIntrinsics(realmRec: Realm) {
+  const intrinsics = Object.create(null);
+  (realmRec as Mutable<Realm>).Intrinsics = intrinsics;
+  makeObjectPrototype(realmRec);
+
+  bootstrapFunctionPrototype(realmRec);
+  bootstrapObjectPrototype(realmRec);
+  bootstrapThrowTypeError(realmRec);
+
+  bootstrapEval(realmRec);
+  bootstrapIsFinite(realmRec);
+  bootstrapIsNaN(realmRec);
+  bootstrapParseFloat(realmRec);
+  bootstrapParseInt(realmRec);
+  bootstrapURIHandling(realmRec);
+
+  bootstrapObject(realmRec);
+
+  bootstrapErrorPrototype(realmRec);
+  bootstrapError(realmRec);
+  bootstrapNativeError(realmRec);
+  bootstrapAggregateErrorPrototype(realmRec);
+  bootstrapAggregateError(realmRec);
+  bootstrapSuppressedErrorPrototype(realmRec);
+  bootstrapSuppressedError(realmRec);
+
+  bootstrapFunction(realmRec);
+  bootstrapAbstractModuleSource(realmRec);
+
+  bootstrapIteratorPrototype(realmRec);
+  bootstrapIterator(realmRec);
+  bootstrapIteratorHelperPrototype(realmRec);
+  bootstrapWrapForValidIteratorPrototype(realmRec);
+
+  bootstrapAsyncIteratorPrototype(realmRec);
+  bootstrapDisposableStackPrototype(realmRec);
+  bootstrapDisposableStack(realmRec);
+  bootstrapAsyncDisposableStackPrototype(realmRec);
+  bootstrapAsyncDisposableStack(realmRec);
+  bootstrapArrayIteratorPrototype(realmRec);
+  bootstrapMapIteratorPrototype(realmRec);
+  bootstrapSetIteratorPrototype(realmRec);
+  bootstrapStringIteratorPrototype(realmRec);
+  bootstrapRegExpStringIteratorPrototype(realmRec);
+  bootstrapForInIteratorPrototype(realmRec);
+
+  bootstrapStringPrototype(realmRec);
+  bootstrapString(realmRec);
+
+  bootstrapArrayPrototype(realmRec);
+  bootstrapArray(realmRec);
+
+  bootstrapBooleanPrototype(realmRec);
+  bootstrapBoolean(realmRec);
+
+  bootstrapNumberPrototype(realmRec);
+  bootstrapNumber(realmRec);
+
+  bootstrapBigIntPrototype(realmRec);
+  bootstrapBigInt(realmRec);
+
+  bootstrapSymbolPrototype(realmRec);
+  bootstrapSymbol(realmRec);
+
+  bootstrapPromisePrototype(realmRec);
+  bootstrapPromise(realmRec);
+
+  bootstrapProxy(realmRec);
+
+  bootstrapReflect(realmRec);
+
+  bootstrapMath(realmRec);
+
+  bootstrapDatePrototype(realmRec);
+  bootstrapDate(realmRec);
+
+  bootstrapRegExpPrototype(realmRec);
+  bootstrapRegExp(realmRec);
+
+  bootstrapSetPrototype(realmRec);
+  bootstrapSet(realmRec);
+
+  bootstrapMapPrototype(realmRec);
+  bootstrapMap(realmRec);
+
+  bootstrapGeneratorFunctionPrototypePrototype(realmRec);
+  bootstrapGeneratorFunctionPrototype(realmRec);
+  bootstrapGeneratorFunction(realmRec);
+
+  bootstrapAsyncFunctionPrototype(realmRec);
+  bootstrapAsyncFunction(realmRec);
+
+  bootstrapAsyncGeneratorFunctionPrototypePrototype(realmRec);
+  bootstrapAsyncGeneratorFunctionPrototype(realmRec);
+  bootstrapAsyncGeneratorFunction(realmRec);
+
+  bootstrapAsyncFromSyncIteratorPrototype(realmRec);
+
+  bootstrapArrayBufferPrototype(realmRec);
+  bootstrapArrayBuffer(realmRec);
+
+  bootstrapTypedArrayPrototype(realmRec);
+  bootstrapTypedArray(realmRec);
+  bootstrapTypedArrayPrototypes(realmRec);
+  bootstrapTypedArrayConstructors(realmRec);
+  bootstrapUint8Array(realmRec);
+
+  bootstrapDataViewPrototype(realmRec);
+  bootstrapDataView(realmRec);
+
+  bootstrapJSON(realmRec);
+
+  bootstrapWeakMapPrototype(realmRec);
+  bootstrapWeakMap(realmRec);
+  bootstrapWeakSetPrototype(realmRec);
+  bootstrapWeakSet(realmRec);
+
+  bootstrapWeakRefPrototype(realmRec);
+  bootstrapWeakRef(realmRec);
+
+  bootstrapFinalizationRegistryPrototype(realmRec);
+  bootstrapFinalizationRegistry(realmRec);
+
+  bootstrapShadowRealmPrototype(realmRec);
+  bootstrapShadowRealm(realmRec);
+
+  bootstrapTemporal(realmRec);
+
+  AddRestrictedFunctionProperties(intrinsics['%Function.prototype%'], realmRec);
+
+  return intrinsics;
+}
+
+/** https://tc39.es/ecma262/#sec-setdefaultglobalbindings */
+export function SetDefaultGlobalBindings(realmRec: Realm) {
+  const global = realmRec.GlobalObject;
+
+  // Value Properties of the Global Object
+  for (const [name, value] of [
+    ['Infinity', toNumberValue(Infinity)],
+    ['NaN', toNumberValue(NaN)],
+    ['undefined', Value.undefined],
+  ] as const) {
+    X(DefinePropertyOrThrow(global, Value(name), Descriptor({
+      Value: value,
+      Writable: Value.false,
+      Enumerable: Value.false,
+      Configurable: Value.false,
+    })));
+  }
+
+  X(DefinePropertyOrThrow(global, Value('globalThis'), Descriptor({
+    Value: realmRec.GlobalEnv.GlobalThisValue,
+    Writable: Value.true,
+    Enumerable: Value.false,
+    Configurable: Value.true,
+  })));
+
+  for (const name of [
+    // Function Properties of the Global Object
+    'eval',
+    'isFinite',
+    'isNaN',
+    'parseFloat',
+    'parseInt',
+    'decodeURI',
+    'decodeURIComponent',
+    'encodeURI',
+    'encodeURIComponent',
+
+    // Constructor Properties of the Global Object
+    'AggregateError',
+    'AsyncDisposableStack',
+    'Array',
+    'ArrayBuffer',
+    'Boolean',
+    'BigInt',
+    'BigInt64Array',
+    'BigUint64Array',
+    'DataView',
+    'Date',
+    'DisposableStack',
+    'Error',
+    'EvalError',
+    'FinalizationRegistry',
+    'Float16Array',
+    'Float32Array',
+    'Float64Array',
+    'Function',
+    'Int8Array',
+    'Int16Array',
+    'Int32Array',
+    'Iterator',
+    'Map',
+    'Number',
+    'Object',
+    'Promise',
+    'Proxy',
+    'RangeError',
+    'ReferenceError',
+    'RegExp',
+    'Set',
+    'ShadowRealm',
+    // 'SharedArrayBuffer',
+    'String',
+    'Symbol',
+    'SuppressedError',
+    'SyntaxError',
+    'Temporal',
+    'TypeError',
+    'Uint8Array',
+    'Uint8ClampedArray',
+    'Uint16Array',
+    'Uint32Array',
+    'URIError',
+    'WeakMap',
+    'WeakRef',
+    'WeakSet',
+
+    // Other Properties of the Global Object
+    // 'Atomics',
+    'JSON',
+    'Math',
+    'Reflect',
+  ] as const) {
+    const value = realmRec.Intrinsics[`%${name}%`];
+    if (!value) {
+      continue;
+    }
+    X(DefinePropertyOrThrow(global, Value(name), Descriptor({
+      Value: value,
+      Writable: Value.true,
+      Enumerable: Value.false,
+      Configurable: Value.true,
+    })));
+  }
+}

package/src/execution-context/WeakReference.mts

@@ -0,0 +1,86 @@
+import {
+  type FinalizationRegistryObject, Q, NormalCompletion, ObjectValue, SymbolValue, Assert, HostCallJobCallback, type JobCallbackRecord, UndefinedValue, Value, type ValueEvaluator, KeyForSymbol,
+  GetActiveScriptOrModule,
+  surroundingAgent,
+  type Job,
+} from '#self';
+
+
+/** https://tc39.es/ecma262/#sec-host-cleanup-finalization-registry */
+export function HostEnqueueFinalizationRegistryCleanupJob(finalizationRegistry: FinalizationRegistryObject): void {
+  const hostHook = surroundingAgent.hostDefinedOptions.hostHooks?.HostEnqueueFinalizationRegistryCleanupJob;
+  if (hostHook) {
+    hostHook(finalizationRegistry);
+    return;
+  }
+  if (surroundingAgent.finalizationRegistryScheduledForCleanup.has(finalizationRegistry)) return;
+  surroundingAgent.finalizationRegistryScheduledForCleanup.add(finalizationRegistry);
+  const cleanJob: Job = {
+    queueName: 'FinalizationRegistryCleanup',
+    job: function finalizationJob() {
+      surroundingAgent.finalizationRegistryScheduledForCleanup.delete(finalizationRegistry);
+      return CleanupFinalizationRegistry(finalizationRegistry);
+    },
+    callerRealm: surroundingAgent.currentRealmRecord,
+    callerScriptOrModule: GetActiveScriptOrModule(),
+  };
+  surroundingAgent.jobQueue.enqueueFinalizationRegistryCleanupJob(cleanJob);
+}
+
+/** https://tc39.es/ecma262/#sec-clear-kept-objects */
+export function ClearKeptObjects() {
+  // 1. Let agentRecord be the surrounding agent's Agent Record.
+  const agentRecord = surroundingAgent.AgentRecord;
+  // 2. Set agentRecord.[[KeptAlive]] to a new empty List.
+  agentRecord.KeptAlive = new Set();
+}
+
+/** https://tc39.es/ecma262/#sec-addtokeptobjects */
+export function AddToKeptObjects(object: ObjectValue | SymbolValue) {
+  // 1. Let agentRecord be the surrounding agent's Agent Record.
+  const agentRecord = surroundingAgent.AgentRecord;
+  // 2. Append object to agentRecord.[[KeptAlive]].
+  agentRecord.KeptAlive.add(object);
+}
+
+/** https://tc39.es/ecma262/#sec-cleanup-finalization-registry */
+export function* CleanupFinalizationRegistry(finalizationRegistry: FinalizationRegistryObject, callback?: JobCallbackRecord): ValueEvaluator<UndefinedValue> {
+  Q(surroundingAgent.debugger_tryTouchDuringPreview(finalizationRegistry));
+  // 1. Assert: finalizationRegistry has [[Cells]] and [[CleanupCallback]] internal slots.
+  Assert('Cells' in finalizationRegistry && 'CleanupCallback' in finalizationRegistry);
+  // 2. Set callback to finalizationRegistry.[[CleanupCallback]].
+  if (callback === undefined) {
+    callback = finalizationRegistry.CleanupCallback;
+  }
+  // 3. While finalizationRegistry.[[Cells]] contains a Record cell such that cell.[[WeakRefTarget]] is empty, an implementation may perform the following steps:
+  for (let i = 0; i < finalizationRegistry.Cells.length; i += 1) {
+    // a. Choose any such _cell_.
+    const cell = finalizationRegistry.Cells[i];
+    if (cell.WeakRefTarget !== undefined) {
+      continue;
+    }
+    // b. Remove cell from finalizationRegistry.[[Cells]].
+    finalizationRegistry.Cells.splice(i, 1);
+    i -= 1;
+    // c. Perform ? HostCallJobCallback(callback, undefined, « cell.[[HeldValue]] »).
+    Q(yield* HostCallJobCallback(callback, Value.undefined, [cell.HeldValue]));
+  }
+  // 4. Return NormalCompletion(undefined).
+  return NormalCompletion(Value.undefined);
+}
+
+/** https://tc39.es/ecma262/#sec-canbeheldweakly */
+export function CanBeHeldWeakly(v: Value): v is ObjectValue | SymbolValue {
+  // 1. If v is an Object, return true.
+  if (v instanceof ObjectValue) {
+    return true;
+  }
+
+  // 2. If v is a Symbol and KeyForSymbol(v) is undefined, return true.
+  if (v instanceof SymbolValue && KeyForSymbol(v) === Value.undefined) {
+    return true;
+  }
+
+  // 3. Return false.
+  return false;
+}

package/src/execution-context/all.mts

@@ -0,0 +1,7 @@
+export * from './Environment.mts';
+export * from './PrivateEnvironment.mts';
+export * from './Realm.mts';
+export * from './ExecutionContext.mts';
+export * from './Job.mts';
+export * from './Agent.mts';
+export * from './WeakReference.mts';

package/src/host-defined/base64.mts

@@ -0,0 +1,58 @@
+/* eslint-disable no-useless-escape */
+/* eslint-disable no-nested-ternary */
+/* eslint-disable no-mixed-operators */
+/* eslint-disable no-plusplus */
+/* eslint-disable no-cond-assign */
+/**
+ * This file is based on https://github.com/MaxArt2501/base64-js/
+ * MIT licensed: https://github.com/MaxArt2501/base64-js/blob/master/LICENSE
+ */
+
+// base64 character set, plus padding character (=)
+const b64 = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=';
+// Regular expression to check formal correctness of base64 encoded strings
+const b64re = /^(?:[A-Za-z\d+\/]{4})*?(?:[A-Za-z\d+\/]{2}(?:==)?|[A-Za-z\d+\/]{3}=?)?$/;
+
+declare function atob(string: string): string;
+declare function btoa(string: string): string;
+
+export const btoa_polyfill = typeof btoa === 'function' ? btoa : function btoa(string: string) {
+  string = String(string);
+  let bitmap; let a; let b; let c;
+  let result = ''; let i = 0;
+  const rest = string.length % 3; // To determine the final padding
+
+  for (; i < string.length;) {
+    if ((a = string.charCodeAt(i++)) > 255
+        || (b = string.charCodeAt(i++)) > 255
+        || (c = string.charCodeAt(i++)) > 255) throw new TypeError("Failed to execute 'btoa' on 'Window': The string to be encoded contains characters outside of the Latin1 range.");
+
+    bitmap = (a << 16) | (b << 8) | c;
+    result += b64.charAt(bitmap >> 18 & 63) + b64.charAt(bitmap >> 12 & 63)
+            + b64.charAt(bitmap >> 6 & 63) + b64.charAt(bitmap & 63);
+  }
+
+  // If there's need of padding, replace the last 'A's with equal signs
+  return rest ? result.slice(0, rest - 3) + '==='.substring(rest) : result;
+};
+
+export const atob_polyfill = typeof atob === 'function' ? atob : function atob(string: string) {
+  // atob can work with strings with whitespaces, even inside the encoded part,
+  // but only \t, \n, \f, \r and ' ', which can be stripped.
+  string = String(string).replace(/[\t\n\f\r ]+/g, '');
+  if (!b64re.test(string)) throw new TypeError("Failed to execute 'atob' on 'Window': The string to be decoded is not correctly encoded.");
+
+  // Adding the padding if missing, for semplicity
+  string += '=='.slice(2 - (string.length & 3));
+  let bitmap; let result = ''; let r1; let r2; let
+    i = 0;
+  for (; i < string.length;) {
+    bitmap = b64.indexOf(string.charAt(i++)) << 18 | b64.indexOf(string.charAt(i++)) << 12
+                    | (r1 = b64.indexOf(string.charAt(i++))) << 6 | (r2 = b64.indexOf(string.charAt(i++)));
+
+    result += r1 === 64 ? String.fromCharCode(bitmap >> 16 & 255)
+      : r2 === 64 ? String.fromCharCode(bitmap >> 16 & 255, bitmap >> 8 & 255)
+        : String.fromCharCode(bitmap >> 16 & 255, bitmap >> 8 & 255, bitmap & 255);
+  }
+  return result;
+};

package/src/host-defined/debugger-util.mts

@@ -0,0 +1,15 @@
+import { surroundingAgent, type ParseNode } from '#self';
+
+const ShouldSkipStepIn: readonly ParseNode['type'][] = [
+  'NumericLiteral', 'NullLiteral', 'StringLiteral', 'BooleanLiteral', 'RegularExpressionLiteral',
+  'CallExpression',
+  'Block',
+];
+
+export function shouldStepOnNode() {
+  const type = surroundingAgent.runningExecutionContext.callSite.lastNode?.type;
+  if (type && !type.endsWith('Statement') && !type.endsWith('Declaration') && !ShouldSkipStepIn.includes(type)) {
+    return true;
+  }
+  return false;
+}

package/src/host-defined/decimal.mts

@@ -0,0 +1,117 @@
+import decimal from 'jsbd';
+import type { RoundOption } from 'jsbd/dist/type.js';
+import { callable } from '../utils/language.mts';
+
+const {
+  BigDecimal,
+  add: d_add, subtract: d_subtract, remainder: d_remainder, divide: d_divide, multiply: d_multiply,
+  equal: d_equal, notEqual: d_notEqual,
+  lessThan: d_lessThan, lessThanOrEqual: d_lessThanOrEqual, greaterThan: d_greaterThan, greaterThanOrEqual: d_greaterThanOrEqual,
+} = (decimal.default || decimal);
+
+
+type DecimalInit = string | number | bigint | decimal.Decimal | Decimal;
+// @ts-expect-error
+export declare function Decimal(value: DecimalInit): Decimal;
+@callable((_, _t, args) => new Decimal(args[0] as DecimalInit))
+// @ts-expect-error
+export class Decimal {
+  private value: decimal.Decimal;
+
+  private constructor(value: DecimalInit) {
+    if (value instanceof Decimal) {
+      this.value = value.value;
+    } else {
+      this.value = BigDecimal(value);
+    }
+  }
+
+  add(other: DecimalInit, option?: RoundOption): Decimal {
+    return new Decimal(d_add(this.value, new Decimal(other).value, option));
+  }
+
+  subtract(other: DecimalInit, option?: RoundOption): Decimal {
+    return new Decimal(d_subtract(this.value, new Decimal(other).value, option));
+  }
+
+  multiply(other: DecimalInit, option?: RoundOption): Decimal {
+    return new Decimal(d_multiply(this.value, new Decimal(other).value, option));
+  }
+
+  divide(other: DecimalInit, option?: RoundOption): Decimal {
+    return new Decimal(d_divide(this.value, new Decimal(other).value, option));
+  }
+
+  remainder(other: DecimalInit, option?: RoundOption): Decimal {
+    return new Decimal(d_remainder(this.value, new Decimal(other).value, option));
+  }
+
+  equals(other: DecimalInit): boolean {
+    return d_equal(this.value, new Decimal(other).value);
+  }
+
+  notEqual(other: DecimalInit): boolean {
+    return d_notEqual(this.value, new Decimal(other).value);
+  }
+
+  lessThan(other: DecimalInit): boolean {
+    return d_lessThan(this.value, new Decimal(other).value);
+  }
+
+  lessThanOrEqual(other: DecimalInit): boolean {
+    return d_lessThanOrEqual(this.value, new Decimal(other).value);
+  }
+
+  greaterThan(other: DecimalInit): boolean {
+    return d_greaterThan(this.value, new Decimal(other).value);
+  }
+
+  greaterThanOrEqual(other: DecimalInit): boolean {
+    return d_greaterThanOrEqual(this.value, new Decimal(other).value);
+  }
+
+  abs(): Decimal {
+    if (this.lessThan(0)) {
+      return new Decimal(this.multiply(-1));
+    }
+    return this;
+  }
+
+  negate(): Decimal {
+    return new Decimal(this.multiply(-1));
+  }
+
+  toBigInt(): bigint {
+    return BigInt(this.value.toString());
+  }
+
+  toNumber(): number {
+    return Number(this.value.toString());
+  }
+
+  modulo(y: DecimalInit): Decimal {
+    // (x % y + y) % y
+    const yDecimal = new Decimal(y).value;
+    return new Decimal(d_remainder(d_add(d_remainder(this.value, yDecimal), yDecimal), yDecimal));
+  }
+
+  truncate() {
+    return new Decimal(this.value.toString().split('.')[0]);
+  }
+
+  floor() {
+    const [integerPart, fractionalPart] = this.value.toString().split('.');
+    if (fractionalPart && this.lessThan(0)) {
+      return new Decimal(integerPart).subtract(1);
+    }
+    return new Decimal(integerPart);
+  }
+
+  ceil() {
+    const [integerPart, fractionalPart] = this.value.toString().split('.');
+    if (fractionalPart && this.greaterThan(0)) {
+      return new Decimal(integerPart).add(1);
+    }
+    return new Decimal(integerPart);
+  }
+}