@lwrjs/client-modules 0.5.8 → 0.5.9

package/build/modules/lwr/lockerDefine/lockerDefine.js

@@ -113,9 +113,13 @@ const {
 } = Object;
 const {
   ownKeys: ReflectOwnKeys$2,
-  setPrototypeOf: ReflectSetPrototypeOf
+  setPrototypeOf: ReflectSetPrototypeOf$2
 } = Reflect;
 
+function isObject(value) {
+  return typeof value === 'object' && value !== null;
+}
+
 function isObjectLike(value) {
   return typeof value === 'function' || typeof value === 'object' && value !== null;
 }
@@ -142,7 +146,7 @@ function toSafeDescriptorMap(descriptorMap) {
   const props = ReflectOwnKeys$2(descriptorMap);
 
   for (let i = 0, len = props.length; i < len; i += 1) {
-    ReflectSetPrototypeOf(descriptorMap[props[i]], null);
+    ReflectSetPrototypeOf$2(descriptorMap[props[i]], null);
   }
 
   return descriptorMap;
@@ -153,7 +157,7 @@ const {
   __lookupGetter__: ObjectProto__lookupGetter__$1,
   // eslint-disable-next-line @typescript-eslint/naming-convention
   __lookupSetter__: ObjectProto__lookupSetter__,
-  hasOwnProperty: ObjectProtoHasOwnProperty$2
+  hasOwnProperty: ObjectProtoHasOwnProperty$1
 } = Object.prototype;
 const {
   assign: ObjectAssign$3,
@@ -172,11 +176,11 @@ const {
 } = Object;
 
 function ObjectHasOwnProperty(obj, key) {
-  return obj !== null && obj !== undefined && ReflectApply$3(ObjectProtoHasOwnProperty$2, obj, [key]);
+  return obj !== null && obj !== undefined && ReflectApply$3(ObjectProtoHasOwnProperty$1, obj, [key]);
 }
 
 function ObjectLookupOwnGetter$1(obj, key) {
-  if (obj === null || obj === undefined || !ReflectApply$3(ObjectProtoHasOwnProperty$2, obj, [key])) {
+  if (obj === null || obj === undefined || !ReflectApply$3(ObjectProtoHasOwnProperty$1, obj, [key])) {
     return undefined;
   }
 
@@ -184,7 +188,7 @@ function ObjectLookupOwnGetter$1(obj, key) {
 }
 
 function ObjectLookupOwnSetter(obj, key) {
-  if (obj === null || obj === undefined || !ReflectApply$3(ObjectProtoHasOwnProperty$2, obj, [key])) {
+  if (obj === null || obj === undefined || !ReflectApply$3(ObjectProtoHasOwnProperty$1, obj, [key])) {
     return undefined;
   }
 
@@ -192,7 +196,7 @@ function ObjectLookupOwnSetter(obj, key) {
 }
 
 function ObjectLookupOwnValue(obj, key) {
-  if (obj === null || obj === undefined || !ReflectApply$3(ObjectProtoHasOwnProperty$2, obj, [key])) {
+  if (obj === null || obj === undefined || !ReflectApply$3(ObjectProtoHasOwnProperty$1, obj, [key])) {
     return undefined;
   }
 
@@ -245,6 +249,11 @@ const {
 } = Function.prototype;
 
 const FunctionBind = (func, thisArg) => ReflectApply$3(FunctionProtoBind, func, [thisArg]);
+
+const {
+  parse: JSONParse,
+  stringify: JSONStringify
+} = JSON;
 const {
   for: SymbolFor,
   iterator: SymbolIterator
@@ -469,7 +478,7 @@ function WeakMapGet(weakMap, key) {
 function WeakMapSet(weakMap, key, value) {
   return ReflectApply$3(WeakMapProtoSet$1, weakMap, [key, value]);
 }
-/*! version: 0.14.13 */
+/*! version: 0.14.15 */
 
 /*!
  * Copyright (C) 2019 salesforce.com, inc.
@@ -751,6 +760,10 @@ function isSharedElement(element) {
   return element === DocumentHeadGetter(doc) || element === DocumentBodyGetter(doc);
 }
 
+function JSONClone(value) {
+  return JSONParse(JSONStringify(value));
+}
+
 const BlobProtoSizeGetter = ObjectLookupOwnGetter$1(Blob.prototype, 'size');
 const {
   slice: BlobProtoSlice
@@ -774,7 +787,9 @@ function BlobTypeGetter(blob) {
   return StringToLowerCase(ReflectApply$3(BlobProtoTypeGetter, blob, emptyArray$1));
 }
 
-const CookieStoreProto = typeof CookieStore === 'undefined' ? undefined : CookieStore.prototype; // This has to be done 1-by-1 because putting a a full file ignore in this file will result in
+const CookieStoreProto = typeof CookieStore === 'undefined' ? undefined :
+/* istanbul ignore next: only available in secure context */
+CookieStore.prototype; // This has to be done 1-by-1 because putting a a full file ignore in this file will result in
 // dist/index.js containing the directive and subsequently being ignored.
 // istanbul ignore next
 
@@ -864,10 +879,14 @@ function HTMLElementDatasetGetter(el) {
 
 const HTMLElementInnerTextSetter = HTMLElementProtoInnerTextSetter ? function HTMLElementInnerTextSetter(el, text) {
   ReflectApply$3(HTMLElementProtoInnerTextSetter, el, [text]);
-} : function HTMLElementInnerTextSetter(_el, _text) {};
+} :
+/* istanbul ignore next: safely ignorable fallback */
+function HTMLElementInnerTextSetter(_el, _text) {};
 const HTMLElementOuterTextSetter = HTMLElementProtoOuterTextSetter ? function HTMLElementOuterTextSetter(el, text) {
   ReflectApply$3(HTMLElementProtoOuterTextSetter, el, [text]);
-} : function HTMLElementOuterTextSetter(_el, _text) {};
+} :
+/* istanbul ignore next: safely ignorable fallback */
+function HTMLElementOuterTextSetter(_el, _text) {};
 
 function HTMLElementStyleGetter$1(el) {
   return ReflectApply$3(HTMLElementProtoStyleGetter$1, el, emptyArray$1);
@@ -922,7 +941,9 @@ function HTMLObjectElementContentDocumentGetter(objectEl) {
 
 const HTMLObjectElementContentWindowGetter = HTMLObjectElementProtoContentWindowGetter ? function HTMLObjectElementContentWindowGetter(objectEl) {
   return ReflectApply$3(HTMLObjectElementProtoContentWindowGetter, objectEl, emptyArray$1);
-} : function HTMLObjectElementContentWindowGetter(_objectEl) {
+} :
+/* istanbul ignore next: safely ignorable fallback */
+function HTMLObjectElementContentWindowGetter(_objectEl) {
   return null;
 };
 const {
@@ -987,8 +1008,8 @@ const {
   createObjectURL: URLCreateObjectURL,
   revokeObjectURL: URLRevokeObjectURL
 } = URL;
-const ALLOW_LIST_PATCHED = ['opener', 'parent'];
-const ALLOW_LIST_RAW = ['close', 'closed', 'focus', 'postMessage'];
+const ALLOW_LIST_PATCHED = ['opener', 'parent', 'postMessage'];
+const ALLOW_LIST_RAW = ['close', 'closed', 'focus'];
 const DEFAULT_OVERWRITTEN_VALUE = {};
 const {
   clearInterval: WindowStaticClearInterval
@@ -996,8 +1017,30 @@ const {
 const WindowStaticLengthGetter = ObjectLookupOwnGetter$1(window, 'length');
 const WindowStaticOpenerGetter = ObjectLookupOwnGetter$1(window, 'opener');
 const WindowStaticParentGetter = ObjectLookupOwnGetter$1(window, 'parent');
+const WindowStaticPostMessageValue = ObjectLookupOwnValue(window, 'postMessage');
 const WindowStaticSelfGetter = ObjectLookupOwnGetter$1(window, 'self');
-const patchedWindowMap = new WeakMapCtor(); // istanbul ignore next
+const patchedWindowMap = new WeakMapCtor(); // NOTE: Currently, only used for "postMessage" to unwrap plain objects and primitives.
+// This is a temporary fix that would remove classes, functions, callbacks, etc.
+
+function patchedWindowPostMessageValue() {
+  for (var _len5 = arguments.length, args = new Array(_len5), _key5 = 0; _key5 < _len5; _key5++) {
+    args[_key5] = arguments[_key5];
+  }
+
+  const message = args.length ? args[0] : undefined;
+
+  if (isObject(message)) {
+    try {
+      args[0] = JSONClone(message);
+    } catch (_unused) {
+      // eslint-disable-next-line @typescript-eslint/no-throw-literal
+      throw new DOMException('The object could not be cloned.');
+    }
+  }
+
+  return ReflectApply$3(WindowStaticPostMessageValue, this, args);
+} // istanbul ignore next
+
 
 function createPatchedWindow(rawWindow) {
   const patchedWindow = {};
@@ -1048,7 +1091,8 @@ function createPatchedWindow(rawWindow) {
       ReflectSetPrototypeOf$1(originalDescriptor, null);
       const {
         get: originalDescriptorGetter,
-        set: originalDescriptorSetter
+        set: originalDescriptorSetter,
+        value: originalDescriptorValue
       } = originalDescriptor;
       let overwrittenValue = DEFAULT_OVERWRITTEN_VALUE;
 
@@ -1068,6 +1112,16 @@ function createPatchedWindow(rawWindow) {
         };
       }
 
+      if (key === 'postMessage' && typeof originalDescriptorValue === 'function') {
+        originalDescriptor.value = function postMessage() {
+          for (var _len6 = arguments.length, args = new Array(_len6), _key6 = 0; _key6 < _len6; _key6++) {
+            args[_key6] = arguments[_key6];
+          }
+
+          return ReflectApply$3(patchedWindowPostMessageValue, rawWindow, args);
+        };
+      }
+
       ReflectDefineProperty(patchedWindow, key, originalDescriptor);
     }
   }
@@ -1120,7 +1174,7 @@ function isWindow(value) {
     // https://html.spec.whatwg.org/multipage/window-object.html#dom-self
     WindowSelfGetter(value);
     return true; // eslint-disable-next-line no-empty
-  } catch (_unused) {}
+  } catch (_unused2) {}
 
   return false;
 }
@@ -1146,8 +1200,8 @@ function WindowSelfGetter(win) {
 }
 
 function WindowSetInterval(win) {
-  for (var _len5 = arguments.length, args = new Array(_len5 > 1 ? _len5 - 1 : 0), _key5 = 1; _key5 < _len5; _key5++) {
-    args[_key5 - 1] = arguments[_key5];
+  for (var _len7 = arguments.length, args = new Array(_len7 > 1 ? _len7 - 1 : 0), _key7 = 1; _key7 < _len7; _key7++) {
+    args[_key7 - 1] = arguments[_key7];
   }
 
   return ReflectApply$3(WindowStaticSetInterval, win, args);
@@ -1193,7 +1247,7 @@ function XhrStatusGetter(xhr) {
 function XhrWithCredentialsSetter(xhr, bool) {
   ReflectApply$3(XhrProtoWithCredentialsSetter, xhr, [bool]);
 }
-/*! version: 0.14.13 */
+/*! version: 0.14.15 */
 
 /*!
  * Copyright (C) 2019 salesforce.com, inc.
@@ -1232,7 +1286,7 @@ function sanitizeURLForElement(url) {
 function sanitizeURLString(urlString) {
   return urlString === '' ? urlString : StringReplace(urlString, REMOVE_URL_CHARS_REGEXP, '');
 }
-/*! version: 0.14.13 */
+/*! version: 0.14.15 */
 
 /*! @license DOMPurify | (c) Cure53 and other contributors | Released under the Apache license 2.0 and Mozilla Public License 2.0 | github.com/cure53/DOMPurify/blob/2.2.2/LICENSE */
 
@@ -2800,7 +2854,7 @@ function sanitizeSvgTextReturnDOM(dirty) {
   const sanitizer = svgSanitizer();
   return sanitizer.sanitize(dirty);
 }
-/*! version: 0.14.13 */
+/*! version: 0.14.15 */
 
 /*!
  * Copyright (C) 2019 salesforce.com, inc.
@@ -3183,6 +3237,8 @@ function prefixCookieName(detailsOrName, key) {
 
   return detailsOrName;
 }
+/* istanbul ignore next: only available in secure context */
+
 
 function factoryPatchedDeleteValue(globalObject, options) {
   const {
@@ -3219,6 +3275,8 @@ function factoryPatchedDeleteValue(globalObject, options) {
 
   return [originalDeleteValue, deleteValue];
 }
+/* istanbul ignore next: only available in secure context */
+
 
 function factoryPatchedGetValue(globalObject, options) {
   const {
@@ -3255,6 +3313,8 @@ function factoryPatchedGetValue(globalObject, options) {
 
   return [originalGetValue, get];
 }
+/* istanbul ignore next: only available in secure context */
+
 
 function factoryPatchedGetAllValue(globalObject, options) {
   const {
@@ -3306,6 +3366,8 @@ function factoryPatchedGetAllValue(globalObject, options) {
 
   return [originalGetAllValue, getAll];
 }
+/* istanbul ignore next: only available in secure context */
+
 
 function factoryPatchedSetValue(globalObject, options) {
   const {
@@ -5238,6 +5300,20 @@ function factoryPatchedParent(globalObject) {
   return [originalParentGetter, parent];
 }
 
+function factoryPatchedPostMessage(globalObject) {
+  const originalPostMessageValue = ObjectLookupOwnValue(globalObject, 'postMessage');
+
+  function postMessage() {
+    for (var _len12 = arguments.length, args = new Array(_len12), _key13 = 0; _key13 < _len12; _key13++) {
+      args[_key13] = arguments[_key13];
+    }
+
+    return ReflectApply$3(patchedWindowPostMessageValue, this, args);
+  }
+
+  return [originalPostMessageValue, postMessage];
+}
+
 function patchedSetIntervalValue(globalObject, options) {
   const {
     evaluator,
@@ -5248,8 +5324,8 @@ function patchedSetIntervalValue(globalObject, options) {
   } = globalObject;
 
   function setInterval() {
-    for (var _len12 = arguments.length, args = new Array(_len12), _key13 = 0; _key13 < _len12; _key13++) {
-      args[_key13] = arguments[_key13];
+    for (var _len13 = arguments.length, args = new Array(_len13), _key14 = 0; _key14 < _len13; _key14++) {
+      args[_key14] = arguments[_key14];
     }
 
     if (args.length) {
@@ -5281,8 +5357,8 @@ function patchedSetTimeoutValue(globalObject, options) {
   } = globalObject;
 
   let setTimeout = function setTimeout() {
-    for (var _len13 = arguments.length, args = new Array(_len13), _key14 = 0; _key14 < _len13; _key14++) {
-      args[_key14] = arguments[_key14];
+    for (var _len14 = arguments.length, args = new Array(_len14), _key15 = 0; _key15 < _len14; _key15++) {
+      args[_key15] = arguments[_key15];
     }
 
     if (args.length) {
@@ -5383,7 +5459,7 @@ patchedConstructor$1, factoryPatchedPrototype, // Storage
 storagePropertyLength, storageGetItemValue, storageSetItemValue, storageKeyValue, storageRemoveItemValue, storageClearValue, storage, // SVGUseElement
 patchedSVGUseElementHrefAttributeSetter, patchedSVGUseElementXlinkHrefAttributeSetter, // URL
 patchedCreateObjectURL, // Window
-patchedFetchValue, factoryPatchedFrames, factoryPatchedLength, patchedOpenValue$1, factoryPatchedOpener, factoryPatchedParent, // Worker
+patchedFetchValue, factoryPatchedFrames, factoryPatchedLength, patchedOpenValue$1, factoryPatchedOpener, factoryPatchedParent, factoryPatchedPostMessage, // Worker
 patchedConstructor, patchedPrototype, // XHR
 patchedOpenValue];
 const fundamentalKeyedDistortionFactories = [// Aura
@@ -5436,8 +5512,8 @@ function makeBlockedPropertyDistortionFactories(globalObject) {
 
 const instrumentDistortionForSandbox = (sandboxKey, value, errorBeacon) => function instrumentedDistortionWrapper() {
   try {
-    for (var _len14 = arguments.length, args = new Array(_len14), _key15 = 0; _key15 < _len14; _key15++) {
-      args[_key15] = arguments[_key15];
+    for (var _len15 = arguments.length, args = new Array(_len15), _key16 = 0; _key16 < _len15; _key16++) {
+      args[_key16] = arguments[_key16];
     }
 
     return ReflectApply$3(value, this, args);
@@ -5511,7 +5587,7 @@ function createExternalDistortionEntries(globalObject, key, evaluator, config) {
   ReflectApply$3(ArrayProtoPush, entries, makeElementDistortionsForSandboxKey(key));
   return entries;
 } // @TODO: [Issue #373] Abstract common code in sandbox and distortion packages
-/*! version: 0.14.13 */
+/*! version: 0.14.15 */
 
 /*!
  * Copyright (C) 2021 salesforce.com, inc.
@@ -5634,8 +5710,11 @@ class DefaultInstrumentation {
 
 
 const defaultInstrumentation = new DefaultInstrumentation();
-/*! version: 0.14.13 */
+/*! version: 0.14.15 */
 
+/*!
+ * Copyright (C) 2019 salesforce.com, inc.
+ */
 /**
  * This file contains an exportable (portable) function `init` used to initialize
  * one side of a membrane on any realm. The only prerequisite is the ability to evaluate
@@ -5656,1347 +5735,1644 @@ const defaultInstrumentation = new DefaultInstrumentation();
  *    the foreign operation operates, it is always the first argument of the foreign
  *    callable for proxies, and the other side can use it via `getSelectedTarget`.
  */
-// eslint-disable-next-line no-shadow
+
+const {
+  setPrototypeOf: ReflectSetPrototypeOf
+} = Reflect; // eslint-disable-next-line no-shadow
+
 var SupportFlagsEnum;
+
 (function (SupportFlagsEnum) {
-    SupportFlagsEnum[SupportFlagsEnum["None"] = 0] = "None";
-    SupportFlagsEnum[SupportFlagsEnum["MagicMarker"] = 1] = "MagicMarker";
+  SupportFlagsEnum[SupportFlagsEnum["None"] = 0] = "None";
+  SupportFlagsEnum[SupportFlagsEnum["MagicMarker"] = 1] = "MagicMarker";
 })(SupportFlagsEnum || (SupportFlagsEnum = {}));
-// istanbul ignore next
+
+ReflectSetPrototypeOf(SupportFlagsEnum, null); // istanbul ignore next
+
 function createMembraneMarshall() {
-    // eslint-disable-next-line no-shadow
-    let MarshallSupportFlagsField;
-    (function (MarshallSupportFlagsField) {
-        MarshallSupportFlagsField[MarshallSupportFlagsField["None"] = 0] = "None";
-        MarshallSupportFlagsField[MarshallSupportFlagsField["MagicMarker"] = 1] = "MagicMarker";
-    })(MarshallSupportFlagsField || (MarshallSupportFlagsField = {}));
-    // eslint-disable-next-line no-shadow
-    let TargetIntegrityTraits;
-    (function (TargetIntegrityTraits) {
-        TargetIntegrityTraits[TargetIntegrityTraits["None"] = 0] = "None";
-        TargetIntegrityTraits[TargetIntegrityTraits["IsNotExtensible"] = 1] = "IsNotExtensible";
-        TargetIntegrityTraits[TargetIntegrityTraits["IsSealed"] = 2] = "IsSealed";
-        TargetIntegrityTraits[TargetIntegrityTraits["IsFrozen"] = 4] = "IsFrozen";
-        TargetIntegrityTraits[TargetIntegrityTraits["Revoked"] = 16] = "Revoked";
-    })(TargetIntegrityTraits || (TargetIntegrityTraits = {}));
-    // eslint-disable-next-line no-shadow
-    let TargetTraits;
-    (function (TargetTraits) {
-        TargetTraits[TargetTraits["None"] = 0] = "None";
-        TargetTraits[TargetTraits["IsArray"] = 1] = "IsArray";
-        TargetTraits[TargetTraits["IsFunction"] = 2] = "IsFunction";
-        TargetTraits[TargetTraits["IsObject"] = 4] = "IsObject";
-        TargetTraits[TargetTraits["IsArrowFunction"] = 8] = "IsArrowFunction";
-        TargetTraits[TargetTraits["Revoked"] = 16] = "Revoked";
-    })(TargetTraits || (TargetTraits = {}));
-    const { eval: cachedLocalEval } = globalThis;
-    const ArrayCtor = Array;
-    const { isArray: isArrayOrNotOrThrowForRevoked } = Array;
-    const { defineProperties: ObjectDefineProperties, freeze: ObjectFreeze, isFrozen: ObjectIsFrozen, isSealed: ObjectIsSealed, seal: ObjectSeal, } = Object;
-    const { hasOwnProperty: ObjectProtoHasOwnProperty, toString: ObjectProtoToString } = Object.prototype;
-    const { revocable: ProxyRevocable } = Proxy;
-    const { defineProperty: ReflectDefineProperty, getOwnPropertyDescriptor: ReflectGetOwnPropertyDescriptor, setPrototypeOf: ReflectSetPrototypeOf, apply: ReflectApply, construct: ReflectConstruct, deleteProperty: ReflectDeleteProperty, get: ReflectGet, set: ReflectSet, has: ReflectHas, getPrototypeOf: ReflectGetPrototypeOf, isExtensible: ReflectIsExtensible, ownKeys: ReflectOwnKeys, preventExtensions: ReflectPreventExtensions, } = Reflect;
-    const { slice: StringProtoSlice } = String.prototype;
-    const TypeErrorCtor = TypeError;
-    const { get: WeakMapProtoGet, set: WeakMapProtoSet } = WeakMap.prototype;
-    const LOCKER_LIVE_MARKER_SYMBOL = Symbol.for('@@lockerLiveValue');
-    const LOCKER_MAGIC_MARKER_SYMBOL = Symbol.for('@@lockerMagicValue');
-    const { toStringTag: TO_STRING_TAG_SYMBOL } = Symbol;
-    const UNDEFINED_SYMBOL = Symbol.for('@@membraneUndefinedValue');
-    return function createHooksCallback(color, trapMutations, supportFlags = SupportFlagsEnum.None, foreignCallableHooksCallback, options) {
-        const { distortionCallback = (o) => o, instrumentation } = options || {
-            __proto__: null,
-        };
-        const proxyTargetToPointerMap = new WeakMap();
-        const SUPPORT_MAGIC_MARKER = !!(supportFlags & MarshallSupportFlagsField.MagicMarker);
-        const INBOUND_INSTRUMENTATION_LABEL = `to:${color}`;
-        const OUTBOUND_INSTRUMENTATION_LABEL = `from:${color}`;
-        let foreignCallablePushTarget;
-        let foreignCallableApply;
-        let foreignCallableConstruct;
-        let foreignCallableDefineProperty;
-        let foreignCallableDeleteProperty;
-        let foreignCallableGetOwnPropertyDescriptor;
-        let foreignCallableGetPrototypeOf;
-        let foreignCallableIsExtensible;
-        let foreignCallableOwnKeys;
-        let foreignCallablePreventExtensions;
-        let foreignCallableSet;
-        let foreignCallableSetPrototypeOf;
-        let foreignCallableGetTargetIntegrityTraits;
-        let foreignCallableGetUnbrandedTag;
-        let foreignCallableHasOwnProperty;
-        let selectedTarget;
-        if (ReflectApply(ObjectProtoHasOwnProperty, Error, ['stackTraceLimit']) &&
-            typeof Error.stackTraceLimit === 'number') {
-            // The default stack trace limit is 10.
-            // Increasing to 20 as a baby step.
-            Error.stackTraceLimit *= 2;
+  const {
+    eval: cachedLocalEval
+  } = globalThis;
+  const ArrayCtor = Array;
+  const {
+    isArray: isArrayOrNotOrThrowForRevoked
+  } = Array;
+  const {
+    defineProperties: ObjectDefineProperties,
+    freeze: ObjectFreeze,
+    isFrozen: ObjectIsFrozen,
+    isSealed: ObjectIsSealed,
+    seal: ObjectSeal
+  } = Object;
+  const {
+    hasOwnProperty: ObjectProtoHasOwnProperty,
+    toString: ObjectProtoToString
+  } = Object.prototype;
+  const {
+    revocable: ProxyRevocable
+  } = Proxy;
+  const {
+    apply: ReflectApply,
+    construct: ReflectConstruct,
+    defineProperty: ReflectDefineProperty,
+    deleteProperty: ReflectDeleteProperty,
+    get: ReflectGet,
+    getOwnPropertyDescriptor: ReflectGetOwnPropertyDescriptor,
+    getPrototypeOf: ReflectGetPrototypeOf,
+    has: ReflectHas,
+    isExtensible: ReflectIsExtensible,
+    ownKeys: ReflectOwnKeys,
+    preventExtensions: ReflectPreventExtensions,
+    set: ReflectSet,
+    // eslint-disable-next-line @typescript-eslint/no-shadow, no-shadow
+    setPrototypeOf: ReflectSetPrototypeOf
+  } = Reflect;
+  const {
+    slice: StringProtoSlice
+  } = String.prototype;
+  const TypeErrorCtor = TypeError;
+  const {
+    get: WeakMapProtoGet,
+    set: WeakMapProtoSet
+  } = WeakMap.prototype;
+  const LOCKER_LIVE_MARKER_SYMBOL = Symbol.for('@@lockerLiveValue');
+  const LOCKER_MAGIC_MARKER_SYMBOL = Symbol.for('@@lockerMagicValue');
+  const {
+    toStringTag: TO_STRING_TAG_SYMBOL
+  } = Symbol;
+  const UNDEFINED_SYMBOL = Symbol.for('@@membraneUndefinedValue'); // eslint-disable-next-line no-shadow
+
+  let MarshallSupportFlagsField;
+
+  (function (MarshallSupportFlagsField) {
+    MarshallSupportFlagsField[MarshallSupportFlagsField["None"] = 0] = "None";
+    MarshallSupportFlagsField[MarshallSupportFlagsField["MagicMarker"] = 1] = "MagicMarker";
+  })(MarshallSupportFlagsField || (MarshallSupportFlagsField = {}));
+
+  ReflectSetPrototypeOf(MarshallSupportFlagsField, null); // eslint-disable-next-line no-shadow
+
+  let TargetIntegrityTraits;
+
+  (function (TargetIntegrityTraits) {
+    TargetIntegrityTraits[TargetIntegrityTraits["None"] = 0] = "None";
+    TargetIntegrityTraits[TargetIntegrityTraits["IsNotExtensible"] = 1] = "IsNotExtensible";
+    TargetIntegrityTraits[TargetIntegrityTraits["IsSealed"] = 2] = "IsSealed";
+    TargetIntegrityTraits[TargetIntegrityTraits["IsFrozen"] = 4] = "IsFrozen";
+    TargetIntegrityTraits[TargetIntegrityTraits["Revoked"] = 16] = "Revoked";
+  })(TargetIntegrityTraits || (TargetIntegrityTraits = {}));
+
+  ReflectSetPrototypeOf(TargetIntegrityTraits, null); // eslint-disable-next-line no-shadow
+
+  let TargetTraits;
+
+  (function (TargetTraits) {
+    TargetTraits[TargetTraits["None"] = 0] = "None";
+    TargetTraits[TargetTraits["IsArray"] = 1] = "IsArray";
+    TargetTraits[TargetTraits["IsFunction"] = 2] = "IsFunction";
+    TargetTraits[TargetTraits["IsObject"] = 4] = "IsObject";
+    TargetTraits[TargetTraits["IsArrowFunction"] = 8] = "IsArrowFunction";
+    TargetTraits[TargetTraits["Revoked"] = 16] = "Revoked";
+  })(TargetTraits || (TargetTraits = {}));
+
+  ReflectSetPrototypeOf(TargetTraits, null);
+  return function createHooksCallback(color, trapMutations) {
+    let supportFlags = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : SupportFlagsEnum.None;
+    let foreignCallableHooksCallback = arguments.length > 3 ? arguments[3] : undefined;
+    let options = arguments.length > 4 ? arguments[4] : undefined;
+    const {
+      distortionCallback = o => o,
+      instrumentation
+    } = options || {
+      __proto__: null
+    };
+    const proxyTargetToPointerMap = new WeakMap();
+    const INBOUND_INSTRUMENTATION_LABEL = `to:${color}`;
+    const OUTBOUND_INSTRUMENTATION_LABEL = `from:${color}`;
+    const SUPPORT_MAGIC_MARKER = !!(supportFlags & MarshallSupportFlagsField.MagicMarker);
+    let foreignCallablePushTarget;
+    let foreignCallableApply;
+    let foreignCallableConstruct;
+    let foreignCallableDefineProperty;
+    let foreignCallableDeleteProperty;
+    let foreignCallableGetOwnPropertyDescriptor;
+    let foreignCallableGetPrototypeOf;
+    let foreignCallableIsExtensible;
+    let foreignCallableOwnKeys;
+    let foreignCallablePreventExtensions;
+    let foreignCallableSet;
+    let foreignCallableSetPrototypeOf;
+    let foreignCallableGetTargetIntegrityTraits;
+    let foreignCallableGetUnbrandedTag;
+    let foreignCallableHasOwnProperty;
+    let selectedTarget;
+
+    function copyForeignDescriptorsIntoShadowTarget(shadowTarget, foreignTargetPointer) {
+      let keys = [];
+      foreignCallableOwnKeys(foreignTargetPointer, function () {
+        for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+          args[_key] = arguments[_key];
         }
-        function copyForeignDescriptorsIntoShadowTarget(shadowTarget, foreignTargetPointer) {
-            let keys = [];
-            foreignCallableOwnKeys(foreignTargetPointer, (...args) => {
-                keys = args;
-            });
-            const descriptors = {};
-            let safeDesc;
-            const callbackWithDescriptor = (configurable, enumerable, writable, valuePointer, getPointer, setPointer) => {
-                safeDesc = createDescriptorFromMeta(configurable, enumerable, writable, valuePointer, getPointer, setPointer);
-            };
-            for (let i = 0, len = keys.length; i < len; i += 1) {
-                const key = keys[i];
-                foreignCallableGetOwnPropertyDescriptor(foreignTargetPointer, key, callbackWithDescriptor);
-                descriptors[key] = safeDesc;
-            }
-            // Use `ObjectDefineProperties` instead of individual
-            // `ReflectDefineProperty` calls for better performance.
-            ObjectDefineProperties(shadowTarget, descriptors);
+
+        keys = args;
+      });
+      const descriptors = {};
+      let safeDesc;
+
+      const callbackWithDescriptor = (configurable, enumerable, writable, valuePointer, getPointer, setPointer) => {
+        safeDesc = createDescriptorFromMeta(configurable, enumerable, writable, valuePointer, getPointer, setPointer);
+      };
+
+      for (let i = 0, len = keys.length; i < len; i += 1) {
+        const key = keys[i];
+        foreignCallableGetOwnPropertyDescriptor(foreignTargetPointer, key, callbackWithDescriptor);
+
+        if (safeDesc) {
+          descriptors[key] = safeDesc;
         }
-        // metadata is the transferable descriptor definition
-        function createDescriptorFromMeta(configurable, enumerable, writable, valuePointer, getPointer, setPointer) {
+      } // Use `ObjectDefineProperties` instead of individual
+      // `ReflectDefineProperty` calls for better performance.
+
+
+      ObjectDefineProperties(shadowTarget, descriptors);
+    } // metadata is the transferable descriptor definition
+
+
+    function createDescriptorFromMeta(configurable, enumerable, writable, valuePointer, getPointer, setPointer) {
+      // @ts-ignore: TS doesn't like __proto__ on property descriptors.
+      const safeDesc = {
+        __proto__: null
+      };
+
+      if (configurable !== UNDEFINED_SYMBOL) {
+        safeDesc.configurable = !!configurable;
+      }
+
+      if (enumerable !== UNDEFINED_SYMBOL) {
+        safeDesc.enumerable = !!enumerable;
+      }
+
+      if (writable !== UNDEFINED_SYMBOL) {
+        safeDesc.writable = !!writable;
+      }
+
+      if (getPointer !== UNDEFINED_SYMBOL) {
+        safeDesc.get = getLocalValue(getPointer);
+      }
+
+      if (setPointer !== UNDEFINED_SYMBOL) {
+        safeDesc.set = getLocalValue(setPointer);
+      }
+
+      if (valuePointer !== UNDEFINED_SYMBOL) {
+        safeDesc.value = getLocalValue(valuePointer);
+      }
+
+      return safeDesc;
+    }
+
+    function createPointer(originalTarget) {
+      // assert: originalTarget is a ProxyTarget
+      const pointer = () => {
+        // assert: selectedTarget is undefined
+        selectedTarget = originalTarget;
+      };
+
+      {
+        // In case debugging is needed, the following lines can help:
+        pointer['[[OriginalTarget]]'] = originalTarget;
+        pointer['[[Color]]'] = color;
+      }
+      return pointer;
+    }
+
+    function createShadowTarget(targetTraits, targetFunctionName) {
+      let shadowTarget;
+
+      if (targetTraits & TargetTraits.IsFunction) {
+        // This shadow target is never invoked. It's needed to avoid
+        // proxy trap invariants. Because it's not invoked the code does
+        // not need to be instrumented for code coverage.
+        //
+        // istanbul ignore next
+        shadowTarget = // eslint-disable-next-line func-names
+        targetTraits & TargetTraits.IsArrowFunction ? () => {} : function () {};
+        {
+          // This is only really needed for debugging,
+          // it helps to identify the proxy by name
+          ReflectDefineProperty(shadowTarget, 'name', {
             // @ts-ignore: TS doesn't like __proto__ on property descriptors.
-            const safeDesc = { __proto__: null };
-            if (configurable !== UNDEFINED_SYMBOL) {
-                safeDesc.configurable = !!configurable;
-            }
-            if (enumerable !== UNDEFINED_SYMBOL) {
-                safeDesc.enumerable = !!enumerable;
-            }
-            if (writable !== UNDEFINED_SYMBOL) {
-                safeDesc.writable = !!writable;
-            }
-            if (getPointer !== UNDEFINED_SYMBOL) {
-                safeDesc.get = getLocalValue(getPointer);
-            }
-            if (setPointer !== UNDEFINED_SYMBOL) {
-                safeDesc.set = getLocalValue(setPointer);
-            }
-            if (valuePointer !== UNDEFINED_SYMBOL) {
-                safeDesc.value = getLocalValue(valuePointer);
-            }
-            return safeDesc;
+            __proto__: null,
+            configurable: true,
+            enumerable: false,
+            value: targetFunctionName,
+            writable: false
+          });
         }
-        function createPointer(originalTarget) {
-            // assert: originalTarget is a ProxyTarget
-            const pointer = () => {
-                // assert: selectedTarget is undefined
-                selectedTarget = originalTarget;
-            };
-            {
-                // In case debugging is needed, the following lines can help:
-                pointer['[[OriginalTarget]]'] = originalTarget;
-                pointer['[[Color]]'] = color;
-            }
-            return pointer;
+      } else {
+        // target is array or object
+        shadowTarget = targetTraits & TargetTraits.IsArray ? [] : {};
+      }
+
+      return shadowTarget;
+    } // this is needed even when using ShadowRealm, because the errors are not going
+    // to cross the callable boundary in a try/catch, instead, they need to be ported
+    // via the membrane artifacts.
+
+
+    function foreignErrorControl(foreignFn) {
+      return function foreignErrorControlFn() {
+        try {
+          for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
+            args[_key2] = arguments[_key2];
+          }
+
+          return ReflectApply(foreignFn, this, args);
+        } catch (e) {
+          const pushedError = getSelectedTarget();
+
+          if (pushedError) {
+            throw pushedError;
+          }
+
+          throw new TypeErrorCtor(e === null || e === void 0 ? void 0 : e.message);
         }
-        function createShadowTarget(targetTraits, targetFunctionName) {
-            let shadowTarget;
-            if (targetTraits & TargetTraits.IsFunction) {
-                // This shadow target is never invoked. It's needed to avoid
-                // proxy trap invariants. Because it's not invoked the code does
-                // not need to be instrumented for code coverage.
-                //
-                // istanbul ignore next
-                shadowTarget =
-                    // eslint-disable-next-line func-names
-                    targetTraits & TargetTraits.IsArrowFunction ? () => { } : function () { };
-                {
-                    // This is only really needed for debugging,
-                    // it helps to identify the proxy by name
-                    ReflectDefineProperty(shadowTarget, 'name', {
-                        // @ts-ignore: TS doesn't like __proto__ on property descriptors.
-                        __proto__: null,
-                        configurable: true,
-                        enumerable: false,
-                        value: targetFunctionName,
-                        writable: false,
-                    });
-                }
-            }
-            else {
-                // target is array or object
-                shadowTarget = targetTraits & TargetTraits.IsArray ? [] : {};
-            }
-            return shadowTarget;
+      };
+    }
+
+    function getDescriptorMeta(unsafePartialDesc) {
+      const safePartialDesc = toSafeDescriptor(unsafePartialDesc);
+      const {
+        configurable,
+        enumerable,
+        writable,
+        value,
+        get,
+        set
+      } = safePartialDesc;
+      return ['configurable' in safePartialDesc ? !!configurable : UNDEFINED_SYMBOL, 'enumerable' in safePartialDesc ? !!enumerable : UNDEFINED_SYMBOL, 'writable' in safePartialDesc ? !!writable : UNDEFINED_SYMBOL, 'value' in safePartialDesc ? getTransferableValue(value) : UNDEFINED_SYMBOL, 'get' in safePartialDesc ? getTransferableValue(get) : UNDEFINED_SYMBOL, 'set' in safePartialDesc ? getTransferableValue(set) : UNDEFINED_SYMBOL];
+    }
+
+    function getDistortedValue(target) {
+      let distortedTarget;
+
+      try {
+        distortedTarget = distortionCallback(target);
+        return distortedTarget;
+      } finally {
+        // if a distortion entry is found, it must be a valid proxy target
+        if (distortedTarget !== target && typeof distortedTarget !== typeof target) {
+          // eslint-disable-next-line no-unsafe-finally
+          throw new TypeErrorCtor(`Invalid distortion ${target}.`);
         }
-        // this is needed even when using ShadowRealm, because the errors are not going
-        // to cross the callable boundary in a try/catch, instead, they need to be ported
-        // via the membrane artifacts.
-        function foreignErrorControl(foreignFn) {
-            return function foreignErrorControlFn(...args) {
-                try {
-                    return ReflectApply(foreignFn, this, args);
-                }
-                catch (e) {
-                    const pushedError = getSelectedTarget();
-                    if (pushedError) {
-                        throw pushedError;
-                    }
-                    throw new TypeErrorCtor(e?.message);
-                }
-            };
+      }
+    }
+
+    function getInheritedPropertyDescriptor(foreignTargetPointer, key) {
+      // Avoiding calling the has trap for any proto chain operation,
+      // instead we implement the regular logic here in this trap.
+      let currentObject = liveGetPrototypeOf(foreignTargetPointer);
+
+      while (currentObject) {
+        const unsafeParentDesc = ReflectGetOwnPropertyDescriptor(currentObject, key);
+
+        if (unsafeParentDesc) {
+          return toSafeDescriptor(unsafeParentDesc);
         }
-        function getDescriptorMeta(unsafePartialDesc) {
-            const safePartialDesc = toSafeDescriptor(unsafePartialDesc);
-            const { configurable, enumerable, writable, value, get, set } = safePartialDesc;
-            return [
-                'configurable' in safePartialDesc ? !!configurable : UNDEFINED_SYMBOL,
-                'enumerable' in safePartialDesc ? !!enumerable : UNDEFINED_SYMBOL,
-                'writable' in safePartialDesc ? !!writable : UNDEFINED_SYMBOL,
-                'value' in safePartialDesc ? getTransferableValue(value) : UNDEFINED_SYMBOL,
-                'get' in safePartialDesc ? getTransferableValue(get) : UNDEFINED_SYMBOL,
-                'set' in safePartialDesc ? getTransferableValue(set) : UNDEFINED_SYMBOL,
-            ];
+
+        currentObject = ReflectGetPrototypeOf(currentObject);
+      }
+
+      return undefined;
+    }
+
+    function getLocalValue(pointerOrPrimitive) {
+      if (typeof pointerOrPrimitive === 'function') {
+        pointerOrPrimitive();
+        return getSelectedTarget();
+      }
+
+      return pointerOrPrimitive;
+    }
+
+    function getSelectedTarget() {
+      // assert: selectedTarget is a ProxyTarget
+      const result = selectedTarget;
+      selectedTarget = undefined;
+      return result;
+    }
+
+    function getTargetTraits(target) {
+      let targetTraits = TargetTraits.None;
+
+      if (typeof target === 'function') {
+        targetTraits |= TargetTraits.IsFunction; // detecting arrow function vs function
+
+        try {
+          targetTraits |= +!('prototype' in target) && TargetTraits.IsArrowFunction;
+        } catch (_unused) {// target is either a revoked proxy, or a proxy that
+          // throws on the `has` trap, in which case going with
+          // a strict mode function seems appropriate.
         }
-        function getDistortedValue(target) {
-            let distortedTarget;
-            try {
-                distortedTarget = distortionCallback(target);
-                return distortedTarget;
-            }
-            finally {
-                // if a distortion entry is found, it must be a valid proxy target
-                if (distortedTarget !== target && typeof distortedTarget !== typeof target) {
-                    // eslint-disable-next-line no-unsafe-finally
-                    throw new TypeErrorCtor(`Invalid distortion ${target}.`);
-                }
-            }
+      } else {
+        let targetIsArray = false;
+
+        try {
+          // try/catch in case Array.isArray throws when target
+          // is a revoked proxy
+          targetIsArray = isArrayOrNotOrThrowForRevoked(target);
+        } catch (_unused2) {
+          // TODO: this might be problematic, because functions
+          // and arrow functions should also be subject to this,
+          // but it seems that we can still create a proxy of
+          // a revoke, and wait until the user-land code actually
+          // access something out of it to throw the proper error.
+          // target is a revoked proxy, so the type doesn't matter
+          // much from this point on
+          targetTraits |= TargetTraits.Revoked;
         }
-        function getInheritedPropertyDescriptor(foreignTargetPointer, key) {
-            // Avoiding calling the has trap for any proto chain operation,
-            // instead we implement the regular logic here in this trap.
-            let currentObject = liveGetPrototypeOf(foreignTargetPointer);
-            while (currentObject) {
-                const unsafeParentDesc = ReflectGetOwnPropertyDescriptor(currentObject, key);
-                if (unsafeParentDesc) {
-                    return toSafeDescriptor(unsafeParentDesc);
-                }
-                currentObject = ReflectGetPrototypeOf(currentObject);
-            }
-            return undefined;
+
+        targetTraits |= +targetIsArray && TargetTraits.IsArray;
+        targetTraits |= +!targetIsArray && TargetTraits.IsObject;
+      }
+
+      return targetTraits;
+    }
+
+    function getTargetIntegrityTraits(target) {
+      let targetIntegrityTraits = TargetIntegrityTraits.None;
+
+      try {
+        // a revoked proxy will break the membrane when reading the meta
+        if (ObjectIsFrozen(target)) {
+          targetIntegrityTraits |= TargetIntegrityTraits.IsSealed & TargetIntegrityTraits.IsFrozen & TargetIntegrityTraits.IsNotExtensible;
+        } else if (ObjectIsSealed(target)) {
+          targetIntegrityTraits |= TargetIntegrityTraits.IsSealed;
+        } else if (!ReflectIsExtensible(target)) {
+          targetIntegrityTraits |= TargetIntegrityTraits.IsNotExtensible;
+        } // if the target was revoked or become revoked during the extraction
+        // of the metadata, we mark it as broken in the catch.
+
+
+        isArrayOrNotOrThrowForRevoked(target);
+      } catch (_unused3) {
+        // intentionally swallowing the error because this method is just
+        // extracting the metadata in a way that it should always succeed
+        // except for the cases in which the target is a proxy that is
+        // either revoked or has some logic that is incompatible with the
+        // membrane, in which case we will just create the proxy for the
+        // membrane but revoke it right after to prevent any leakage.
+        targetIntegrityTraits |= TargetIntegrityTraits.Revoked;
+      }
+
+      return targetIntegrityTraits;
+    }
+
+    function getTransferablePointer(originalTarget) {
+      let proxyPointer = ReflectApply(WeakMapProtoGet, proxyTargetToPointerMap, [originalTarget]);
+
+      if (proxyPointer) {
+        return proxyPointer;
+      }
+
+      const distortedTarget = getDistortedValue(originalTarget); // the closure works as the implicit WeakMap
+
+      const targetPointer = createPointer(distortedTarget);
+      const targetTraits = getTargetTraits(distortedTarget);
+      let targetFunctionName;
+
+      if (typeof originalTarget === 'function') {
+        try {
+          // a revoked proxy will throw when reading the function name
+          const unsafeDesc = ReflectGetOwnPropertyDescriptor(originalTarget, 'name');
+
+          if (unsafeDesc) {
+            const safeDesc = toSafeDescriptor(unsafeDesc);
+            targetFunctionName = safeDesc.value;
+          }
+        } catch (_unused4) {// intentionally swallowing the error because this method is just extracting
+          // the function in a way that it should always succeed except for the cases
+          // in which the provider is a proxy that is either revoked or has some logic
+          // to prevent reading the name property descriptor.
         }
-        function getLocalValue(pointerOrPrimitive) {
-            if (typeof pointerOrPrimitive === 'function') {
-                pointerOrPrimitive();
-                return getSelectedTarget();
+      }
+
+      proxyPointer = foreignCallablePushTarget(targetPointer, targetTraits, targetFunctionName); // the WeakMap is populated with the original target rather then the distorted one
+      // while the pointer always uses the distorted one.
+      // TODO: this mechanism poses another issue, which is that the return value of
+      // getSelectedTarget() can never be used to call across the membrane because that
+      // will cause a wrapping around the potential distorted value instead of the original
+      // value. This is not fatal, but implies that for every distorted value where will
+      // two proxies that are not ===, which is weird. Guaranteeing this is not easy because
+      // it means auditing the code.
+
+      ReflectApply(WeakMapProtoSet, proxyTargetToPointerMap, [originalTarget, proxyPointer]);
+      return proxyPointer;
+    }
+
+    function getTransferableValue(value) {
+      // Internationally ignoring the case of (typeof document.all === 'undefined')
+      // because in the reserve membrane, you never get one of those exotic objects.
+      if (typeof value === 'undefined') {
+        return undefined;
+      } // TODO: What other ways to optimize this method?
+
+
+      if (value === null || typeof value !== 'function' && typeof value !== 'object') {
+        return value;
+      }
+
+      return getTransferablePointer(value);
+    } // This wrapping mechanism provides the means to add instrumentation
+    // to the callable functions used to coordinate work between the sides
+    // of the membrane.
+    // TODO: do we need to pass more info into instrumentation hooks?
+    // prettier-ignore
+
+
+    function instrumentCallableWrapper(fn, activityName, crossingDirection) {
+      if (instrumentation) {
+        return function instrumentedFn() {
+          const activity = instrumentation.startActivity(activityName, {
+            crossingDirection
+          });
+
+          try {
+            for (var _len3 = arguments.length, args = new Array(_len3), _key3 = 0; _key3 < _len3; _key3++) {
+              args[_key3] = arguments[_key3];
             }
-            return pointerOrPrimitive;
+
+            return ReflectApply(fn, this, args);
+          } catch (e) {
+            activity.error(e);
+            throw e;
+          } finally {
+            activity.stop();
+          }
+        };
+      }
+
+      return fn;
+    }
+    /**
+     * An object is marked as a "live" object when it has a
+     * LOCKER_LIVE_MARKER_SYMBOL property. Live objects have their
+     * defineProperty, deleteProperty, preventExtensions, set, and
+     * setPrototypeOf proxy traps as "live" variations meaning that when
+     * mutation occurs instead of maintaining a separate object graph of
+     * changes the mutations are performed directly on the foreign target.
+     *
+     */
+
+
+    function isForeignTargetMarkedLive(foreignTargetPointer) {
+      return foreignCallableHasOwnProperty(foreignTargetPointer, LOCKER_LIVE_MARKER_SYMBOL);
+    }
+    /**
+     * An object is marked as a "magic" object when it has a
+     * LOCKER_MAGIC_MARKER_SYMBOL property. These objects have magical side
+     * effects when setting properties, which would be broken by a Define
+     * Property operation. For example, the `style` object of an HTMLElement
+     * in Safari <= 14. This marker is a signal to the membrane that it must
+     * use a Set operation, instead of a Define Property operation.
+     *
+     */
+
+
+    function isMarkedMagic(object) {
+      return SUPPORT_MAGIC_MARKER && ReflectApply(ObjectProtoHasOwnProperty, object, [LOCKER_MAGIC_MARKER_SYMBOL]);
+    }
+
+    function liveDefineProperty(foreignTargetPointer, shadowTarget, key, unsafePartialDesc) {
+      const descMeta = getDescriptorMeta(unsafePartialDesc);
+      const result = foreignCallableDefineProperty(foreignTargetPointer, key, descMeta[0], // configurable
+      descMeta[1], // enumerable
+      descMeta[2], // writable
+      descMeta[3], // valuePointer
+      descMeta[4], // getPointer
+      descMeta[5] // setPointer
+      );
+
+      if (result) {
+        // Intentionally testing against false since it could be
+        // undefined as well
+        if (descMeta[0]
+        /* configurable */
+        === false) {
+          foreignCallableGetOwnPropertyDescriptor(foreignTargetPointer, key, (configurable, enumerable, writable, valuePointer, getPointer, setPointer) => {
+            ReflectDefineProperty(shadowTarget, key, createDescriptorFromMeta(configurable, enumerable, writable, valuePointer, getPointer, setPointer));
+          });
         }
-        function getSelectedTarget() {
-            // assert: selectedTarget is a ProxyTarget
-            const r = selectedTarget;
-            selectedTarget = undefined;
-            return r;
+      }
+
+      return result;
+    }
+
+    function liveDeleteProperty(foreignTargetPointer, _shadowTarget, key) {
+      return foreignCallableDeleteProperty(foreignTargetPointer, key);
+    }
+
+    function liveGet(foreignTargetPointer, shadowTarget, key, receiver) {
+      const safeDesc = liveGetOwnPropertyDescriptor(foreignTargetPointer, shadowTarget, key) || getInheritedPropertyDescriptor(foreignTargetPointer, key);
+
+      if (safeDesc) {
+        const {
+          get: getter,
+          value: localValue
+        } = safeDesc;
+
+        if (getter) {
+          // Even though the getter function exists, we can't use
+          // `ReflectGet` because there might be a distortion for
+          // that getter function, in which case we must resolve
+          // the local getter and call it instead.
+          return ReflectApply(getter, receiver, []);
         }
-        function getTargetTraits(target) {
-            let targetTraits = TargetTraits.None;
-            if (typeof target === 'function') {
-                targetTraits |= TargetTraits.IsFunction;
-                // detecting arrow function vs function
-                try {
-                    targetTraits |= +!('prototype' in target) && TargetTraits.IsArrowFunction;
-                }
-                catch {
-                    // target is either a revoked proxy, or a proxy that
-                    // throws on the `has` trap, in which case going with
-                    // a strict mode function seems appropriate.
-                }
-            }
-            else {
-                let targetIsArray = false;
-                try {
-                    // try/catch in case Array.isArray throws when target
-                    // is a revoked proxy
-                    targetIsArray = isArrayOrNotOrThrowForRevoked(target);
-                }
-                catch {
-                    // TODO: this might be problematic, because functions
-                    // and arrow functions should also be subject to this,
-                    // but it seems that we can still create a proxy of
-                    // a revoke, and wait until the user-land code actually
-                    // access something out of it to throw the proper error.
-                    // target is a revoked proxy, so the type doesn't matter
-                    // much from this point on
-                    targetTraits |= TargetTraits.Revoked;
-                }
-                targetTraits |= +targetIsArray && TargetTraits.IsArray;
-                targetTraits |= +!targetIsArray && TargetTraits.IsObject;
-            }
-            return targetTraits;
+
+        return localValue;
+      }
+
+      if (key === TO_STRING_TAG_SYMBOL) {
+        return foreignCallableGetUnbrandedTag(foreignTargetPointer);
+      }
+
+      return undefined;
+    }
+
+    function liveGetOwnPropertyDescriptor(foreignTargetPointer, shadowTarget, key) {
+      let safeDesc;
+      foreignCallableGetOwnPropertyDescriptor(foreignTargetPointer, key, (configurable, enumerable, writable, valuePointer, getPointer, setPointer) => {
+        safeDesc = createDescriptorFromMeta(configurable, enumerable, writable, valuePointer, getPointer, setPointer);
+
+        if (safeDesc.configurable === false) {
+          // updating the descriptor to non-configurable on the shadow
+          ReflectDefineProperty(shadowTarget, key, safeDesc);
         }
-        function getTargetIntegrityTraits(target) {
-            let targetIntegrityTraits = TargetIntegrityTraits.None;
-            try {
-                // a revoked proxy will break the membrane when reading the meta
-                if (ObjectIsFrozen(target)) {
-                    targetIntegrityTraits |=
-                        TargetIntegrityTraits.IsSealed &
-                            TargetIntegrityTraits.IsFrozen &
-                            TargetIntegrityTraits.IsNotExtensible;
-                }
-                else if (ObjectIsSealed(target)) {
-                    targetIntegrityTraits |= TargetIntegrityTraits.IsSealed;
-                }
-                else if (!ReflectIsExtensible(target)) {
-                    targetIntegrityTraits |= TargetIntegrityTraits.IsNotExtensible;
-                }
-                // if the target was revoked or become revoked during the extraction
-                // of the metadata, we mark it as broken in the catch.
-                isArrayOrNotOrThrowForRevoked(target);
-            }
-            catch {
-                // intentionally swallowing the error because this method is just
-                // extracting the metadata in a way that it should always succeed
-                // except for the cases in which the target is a proxy that is
-                // either revoked or has some logic that is incompatible with the
-                // membrane, in which case we will just create the proxy for the
-                // membrane but revoke it right after to prevent any leakage.
-                targetIntegrityTraits |= TargetIntegrityTraits.Revoked;
-            }
-            return targetIntegrityTraits;
+      });
+      return safeDesc;
+    }
+
+    function liveGetPrototypeOf(foreignTargetPointer) {
+      return getLocalValue(foreignCallableGetPrototypeOf(foreignTargetPointer));
+    }
+
+    function liveHas(foreignTargetPointer, key) {
+      if (foreignCallableHasOwnProperty(foreignTargetPointer, key)) {
+        return true;
+      } // Avoiding calling the has trap for any proto chain operation,
+      // instead we implement the regular logic here in this trap.
+
+
+      let currentObject = liveGetPrototypeOf(foreignTargetPointer);
+
+      while (currentObject) {
+        if (ReflectApply(ObjectProtoHasOwnProperty, currentObject, [key])) {
+          return true;
         }
-        function getTransferablePointer(originalTarget) {
-            let proxyPointer = ReflectApply(WeakMapProtoGet, proxyTargetToPointerMap, [
-                originalTarget,
-            ]);
-            if (proxyPointer) {
-                return proxyPointer;
-            }
-            const distortedTarget = getDistortedValue(originalTarget);
-            // the closure works as the implicit WeakMap
-            const targetPointer = createPointer(distortedTarget);
-            const targetTraits = getTargetTraits(distortedTarget);
-            let targetFunctionName;
-            if (typeof originalTarget === 'function') {
-                try {
-                    // a revoked proxy will throw when reading the function name
-                    const unsafeDesc = ReflectGetOwnPropertyDescriptor(originalTarget, 'name');
-                    if (unsafeDesc) {
-                        const safeDesc = toSafeDescriptor(unsafeDesc);
-                        targetFunctionName = safeDesc.value;
-                    }
-                }
-                catch {
-                    // intentionally swallowing the error because this method is just extracting
-                    // the function in a way that it should always succeed except for the cases
-                    // in which the provider is a proxy that is either revoked or has some logic
-                    // to prevent reading the name property descriptor.
-                }
-            }
-            proxyPointer = foreignCallablePushTarget(targetPointer, targetTraits, targetFunctionName);
-            // the WeakMap is populated with the original target rather then the distorted one
-            // while the pointer always uses the distorted one.
-            // TODO: this mechanism poses another issue, which is that the return value of
-            // getSelectedTarget() can never be used to call across the membrane because that
-            // will cause a wrapping around the potential distorted value instead of the original
-            // value. This is not fatal, but implies that for every distorted value where will
-            // two proxies that are not ===, which is weird. Guaranteeing this is not easy because
-            // it means auditing the code.
-            ReflectApply(WeakMapProtoSet, proxyTargetToPointerMap, [originalTarget, proxyPointer]);
-            return proxyPointer;
+
+        currentObject = ReflectGetPrototypeOf(currentObject);
+      }
+
+      return false;
+    }
+
+    function liveIsExtensible(foreignTargetPointer, shadowTarget) {
+      // check if already locked
+      if (ReflectIsExtensible(shadowTarget)) {
+        if (foreignCallableIsExtensible(foreignTargetPointer)) {
+          return true;
         }
-        function getTransferableValue(value) {
-            // internationally ignoring the case of (typeof document.all === 'undefined') because
-            // in the reserve membrane, you never get one of those exotic objects
-            if (typeof value === 'undefined') {
-                return undefined;
-            }
-            // TODO: what other ways to optimize this method?
-            if (value === null || (typeof value !== 'function' && typeof value !== 'object')) {
-                return value;
-            }
-            return getTransferablePointer(value);
-        }
-        // This wrapping mechanism provides the means to add instrumentation
-        // to the callable functions used to coordinate work between the sides
-        // of the membrane.
-        // TODO: do we need to pass more info into instrumentation hooks?
-        // prettier-ignore
-        function instrumentCallableWrapper(fn, activityName, crossingDirection) {
-            if (instrumentation) {
-                return function instrumentedFn(...args) {
-                    const activity = instrumentation.startActivity(activityName, {
-                        crossingDirection
-                    });
-                    try {
-                        return ReflectApply(fn, this, args);
-                    }
-                    catch (e) {
-                        activity.error(e);
-                        throw e;
-                    }
-                    finally {
-                        activity.stop();
-                    }
-                };
-            }
-            return fn;
-        }
-        /**
-         * An object is marked as a "live" object when it has a
-         * LOCKER_LIVE_MARKER_SYMBOL property. Live objects have their
-         * defineProperty, deleteProperty, preventExtensions, set, and
-         * setPrototypeOf proxy traps as "live" variations meaning that when
-         * mutation occurs instead of maintaining a separate object graph of
-         * changes the mutations are performed directly on the foreign target.
-         *
-         */
-        function isForeignTargetMarkedLive(foreignTargetPointer) {
-            return foreignCallableHasOwnProperty(foreignTargetPointer, LOCKER_LIVE_MARKER_SYMBOL);
-        }
-        /**
-         * An object is marked as a "magic" object when it has a
-         * LOCKER_MAGIC_MARKER_SYMBOL property. These objects have magical side
-         * effects when setting properties, which would be broken by a Define
-         * Property operation. For example, the `style` object of an HTMLElement
-         * in Safari <= 14. This marker is a signal to the membrane that it must
-         * use a Set operation, instead of a Define Property operation.
-         *
-         */
-        function isMarkedMagic(object) {
-            return (SUPPORT_MAGIC_MARKER &&
-                ReflectApply(ObjectProtoHasOwnProperty, object, [LOCKER_MAGIC_MARKER_SYMBOL]));
-        }
-        function liveDefineProperty(foreignTargetPointer, shadowTarget, key, unsafePartialDesc) {
-            const descMeta = getDescriptorMeta(unsafePartialDesc);
-            const result = foreignCallableDefineProperty(foreignTargetPointer, key, descMeta[0], // configurable
-            descMeta[1], // enumerable
-            descMeta[2], // writable
-            descMeta[3], // valuePointer
-            descMeta[4], // getPointer
-            descMeta[5] // setPointer
-            );
-            if (result) {
-                // Intentionally testing against false since it could be
-                // undefined as well
-                if (descMeta[0] /* configurable */ === false) {
-                    foreignCallableGetOwnPropertyDescriptor(foreignTargetPointer, key, (configurable, enumerable, writable, valuePointer, getPointer, setPointer) => {
-                        ReflectDefineProperty(shadowTarget, key, createDescriptorFromMeta(configurable, enumerable, writable, valuePointer, getPointer, setPointer));
-                    });
-                }
-            }
-            return result;
-        }
-        function liveDeleteProperty(foreignTargetPointer, _shadowTarget, key) {
-            return foreignCallableDeleteProperty(foreignTargetPointer, key);
+
+        lockShadowTarget(shadowTarget, foreignTargetPointer);
+      }
+
+      return false;
+    }
+
+    function liveOwnKeys(foreignTargetPointer) {
+      let keys;
+      foreignCallableOwnKeys(foreignTargetPointer, function () {
+        for (var _len4 = arguments.length, args = new Array(_len4), _key4 = 0; _key4 < _len4; _key4++) {
+          args[_key4] = arguments[_key4];
         }
-        function liveGet(foreignTargetPointer, shadowTarget, key, receiver) {
-            const safeDesc = liveGetOwnPropertyDescriptor(foreignTargetPointer, shadowTarget, key) ||
-                getInheritedPropertyDescriptor(foreignTargetPointer, key);
-            if (safeDesc) {
-                const { get: getter, value: localValue } = safeDesc;
-                if (getter) {
-                    // Even though the getter function exists, we can't use
-                    // `ReflectGet` because there might be a distortion for
-                    // that getter function, in which case we must resolve
-                    // the local getter and call it instead.
-                    return ReflectApply(getter, receiver, []);
-                }
-                return localValue;
-            }
-            if (key === TO_STRING_TAG_SYMBOL) {
-                return foreignCallableGetUnbrandedTag(foreignTargetPointer);
-            }
-            return undefined;
+
+        keys = args;
+      }); // @ts-ignore: Prevent used before assignment error.
+
+      return keys || [];
+    }
+
+    function livePreventExtensions(foreignTargetPointer, shadowTarget) {
+      if (ReflectIsExtensible(shadowTarget)) {
+        if (!foreignCallablePreventExtensions(foreignTargetPointer)) {
+          // if the target is a proxy manually created, it might
+          // reject the preventExtension call, in which case we
+          // should not attempt to lock down the shadow target.
+          if (!foreignCallableIsExtensible(foreignTargetPointer)) {
+            lockShadowTarget(shadowTarget, foreignTargetPointer);
+          }
+
+          return false;
         }
-        function liveGetOwnPropertyDescriptor(foreignTargetPointer, shadowTarget, key) {
-            let safeDesc;
-            foreignCallableGetOwnPropertyDescriptor(foreignTargetPointer, key, (configurable, enumerable, writable, valuePointer, getPointer, setPointer) => {
-                safeDesc = createDescriptorFromMeta(configurable, enumerable, writable, valuePointer, getPointer, setPointer);
-                if (safeDesc.configurable === false) {
-                    // updating the descriptor to non-configurable on the shadow
-                    ReflectDefineProperty(shadowTarget, key, safeDesc);
-                }
-            });
-            return safeDesc;
+
+        lockShadowTarget(shadowTarget, foreignTargetPointer);
+      }
+
+      return true;
+    }
+
+    function liveSet(foreignTargetPointer, shadowTarget, key, value, receiver, useFastPath) {
+      // Following the specification steps for
+      // OrdinarySetWithOwnDescriptor ( O, P, V, Receiver, ownDesc ).
+      // https://tc39.es/ecma262/#sec-ordinarysetwithowndescriptor
+      const safeOwnDesc = liveGetOwnPropertyDescriptor(foreignTargetPointer, shadowTarget, key);
+      const safeDesc = safeOwnDesc || getInheritedPropertyDescriptor(foreignTargetPointer, key);
+
+      if (safeDesc) {
+        if ('get' in safeDesc || 'set' in safeDesc) {
+          const {
+            set: setter
+          } = safeDesc;
+
+          if (setter) {
+            // Even though the setter function exists, we can't use
+            // `ReflectSet` because there might be a distortion for
+            // that setter function, in which case we must resolve
+            // the local setter and call it instead.
+            ReflectApply(setter, receiver, [value]); // If there is a setter, it either throw or we can assume
+            // the value was set.
+
+            return true;
+          }
+
+          return false;
         }
-        function liveGetPrototypeOf(foreignTargetPointer) {
-            return getLocalValue(foreignCallableGetPrototypeOf(foreignTargetPointer));
+
+        if (safeDesc.writable === false) {
+          return false;
         }
-        function liveHas(foreignTargetPointer, key) {
-            if (foreignCallableHasOwnProperty(foreignTargetPointer, key)) {
-                return true;
-            }
-            // avoiding calling the has trap for any proto chain operation,
-            // instead we implement the regular logic here in this trap.
-            let currentObject = liveGetPrototypeOf(foreignTargetPointer);
-            while (currentObject) {
-                if (ReflectApply(ObjectProtoHasOwnProperty, currentObject, [key])) {
-                    return true;
-                }
-                currentObject = ReflectGetPrototypeOf(currentObject);
-            }
-            return false;
+      }
+
+      let safeReceiverDesc;
+
+      if (useFastPath) {
+        // In the fast path we know the receiver is the proxy.
+        safeReceiverDesc = safeOwnDesc;
+      } else {
+        // Exit early if receiver is not object like.
+        if (receiver === null || typeof receiver !== 'function' && typeof receiver !== 'object') {
+          return false;
         }
-        function liveIsExtensible(foreignTargetPointer, shadowTarget) {
-            // check if already locked
-            if (ReflectIsExtensible(shadowTarget)) {
-                if (foreignCallableIsExtensible(foreignTargetPointer)) {
-                    return true;
-                }
-                lockShadowTarget(shadowTarget, foreignTargetPointer);
-            }
-            return false;
+
+        const unsafeReceiverDesc = ReflectGetOwnPropertyDescriptor(receiver, key);
+
+        if (unsafeReceiverDesc) {
+          safeReceiverDesc = toSafeDescriptor(unsafeReceiverDesc);
         }
-        function liveOwnKeys(foreignTargetPointer) {
-            let keys;
-            foreignCallableOwnKeys(foreignTargetPointer, (...args) => {
-                keys = args;
-            });
-            // @ts-ignore: Prevent used before assignment error.
-            return keys || [];
+      }
+
+      if (safeReceiverDesc) {
+        // Exit early for accessor descriptors or non-writable data
+        // descriptors.
+        if ('get' in safeReceiverDesc || 'set' in safeReceiverDesc || safeReceiverDesc.writable === false) {
+          return false;
         }
-        function livePreventExtensions(foreignTargetPointer, shadowTarget) {
-            if (ReflectIsExtensible(shadowTarget)) {
-                if (!foreignCallablePreventExtensions(foreignTargetPointer)) {
-                    // if the target is a proxy manually created, it might
-                    // reject the preventExtension call, in which case we
-                    // should not attempt to lock down the shadow target.
-                    if (!foreignCallableIsExtensible(foreignTargetPointer)) {
-                        lockShadowTarget(shadowTarget, foreignTargetPointer);
-                    }
-                    return false;
-                }
-                lockShadowTarget(shadowTarget, foreignTargetPointer);
-            }
-            return true;
+
+        if (isMarkedMagic(receiver)) {
+          // Workaround for Safari <= 14 bug on CSSStyleDeclaration
+          // objects which lose their magic setters if set with
+          // defineProperty.
+          foreignCallableSet(foreignTargetPointer, key, getTransferableValue(value), getTransferablePointer(receiver));
+        } else {
+          // Setting the descriptor with only a value entry should not
+          // affect existing descriptor traits.
+          ReflectDefineProperty(receiver, key, {
+            // @ts-ignore: TS doesn't like __proto__ on property descriptors.
+            __proto__: null,
+            value
+          });
         }
-        function liveSet(foreignTargetPointer, shadowTarget, key, value, receiver, useFastPath) {
-            // Following the specification steps for
-            // OrdinarySetWithOwnDescriptor ( O, P, V, Receiver, ownDesc ).
-            // https://tc39.es/ecma262/#sec-ordinarysetwithowndescriptor
-            const safeOwnDesc = liveGetOwnPropertyDescriptor(foreignTargetPointer, shadowTarget, key);
-            const safeDesc = safeOwnDesc || getInheritedPropertyDescriptor(foreignTargetPointer, key);
-            if (safeDesc) {
-                if ('get' in safeDesc || 'set' in safeDesc) {
-                    const { set: setter } = safeDesc;
-                    if (setter) {
-                        // Even though the setter function exists, we can't use
-                        // `ReflectSet` because there might be a distortion for
-                        // that setter function, in which case we must resolve
-                        // the local setter and call it instead.
-                        ReflectApply(setter, receiver, [value]);
-                        // If there is a setter, it either throw or we can assume
-                        // the value was set.
-                        return true;
-                    }
-                    return false;
-                }
-                if (safeDesc.writable === false) {
-                    return false;
-                }
-            }
-            let safeReceiverDesc;
-            if (useFastPath) {
-                // In the fast path we know the receiver is the proxy.
-                safeReceiverDesc = safeOwnDesc;
-            }
-            else {
-                // Exit early if receiver is not object like.
-                if (receiver === null ||
-                    (typeof receiver !== 'function' && typeof receiver !== 'object')) {
-                    return false;
-                }
-                const unsafeReceiverDesc = ReflectGetOwnPropertyDescriptor(receiver, key);
-                if (unsafeReceiverDesc) {
-                    safeReceiverDesc = toSafeDescriptor(unsafeReceiverDesc);
-                }
+
+        return true;
+      } // `ReflectDefineProperty` and `ReflectSet` both are expected to
+      // return `false` when attempting to add a new property if the
+      // receiver is not extensible.
+
+
+      return ReflectDefineProperty(receiver, key, {
+        // @ts-ignore: TS doesn't like __proto__ on property descriptors.
+        __proto__: null,
+        configurable: true,
+        enumerable: true,
+        value,
+        writable: true
+      });
+    }
+
+    function liveSetPrototypeOf(foreignTargetPointer, proto) {
+      const transferableProto = getTransferableValue(proto);
+      return foreignCallableSetPrototypeOf(foreignTargetPointer, transferableProto);
+    }
+
+    function lockShadowTarget(shadowTarget, foreignTargetPointer) {
+      copyForeignDescriptorsIntoShadowTarget(shadowTarget, foreignTargetPointer); // setting up __proto__ of the shadowTarget
+
+      const proto = liveGetPrototypeOf(foreignTargetPointer);
+      ReflectSetPrototypeOf(shadowTarget, proto); // locking down the extensibility of shadowTarget
+
+      ReflectPreventExtensions(shadowTarget);
+    }
+
+    function pushErrorAcrossBoundary(e) {
+      const transferableError = getTransferableValue(e);
+
+      if (typeof transferableError === 'function') {
+        transferableError();
+      }
+
+      return e;
+    }
+
+    function toSafeDescriptor(desc) {
+      ReflectSetPrototypeOf(desc, null);
+      return desc;
+    }
+
+    class BoundaryProxyHandler {
+      constructor(foreignTargetPointer, foreignTargetTraits, foreignTargetFunctionName) {
+        // the purpose of this public field is to help developers to identify
+        // what side of the membrane they are debugging.
+        this.color = color; // apply trap is generic, and should never change independently of the type of membrane
+
+        this.apply = function applyTrap(_shadowTarget, thisArg, args) {
+          const {
+            foreignTargetPointer
+          } = this;
+          const transferableThisArg = getTransferableValue(thisArg);
+          const combinedArgs = [foreignTargetPointer, transferableThisArg];
+          const {
+            length: argsLen
+          } = args;
+          const {
+            length: combinedOffset
+          } = combinedArgs;
+          combinedArgs.length += argsLen;
+
+          for (let i = 0, len = argsLen; i < len; i += 1) {
+            const arg = args[i];
+            const combinedIndex = i + combinedOffset; // Inlining `getTransferableValue`.
+
+            if (typeof arg === 'undefined') {
+              combinedArgs[combinedIndex] = undefined;
+            } else if (arg === null || typeof arg !== 'function' && typeof arg !== 'object') {
+              combinedArgs[combinedIndex] = arg;
+            } else {
+              combinedArgs[combinedIndex] = getTransferablePointer(arg);
             }
-            if (safeReceiverDesc) {
-                // Exit early for accessor descriptors or non-writable data
-                // descriptors.
-                if ('get' in safeReceiverDesc ||
-                    'set' in safeReceiverDesc ||
-                    safeReceiverDesc.writable === false) {
-                    return false;
-                }
-                if (isMarkedMagic(receiver)) {
-                    // Workaround for Safari <= 14 bug on CSSStyleDeclaration
-                    // objects which lose their magic setters if set with
-                    // defineProperty.
-                    foreignCallableSet(foreignTargetPointer, key, getTransferableValue(value), getTransferablePointer(receiver));
-                }
-                else {
-                    // Setting the descriptor with only a value entry should not
-                    // affect existing descriptor traits.
-                    ReflectDefineProperty(receiver, key, {
-                        // @ts-ignore: TS doesn't like __proto__ on property descriptors.
-                        __proto__: null,
-                        value,
-                    });
-                }
-                return true;
+          }
+
+          return getLocalValue(ReflectApply(foreignCallableApply, undefined, combinedArgs));
+        }; // construct trap is generic, and should never change independently
+        // of the type of membrane
+
+
+        this.construct = function constructTrap(_shadowTarget, args, newTarget) {
+          if (newTarget === undefined) {
+            throw new TypeErrorCtor();
+          }
+
+          const {
+            foreignTargetPointer
+          } = this;
+          const transferableNewTarget = getTransferableValue(newTarget);
+          const combinedArgs = [foreignTargetPointer, transferableNewTarget];
+          const {
+            length: argsLen
+          } = args;
+          const {
+            length: combinedOffset
+          } = combinedArgs;
+          combinedArgs.length += argsLen;
+
+          for (let i = 0, len = argsLen; i < len; i += 1) {
+            const arg = args[i];
+            const combinedIndex = i + combinedOffset; // Inline `getTransferableValue`.
+
+            if (typeof arg === 'undefined') {
+              combinedArgs[combinedIndex] = undefined;
+            } else if (arg === null || typeof arg !== 'function' && typeof arg !== 'object') {
+              combinedArgs[combinedIndex] = arg;
+            } else {
+              combinedArgs[combinedIndex] = getTransferablePointer(arg);
             }
-            // `ReflectDefineProperty` and `ReflectSet` both are expected to
-            // return `false` when attempting to add a new property if the
-            // receiver is not extensible.
-            return ReflectDefineProperty(receiver, key, {
-                // @ts-ignore: TS doesn't like __proto__ on property descriptors.
-                __proto__: null,
-                configurable: true,
-                enumerable: true,
-                value,
-                writable: true,
-            });
-        }
-        function liveSetPrototypeOf(foreignTargetPointer, proto) {
-            const transferableProto = getTransferableValue(proto);
-            return foreignCallableSetPrototypeOf(foreignTargetPointer, transferableProto);
-        }
-        function lockShadowTarget(shadowTarget, foreignTargetPointer) {
-            copyForeignDescriptorsIntoShadowTarget(shadowTarget, foreignTargetPointer);
-            // setting up __proto__ of the shadowTarget
-            const proto = liveGetPrototypeOf(foreignTargetPointer);
-            ReflectSetPrototypeOf(shadowTarget, proto);
-            // locking down the extensibility of shadowTarget
-            ReflectPreventExtensions(shadowTarget);
+          }
+
+          return getLocalValue(ReflectApply(foreignCallableConstruct, undefined, combinedArgs));
+        };
+
+        const shadowTarget = createShadowTarget(foreignTargetTraits, foreignTargetFunctionName);
+        const {
+          proxy,
+          revoke
+        } = ProxyRevocable(shadowTarget, this);
+        this.foreignTargetPointer = foreignTargetPointer;
+        this.proxy = proxy;
+        this.revoke = revoke; // inserting default traps
+
+        this.defineProperty = BoundaryProxyHandler.defaultDefinePropertyTrap;
+        this.deleteProperty = BoundaryProxyHandler.defaultDeletePropertyTrap;
+        this.isExtensible = BoundaryProxyHandler.defaultIsExtensibleTrap;
+        this.getOwnPropertyDescriptor = BoundaryProxyHandler.defaultGetOwnPropertyDescriptorTrap;
+        this.getPrototypeOf = BoundaryProxyHandler.defaultGetPrototypeOfTrap;
+        this.get = BoundaryProxyHandler.defaultGetTrap;
+        this.has = BoundaryProxyHandler.defaultHasTrap;
+        this.ownKeys = BoundaryProxyHandler.defaultOwnKeysTrap;
+        this.preventExtensions = BoundaryProxyHandler.defaultPreventExtensionsTrap;
+        this.setPrototypeOf = BoundaryProxyHandler.defaultSetPrototypeOfTrap;
+        this.set = BoundaryProxyHandler.defaultSetTrap;
+
+        if (foreignTargetTraits & TargetTraits.Revoked) {
+          revoke();
         }
-        function pushErrorAcrossBoundary(e) {
-            const transferableError = getTransferableValue(e);
-            if (typeof transferableError === 'function') {
-                transferableError();
-            }
-            return e;
+
+        if (!trapMutations) {
+          // if local mutations are not trapped, then freezing the handler is ok
+          // because it is not expecting to change in the future.
+          // future optimization: hoping that proxies with frozen handlers can be faster
+          ObjectFreeze(this);
         }
-        function toSafeDescriptor(desc) {
-            ReflectSetPrototypeOf(desc, null);
-            return desc;
+      } // internal utilities
+
+
+      makeProxyLive() {
+        // assert: trapMutations must be true
+        // replacing pending traps with live traps that can work with
+        // the target without taking snapshots.
+        this.defineProperty = BoundaryProxyHandler.liveDefinePropertyTrap;
+        this.deleteProperty = BoundaryProxyHandler.liveDeletePropertyTrap;
+        this.preventExtensions = BoundaryProxyHandler.livePreventExtensionsTrap;
+        this.set = BoundaryProxyHandler.liveSetTrap;
+        this.setPrototypeOf = BoundaryProxyHandler.liveSetPrototypeOfTrap; // future optimization: hoping that proxies with frozen handlers can be faster
+
+        ObjectFreeze(this);
+      }
+
+      makeProxyStatic(shadowTarget) {
+        // assert: trapMutations must be true
+        const {
+          foreignTargetPointer
+        } = this;
+        const targetIntegrityTraits = foreignCallableGetTargetIntegrityTraits(foreignTargetPointer);
+
+        if (targetIntegrityTraits & TargetIntegrityTraits.Revoked) {
+          // the target is a revoked proxy, in which case we revoke
+          // this proxy as well.
+          this.revoke();
+          return;
+        } // adjusting the proto chain of the shadowTarget
+
+
+        try {
+          // a proxy that revoke itself when the __proto__ is accessed
+          // can break the membrane, therefore we need protection
+          const proto = liveGetPrototypeOf(foreignTargetPointer);
+          ReflectSetPrototypeOf(shadowTarget, proto);
+        } catch (_unused5) {
+          // TODO: is revoke the right action here? maybe just setting
+          // proto to null instead?
+          this.revoke();
+          return;
+        } // defining own descriptors
+
+
+        copyForeignDescriptorsIntoShadowTarget(shadowTarget, foreignTargetPointer); // preserving the semantics of the object
+
+        if (targetIntegrityTraits & TargetIntegrityTraits.IsFrozen) {
+          ObjectFreeze(shadowTarget);
+        } else if (targetIntegrityTraits & TargetIntegrityTraits.IsSealed) {
+          ObjectSeal(shadowTarget);
+        } else if (targetIntegrityTraits & TargetIntegrityTraits.IsNotExtensible) {
+          ReflectPreventExtensions(shadowTarget);
+        } // resetting all traps except apply and construct for static
+        // proxies since the proxy target is the shadow target and all
+        // operations are going to be applied to it rather than the real
+        // target.
+
+
+        this.defineProperty = BoundaryProxyHandler.staticDefinePropertyTrap;
+        this.deleteProperty = BoundaryProxyHandler.staticDeletePropertyTrap;
+        this.get = BoundaryProxyHandler.staticGetTrap;
+        this.getOwnPropertyDescriptor = BoundaryProxyHandler.staticGetOwnPropertyDescriptorTrap;
+        this.getPrototypeOf = BoundaryProxyHandler.staticGetPrototypeOfTrap;
+        this.has = BoundaryProxyHandler.staticHasTrap;
+        this.isExtensible = BoundaryProxyHandler.staticIsExtensibleTrap;
+        this.ownKeys = BoundaryProxyHandler.staticOwnKeysTrap;
+        this.preventExtensions = BoundaryProxyHandler.staticPreventExtensionsTrap;
+        this.set = BoundaryProxyHandler.staticSetTrap;
+        this.setPrototypeOf = BoundaryProxyHandler.staticSetPrototypeOfTrap; // future optimization: hoping that proxies with frozen handlers can be faster
+
+        ObjectFreeze(this);
+      }
+
+      makeProxyUnambiguous(shadowTarget) {
+        // assert: trapMutations must be true
+        if (isForeignTargetMarkedLive(this.foreignTargetPointer)) {
+          this.makeProxyLive();
+        } else {
+          this.makeProxyStatic(shadowTarget);
         }
-        class BoundaryProxyHandler {
-            constructor(foreignTargetPointer, foreignTargetTraits, foreignTargetFunctionName) {
-                // the purpose of this public field is to help developers to identify
-                // what side of the membrane they are debugging.
-                this.color = color;
-                // apply trap is generic, and should never change independently of the type of membrane
-                this.apply = function applyTrap(_shadowTarget, thisArg, args) {
-                    const { foreignTargetPointer } = this;
-                    const transferableThisArg = getTransferableValue(thisArg);
-                    const combinedArgs = [foreignTargetPointer, transferableThisArg];
-                    const { length: argsLen } = args;
-                    const { length: combinedOffset } = combinedArgs;
-                    combinedArgs.length += argsLen;
-                    for (let i = 0, len = argsLen; i < len; i += 1) {
-                        combinedArgs[i + combinedOffset] = getTransferableValue(args[i]);
-                    }
-                    return getLocalValue(ReflectApply(foreignCallableApply, undefined, combinedArgs));
-                };
-                // construct trap is generic, and should never change independently
-                // of the type of membrane
-                this.construct = function constructTrap(_shadowTarget, args, newTarget) {
-                    if (newTarget === undefined) {
-                        throw new TypeErrorCtor();
-                    }
-                    const { foreignTargetPointer } = this;
-                    const transferableNewTarget = getTransferableValue(newTarget);
-                    const combinedArgs = [foreignTargetPointer, transferableNewTarget];
-                    const { length: argsLen } = args;
-                    const { length: combinedOffset } = combinedArgs;
-                    combinedArgs.length += argsLen;
-                    for (let i = 0, len = argsLen; i < len; i += 1) {
-                        combinedArgs[i + combinedOffset] = getTransferableValue(args[i]);
-                    }
-                    return getLocalValue(ReflectApply(foreignCallableConstruct, undefined, combinedArgs));
-                };
-                const shadowTarget = createShadowTarget(foreignTargetTraits, foreignTargetFunctionName);
-                const { proxy, revoke } = ProxyRevocable(shadowTarget, this);
-                this.foreignTargetPointer = foreignTargetPointer;
-                this.proxy = proxy;
-                this.revoke = revoke;
-                // inserting default traps
-                this.defineProperty = BoundaryProxyHandler.defaultDefinePropertyTrap;
-                this.deleteProperty = BoundaryProxyHandler.defaultDeletePropertyTrap;
-                this.isExtensible = BoundaryProxyHandler.defaultIsExtensibleTrap;
-                this.getOwnPropertyDescriptor =
-                    BoundaryProxyHandler.defaultGetOwnPropertyDescriptorTrap;
-                this.getPrototypeOf = BoundaryProxyHandler.defaultGetPrototypeOfTrap;
-                this.get = BoundaryProxyHandler.defaultGetTrap;
-                this.has = BoundaryProxyHandler.defaultHasTrap;
-                this.ownKeys = BoundaryProxyHandler.defaultOwnKeysTrap;
-                this.preventExtensions = BoundaryProxyHandler.defaultPreventExtensionsTrap;
-                this.setPrototypeOf = BoundaryProxyHandler.defaultSetPrototypeOfTrap;
-                this.set = BoundaryProxyHandler.defaultSetTrap;
-                if (foreignTargetTraits & TargetTraits.Revoked) {
-                    revoke();
-                }
-                if (!trapMutations) {
-                    // if local mutations are not trapped, then freezing the handler is ok
-                    // because it is not expecting to change in the future.
-                    // future optimization: hoping that proxies with frozen handlers can be faster
-                    ObjectFreeze(this);
-                }
-            }
-            // internal utilities
-            makeProxyLive() {
-                // assert: trapMutations must be true
-                // replacing pending traps with live traps that can work with
-                // the target without taking snapshots.
-                this.defineProperty = BoundaryProxyHandler.liveDefinePropertyTrap;
-                this.deleteProperty = BoundaryProxyHandler.liveDeletePropertyTrap;
-                this.preventExtensions = BoundaryProxyHandler.livePreventExtensionsTrap;
-                this.set = BoundaryProxyHandler.liveSetTrap;
-                this.setPrototypeOf = BoundaryProxyHandler.liveSetPrototypeOfTrap;
-                // future optimization: hoping that proxies with frozen handlers can be faster
-                ObjectFreeze(this);
-            }
-            makeProxyStatic(shadowTarget) {
-                // assert: trapMutations must be true
-                const { foreignTargetPointer } = this;
-                const targetIntegrityTraits = foreignCallableGetTargetIntegrityTraits(foreignTargetPointer);
-                if (targetIntegrityTraits & TargetIntegrityTraits.Revoked) {
-                    // the target is a revoked proxy, in which case we revoke
-                    // this proxy as well.
-                    this.revoke();
-                    return;
-                }
-                // adjusting the proto chain of the shadowTarget
-                try {
-                    // a proxy that revoke itself when the __proto__ is accessed
-                    // can break the membrane, therefore we need protection
-                    const proto = liveGetPrototypeOf(foreignTargetPointer);
-                    ReflectSetPrototypeOf(shadowTarget, proto);
-                }
-                catch {
-                    // TODO: is revoke the right action here? maybe just setting
-                    // proto to null instead?
-                    this.revoke();
-                    return;
-                }
-                // defining own descriptors
-                copyForeignDescriptorsIntoShadowTarget(shadowTarget, foreignTargetPointer);
-                // preserving the semantics of the object
-                if (targetIntegrityTraits & TargetIntegrityTraits.IsFrozen) {
-                    ObjectFreeze(shadowTarget);
-                }
-                else if (targetIntegrityTraits & TargetIntegrityTraits.IsSealed) {
-                    ObjectSeal(shadowTarget);
-                }
-                else if (targetIntegrityTraits & TargetIntegrityTraits.IsNotExtensible) {
-                    ReflectPreventExtensions(shadowTarget);
-                }
-                // resetting all traps except apply and construct for static
-                // proxies since the proxy target is the shadow target and all
-                // operations are going to be applied to it rather than the real
-                // target.
-                this.defineProperty = BoundaryProxyHandler.staticDefinePropertyTrap;
-                this.deleteProperty = BoundaryProxyHandler.staticDeletePropertyTrap;
-                this.get = BoundaryProxyHandler.staticGetTrap;
-                this.getOwnPropertyDescriptor =
-                    BoundaryProxyHandler.staticGetOwnPropertyDescriptorTrap;
-                this.getPrototypeOf = BoundaryProxyHandler.staticGetPrototypeOfTrap;
-                this.has = BoundaryProxyHandler.staticHasTrap;
-                this.isExtensible = BoundaryProxyHandler.staticIsExtensibleTrap;
-                this.ownKeys = BoundaryProxyHandler.staticOwnKeysTrap;
-                this.preventExtensions = BoundaryProxyHandler.staticPreventExtensionsTrap;
-                this.set = BoundaryProxyHandler.staticSetTrap;
-                this.setPrototypeOf = BoundaryProxyHandler.staticSetPrototypeOfTrap;
-                // future optimization: hoping that proxies with frozen handlers can be faster
-                ObjectFreeze(this);
-            }
-            makeProxyUnambiguous(shadowTarget) {
-                // assert: trapMutations must be true
-                if (isForeignTargetMarkedLive(this.foreignTargetPointer)) {
-                    this.makeProxyLive();
-                }
-                else {
-                    this.makeProxyStatic(shadowTarget);
-                }
-            }
-            // logic implementation of all traps
-            // live traps:
-            /**
-             * Traps with proto chain traversal capabilities are the exception of
-             * the rules here, the problem is that the other side might or might
-             * not have:
-             * a) local mutations only
-             * b) distortions
-             *
-             * Therefore, the logic has to be bound to the caller, the one
-             * initiating the across membrane access.
-             */
-            static liveDefinePropertyTrap(shadowTarget, key, unsafePartialDesc) {
-                return liveDefineProperty(this.foreignTargetPointer, shadowTarget, key, unsafePartialDesc);
-            }
-            static liveDeletePropertyTrap(shadowTarget, key) {
-                return liveDeleteProperty(this.foreignTargetPointer, shadowTarget, key);
-            }
-            static liveGetOwnPropertyDescriptorTrap(shadowTarget, key) {
-                return liveGetOwnPropertyDescriptor(this.foreignTargetPointer, shadowTarget, key);
-            }
-            static liveGetPrototypeOfTrap(_shadowTarget) {
-                return liveGetPrototypeOf(this.foreignTargetPointer);
-            }
-            /**
-             * This trap cannot just use `ReflectGet` directly on the `target`
-             * because the red object graph might have mutations that are only
-             * visible on the red side, which means looking into `target` directly
-             * is not viable. Instead, we need to implement a more crafty solution
-             * that looks into target's own properties, or in the red proto chain
-             * when needed.
-             *
-             * In a transparent membrane, this method will have been a lot simpler, like:
-             *
-             *   const { foreignTargetPointer } = this;
-             *   const receiverPointer = getValueOrPointer(receiver);
-             *   const foreignValueOrCallable =
-             *      foreignCallableGet(foreignTargetPointer, key, receiverPointer);
-             *   return getLocalValue(foreignValueOrCallable);
-             *
-             */
-            static liveGetTrap(shadowTarget, key, receiver) {
-                // assert: trapMutations must be true
-                return liveGet(this.foreignTargetPointer, shadowTarget, key, receiver);
-            }
-            /**
-             * This trap cannot just use `Reflect.has` or the `in` operator
-             * directly because the red object graph might have mutations that
-             * are only visible on the red side, which means looking into `target`
-             * directly is not viable. Instead, we need to implement a more crafty
-             * solution that looks into target's own properties, or in the red
-             * proto chain when needed.
-             *
-             * In a transparent membrane, this method will have been a lot
-             * simpler, like:
-             *
-             *      const { foreignTargetPointer } = this;
-             *      return foreignCallableHas(foreignTargetPointer, key);
-             *
-             */
-            static liveHasTrap(_shadowTarget, key) {
-                // assert: trapMutations must be true
-                return liveHas(this.foreignTargetPointer, key);
-            }
-            static liveIsExtensibleTrap(shadowTarget) {
-                return liveIsExtensible(this.foreignTargetPointer, shadowTarget);
-            }
-            static liveOwnKeysTrap(_shadowTarget) {
-                return liveOwnKeys(this.foreignTargetPointer);
-            }
-            static livePreventExtensionsTrap(shadowTarget) {
-                return livePreventExtensions(this.foreignTargetPointer, shadowTarget);
-            }
-            static liveSetPrototypeOfTrap(_shadowTarget, proto) {
-                return liveSetPrototypeOf(this.foreignTargetPointer, proto);
-            }
-            /**
-             * This trap cannot just use `ReflectSet` directly on the `target` because
-             * the red object graph might have mutations that are only visible on the red side,
-             * which means looking into `target` directly is not viable. Instead, we need to
-             * implement a more crafty solution that looks into target's own properties, or
-             * in the red proto chain when needed.
-             *
-             *  const { foreignTargetPointer } = this;
-             *  const valuePointer = getValueOrPointer(value);
-             *  const receiverPointer = getValueOrPointer(receiver);
-             *  return foreignCallableSet(foreignTargetPointer, key, valuePointer, receiverPointer);
-             *
-             */
-            static liveSetTrap(shadowTarget, key, value, receiver) {
-                // assert: trapMutations must be true
-                const useFastPath = this.proxy === receiver;
-                return liveSet(this.foreignTargetPointer, shadowTarget, key, value, receiver, useFastPath);
-            }
-            // pending traps
-            static pendingDefinePropertyTrap(shadowTarget, key, unsafePartialDesc) {
-                // assert: trapMutations must be true
-                this.makeProxyUnambiguous(shadowTarget);
-                return this.defineProperty(shadowTarget, key, unsafePartialDesc);
-            }
-            static pendingDeletePropertyTrap(shadowTarget, key) {
-                // assert: trapMutations must be true
-                this.makeProxyUnambiguous(shadowTarget);
-                return this.deleteProperty(shadowTarget, key);
-            }
-            static pendingPreventExtensionsTrap(shadowTarget) {
-                // assert: trapMutations must be true
-                this.makeProxyUnambiguous(shadowTarget);
-                return this.preventExtensions(shadowTarget);
-            }
-            static pendingSetPrototypeOfTrap(shadowTarget, proto) {
-                // assert: trapMutations must be true
-                this.makeProxyUnambiguous(shadowTarget);
-                return this.setPrototypeOf(shadowTarget, proto);
-            }
-            static pendingSetTrap(shadowTarget, key, value, receiver) {
-                // assert: trapMutations must be true
-                this.makeProxyUnambiguous(shadowTarget);
-                return this.set(shadowTarget, key, value, receiver);
-            }
-            /**
-             * This trap is just `ReflectGet` plus handling of object branding
-             * for proxies.
-             *
-             */
-            static staticGetTrap(shadowTarget, key, receiver) {
-                if (key === TO_STRING_TAG_SYMBOL) {
-                    return foreignCallableGetUnbrandedTag(this.foreignTargetPointer);
-                }
-                return ReflectGet(shadowTarget, key, receiver);
-            }
+      } // logic implementation of all traps
+      // live traps:
+
+      /**
+       * Traps with proto chain traversal capabilities are the exception of
+       * the rules here, the problem is that the other side might or might
+       * not have:
+       * a) local mutations only
+       * b) distortions
+       *
+       * Therefore, the logic has to be bound to the caller, the one
+       * initiating the across membrane access.
+       */
+
+
+      static liveDefinePropertyTrap(shadowTarget, key, unsafePartialDesc) {
+        return liveDefineProperty(this.foreignTargetPointer, shadowTarget, key, unsafePartialDesc);
+      }
+
+      static liveDeletePropertyTrap(shadowTarget, key) {
+        return liveDeleteProperty(this.foreignTargetPointer, shadowTarget, key);
+      }
+
+      static liveGetOwnPropertyDescriptorTrap(shadowTarget, key) {
+        return liveGetOwnPropertyDescriptor(this.foreignTargetPointer, shadowTarget, key);
+      }
+
+      static liveGetPrototypeOfTrap(_shadowTarget) {
+        return liveGetPrototypeOf(this.foreignTargetPointer);
+      }
+      /**
+       * This trap cannot just use `ReflectGet` directly on the `target`
+       * because the red object graph might have mutations that are only
+       * visible on the red side, which means looking into `target` directly
+       * is not viable. Instead, we need to implement a more crafty solution
+       * that looks into target's own properties, or in the red proto chain
+       * when needed.
+       *
+       * In a transparent membrane, this method will have been a lot simpler, like:
+       *
+       *   const { foreignTargetPointer } = this;
+       *   const receiverPointer = getValueOrPointer(receiver);
+       *   const foreignValueOrCallable =
+       *      foreignCallableGet(foreignTargetPointer, key, receiverPointer);
+       *   return getLocalValue(foreignValueOrCallable);
+       *
+       */
+
+
+      static liveGetTrap(shadowTarget, key, receiver) {
+        // assert: trapMutations must be true
+        return liveGet(this.foreignTargetPointer, shadowTarget, key, receiver);
+      }
+      /**
+       * This trap cannot just use `Reflect.has` or the `in` operator
+       * directly because the red object graph might have mutations that
+       * are only visible on the red side, which means looking into `target`
+       * directly is not viable. Instead, we need to implement a more crafty
+       * solution that looks into target's own properties, or in the red
+       * proto chain when needed.
+       *
+       * In a transparent membrane, this method will have been a lot
+       * simpler, like:
+       *
+       *      const { foreignTargetPointer } = this;
+       *      return foreignCallableHas(foreignTargetPointer, key);
+       *
+       */
+
+
+      static liveHasTrap(_shadowTarget, key) {
+        // assert: trapMutations must be true
+        return liveHas(this.foreignTargetPointer, key);
+      }
+
+      static liveIsExtensibleTrap(shadowTarget) {
+        return liveIsExtensible(this.foreignTargetPointer, shadowTarget);
+      }
+
+      static liveOwnKeysTrap(_shadowTarget) {
+        return liveOwnKeys(this.foreignTargetPointer);
+      }
+
+      static livePreventExtensionsTrap(shadowTarget) {
+        return livePreventExtensions(this.foreignTargetPointer, shadowTarget);
+      }
+
+      static liveSetPrototypeOfTrap(_shadowTarget, proto) {
+        return liveSetPrototypeOf(this.foreignTargetPointer, proto);
+      }
+      /**
+       * This trap cannot just use `ReflectSet` directly on the `target` because
+       * the red object graph might have mutations that are only visible on the red side,
+       * which means looking into `target` directly is not viable. Instead, we need to
+       * implement a more crafty solution that looks into target's own properties, or
+       * in the red proto chain when needed.
+       *
+       *  const { foreignTargetPointer } = this;
+       *  const valuePointer = getValueOrPointer(value);
+       *  const receiverPointer = getValueOrPointer(receiver);
+       *  return foreignCallableSet(foreignTargetPointer, key, valuePointer, receiverPointer);
+       *
+       */
+
+
+      static liveSetTrap(shadowTarget, key, value, receiver) {
+        // assert: trapMutations must be true
+        const useFastPath = this.proxy === receiver;
+        return liveSet(this.foreignTargetPointer, shadowTarget, key, value, receiver, useFastPath);
+      } // pending traps
+
+
+      static pendingDefinePropertyTrap(shadowTarget, key, unsafePartialDesc) {
+        // assert: trapMutations must be true
+        this.makeProxyUnambiguous(shadowTarget);
+        return this.defineProperty(shadowTarget, key, unsafePartialDesc);
+      }
+
+      static pendingDeletePropertyTrap(shadowTarget, key) {
+        // assert: trapMutations must be true
+        this.makeProxyUnambiguous(shadowTarget);
+        return this.deleteProperty(shadowTarget, key);
+      }
+
+      static pendingPreventExtensionsTrap(shadowTarget) {
+        // assert: trapMutations must be true
+        this.makeProxyUnambiguous(shadowTarget);
+        return this.preventExtensions(shadowTarget);
+      }
+
+      static pendingSetPrototypeOfTrap(shadowTarget, proto) {
+        // assert: trapMutations must be true
+        this.makeProxyUnambiguous(shadowTarget);
+        return this.setPrototypeOf(shadowTarget, proto);
+      }
+
+      static pendingSetTrap(shadowTarget, key, value, receiver) {
+        // assert: trapMutations must be true
+        this.makeProxyUnambiguous(shadowTarget);
+        return this.set(shadowTarget, key, value, receiver);
+      }
+      /**
+       * This trap is just `ReflectGet` plus handling of object branding
+       * for proxies.
+       *
+       */
+
+
+      static staticGetTrap(shadowTarget, key, receiver) {
+        if (key === TO_STRING_TAG_SYMBOL) {
+          return foreignCallableGetUnbrandedTag(this.foreignTargetPointer);
         }
-        BoundaryProxyHandler.staticDefinePropertyTrap = ReflectDefineProperty;
-        BoundaryProxyHandler.staticDeletePropertyTrap = ReflectDeleteProperty;
-        BoundaryProxyHandler.staticGetOwnPropertyDescriptorTrap = ReflectGetOwnPropertyDescriptor;
-        BoundaryProxyHandler.staticGetPrototypeOfTrap = ReflectGetPrototypeOf;
-        BoundaryProxyHandler.staticHasTrap = ReflectHas;
-        BoundaryProxyHandler.staticIsExtensibleTrap = ReflectIsExtensible;
-        BoundaryProxyHandler.staticOwnKeysTrap = ReflectOwnKeys;
-        BoundaryProxyHandler.staticPreventExtensionsTrap = ReflectPreventExtensions;
-        BoundaryProxyHandler.staticSetTrap = ReflectSet;
-        BoundaryProxyHandler.staticSetPrototypeOfTrap = ReflectSetPrototypeOf;
-        // static default traps
-        // (optimization to avoid computations of the proper trap in constructor)
-        BoundaryProxyHandler.defaultGetTrap = BoundaryProxyHandler.liveGetTrap;
-        BoundaryProxyHandler.defaultGetOwnPropertyDescriptorTrap = BoundaryProxyHandler.liveGetOwnPropertyDescriptorTrap;
-        BoundaryProxyHandler.defaultGetPrototypeOfTrap = BoundaryProxyHandler.liveGetPrototypeOfTrap;
-        BoundaryProxyHandler.defaultHasTrap = BoundaryProxyHandler.liveHasTrap;
-        BoundaryProxyHandler.defaultIsExtensibleTrap = BoundaryProxyHandler.liveIsExtensibleTrap;
-        BoundaryProxyHandler.defaultOwnKeysTrap = BoundaryProxyHandler.liveOwnKeysTrap;
-        // pending traps are only really needed if this membrane traps
-        // mutations to avoid mutations operations on the side of the membrane.
-        // TODO: find a way to optimize the declaration rather than instantiation
-        BoundaryProxyHandler.defaultDefinePropertyTrap = trapMutations
-            ? BoundaryProxyHandler.pendingDefinePropertyTrap
-            : BoundaryProxyHandler.liveDefinePropertyTrap;
-        BoundaryProxyHandler.defaultDeletePropertyTrap = trapMutations
-            ? BoundaryProxyHandler.pendingDeletePropertyTrap
-            : BoundaryProxyHandler.liveDeletePropertyTrap;
-        BoundaryProxyHandler.defaultPreventExtensionsTrap = trapMutations
-            ? BoundaryProxyHandler.pendingPreventExtensionsTrap
-            : BoundaryProxyHandler.livePreventExtensionsTrap;
-        BoundaryProxyHandler.defaultSetTrap = trapMutations
-            ? BoundaryProxyHandler.pendingSetTrap
-            : BoundaryProxyHandler.liveSetTrap;
-        BoundaryProxyHandler.defaultSetPrototypeOfTrap = trapMutations
-            ? BoundaryProxyHandler.pendingSetPrototypeOfTrap
-            : BoundaryProxyHandler.liveSetPrototypeOfTrap;
-        ReflectSetPrototypeOf(BoundaryProxyHandler.prototype, null);
-        // future optimization: hoping proxies with frozen handlers can be faster
-        ObjectFreeze(BoundaryProxyHandler.prototype);
-        // exporting callable hooks for a foreign realm
-        foreignCallableHooksCallback(
-        // globalThisPointer
-        // When crossing, should be mapped to the foreign globalThis
-        createPointer(globalThis), 
-        // getSelectedTarget
-        getSelectedTarget, 
-        // getTransferableValue
-        getTransferableValue, 
-        // callableGetPropertyValuePointer: this callable function allows
-        // the foreign realm to access a linkable pointer for a property value.
-        // In order to do that, the foreign side must provide a pointer and
-        // a key access the value in order to produce a pointer
-        (targetPointer, key) => {
-            targetPointer();
-            const target = getSelectedTarget();
-            const value = target[key];
-            // TODO: what if the value is not a valid proxy target?
-            return createPointer(value);
-        }, 
-        // callableEvaluate
-        (sourceText) => {
-            try {
-                return getTransferableValue(cachedLocalEval(sourceText));
-            }
-            catch (e) {
-                throw pushErrorAcrossBoundary(e);
-            }
-        }, 
-        // callableLinkPointers: this callable function allows the foreign
-        // realm to define a linkage between two values across the membrane.
-        (targetPointer, newPointer) => {
-            targetPointer();
-            const target = getSelectedTarget();
-            ReflectApply(WeakMapProtoSet, proxyTargetToPointerMap, [target, newPointer]);
-        }, 
-        /**
-         * callablePushTarget: This function can be used by a foreign realm to install a proxy
-         * into this realm that correspond to an object from the foreign realm. It returns
-         * a Pointer that can be used by the foreign realm to pass back a reference to this
-         * realm when passing arguments or returning from a foreign callable invocation. This
-         * function is extremely important to understand the mechanics of this membrane.
-         */
-        (foreignTargetPointer, foreignTargetTraits, foreignTargetFunctionName) => {
-            const { proxy } = new BoundaryProxyHandler(foreignTargetPointer, foreignTargetTraits, foreignTargetFunctionName);
-            ReflectApply(WeakMapProtoSet, proxyTargetToPointerMap, [
-                proxy,
-                foreignTargetPointer,
-            ]);
-            return createPointer(proxy);
-        }, 
-        // callableApply
-        instrumentCallableWrapper((targetPointer, thisArgPointerOrValue, ...listOfValuesOrPointers) => {
-            targetPointer();
-            const fn = getSelectedTarget();
-            const thisArg = getLocalValue(thisArgPointerOrValue);
-            const { length: argsLen } = listOfValuesOrPointers;
-            const args = new ArrayCtor(argsLen);
-            for (let i = 0, len = argsLen; i < len; i += 1) {
-                args[i] = getLocalValue(listOfValuesOrPointers[i]);
-            }
-            let value;
-            try {
-                value = ReflectApply(fn, thisArg, args);
-            }
-            catch (e) {
-                throw pushErrorAcrossBoundary(e);
-            }
-            return getTransferableValue(value);
-        }, 'callableApply', INBOUND_INSTRUMENTATION_LABEL), 
-        // callableConstruct
-        instrumentCallableWrapper((targetPointer, newTargetPointerOrValue, ...listOfValuesOrPointers) => {
-            targetPointer();
-            const constructor = getSelectedTarget();
-            const newTarget = getLocalValue(newTargetPointerOrValue);
-            const { length: argsLen } = listOfValuesOrPointers;
-            const args = new ArrayCtor(argsLen);
-            for (let i = 0, len = argsLen; i < len; i += 1) {
-                args[i] = getLocalValue(listOfValuesOrPointers[i]);
-            }
-            let value;
-            try {
-                value = ReflectConstruct(constructor, args, newTarget);
-            }
-            catch (e) {
-                throw pushErrorAcrossBoundary(e);
-            }
-            return getTransferableValue(value);
-        }, 'callableConstruct', INBOUND_INSTRUMENTATION_LABEL), 
-        // callableDefineProperty
-        instrumentCallableWrapper((targetPointer, key, configurable, enumerable, writable, valuePointer, getPointer, setPointer) => {
-            targetPointer();
-            const target = getSelectedTarget();
-            try {
-                return ReflectDefineProperty(target, key, createDescriptorFromMeta(configurable, enumerable, writable, valuePointer, getPointer, setPointer));
-            }
-            catch (e) {
-                throw pushErrorAcrossBoundary(e);
-            }
-        }, 'callableDefineProperty', INBOUND_INSTRUMENTATION_LABEL), 
-        // callableDeleteProperty
-        instrumentCallableWrapper((targetPointer, key) => {
-            targetPointer();
-            const target = getSelectedTarget();
-            try {
-                return ReflectDeleteProperty(target, key);
-            }
-            catch (e) {
-                throw pushErrorAcrossBoundary(e);
-            }
-        }, 'callableDeleteProperty', INBOUND_INSTRUMENTATION_LABEL), 
-        // callableGetOwnPropertyDescriptor
-        instrumentCallableWrapper((targetPointer, key, foreignCallableDescriptorCallback) => {
-            targetPointer();
-            const target = getSelectedTarget();
-            let unsafeDesc;
-            try {
-                unsafeDesc = ReflectGetOwnPropertyDescriptor(target, key);
-            }
-            catch (e) {
-                throw pushErrorAcrossBoundary(e);
-            }
-            if (unsafeDesc) {
-                const descMeta = getDescriptorMeta(unsafeDesc);
-                foreignCallableDescriptorCallback(descMeta[0], // configurable
-                descMeta[1], // enumerable
-                descMeta[2], // writable
-                descMeta[3], // valuePointer
-                descMeta[4], // getPointer
-                descMeta[5] // setPointer
-                );
-            }
-        }, 'callableGetOwnPropertyDescriptor', INBOUND_INSTRUMENTATION_LABEL), 
-        // callableGetPrototypeOf
-        instrumentCallableWrapper((targetPointer) => {
-            targetPointer();
-            const target = getSelectedTarget();
-            let proto;
-            try {
-                proto = ReflectGetPrototypeOf(target);
-            }
-            catch (e) {
-                throw pushErrorAcrossBoundary(e);
-            }
-            return getTransferableValue(proto);
-        }, 'callableGetPrototypeOf', INBOUND_INSTRUMENTATION_LABEL), 
-        // callableIsExtensible
-        instrumentCallableWrapper((targetPointer) => {
-            targetPointer();
-            const target = getSelectedTarget();
-            try {
-                return ReflectIsExtensible(target);
-            }
-            catch (e) {
-                throw pushErrorAcrossBoundary(e);
-            }
-        }, 'callableIsExtensible', INBOUND_INSTRUMENTATION_LABEL), 
-        // callableOwnKeys
-        instrumentCallableWrapper((targetPointer, foreignCallableKeysCallback) => {
-            targetPointer();
-            const target = getSelectedTarget();
-            let keys;
-            try {
-                keys = ReflectOwnKeys(target);
-            }
-            catch (e) {
-                throw pushErrorAcrossBoundary(e);
-            }
-            ReflectApply(foreignCallableKeysCallback, undefined, keys);
-        }, 'callableOwnKeys', INBOUND_INSTRUMENTATION_LABEL), 
-        // callablePreventExtensions
-        instrumentCallableWrapper((targetPointer) => {
-            targetPointer();
-            const target = getSelectedTarget();
-            try {
-                return ReflectPreventExtensions(target);
-            }
-            catch (e) {
-                throw pushErrorAcrossBoundary(e);
-            }
-        }, 'callablePreventExtensions', INBOUND_INSTRUMENTATION_LABEL), 
-        // callableSet
-        instrumentCallableWrapper((targetPointer, propertyKey, valuePointer, receiverPointer) => {
-            targetPointer();
-            const target = getSelectedTarget();
-            try {
-                return ReflectSet(target, propertyKey, getLocalValue(valuePointer), getLocalValue(receiverPointer));
-            }
-            catch (e) {
-                throw pushErrorAcrossBoundary(e);
-            }
-        }, 'callableSet', INBOUND_INSTRUMENTATION_LABEL), 
-        // callableSetPrototypeOf
-        instrumentCallableWrapper((targetPointer, protoPointerOrNull) => {
-            targetPointer();
-            const target = getSelectedTarget();
-            const proto = getLocalValue(protoPointerOrNull);
-            try {
-                return ReflectSetPrototypeOf(target, proto);
-            }
-            catch (e) {
-                throw pushErrorAcrossBoundary(e);
-            }
-        }, 'callableSetPrototypeOf', INBOUND_INSTRUMENTATION_LABEL), 
-        // callableGetTargetIntegrityTraits
-        instrumentCallableWrapper((targetPointer) => {
-            targetPointer();
-            const target = getSelectedTarget();
-            return getTargetIntegrityTraits(target);
-        }, 'callableGetTargetIntegrityTraits', INBOUND_INSTRUMENTATION_LABEL), 
-        // callableGetUnbrandedTag
-        instrumentCallableWrapper((targetPointer) => {
-            targetPointer();
-            const target = getSelectedTarget();
-            try {
-                if (typeof target === 'object' &&
-                    target !== null &&
-                    !isArrayOrNotOrThrowForRevoked(target)) {
-                    // Section 19.1.3.6: Object.prototype.toString()
-                    // Step 16: If `Type(tag)` is not `String`, let `tag` be `builtinTag`.
-                    // https://tc39.github.io/ecma262/#sec-object.prototype.tostring
-                    const toStringValue = ReflectApply(ObjectProtoToString, target, []);
-                    return ReflectApply(StringProtoSlice, toStringValue, [8, -1]);
-                }
-                // eslint-disable-next-line no-empty
-            }
-            catch { }
-            return undefined;
-        }, 'callableGetUnbrandedTag', INBOUND_INSTRUMENTATION_LABEL), 
-        // callableHasOwnProperty
-        instrumentCallableWrapper((targetPointer, key) => {
-            targetPointer();
-            const target = getSelectedTarget();
-            try {
-                return ReflectApply(ObjectProtoHasOwnProperty, target, [key]);
-            }
-            catch (e) {
-                throw pushErrorAcrossBoundary(e);
-            }
-        }, 'callableHasOwnProperty', INBOUND_INSTRUMENTATION_LABEL));
-        return (...hooks) => {
-            const { 
-            // 0: globalThisPointer,
-            // 1: getSelectedTarget,
-            // 2: getTransferableValue,
-            // 3: callableGetPropertyValuePointer,
-            // 4: callableEvaluate,
-            // 5: callableLinkPointers,
-            6: callablePushTarget, 7: callableApply, 8: callableConstruct, 9: callableDefineProperty, 10: callableDeleteProperty, 11: callableGetOwnPropertyDescriptor, 12: callableGetPrototypeOf, 13: callableIsExtensible, 14: callableOwnKeys, 15: callablePreventExtensions, 16: callableSet, 17: callableSetPrototypeOf, 18: callableGetTargetIntegrityTraits, 19: callableGetUnbrandedTag, 20: callableHasOwnProperty, } = hooks;
-            foreignCallablePushTarget = callablePushTarget;
-            // traps utilities
-            foreignCallableApply = foreignErrorControl(instrumentCallableWrapper(callableApply, 'callableApply', OUTBOUND_INSTRUMENTATION_LABEL));
-            foreignCallableConstruct = foreignErrorControl(instrumentCallableWrapper(callableConstruct, 'callableConstruct', OUTBOUND_INSTRUMENTATION_LABEL));
-            foreignCallableDefineProperty = foreignErrorControl(instrumentCallableWrapper(callableDefineProperty, 'callableDefineProperty', OUTBOUND_INSTRUMENTATION_LABEL));
-            foreignCallableDeleteProperty = foreignErrorControl(instrumentCallableWrapper(callableDeleteProperty, 'callableDeleteProperty', OUTBOUND_INSTRUMENTATION_LABEL));
-            foreignCallableGetOwnPropertyDescriptor = foreignErrorControl(instrumentCallableWrapper(callableGetOwnPropertyDescriptor, 'callableGetOwnPropertyDescriptor', OUTBOUND_INSTRUMENTATION_LABEL));
-            foreignCallableGetPrototypeOf = foreignErrorControl(instrumentCallableWrapper(callableGetPrototypeOf, 'callableGetPrototypeOf', OUTBOUND_INSTRUMENTATION_LABEL));
-            foreignCallableIsExtensible = foreignErrorControl(instrumentCallableWrapper(callableIsExtensible, 'callableIsExtensible', OUTBOUND_INSTRUMENTATION_LABEL));
-            foreignCallableOwnKeys = foreignErrorControl(instrumentCallableWrapper(callableOwnKeys, 'callableOwnKeys', OUTBOUND_INSTRUMENTATION_LABEL));
-            foreignCallablePreventExtensions = foreignErrorControl(instrumentCallableWrapper(callablePreventExtensions, 'callablePreventExtensions', OUTBOUND_INSTRUMENTATION_LABEL));
-            foreignCallableSet = foreignErrorControl(instrumentCallableWrapper(callableSet, 'callableSet', OUTBOUND_INSTRUMENTATION_LABEL));
-            foreignCallableSetPrototypeOf = foreignErrorControl(instrumentCallableWrapper(callableSetPrototypeOf, 'callableSetPrototypeOf', OUTBOUND_INSTRUMENTATION_LABEL));
-            foreignCallableGetTargetIntegrityTraits = foreignErrorControl(instrumentCallableWrapper(callableGetTargetIntegrityTraits, 'callableGetTargetIntegrityTraits', OUTBOUND_INSTRUMENTATION_LABEL));
-            foreignCallableGetUnbrandedTag = foreignErrorControl(instrumentCallableWrapper(callableGetUnbrandedTag, 'callableGetUnbrandedTag', OUTBOUND_INSTRUMENTATION_LABEL));
-            foreignCallableHasOwnProperty = foreignErrorControl(instrumentCallableWrapper(callableHasOwnProperty, 'callableHasOwnProperty', OUTBOUND_INSTRUMENTATION_LABEL));
-        };
+
+        return ReflectGet(shadowTarget, key, receiver);
+      }
+
+    }
+
+    BoundaryProxyHandler.staticDefinePropertyTrap = ReflectDefineProperty;
+    BoundaryProxyHandler.staticDeletePropertyTrap = ReflectDeleteProperty;
+    BoundaryProxyHandler.staticGetOwnPropertyDescriptorTrap = ReflectGetOwnPropertyDescriptor;
+    BoundaryProxyHandler.staticGetPrototypeOfTrap = ReflectGetPrototypeOf;
+    BoundaryProxyHandler.staticHasTrap = ReflectHas;
+    BoundaryProxyHandler.staticIsExtensibleTrap = ReflectIsExtensible;
+    BoundaryProxyHandler.staticOwnKeysTrap = ReflectOwnKeys;
+    BoundaryProxyHandler.staticPreventExtensionsTrap = ReflectPreventExtensions;
+    BoundaryProxyHandler.staticSetTrap = ReflectSet;
+    BoundaryProxyHandler.staticSetPrototypeOfTrap = ReflectSetPrototypeOf; // static default traps
+    // (optimization to avoid computations of the proper trap in constructor)
+
+    BoundaryProxyHandler.defaultGetTrap = BoundaryProxyHandler.liveGetTrap;
+    BoundaryProxyHandler.defaultGetOwnPropertyDescriptorTrap = BoundaryProxyHandler.liveGetOwnPropertyDescriptorTrap;
+    BoundaryProxyHandler.defaultGetPrototypeOfTrap = BoundaryProxyHandler.liveGetPrototypeOfTrap;
+    BoundaryProxyHandler.defaultHasTrap = BoundaryProxyHandler.liveHasTrap;
+    BoundaryProxyHandler.defaultIsExtensibleTrap = BoundaryProxyHandler.liveIsExtensibleTrap;
+    BoundaryProxyHandler.defaultOwnKeysTrap = BoundaryProxyHandler.liveOwnKeysTrap; // pending traps are only really needed if this membrane traps
+    // mutations to avoid mutations operations on the side of the membrane.
+    // TODO: find a way to optimize the declaration rather than instantiation
+
+    BoundaryProxyHandler.defaultDefinePropertyTrap = trapMutations ? BoundaryProxyHandler.pendingDefinePropertyTrap : BoundaryProxyHandler.liveDefinePropertyTrap;
+    BoundaryProxyHandler.defaultDeletePropertyTrap = trapMutations ? BoundaryProxyHandler.pendingDeletePropertyTrap : BoundaryProxyHandler.liveDeletePropertyTrap;
+    BoundaryProxyHandler.defaultPreventExtensionsTrap = trapMutations ? BoundaryProxyHandler.pendingPreventExtensionsTrap : BoundaryProxyHandler.livePreventExtensionsTrap;
+    BoundaryProxyHandler.defaultSetTrap = trapMutations ? BoundaryProxyHandler.pendingSetTrap : BoundaryProxyHandler.liveSetTrap;
+    BoundaryProxyHandler.defaultSetPrototypeOfTrap = trapMutations ? BoundaryProxyHandler.pendingSetPrototypeOfTrap : BoundaryProxyHandler.liveSetPrototypeOfTrap;
+    ReflectSetPrototypeOf(BoundaryProxyHandler.prototype, null); // future optimization: hoping proxies with frozen handlers can be faster
+
+    ObjectFreeze(BoundaryProxyHandler.prototype); // exporting callable hooks for a foreign realm
+
+    foreignCallableHooksCallback( // globalThisPointer
+    // When crossing, should be mapped to the foreign globalThis
+    createPointer(globalThis), // getSelectedTarget
+    getSelectedTarget, // getTransferableValue
+    getTransferableValue, // callableGetPropertyValuePointer: this callable function allows
+    // the foreign realm to access a linkable pointer for a property value.
+    // In order to do that, the foreign side must provide a pointer and
+    // a key access the value in order to produce a pointer
+    (targetPointer, key) => {
+      targetPointer();
+      const target = getSelectedTarget();
+      const value = target[key]; // TODO: what if the value is not a valid proxy target?
+
+      return createPointer(value);
+    }, // callableEvaluate
+    sourceText => {
+      try {
+        return getTransferableValue(cachedLocalEval(sourceText));
+      } catch (e) {
+        throw pushErrorAcrossBoundary(e);
+      }
+    }, // callableLinkPointers: this callable function allows the foreign
+    // realm to define a linkage between two values across the membrane.
+    (targetPointer, newPointer) => {
+      targetPointer();
+      const target = getSelectedTarget();
+      ReflectApply(WeakMapProtoSet, proxyTargetToPointerMap, [target, newPointer]);
+    },
+    /**
+     * callablePushTarget: This function can be used by a foreign realm to install a proxy
+     * into this realm that correspond to an object from the foreign realm. It returns
+     * a Pointer that can be used by the foreign realm to pass back a reference to this
+     * realm when passing arguments or returning from a foreign callable invocation. This
+     * function is extremely important to understand the mechanics of this membrane.
+     */
+    (foreignTargetPointer, foreignTargetTraits, foreignTargetFunctionName) => {
+      const {
+        proxy
+      } = new BoundaryProxyHandler(foreignTargetPointer, foreignTargetTraits, foreignTargetFunctionName);
+      ReflectApply(WeakMapProtoSet, proxyTargetToPointerMap, [proxy, foreignTargetPointer]);
+      return createPointer(proxy);
+    }, // callableApply
+    instrumentCallableWrapper(function (targetPointer, thisArgPointerOrValue) {
+      targetPointer();
+      const fn = getSelectedTarget();
+      const thisArg = getLocalValue(thisArgPointerOrValue);
+
+      for (var _len5 = arguments.length, listOfValuesOrPointers = new Array(_len5 > 2 ? _len5 - 2 : 0), _key5 = 2; _key5 < _len5; _key5++) {
+        listOfValuesOrPointers[_key5 - 2] = arguments[_key5];
+      }
+
+      const {
+        length: argsLen
+      } = listOfValuesOrPointers;
+      const args = new ArrayCtor(argsLen);
+
+      for (let i = 0, len = argsLen; i < len; i += 1) {
+        args[i] = getLocalValue(listOfValuesOrPointers[i]);
+      }
+
+      let value;
+
+      try {
+        value = ReflectApply(fn, thisArg, args);
+      } catch (e) {
+        throw pushErrorAcrossBoundary(e);
+      }
+
+      return getTransferableValue(value);
+    }, 'callableApply', INBOUND_INSTRUMENTATION_LABEL), // callableConstruct
+    instrumentCallableWrapper(function (targetPointer, newTargetPointerOrValue) {
+      targetPointer();
+      const constructor = getSelectedTarget();
+      const newTarget = getLocalValue(newTargetPointerOrValue);
+
+      for (var _len6 = arguments.length, listOfValuesOrPointers = new Array(_len6 > 2 ? _len6 - 2 : 0), _key6 = 2; _key6 < _len6; _key6++) {
+        listOfValuesOrPointers[_key6 - 2] = arguments[_key6];
+      }
+
+      const {
+        length: argsLen
+      } = listOfValuesOrPointers;
+      const args = new ArrayCtor(argsLen);
+
+      for (let i = 0, len = argsLen; i < len; i += 1) {
+        args[i] = getLocalValue(listOfValuesOrPointers[i]);
+      }
+
+      let value;
+
+      try {
+        value = ReflectConstruct(constructor, args, newTarget);
+      } catch (e) {
+        throw pushErrorAcrossBoundary(e);
+      }
+
+      return getTransferableValue(value);
+    }, 'callableConstruct', INBOUND_INSTRUMENTATION_LABEL), // callableDefineProperty
+    instrumentCallableWrapper((targetPointer, key, configurable, enumerable, writable, valuePointer, getPointer, setPointer) => {
+      targetPointer();
+      const target = getSelectedTarget();
+
+      try {
+        return ReflectDefineProperty(target, key, createDescriptorFromMeta(configurable, enumerable, writable, valuePointer, getPointer, setPointer));
+      } catch (e) {
+        throw pushErrorAcrossBoundary(e);
+      }
+    }, 'callableDefineProperty', INBOUND_INSTRUMENTATION_LABEL), // callableDeleteProperty
+    instrumentCallableWrapper((targetPointer, key) => {
+      targetPointer();
+      const target = getSelectedTarget();
+
+      try {
+        return ReflectDeleteProperty(target, key);
+      } catch (e) {
+        throw pushErrorAcrossBoundary(e);
+      }
+    }, 'callableDeleteProperty', INBOUND_INSTRUMENTATION_LABEL), // callableGetOwnPropertyDescriptor
+    instrumentCallableWrapper((targetPointer, key, foreignCallableDescriptorCallback) => {
+      targetPointer();
+      const target = getSelectedTarget();
+      let unsafeDesc;
+
+      try {
+        unsafeDesc = ReflectGetOwnPropertyDescriptor(target, key);
+      } catch (e) {
+        throw pushErrorAcrossBoundary(e);
+      }
+
+      if (unsafeDesc) {
+        const descMeta = getDescriptorMeta(unsafeDesc);
+        foreignCallableDescriptorCallback(descMeta[0], // configurable
+        descMeta[1], // enumerable
+        descMeta[2], // writable
+        descMeta[3], // valuePointer
+        descMeta[4], // getPointer
+        descMeta[5] // setPointer
+        );
+      }
+    }, 'callableGetOwnPropertyDescriptor', INBOUND_INSTRUMENTATION_LABEL), // callableGetPrototypeOf
+    instrumentCallableWrapper(targetPointer => {
+      targetPointer();
+      const target = getSelectedTarget();
+      let proto;
+
+      try {
+        proto = ReflectGetPrototypeOf(target);
+      } catch (e) {
+        throw pushErrorAcrossBoundary(e);
+      }
+
+      return getTransferableValue(proto);
+    }, 'callableGetPrototypeOf', INBOUND_INSTRUMENTATION_LABEL), // callableIsExtensible
+    instrumentCallableWrapper(targetPointer => {
+      targetPointer();
+      const target = getSelectedTarget();
+
+      try {
+        return ReflectIsExtensible(target);
+      } catch (e) {
+        throw pushErrorAcrossBoundary(e);
+      }
+    }, 'callableIsExtensible', INBOUND_INSTRUMENTATION_LABEL), // callableOwnKeys
+    instrumentCallableWrapper((targetPointer, foreignCallableKeysCallback) => {
+      targetPointer();
+      const target = getSelectedTarget();
+      let keys;
+
+      try {
+        keys = ReflectOwnKeys(target);
+      } catch (e) {
+        throw pushErrorAcrossBoundary(e);
+      }
+
+      ReflectApply(foreignCallableKeysCallback, undefined, keys);
+    }, 'callableOwnKeys', INBOUND_INSTRUMENTATION_LABEL), // callablePreventExtensions
+    instrumentCallableWrapper(targetPointer => {
+      targetPointer();
+      const target = getSelectedTarget();
+
+      try {
+        return ReflectPreventExtensions(target);
+      } catch (e) {
+        throw pushErrorAcrossBoundary(e);
+      }
+    }, 'callablePreventExtensions', INBOUND_INSTRUMENTATION_LABEL), // callableSet
+    instrumentCallableWrapper((targetPointer, propertyKey, valuePointer, receiverPointer) => {
+      targetPointer();
+      const target = getSelectedTarget();
+
+      try {
+        return ReflectSet(target, propertyKey, getLocalValue(valuePointer), getLocalValue(receiverPointer));
+      } catch (e) {
+        throw pushErrorAcrossBoundary(e);
+      }
+    }, 'callableSet', INBOUND_INSTRUMENTATION_LABEL), // callableSetPrototypeOf
+    instrumentCallableWrapper((targetPointer, protoPointerOrNull) => {
+      targetPointer();
+      const target = getSelectedTarget();
+      const proto = getLocalValue(protoPointerOrNull);
+
+      try {
+        return ReflectSetPrototypeOf(target, proto);
+      } catch (e) {
+        throw pushErrorAcrossBoundary(e);
+      }
+    }, 'callableSetPrototypeOf', INBOUND_INSTRUMENTATION_LABEL), // callableGetTargetIntegrityTraits
+    instrumentCallableWrapper(targetPointer => {
+      targetPointer();
+      const target = getSelectedTarget();
+      return getTargetIntegrityTraits(target);
+    }, 'callableGetTargetIntegrityTraits', INBOUND_INSTRUMENTATION_LABEL), // callableGetUnbrandedTag
+    instrumentCallableWrapper(targetPointer => {
+      targetPointer();
+      const target = getSelectedTarget();
+
+      try {
+        if (typeof target === 'object' && target !== null && !isArrayOrNotOrThrowForRevoked(target)) {
+          // Section 19.1.3.6: Object.prototype.toString()
+          // Step 16: If `Type(tag)` is not `String`, let `tag` be `builtinTag`.
+          // https://tc39.github.io/ecma262/#sec-object.prototype.tostring
+          const toStringValue = ReflectApply(ObjectProtoToString, target, []);
+          return ReflectApply(StringProtoSlice, toStringValue, [8, -1]);
+        } // eslint-disable-next-line no-empty
+
+      } catch (_unused6) {}
+
+      return undefined;
+    }, 'callableGetUnbrandedTag', INBOUND_INSTRUMENTATION_LABEL), // callableHasOwnProperty
+    instrumentCallableWrapper((targetPointer, key) => {
+      targetPointer();
+      const target = getSelectedTarget();
+
+      try {
+        return ReflectApply(ObjectProtoHasOwnProperty, target, [key]);
+      } catch (e) {
+        throw pushErrorAcrossBoundary(e);
+      }
+    }, 'callableHasOwnProperty', INBOUND_INSTRUMENTATION_LABEL));
+    return function () {
+      for (var _len7 = arguments.length, hooks = new Array(_len7), _key7 = 0; _key7 < _len7; _key7++) {
+        hooks[_key7] = arguments[_key7];
+      }
+
+      const {
+        // 0: globalThisPointer,
+        // 1: getSelectedTarget,
+        // 2: getTransferableValue,
+        // 3: callableGetPropertyValuePointer,
+        // 4: callableEvaluate,
+        // 5: callableLinkPointers,
+        6: callablePushTarget,
+        7: callableApply,
+        8: callableConstruct,
+        9: callableDefineProperty,
+        10: callableDeleteProperty,
+        11: callableGetOwnPropertyDescriptor,
+        12: callableGetPrototypeOf,
+        13: callableIsExtensible,
+        14: callableOwnKeys,
+        15: callablePreventExtensions,
+        16: callableSet,
+        17: callableSetPrototypeOf,
+        18: callableGetTargetIntegrityTraits,
+        19: callableGetUnbrandedTag,
+        20: callableHasOwnProperty
+      } = hooks;
+      foreignCallablePushTarget = callablePushTarget; // traps utilities
+
+      foreignCallableApply = foreignErrorControl(instrumentCallableWrapper(callableApply, 'callableApply', OUTBOUND_INSTRUMENTATION_LABEL));
+      foreignCallableConstruct = foreignErrorControl(instrumentCallableWrapper(callableConstruct, 'callableConstruct', OUTBOUND_INSTRUMENTATION_LABEL));
+      foreignCallableDefineProperty = foreignErrorControl(instrumentCallableWrapper(callableDefineProperty, 'callableDefineProperty', OUTBOUND_INSTRUMENTATION_LABEL));
+      foreignCallableDeleteProperty = foreignErrorControl(instrumentCallableWrapper(callableDeleteProperty, 'callableDeleteProperty', OUTBOUND_INSTRUMENTATION_LABEL));
+      foreignCallableGetOwnPropertyDescriptor = foreignErrorControl(instrumentCallableWrapper(callableGetOwnPropertyDescriptor, 'callableGetOwnPropertyDescriptor', OUTBOUND_INSTRUMENTATION_LABEL));
+      foreignCallableGetPrototypeOf = foreignErrorControl(instrumentCallableWrapper(callableGetPrototypeOf, 'callableGetPrototypeOf', OUTBOUND_INSTRUMENTATION_LABEL));
+      foreignCallableIsExtensible = foreignErrorControl(instrumentCallableWrapper(callableIsExtensible, 'callableIsExtensible', OUTBOUND_INSTRUMENTATION_LABEL));
+      foreignCallableOwnKeys = foreignErrorControl(instrumentCallableWrapper(callableOwnKeys, 'callableOwnKeys', OUTBOUND_INSTRUMENTATION_LABEL));
+      foreignCallablePreventExtensions = foreignErrorControl(instrumentCallableWrapper(callablePreventExtensions, 'callablePreventExtensions', OUTBOUND_INSTRUMENTATION_LABEL));
+      foreignCallableSet = foreignErrorControl(instrumentCallableWrapper(callableSet, 'callableSet', OUTBOUND_INSTRUMENTATION_LABEL));
+      foreignCallableSetPrototypeOf = foreignErrorControl(instrumentCallableWrapper(callableSetPrototypeOf, 'callableSetPrototypeOf', OUTBOUND_INSTRUMENTATION_LABEL));
+      foreignCallableGetTargetIntegrityTraits = foreignErrorControl(instrumentCallableWrapper(callableGetTargetIntegrityTraits, 'callableGetTargetIntegrityTraits', OUTBOUND_INSTRUMENTATION_LABEL));
+      foreignCallableGetUnbrandedTag = foreignErrorControl(instrumentCallableWrapper(callableGetUnbrandedTag, 'callableGetUnbrandedTag', OUTBOUND_INSTRUMENTATION_LABEL));
+      foreignCallableHasOwnProperty = foreignErrorControl(instrumentCallableWrapper(callableHasOwnProperty, 'callableHasOwnProperty', OUTBOUND_INSTRUMENTATION_LABEL));
     };
+  };
 }
 
-const TypeErrorCtor$1 = TypeError;
-const marshallSourceTextInStrictMode = `(function(){'use strict';return (${createMembraneMarshall.toString()})})()`;
-// eslint-disable-next-line no-eval
+const TypeErrorCtor$1 = TypeError; // istanbul ignore next
+
+const marshallSourceTextInStrictMode = `
+(function(){
+    'use strict';
+    (${function initializeShadowRealm() {
+  if (typeof Error.stackTraceLimit === 'number') {
+    // The default stack trace limit is 10.
+    // Increasing to 20 as a baby step.
+    Error.stackTraceLimit *= 2;
+  }
+}.toString()})();
+    return (${createMembraneMarshall.toString()})
+})()`; // eslint-disable-next-line no-eval
+
 function createConnector(evaluator) {
-    if (!evaluator) {
-        throw new TypeErrorCtor$1('Missing evaluator function');
-    }
-    // The result of this eval will be a function that returns a function.
-    // The hooks connector is the last returned function, so we invoke the
-    // result of the eval operation and return that result.
-    return evaluator(marshallSourceTextInStrictMode)();
+  if (!evaluator) {
+    throw new TypeErrorCtor$1('Missing evaluator function.');
+  } // The result of this eval will be a function that returns a function.
+  // The hooks connector is the last returned function, so we invoke the
+  // result of the eval operation and return that result.
+
+
+  return evaluator(marshallSourceTextInStrictMode)();
 }
 
 const SHOULD_TRAP_MUTATION = true;
 const SHOULD_NOT_TRAP_MUTATION = false;
 const UNDEFINED_SYMBOL = Symbol.for('@@membraneUndefinedValue');
 const ErrorCtor = Error;
-const { assign: ObjectAssign$2, keys: ObjectKeys } = Object;
-const { hasOwnProperty: ObjectProtoHasOwnProperty$1 } = Object.prototype;
-const { apply: ReflectApply$1$1, ownKeys: ReflectOwnKeys$1 } = Reflect;
-const { slice: StringProtoSlice, toUpperCase: StringProtoToUpperCase } = String.prototype;
+const {
+  assign: ObjectAssign$2,
+  keys: ObjectKeys
+} = Object;
+const {
+  apply: ReflectApply$1$1,
+  ownKeys: ReflectOwnKeys$1
+} = Reflect;
+const {
+  slice: StringProtoSlice,
+  toUpperCase: StringProtoToUpperCase
+} = String.prototype;
+
 function capitalizeFirstChar(string) {
-    const { length } = string;
-    if (!length) {
-        return string;
-    }
-    const upper = ReflectApply$1$1(StringProtoToUpperCase, string[0], []);
-    return length === 1 ? upper : upper + ReflectApply$1$1(StringProtoSlice, string, [1]);
+  const {
+    length
+  } = string;
+
+  if (!length) {
+    return string;
+  }
+
+  const upper = ReflectApply$1$1(StringProtoToUpperCase, string[0], []);
+  return length === 1 ? upper : upper + ReflectApply$1$1(StringProtoSlice, string, [1]);
 }
+
 class VirtualEnvironment {
-    constructor(options) {
-        if (options === undefined) {
-            throw new ErrorCtor(`Missing VirtualEnvironmentOptions options bag.`);
-        }
-        const { blueConnector, redConnector, distortionCallback, support, instrumentation } = options;
-        this.blueConnector = blueConnector;
-        this.redConnector = redConnector;
-        let supportFlags = SupportFlagsEnum.None;
-        const supportProps = support ? ObjectKeys(support) : [];
-        for (let i = 0, len = supportProps.length; i < len; i += 1) {
-            const key = capitalizeFirstChar(supportProps[i]);
-            if (ReflectApply$1$1(ObjectProtoHasOwnProperty$1, SupportFlagsEnum, [key])) {
-                supportFlags |= SupportFlagsEnum[key];
-            }
-        }
-        let blueHooks;
-        let redHooks;
-        const blueExportsCallback = (...hooks) => {
-            blueHooks = hooks;
-        };
-        const redExportsCallback = (...hooks) => {
-            redHooks = hooks;
-        };
-        const initLocalOptions = {
-            distortionCallback,
-            instrumentation,
-        };
-        const localConnect = blueConnector('blue', SHOULD_NOT_TRAP_MUTATION, supportFlags, blueExportsCallback, initLocalOptions);
-        const foreignConnect = redConnector('red', SHOULD_TRAP_MUTATION, supportFlags, redExportsCallback);
-        ReflectApply$1$1(localConnect, undefined, redHooks);
-        ReflectApply$1$1(foreignConnect, undefined, blueHooks);
-        const { 0: blueGlobalThisPointer, 1: blueGetSelectedTarget, 2: blueGetTransferableValue, 3: blueCallableGetPropertyValuePointer, 
-        // 4: blueCallableEvaluate,
-        5: blueCallableLinkPointers, } = blueHooks;
-        this.blueGlobalThisPointer = blueGlobalThisPointer;
-        this.blueGetSelectedTarget = blueGetSelectedTarget;
-        this.blueGetTransferableValue = blueGetTransferableValue;
-        this.blueCallableGetPropertyValuePointer = blueCallableGetPropertyValuePointer;
-        this.blueCallableLinkPointers = blueCallableLinkPointers;
-        const { 0: redGlobalThisPointer, 
-        // 1: redGetSelectedTarget,
-        // 2: redGetTransferableValue,
-        3: redCallableGetPropertyValuePointer, 4: redCallableEvaluate, 5: redCallableLinkPointers, 
-        // 6: redCallablePushTarget,
-        // 7: redCallableApply,
-        // 8: redCallableConstruct,
-        9: redCallableDefineProperty, 
-        // 10: redCallableDeleteProperty,
-        // 11: redCallableGetOwnPropertyDescriptor,
-        // 12: redCallableGetPrototypeOf,
-        // 13: redCallableIsExtensible,
-        // 14: redCallableOwnKeys,
-        // 15: redCallablePreventExtensions,
-        // 16: redCallableSet,
-        17: redCallableSetPrototypeOf, } = redHooks;
-        this.redGlobalThisPointer = redGlobalThisPointer;
-        this.redCallableEvaluate = redCallableEvaluate;
-        this.redCallableSetPrototypeOf = redCallableSetPrototypeOf;
-        this.redCallableDefineProperty = redCallableDefineProperty;
-        this.redCallableGetPropertyValuePointer = redCallableGetPropertyValuePointer;
-        this.redCallableLinkPointers = redCallableLinkPointers;
-    }
-    evaluate(sourceText) {
-        try {
-            const pointerOrPrimitiveValue = this.redCallableEvaluate(sourceText);
-            if (typeof pointerOrPrimitiveValue === 'function') {
-                pointerOrPrimitiveValue();
-                return this.blueGetSelectedTarget();
-            }
-            return pointerOrPrimitiveValue;
-        }
-        catch (e) {
-            const pushedError = this.blueGetSelectedTarget();
-            if (pushedError) {
-                throw pushedError;
-            }
-            throw e;
-        }
+  constructor(options) {
+    if (options === undefined) {
+      throw new ErrorCtor(`Missing VirtualEnvironmentOptions options bag.`);
     }
-    link(...keys) {
-        let bluePointer = this.blueGlobalThisPointer;
-        let redPointer = this.redGlobalThisPointer;
-        for (let i = 0, len = keys.length; i < len; i += 1) {
-            const key = keys[i];
-            bluePointer = this.blueCallableGetPropertyValuePointer(bluePointer, key);
-            redPointer = this.redCallableGetPropertyValuePointer(redPointer, key);
-        }
-        this.redCallableLinkPointers(redPointer, bluePointer);
-        this.blueCallableLinkPointers(bluePointer, redPointer);
-    }
-    remap(target, blueDescriptors) {
-        const keys = ReflectOwnKeys$1(blueDescriptors);
-        const targetPointer = this.blueGetTransferableValue(target);
-        // prettier-ignore
-        for (let i = 0, len = keys.length; i < len; i += 1) {
-            const key = keys[i];
-            const unsafeBlueDesc = blueDescriptors[key];
-            // Avoid poisoning by only installing own properties from blueDescriptors
-            // eslint-disable-next-line prefer-object-spread
-            const safeBlueDesc = ObjectAssign$2({ __proto__: null }, unsafeBlueDesc);
-            // Install descriptor into the red side.
-            this.redCallableDefineProperty(targetPointer, key, 'configurable' in safeBlueDesc
-                ? !!safeBlueDesc.configurable
-                : UNDEFINED_SYMBOL, 'enumerable' in safeBlueDesc
-                ? !!safeBlueDesc.enumerable
-                : UNDEFINED_SYMBOL, 'writable' in safeBlueDesc
-                ? !!safeBlueDesc.writable
-                : UNDEFINED_SYMBOL, 'value' in safeBlueDesc
-                ? this.blueGetTransferableValue(safeBlueDesc.value)
-                : UNDEFINED_SYMBOL, 'get' in safeBlueDesc
-                ? this.blueGetTransferableValue(safeBlueDesc.get)
-                : UNDEFINED_SYMBOL, 'set' in safeBlueDesc
-                ? this.blueGetTransferableValue(safeBlueDesc.set)
-                : UNDEFINED_SYMBOL);
-        }
+
+    const {
+      blueConnector,
+      redConnector,
+      distortionCallback,
+      support,
+      instrumentation
+    } = options;
+    this.blueConnector = blueConnector;
+    this.redConnector = redConnector;
+    let supportFlags = SupportFlagsEnum.None;
+    const supportKeys = support ? ObjectKeys(support) : [];
+
+    for (let i = 0, len = supportKeys.length; i < len; i += 1) {
+      const enumKey = capitalizeFirstChar(supportKeys[i]);
+      supportFlags |= SupportFlagsEnum[enumKey];
+    }
+
+    let blueHooks;
+    let redHooks;
+
+    const blueExportsCallback = function blueExportsCallback() {
+      for (var _len8 = arguments.length, hooks = new Array(_len8), _key8 = 0; _key8 < _len8; _key8++) {
+        hooks[_key8] = arguments[_key8];
+      }
+
+      blueHooks = hooks;
+    };
+
+    const redExportsCallback = function redExportsCallback() {
+      for (var _len9 = arguments.length, hooks = new Array(_len9), _key9 = 0; _key9 < _len9; _key9++) {
+        hooks[_key9] = arguments[_key9];
+      }
+
+      redHooks = hooks;
+    };
+
+    const initLocalOptions = {
+      distortionCallback,
+      instrumentation
+    };
+    const localConnect = blueConnector('blue', SHOULD_NOT_TRAP_MUTATION, supportFlags, blueExportsCallback, initLocalOptions);
+    const foreignConnect = redConnector('red', SHOULD_TRAP_MUTATION, supportFlags, redExportsCallback);
+    ReflectApply$1$1(localConnect, undefined, redHooks);
+    ReflectApply$1$1(foreignConnect, undefined, blueHooks);
+    const {
+      0: blueGlobalThisPointer,
+      1: blueGetSelectedTarget,
+      2: blueGetTransferableValue,
+      3: blueCallableGetPropertyValuePointer,
+      // 4: blueCallableEvaluate,
+      5: blueCallableLinkPointers
+    } = blueHooks;
+    this.blueGlobalThisPointer = blueGlobalThisPointer;
+    this.blueGetSelectedTarget = blueGetSelectedTarget;
+    this.blueGetTransferableValue = blueGetTransferableValue;
+    this.blueCallableGetPropertyValuePointer = blueCallableGetPropertyValuePointer;
+    this.blueCallableLinkPointers = blueCallableLinkPointers;
+    const {
+      0: redGlobalThisPointer,
+      // 1: redGetSelectedTarget,
+      // 2: redGetTransferableValue,
+      3: redCallableGetPropertyValuePointer,
+      4: redCallableEvaluate,
+      5: redCallableLinkPointers,
+      // 6: redCallablePushTarget,
+      // 7: redCallableApply,
+      // 8: redCallableConstruct,
+      9: redCallableDefineProperty,
+      // 10: redCallableDeleteProperty,
+      // 11: redCallableGetOwnPropertyDescriptor,
+      // 12: redCallableGetPrototypeOf,
+      // 13: redCallableIsExtensible,
+      // 14: redCallableOwnKeys,
+      // 15: redCallablePreventExtensions,
+      // 16: redCallableSet,
+      17: redCallableSetPrototypeOf
+    } = redHooks;
+    this.redGlobalThisPointer = redGlobalThisPointer;
+    this.redCallableEvaluate = redCallableEvaluate;
+    this.redCallableSetPrototypeOf = redCallableSetPrototypeOf;
+    this.redCallableDefineProperty = redCallableDefineProperty;
+    this.redCallableGetPropertyValuePointer = redCallableGetPropertyValuePointer;
+    this.redCallableLinkPointers = redCallableLinkPointers;
+  }
+
+  evaluate(sourceText) {
+    try {
+      const pointerOrPrimitiveValue = this.redCallableEvaluate(sourceText);
+
+      if (typeof pointerOrPrimitiveValue === 'function') {
+        pointerOrPrimitiveValue();
+        return this.blueGetSelectedTarget();
+      }
+
+      return pointerOrPrimitiveValue;
+    } catch (e) {
+      const pushedError = this.blueGetSelectedTarget();
+
+      if (pushedError) {
+        throw pushedError;
+      }
+
+      throw e;
+    }
+  }
+
+  link() {
+    let bluePointer = this.blueGlobalThisPointer;
+    let redPointer = this.redGlobalThisPointer;
+
+    for (let i = 0, len = arguments.length; i < len; i += 1) {
+      const key = i < 0 || arguments.length <= i ? undefined : arguments[i];
+      bluePointer = this.blueCallableGetPropertyValuePointer(bluePointer, key);
+      redPointer = this.redCallableGetPropertyValuePointer(redPointer, key);
     }
-    remapProto(target, proto) {
-        const targetPointer = this.blueGetTransferableValue(target);
-        const pointerOrNull = this.blueGetTransferableValue(proto);
-        this.redCallableSetPrototypeOf(targetPointer, pointerOrNull);
+
+    this.redCallableLinkPointers(redPointer, bluePointer);
+    this.blueCallableLinkPointers(bluePointer, redPointer);
+  }
+
+  remap(target, blueDescriptors) {
+    const keys = ReflectOwnKeys$1(blueDescriptors);
+    const targetPointer = this.blueGetTransferableValue(target); // prettier-ignore
+
+    for (let i = 0, len = keys.length; i < len; i += 1) {
+      const key = keys[i];
+      const unsafeBlueDesc = blueDescriptors[key]; // Avoid poisoning by only installing own properties from blueDescriptors
+      // eslint-disable-next-line prefer-object-spread
+
+      const safeBlueDesc = ObjectAssign$2({
+        __proto__: null
+      }, unsafeBlueDesc); // Install descriptor into the red side.
+
+      this.redCallableDefineProperty(targetPointer, key, 'configurable' in safeBlueDesc ? !!safeBlueDesc.configurable : UNDEFINED_SYMBOL, 'enumerable' in safeBlueDesc ? !!safeBlueDesc.enumerable : UNDEFINED_SYMBOL, 'writable' in safeBlueDesc ? !!safeBlueDesc.writable : UNDEFINED_SYMBOL, 'value' in safeBlueDesc ? this.blueGetTransferableValue(safeBlueDesc.value) : UNDEFINED_SYMBOL, 'get' in safeBlueDesc ? this.blueGetTransferableValue(safeBlueDesc.get) : UNDEFINED_SYMBOL, 'set' in safeBlueDesc ? this.blueGetTransferableValue(safeBlueDesc.set) : UNDEFINED_SYMBOL);
     }
+  }
+
+  remapProto(target, proto) {
+    const targetPointer = this.blueGetTransferableValue(target);
+    const pointerOrNull = this.blueGetTransferableValue(proto);
+    this.redCallableSetPrototypeOf(targetPointer, pointerOrNull);
+  }
+
 }
 
-const { includes: ArrayProtoIncludes } = Array.prototype;
-const { has: SetProtoHas } = Set.prototype;
-const { apply: ReflectApply$2, getOwnPropertyDescriptor: ReflectGetOwnPropertyDescriptor, ownKeys: ReflectOwnKeys, } = Reflect;
+const {
+  includes: ArrayProtoIncludes
+} = Array.prototype;
+const {
+  has: SetProtoHas
+} = Set.prototype;
+const {
+  apply: ReflectApply$2,
+  getOwnPropertyDescriptor: ReflectGetOwnPropertyDescriptor,
+  ownKeys: ReflectOwnKeys
+} = Reflect;
 /**
  * This list must be in sync with ecma-262, anything new added to the global object
  * should be considered, to decide whether or not they need remapping. The default
@@ -7016,194 +7392,147 @@ const { apply: ReflectApply$2, getOwnPropertyDescriptor: ReflectGetOwnPropertyDe
  * problematic, and requires a lot more work to guarantee that objects from both sides
  * can be considered equivalents (without identity discontinuity).
  */
-const ESGlobalKeys = new Set([
-    // *** 19.1 Value Properties of the Global Object
-    'globalThis',
-    'Infinity',
-    'NaN',
-    'undefined',
-    // *** 19.2 Function Properties of the Global Object
-    'eval',
-    'isFinite',
-    'isNaN',
-    'parseFloat',
-    'parseInt',
-    'decodeURI',
-    'decodeURIComponent',
-    'encodeURI',
-    'encodeURIComponent',
-    // *** 19.3 Constructor Properties of the Global Object
-    'AggregateError',
-    'Array',
-    'ArrayBuffer',
-    'BigInt',
-    'BigInt64Array',
-    'BigUint64Array',
-    'Boolean',
-    'DataView',
-    // 'Date', // Unstable & Remapped
-    'Error',
-    'EvalError',
-    'FinalizationRegistry',
-    'Float32Array',
-    'Float64Array',
-    'Function',
-    'Int8Array',
-    'Int16Array',
-    'Int32Array',
-    // 'Map', // Remapped
-    'Number',
-    'Object',
-    // Allow Blue `Promise` constructor to overwrite the Red one so that promises
-    // created by the `Promise` constructor or APIs like `fetch` will work.
-    // 'Promise', // Remapped
-    'Proxy',
-    'RangeError',
-    'ReferenceError',
-    'RegExp',
-    // 'Set', // Remapped
-    'SharedArrayBuffer',
-    'String',
-    'Symbol',
-    'SyntaxError',
-    'TypeError',
-    'Uint8Array',
-    'Uint8ClampedArray',
-    'Uint16Array',
-    'Uint32Array',
-    'URIError',
-    // 'WeakMap', // Remapped
-    // 'WeakSet', // Remapped
-    'WeakRef',
-    // *** 18.4 Other Properties of the Global Object
-    'Atomics',
-    'JSON',
-    'Math',
-    'Reflect',
-    // *** Annex B
-    'escape',
-    'unescape',
-    // *** ECMA-402
-    // 'Intl',  // Unstable & Remapped
-]);
-// These are foundational things that should never be wrapped but are equivalent
+
+const ESGlobalKeys = new Set([// *** 19.1 Value Properties of the Global Object
+'globalThis', 'Infinity', 'NaN', 'undefined', // *** 19.2 Function Properties of the Global Object
+'eval', 'isFinite', 'isNaN', 'parseFloat', 'parseInt', 'decodeURI', 'decodeURIComponent', 'encodeURI', 'encodeURIComponent', // *** 19.3 Constructor Properties of the Global Object
+'AggregateError', 'Array', 'ArrayBuffer', 'BigInt', 'BigInt64Array', 'BigUint64Array', 'Boolean', 'DataView', // 'Date', // Unstable & Remapped
+'Error', 'EvalError', 'FinalizationRegistry', 'Float32Array', 'Float64Array', 'Function', 'Int8Array', 'Int16Array', 'Int32Array', // 'Map', // Remapped
+'Number', 'Object', // Allow Blue `Promise` constructor to overwrite the Red one so that promises
+// created by the `Promise` constructor or APIs like `fetch` will work.
+// 'Promise', // Remapped
+'Proxy', 'RangeError', 'ReferenceError', 'RegExp', // 'Set', // Remapped
+'SharedArrayBuffer', 'String', 'Symbol', 'SyntaxError', 'TypeError', 'Uint8Array', 'Uint8ClampedArray', 'Uint16Array', 'Uint32Array', 'URIError', // 'WeakMap', // Remapped
+// 'WeakSet', // Remapped
+'WeakRef', // *** 18.4 Other Properties of the Global Object
+'Atomics', 'JSON', 'Math', 'Reflect', // *** Annex B
+'escape', 'unescape' // *** ECMA-402
+// 'Intl',  // Unstable & Remapped
+]); // These are foundational things that should never be wrapped but are equivalent
 // TODO: revisit this list.
-const ReflectiveIntrinsicObjectNames = [
-    'AggregateError',
-    'Array',
-    'Error',
-    'EvalError',
-    'Function',
-    'Object',
-    'Proxy',
-    'RangeError',
-    'ReferenceError',
-    'SyntaxError',
-    'TypeError',
-    'URIError',
-    'eval',
-];
+
+const ReflectiveIntrinsicObjectNames = ['AggregateError', 'Array', 'Error', 'EvalError', 'Function', 'Object', 'Proxy', 'RangeError', 'ReferenceError', 'SyntaxError', 'TypeError', 'URIError', 'eval'];
+
 function assignFilteredGlobalObjectShapeDescriptors(descriptorMap, source) {
-    const keys = ReflectOwnKeys(source);
-    for (let i = 0, len = keys.length; i < len; i += 1) {
-        // forcing to string here because of TypeScript's PropertyDescriptorMap
-        // definition, which doesn't support symbols as entries.
-        const key = keys[i];
-        // avoid overriding ECMAScript global names that correspond
-        // to global intrinsics. This guarantee that those entries
-        // will be ignored if present in the endowments object.
-        // TODO: what if the intent is to polyfill one of those
-        // intrinsics?
-        if (!isIntrinsicGlobalName(key) && !isReflectiveGlobalName(key)) {
-            const unsafeDesc = ReflectGetOwnPropertyDescriptor(source, key);
-            // Safari 14.0.x (macOS) and 14.2 (iOS) have a bug where 'showModalDialog'
-            // is returned in the list of own keys produces by ReflectOwnKeys(iframeWindow),
-            // however 'showModalDialog' is not an own property and produces
-            // undefined at ReflectGetOwnPropertyDescriptor(window, key);
-            //
-            // In all other browsers, 'showModalDialog' is not an own property
-            // and does not appear in the list produces by ReflectOwnKeys(iframeWindow).
-            //
-            // So, as a general rule: if there is not an own descriptor,
-            // ignore the entry and continue.
-            if (unsafeDesc) {
-                descriptorMap[key] = unsafeDesc;
-            }
-        }
+  const keys = ReflectOwnKeys(source);
+
+  for (let i = 0, len = keys.length; i < len; i += 1) {
+    // forcing to string here because of TypeScript's PropertyDescriptorMap
+    // definition, which doesn't support symbols as entries.
+    const key = keys[i]; // avoid overriding ECMAScript global names that correspond
+    // to global intrinsics. This guarantee that those entries
+    // will be ignored if present in the endowments object.
+    // TODO: what if the intent is to polyfill one of those
+    // intrinsics?
+
+    if (!ReflectApply$2(SetProtoHas, ESGlobalKeys, [key]) && !ReflectApply$2(ArrayProtoIncludes, ReflectiveIntrinsicObjectNames, [key])) {
+      const unsafeDesc = ReflectGetOwnPropertyDescriptor(source, key); // Safari 14.0.x (macOS) and 14.2 (iOS) have a bug where 'showModalDialog'
+      // is returned in the list of own keys produces by ReflectOwnKeys(iframeWindow),
+      // however 'showModalDialog' is not an own property and produces
+      // undefined at ReflectGetOwnPropertyDescriptor(window, key);
+      //
+      // In all other browsers, 'showModalDialog' is not an own property
+      // and does not appear in the list produces by ReflectOwnKeys(iframeWindow).
+      //
+      // So, as a general rule: if there is not an own descriptor,
+      // ignore the entry and continue.
+
+      if (unsafeDesc) {
+        descriptorMap[key] = unsafeDesc;
+      }
     }
-    return descriptorMap;
-}
-function isIntrinsicGlobalName(key) {
-    return ReflectApply$2(SetProtoHas, ESGlobalKeys, [key]);
-}
-function isReflectiveGlobalName(key) {
-    return ReflectApply$2(ArrayProtoIncludes, ReflectiveIntrinsicObjectNames, [key]);
+  }
+
+  return descriptorMap;
 }
+
 function linkIntrinsics(env, globalObjectVirtualizationTarget) {
-    // remapping intrinsics that are realm's agnostic
-    for (let i = 0, len = ReflectiveIntrinsicObjectNames.length; i < len; i += 1) {
-        const globalName = ReflectiveIntrinsicObjectNames[i];
-        const reflectiveValue = globalObjectVirtualizationTarget[globalName];
-        if (reflectiveValue) {
-            env.link(globalName);
-            // Proxy.prototype is undefined, being the only weird thing here
-            if (reflectiveValue.prototype) {
-                env.link(globalName, 'prototype');
-            }
-        }
+  // remapping intrinsics that are realm's agnostic
+  for (let i = 0, len = ReflectiveIntrinsicObjectNames.length; i < len; i += 1) {
+    const globalName = ReflectiveIntrinsicObjectNames[i];
+    const reflectiveValue = globalObjectVirtualizationTarget[globalName];
+
+    if (reflectiveValue) {
+      env.link(globalName); // Proxy.prototype is undefined, being the only weird thing here
+
+      if (reflectiveValue.prototype) {
+        env.link(globalName, 'prototype');
+      }
     }
+  }
 }
-function getResolvedShapeDescriptors(...sources) {
-    const descriptors = {};
-    for (let i = 0, len = sources.length; i < len; i += 1) {
-        const source = sources[i];
-        if (source) {
-            assignFilteredGlobalObjectShapeDescriptors(descriptors, source);
-        }
+
+function getResolvedShapeDescriptors() {
+  const descriptors = {};
+
+  for (let i = 0, len = arguments.length; i < len; i += 1) {
+    const source = i < 0 || arguments.length <= i ? undefined : arguments[i];
+
+    if (source) {
+      assignFilteredGlobalObjectShapeDescriptors(descriptors, source);
     }
-    return descriptors;
+  }
+
+  return descriptors;
 }
 
 const TypeErrorCtor = TypeError;
+
 function validateRequiredGlobalShapeAndVirtualizationObjects(globalObjectShape, globalObjectVirtualizationTarget) {
-    if (!globalObjectShape) {
-        throw new TypeErrorCtor('Missing global object shape.');
-    }
-    if (!globalObjectVirtualizationTarget) {
-        throw new TypeErrorCtor('Missing global object virtualization target.');
-    }
-    return undefined;
+  if (!globalObjectShape) {
+    throw new TypeErrorCtor('Missing global object shape.');
+  }
+
+  if (!globalObjectVirtualizationTarget) {
+    throw new TypeErrorCtor('Missing global object virtualization target.');
+  }
+
+  return undefined;
 }
 
-const { assign: ObjectAssign$1, getOwnPropertyDescriptors: ObjectGetOwnPropertyDescriptors } = Object;
-const { getPrototypeOf: ReflectGetPrototypeOf, apply: ReflectApply$1 } = Reflect;
-const { get: WeakMapProtoGet, set: WeakMapProtoSet } = WeakMap.prototype;
+const {
+  assign: ObjectAssign$1,
+  getOwnPropertyDescriptors: ObjectGetOwnPropertyDescriptors
+} = Object;
+const {
+  getPrototypeOf: ReflectGetPrototypeOf,
+  apply: ReflectApply$1
+} = Reflect;
+const {
+  get: WeakMapProtoGet,
+  set: WeakMapProtoSet
+} = WeakMap.prototype;
 const cachedBlueGlobalMap = new WeakMap();
+
 function getBaseReferences(window) {
-    const record = { __proto__: null };
-    // caching references to object values that can't be replaced
-    // window -> Window -> WindowProperties -> EventTarget
-    record.window = window.window;
-    record.document = window.document;
-    record.WindowProto = ReflectGetPrototypeOf(record.window);
-    record.WindowPropertiesProto = ReflectGetPrototypeOf(record.WindowProto);
-    record.EventTargetProto = ReflectGetPrototypeOf(record.WindowPropertiesProto);
-    record.DocumentProto = ReflectGetPrototypeOf(record.document);
-    return record;
+  const record = {
+    __proto__: null
+  }; // caching references to object values that can't be replaced
+  // window -> Window -> WindowProperties -> EventTarget
+
+  record.window = window.window;
+  record.document = window.document;
+  record.WindowProto = ReflectGetPrototypeOf(record.window);
+  record.WindowPropertiesProto = ReflectGetPrototypeOf(record.WindowProto);
+  record.EventTargetProto = ReflectGetPrototypeOf(record.WindowPropertiesProto);
+  record.DocumentProto = ReflectGetPrototypeOf(record.document);
+  return record;
 }
+
 function getCachedBlueReferences(window) {
-    let record = ReflectApply$1(WeakMapProtoGet, cachedBlueGlobalMap, [window]);
-    if (record) {
-        return record;
-    }
-    record = getBaseReferences(window);
-    // caching the record
-    ReflectApply$1(WeakMapProtoSet, cachedBlueGlobalMap, [window, record]);
-    // intentionally avoiding remapping any Window.prototype descriptor,
-    // there is nothing in this prototype that needs to be remapped.
-    record.WindowProtoDescriptors = {};
-    record.EventTargetProtoDescriptors = ObjectGetOwnPropertyDescriptors(record.EventTargetProto);
+  let record = ReflectApply$1(WeakMapProtoGet, cachedBlueGlobalMap, [window]);
+
+  if (record) {
     return record;
+  }
+
+  record = getBaseReferences(window); // caching the record
+
+  ReflectApply$1(WeakMapProtoSet, cachedBlueGlobalMap, [window, record]); // intentionally avoiding remapping any Window.prototype descriptor,
+  // there is nothing in this prototype that needs to be remapped.
+
+  record.EventTargetProtoDescriptors = ObjectGetOwnPropertyDescriptors(record.EventTargetProto);
+  return record;
 }
 /**
  * Initialization operation to capture and cache all unforgeable references
@@ -7211,6 +7540,8 @@ function getCachedBlueReferences(window) {
  * usually help because this library runs before anything else that can poison
  * the environment.
  */
+
+
 getCachedBlueReferences(window);
 /**
  * global descriptors are a combination of 3 set of descriptors:
@@ -7239,212 +7570,254 @@ getCachedBlueReferences(window);
  * that will be installed (via the membrane) as global descriptors in
  * the red realm.
  */
+
 function filterWindowDescriptors(endowmentsDescriptors) {
-    const to = {};
-    // endowments descriptors will overrule any default descriptor inferred
-    // from the detached iframe. note that they are already filtered, not need
-    // to check against intrinsics again.
-    ObjectAssign$1(to, endowmentsDescriptors);
-    // removing unforgeable descriptors that cannot be installed
-    delete to.location;
-    delete to.document;
-    delete to.window;
-    delete to.top;
-    // Some DOM APIs do brand checks for TypeArrays and others objects,
-    // in this case, if the API is not dangerous, and works in a detached
-    // iframe, we can let the sandbox to use the iframe's api directly,
-    // instead of remapping it to the blue realm.
-    // TODO [issue #67]: review this list
-    delete to.crypto;
-    // others browser specific undeniable globals
-    delete to.chrome;
-    return to;
+  const to = {}; // endowments descriptors will overrule any default descriptor inferred
+  // from the detached iframe. note that they are already filtered, not need
+  // to check against intrinsics again.
+
+  ObjectAssign$1(to, endowmentsDescriptors); // removing unforgeable descriptors that cannot be installed
+
+  delete to.document;
+  delete to.location;
+  delete to.top;
+  delete to.window; // Some DOM APIs do brand checks for TypeArrays and others objects,
+  // in this case, if the API is not dangerous, and works in a detached
+  // iframe, we can let the sandbox to use the iframe's api directly,
+  // instead of remapping it to the blue realm.
+  // TODO [issue #67]: review this list
+
+  delete to.crypto; // others browser specific undeniable globals
+
+  delete to.chrome;
+  return to;
 }
+
 function tameDOM(env, blueRefs, endowmentsDescriptors) {
-    // adjusting proto chain of window.document
-    env.remapProto(blueRefs.document, blueRefs.DocumentProto);
-    const globalDescriptors = filterWindowDescriptors(endowmentsDescriptors);
-    // remapping globals
-    env.remap(blueRefs.window, globalDescriptors);
-    // remapping unforgeable objects
-    env.remap(blueRefs.EventTargetProto, blueRefs.EventTargetProtoDescriptors);
-    env.remap(blueRefs.WindowProto, blueRefs.WindowProtoDescriptors);
-    /**
-     * WindowProperties.prototype is magical, it provide access to any
-     * object that "clobbers" the WindowProxy instance for easy access. E.g.:
-     *
-     *     var object = document.createElement('object');
-     *     object.id = 'foo';
-     *     document.body.appendChild(object);
-     *
-     * The result of this code is that `window.foo` points to the HTMLObjectElement
-     * instance, and in some browsers, those are not even reported as descriptors
-     * installed on WindowProperties.prototype, but they are instead magically
-     * resolved when accessing `foo` from `window`.
-     *
-     * This forces us to avoid using the descriptors from the blue window directly,
-     * and instead, we might only need to shadow the descriptors installed in the brand
-     * new iframe, that way any magical entry from the blue window will not be
-     * installed on the iframe. That turns out to be also empty, therefore we
-     * don't need to remap `blueRefs.WindowPropertiesProto` descriptors at all.
-     */
+  // adjusting proto chain of window.document
+  env.remapProto(blueRefs.document, blueRefs.DocumentProto);
+  const globalDescriptors = filterWindowDescriptors(endowmentsDescriptors); // remapping globals
+
+  env.remap(blueRefs.window, globalDescriptors); // remapping unforgeable objects
+
+  env.remap(blueRefs.EventTargetProto, blueRefs.EventTargetProtoDescriptors);
+  /**
+   * WindowProperties.prototype is magical, it provide access to any
+   * object that "clobbers" the WindowProxy instance for easy access. E.g.:
+   *
+   *     var object = document.createElement('object');
+   *     object.id = 'foo';
+   *     document.body.appendChild(object);
+   *
+   * The result of this code is that `window.foo` points to the HTMLObjectElement
+   * instance, and in some browsers, those are not even reported as descriptors
+   * installed on WindowProperties.prototype, but they are instead magically
+   * resolved when accessing `foo` from `window`.
+   *
+   * This forces us to avoid using the descriptors from the blue window directly,
+   * and instead, we might only need to shadow the descriptors installed in the brand
+   * new iframe, that way any magical entry from the blue window will not be
+   * installed on the iframe. That turns out to be also empty, therefore we
+   * don't need to remap `blueRefs.WindowPropertiesProto` descriptors at all.
+   */
 }
+
 function linkUnforgeables(env, blueGlobalThis) {
-    // The test of instance of event target is important to discard environments
-    // in which a fake window (e.g. jest) is not following the specs, and can
-    // break this membrane.
-    if (blueGlobalThis.EventTarget && blueGlobalThis instanceof EventTarget) {
-        // window.document
-        env.link('document');
-        // window.__proto__ (aka Window.prototype)
-        env.link('__proto__');
-        // window.__proto__.__proto__ (aka WindowProperties.prototype)
-        env.link('__proto__', '__proto__');
-        // window.__proto__.__proto__.__proto__ (aka EventTarget.prototype)
-        env.link('__proto__', '__proto__', '__proto__');
-    }
+  // The test of instance of event target is important to discard environments
+  // in which a fake window (e.g. jest) is not following the specs, and can
+  // break this membrane.
+  if (blueGlobalThis.EventTarget && blueGlobalThis instanceof EventTarget) {
+    // window.document
+    env.link('document'); // window.__proto__ (aka Window.prototype)
+
+    env.link('__proto__'); // window.__proto__.__proto__ (aka WindowProperties.prototype)
+
+    env.link('__proto__', '__proto__'); // window.__proto__.__proto__.__proto__ (aka EventTarget.prototype)
+
+    env.link('__proto__', '__proto__', '__proto__');
+  }
 }
 
 const IFRAME_SANDBOX_ATTRIBUTE_VALUE = 'allow-same-origin allow-scripts';
 const emptyArray = [];
-const { close: DocumentProtoClose, createElement: DocumentProtoCreateElement, open: DocumentProtoOpen, } = document;
-const { remove: ElementProtoRemove, setAttribute: ElementProtoSetAttribute } = Element.prototype;
-const { appendChild: NodeProtoAppendChild } = Node.prototype;
-const { assign: ObjectAssign } = Object;
-const { 
-// eslint-disable-next-line @typescript-eslint/naming-convention
-__lookupGetter__: ObjectProto__lookupGetter__, hasOwnProperty: ObjectProtoHasOwnProperty, } = Object.prototype;
-const { apply: ReflectApply } = Reflect;
+const {
+  close: DocumentProtoClose,
+  createElement: DocumentProtoCreateElement,
+  open: DocumentProtoOpen
+} = document;
+const {
+  remove: ElementProtoRemove,
+  setAttribute: ElementProtoSetAttribute
+} = Element.prototype;
+const {
+  appendChild: NodeProtoAppendChild
+} = Node.prototype;
+const {
+  assign: ObjectAssign
+} = Object;
+const {
+  // eslint-disable-next-line @typescript-eslint/naming-convention
+  __lookupGetter__: ObjectProto__lookupGetter__,
+  hasOwnProperty: ObjectProtoHasOwnProperty
+} = Object.prototype;
+const {
+  apply: ReflectApply
+} = Reflect;
+
 function ObjectLookupOwnGetter(obj, key) {
-    // Since this function is only used internally, and would not otherwise be
-    // reachable by user code, istanbul can ignore test coverage for the
-    // following condition.
-    // istanbul ignore next
-    // eslint-disable-next-line @typescript-eslint/no-use-before-define
-    if (obj === null || obj === undefined || !ReflectApply(ObjectProtoHasOwnProperty, obj, [key])) {
-        return undefined;
-    }
-    // eslint-disable-next-line @typescript-eslint/no-use-before-define
-    return ReflectApply(ObjectProto__lookupGetter__, obj, [key]);
+  // Since this function is only used internally, and would not otherwise be
+  // reachable by user code, istanbul can ignore test coverage for the
+  // following condition.
+  // istanbul ignore next
+  // eslint-disable-next-line @typescript-eslint/no-use-before-define
+  if (obj === null || obj === undefined || !ReflectApply(ObjectProtoHasOwnProperty, obj, [key])) {
+    return undefined;
+  } // eslint-disable-next-line @typescript-eslint/no-use-before-define
+
+
+  return ReflectApply(ObjectProto__lookupGetter__, obj, [key]);
 }
+
 const DocumentProtoBodyGetter = ObjectLookupOwnGetter(Document.prototype, 'body');
 const HTMLElementProtoStyleGetter = ObjectLookupOwnGetter(HTMLElement.prototype, 'style');
 const HTMLIFrameElementProtoContentWindowGetter = ObjectLookupOwnGetter(HTMLIFrameElement.prototype, 'contentWindow');
 const NodeProtoIsConnectedGetter = ObjectLookupOwnGetter(Node.prototype, 'isConnected');
 const NodeProtoLastChildGetter = ObjectLookupOwnGetter(Node.prototype, 'lastChild');
+
 function DocumentBody(doc) {
-    return ReflectApply(DocumentProtoBodyGetter, doc, emptyArray);
+  return ReflectApply(DocumentProtoBodyGetter, doc, emptyArray);
 }
+
 function DocumentClose(doc) {
-    return ReflectApply(DocumentProtoClose, doc, emptyArray);
+  return ReflectApply(DocumentProtoClose, doc, emptyArray);
 }
+
 function DocumentCreateElement(doc, tagName) {
-    return ReflectApply(DocumentProtoCreateElement, doc, [tagName]);
+  return ReflectApply(DocumentProtoCreateElement, doc, [tagName]);
 }
+
 function DocumentOpen(doc) {
-    return ReflectApply(DocumentProtoOpen, doc, emptyArray);
+  return ReflectApply(DocumentProtoOpen, doc, emptyArray);
 }
+
 function ElementSetAttribute(el, name, value) {
-    return ReflectApply(ElementProtoSetAttribute, el, [name, value]);
+  return ReflectApply(ElementProtoSetAttribute, el, [name, value]);
 }
+
 function ElementRemove(element) {
-    return ReflectApply(ElementProtoRemove, element, emptyArray);
+  return ReflectApply(ElementProtoRemove, element, emptyArray);
 }
+
 function HTMLElementStyleGetter(el) {
-    return ReflectApply(HTMLElementProtoStyleGetter, el, emptyArray);
+  return ReflectApply(HTMLElementProtoStyleGetter, el, emptyArray);
 }
+
 function HTMLIFrameElementContentWindowGetter(iframe) {
-    return ReflectApply(HTMLIFrameElementProtoContentWindowGetter, iframe, emptyArray);
+  return ReflectApply(HTMLIFrameElementProtoContentWindowGetter, iframe, emptyArray);
 }
+
 function NodeAppendChild(parent, child) {
-    return ReflectApply(NodeProtoAppendChild, parent, [child]);
-}
-// It's impossible to test whether NodeLastChild(document) is reached
+  return ReflectApply(NodeProtoAppendChild, parent, [child]);
+} // It's impossible to test whether NodeLastChild(document) is reached
 // in a normal Karma test environment, because the document will always
 // have a body element. Ignore this in coverage reporting to
 // avoid a penalty.
 // istanbul ignore next
+
+
 function NodeLastChild(node) {
-    return ReflectApply(NodeProtoLastChildGetter, node, emptyArray);
+  return ReflectApply(NodeProtoLastChildGetter, node, emptyArray);
 }
+
 function NodeIsConnected(node) {
-    return ReflectApply(NodeProtoIsConnectedGetter, node, emptyArray);
+  return ReflectApply(NodeProtoIsConnectedGetter, node, emptyArray);
 }
+
 function createDetachableIframe$1() {
-    // @ts-ignore document global ref - in browsers
-    const iframe = DocumentCreateElement(document, 'iframe');
-    // It's impossible to test whether NodeLastChild(document) is reached
-    // in a normal Karma test environment. (See explanation above,
-    // at NodeLastChild definition.)
-    const parent = DocumentBody(document) || /* istanbul ignore next */ NodeLastChild(document);
-    const style = HTMLElementStyleGetter(iframe);
-    style.display = 'none';
-    ElementSetAttribute(iframe, 'sandbox', IFRAME_SANDBOX_ATTRIBUTE_VALUE);
-    NodeAppendChild(parent, iframe);
-    return iframe;
+  // @ts-ignore document global ref - in browsers
+  const iframe = DocumentCreateElement(document, 'iframe'); // It's impossible to test whether NodeLastChild(document) is reached
+  // in a normal Karma test environment. (See explanation above,
+  // at NodeLastChild definition.)
+
+  const parent = DocumentBody(document) ||
+  /* istanbul ignore next */
+  NodeLastChild(document);
+  const style = HTMLElementStyleGetter(iframe);
+  style.display = 'none';
+  ElementSetAttribute(iframe, 'sandbox', IFRAME_SANDBOX_ATTRIBUTE_VALUE);
+  NodeAppendChild(parent, iframe);
+  return iframe;
 }
+
 function removeIframe(iframe) {
-    // In Chrome debugger statements will be ignored when the iframe is removed
-    // from the document. Other browsers like Firefox and Safari work as expected.
-    // https://bugs.chromium.org/p/chromium/issues/detail?id=1015462
-    // Because the detachable iframe is created, and then optionally removed, all
-    // within the execution of createVirtualEnvironment, there is no point in which
-    // test code can interfere with iframe element, or its prototype chain, in
-    // order to remove it from the DOM, or stub the isConnected accessor
-    // (the latter is already too late before createVirtualEnvironment is ever called).
-    // For this reason, ignore the lack of `else` path coverage.
-    //
-    // istanbul ignore else
-    if (NodeIsConnected(iframe)) {
-        ElementRemove(iframe);
-    }
+  // In Chrome debugger statements will be ignored when the iframe is removed
+  // from the document. Other browsers like Firefox and Safari work as expected.
+  // https://bugs.chromium.org/p/chromium/issues/detail?id=1015462
+  // Because the detachable iframe is created, and then optionally removed, all
+  // within the execution of createVirtualEnvironment, there is no point in which
+  // test code can interfere with iframe element, or its prototype chain, in
+  // order to remove it from the DOM, or stub the isConnected accessor
+  // (the latter is already too late before createVirtualEnvironment is ever called).
+  // For this reason, ignore the lack of `else` path coverage.
+  //
+  // istanbul ignore else
+  if (NodeIsConnected(iframe)) {
+    ElementRemove(iframe);
+  }
 }
+
 const createHooksCallback = createMembraneMarshall();
+
 function createVirtualEnvironment(globalObjectShape, globalObjectVirtualizationTarget, providedOptions) {
-    validateRequiredGlobalShapeAndVirtualizationObjects(globalObjectShape, globalObjectVirtualizationTarget);
-    // eslint-disable-next-line prefer-object-spread
-    const options = ObjectAssign({
-        __proto__: null,
-        keepAlive: false,
-    }, providedOptions);
-    // eslint-disable-next-line prefer-object-spread
-    const { distortionCallback, endowments = {}, keepAlive, support, instrumentation } = options;
-    const iframe = createDetachableIframe$1();
-    const redWindow = HTMLIFrameElementContentWindowGetter(iframe).window;
-    const { document: redDocument } = redWindow;
-    const blueConnector = createHooksCallback;
-    const redConnector = createConnector(redWindow.eval);
-    // Extract the global references and descriptors before any interference.
-    const blueRefs = getCachedBlueReferences(globalObjectVirtualizationTarget);
-    // Create a new environment.
-    const env = new VirtualEnvironment({
-        blueConnector,
-        distortionCallback,
-        redConnector,
-        support,
-        instrumentation,
-    });
-    env.link('window');
-    linkIntrinsics(env, globalObjectVirtualizationTarget);
-    linkUnforgeables(env, globalObjectVirtualizationTarget);
-    tameDOM(env, blueRefs, getResolvedShapeDescriptors(globalObjectShape, endowments));
-    // Once we get the iframe info ready, and all mapped, we can proceed
-    // to detach the iframe only if the keepAlive option isn't true.
-    if (keepAlive !== true) {
-        removeIframe(iframe);
-    }
-    else {
-        // TODO: Temporary hack to preserve the document reference in Firefox.
-        // https://bugzilla.mozilla.org/show_bug.cgi?id=543435
-        DocumentOpen(redDocument);
-        DocumentClose(redDocument);
-    }
-    return env;
+  validateRequiredGlobalShapeAndVirtualizationObjects(globalObjectShape, globalObjectVirtualizationTarget); // eslint-disable-next-line prefer-object-spread
+
+  const options = ObjectAssign({
+    __proto__: null,
+    keepAlive: false
+  }, providedOptions); // eslint-disable-next-line prefer-object-spread
+
+  const {
+    distortionCallback,
+    endowments = {},
+    keepAlive,
+    support,
+    instrumentation
+  } = options;
+  const iframe = createDetachableIframe$1();
+  const redWindow = HTMLIFrameElementContentWindowGetter(iframe).window;
+  const {
+    document: redDocument
+  } = redWindow;
+  const blueConnector = createHooksCallback;
+  const redConnector = createConnector(redWindow.eval); // Extract the global references and descriptors before any interference.
+
+  const blueRefs = getCachedBlueReferences(globalObjectVirtualizationTarget); // Create a new environment.
+
+  const env = new VirtualEnvironment({
+    blueConnector,
+    distortionCallback,
+    redConnector,
+    support,
+    instrumentation
+  });
+  env.link('window');
+  linkIntrinsics(env, globalObjectVirtualizationTarget);
+  linkUnforgeables(env, globalObjectVirtualizationTarget);
+  tameDOM(env, blueRefs, getResolvedShapeDescriptors(globalObjectShape, endowments)); // Once we get the iframe info ready, and all mapped, we can proceed
+  // to detach the iframe only if the keepAlive option isn't true.
+
+  if (keepAlive !== true) {
+    removeIframe(iframe);
+  } else {
+    // TODO: Temporary hack to preserve the document reference in Firefox.
+    // https://bugzilla.mozilla.org/show_bug.cgi?id=543435
+    DocumentOpen(redDocument);
+    DocumentClose(redDocument);
+  }
+
+  return env;
 }
 
-/*!
- * Copyright (C) 2019 salesforce.com, inc.
- */
 let lockerBlueRealmGlobalObjectShape;
 let lockerEvalContextValue;
 let lockerEvalHelpersValue;
@@ -7683,8 +8056,8 @@ function createSandbox(key, distortionFactory, endowments, instrumentation) {
     const headRef = docRef.head;
 
     function DocumentCreateElement(doc) {
-      for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key2 = 1; _key2 < _len; _key2++) {
-        args[_key2 - 1] = arguments[_key2];
+      for (var _len10 = arguments.length, args = new Array(_len10 > 1 ? _len10 - 1 : 0), _key10 = 1; _key10 < _len10; _key10++) {
+        args[_key10 - 1] = arguments[_key10];
       }
 
       return ReflectApply(DocumentProtoCreateElement, doc, args);
@@ -7703,8 +8076,8 @@ function createSandbox(key, distortionFactory, endowments, instrumentation) {
     }
 
     function EventTargetAddEventListener(target) {
-      for (var _len2 = arguments.length, args = new Array(_len2 > 1 ? _len2 - 1 : 0), _key3 = 1; _key3 < _len2; _key3++) {
-        args[_key3 - 1] = arguments[_key3];
+      for (var _len11 = arguments.length, args = new Array(_len11 > 1 ? _len11 - 1 : 0), _key11 = 1; _key11 < _len11; _key11++) {
+        args[_key11 - 1] = arguments[_key11];
       }
 
       return ReflectApply(EventTargetProtoAddEventListener, target, args);
@@ -7933,7 +8306,7 @@ function evaluateInSandbox(key, sourceText, context, endowments, instrumentation
   activityEvaluateInSandbox.stop();
   return result;
 }
-/*! version: 0.14.13 */
+/*! version: 0.14.15 */
 
 const loaderDefine = globalThis.LWR.define;
 /**