@metamask/snaps-execution-environments 0.34.1-flask.1 → 0.35.1-flask.1

package/dist/cjs/common/endowments/math.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return _default;
+    }
+});
+const _globalObject = require("../globalObject");
+const _crypto = require("./crypto");
+/**
+ * Create a {@link Math} object, with the same properties as the global
+ * {@link Math} object, but with the {@link Math.random} method replaced.
+ *
+ * @returns The {@link Math} object with the {@link Math.random} method
+ * replaced.
+ */ function createMath() {
+    // `Math` does not work with `Object.keys`, `Object.entries`, etc., so we
+    // need to create a new object with the same properties.
+    const keys = Object.getOwnPropertyNames(_globalObject.rootRealmGlobal.Math);
+    const math = keys.reduce((target, key)=>{
+        if (key === 'random') {
+            return target;
+        }
+        return {
+            ...target,
+            [key]: _globalObject.rootRealmGlobal.Math[key]
+        };
+    }, {});
+    // Since the math endowment requires crypto, we can leverage the crypto endowment factory to get a hardened and platform agnostic instance of webcrypto
+    const { crypto: hardenedCrypto } = (0, _crypto.createCrypto)();
+    return harden({
+        Math: {
+            ...math,
+            random: ()=>{
+                // NOTE: This is not intended to be a secure replacement for the weak
+                // random number generator used by `Math.random`. It is only intended to
+                // prevent side channel attacks of `Math.random` by replacing it with an
+                // alternative implementation that is not vulnerable to the same
+                // attacks.
+                //
+                // This does not mean that this implementation is secure. It is not
+                // intended to be used in a security context, and this implementation
+                // may change at any time.
+                //
+                // To securely generate random numbers, use a cryptographically secure
+                // random number generator, such as the one provided by the Web Crypto
+                // API:
+                //
+                // - https://developer.mozilla.org/en-US/docs/Web/API/SubtleCrypto/generateKey
+                // - https://developer.mozilla.org/en-US/docs/Web/API/Crypto/getRandomValues
+                return hardenedCrypto.getRandomValues(new Uint32Array(1))[0] / 2 ** 32;
+            }
+        }
+    });
+}
+const endowmentModule = {
+    names: [
+        'Math'
+    ],
+    factory: createMath
+};
+const _default = endowmentModule;
+
+//# sourceMappingURL=math.js.map

package/dist/cjs/common/endowments/math.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/common/endowments/math.ts"],"sourcesContent":["import { rootRealmGlobal } from '../globalObject';\nimport { createCrypto } from './crypto';\n\n/**\n * Create a {@link Math} object, with the same properties as the global\n * {@link Math} object, but with the {@link Math.random} method replaced.\n *\n * @returns The {@link Math} object with the {@link Math.random} method\n * replaced.\n */\nfunction createMath() {\n  // `Math` does not work with `Object.keys`, `Object.entries`, etc., so we\n  // need to create a new object with the same properties.\n  const keys = Object.getOwnPropertyNames(\n    rootRealmGlobal.Math,\n  ) as (keyof typeof Math)[];\n\n  const math = keys.reduce<Partial<Math>>((target, key) => {\n    if (key === 'random') {\n      return target;\n    }\n\n    return { ...target, [key]: rootRealmGlobal.Math[key] };\n  }, {});\n\n  // Since the math endowment requires crypto, we can leverage the crypto endowment factory to get a hardened and platform agnostic instance of webcrypto\n  const { crypto: hardenedCrypto } = createCrypto();\n\n  return harden({\n    Math: {\n      ...math,\n      random: () => {\n        // NOTE: This is not intended to be a secure replacement for the weak\n        // random number generator used by `Math.random`. It is only intended to\n        // prevent side channel attacks of `Math.random` by replacing it with an\n        // alternative implementation that is not vulnerable to the same\n        // attacks.\n        //\n        // This does not mean that this implementation is secure. It is not\n        // intended to be used in a security context, and this implementation\n        // may change at any time.\n        //\n        // To securely generate random numbers, use a cryptographically secure\n        // random number generator, such as the one provided by the Web Crypto\n        // API:\n        //\n        // - https://developer.mozilla.org/en-US/docs/Web/API/SubtleCrypto/generateKey\n        // - https://developer.mozilla.org/en-US/docs/Web/API/Crypto/getRandomValues\n        return hardenedCrypto.getRandomValues(new Uint32Array(1))[0] / 2 ** 32;\n      },\n    },\n  });\n}\n\nconst endowmentModule = {\n  names: ['Math'] as const,\n  factory: createMath,\n};\n\nexport default endowmentModule;\n"],"names":["createMath","keys","Object","getOwnPropertyNames","rootRealmGlobal","Math","math","reduce","target","key","crypto","hardenedCrypto","createCrypto","harden","random","getRandomValues","Uint32Array","endowmentModule","names","factory"],"mappings":";;;;+BA2DA;;;eAAA;;;8BA3DgC;wBACH;AAE7B;;;;;;CAMC,GACD,SAASA;IACP,yEAAyE;IACzE,wDAAwD;IACxD,MAAMC,OAAOC,OAAOC,mBAAmB,CACrCC,6BAAe,CAACC,IAAI;IAGtB,MAAMC,OAAOL,KAAKM,MAAM,CAAgB,CAACC,QAAQC;QAC/C,IAAIA,QAAQ,UAAU;YACpB,OAAOD;QACT;QAEA,OAAO;YAAE,GAAGA,MAAM;YAAE,CAACC,IAAI,EAAEL,6BAAe,CAACC,IAAI,CAACI,IAAI;QAAC;IACvD,GAAG,CAAC;IAEJ,uJAAuJ;IACvJ,MAAM,EAAEC,QAAQC,cAAc,EAAE,GAAGC,IAAAA,oBAAY;IAE/C,OAAOC,OAAO;QACZR,MAAM;YACJ,GAAGC,IAAI;YACPQ,QAAQ;gBACN,qEAAqE;gBACrE,wEAAwE;gBACxE,wEAAwE;gBACxE,gEAAgE;gBAChE,WAAW;gBACX,EAAE;gBACF,mEAAmE;gBACnE,qEAAqE;gBACrE,0BAA0B;gBAC1B,EAAE;gBACF,sEAAsE;gBACtE,sEAAsE;gBACtE,OAAO;gBACP,EAAE;gBACF,8EAA8E;gBAC9E,4EAA4E;gBAC5E,OAAOH,eAAeI,eAAe,CAAC,IAAIC,YAAY,GAAG,CAAC,EAAE,GAAG,KAAK;YACtE;QACF;IACF;AACF;AAEA,MAAMC,kBAAkB;IACtBC,OAAO;QAAC;KAAO;IACfC,SAASnB;AACX;MAEA,WAAeiB"}

package/dist/cjs/common/endowments/network.js

@@ -0,0 +1,206 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return _default;
+    }
+});
+const _utils = require("../utils");
+function _check_private_redeclaration(obj, privateCollection) {
+    if (privateCollection.has(obj)) {
+        throw new TypeError("Cannot initialize the same private elements twice on an object");
+    }
+}
+function _class_apply_descriptor_get(receiver, descriptor) {
+    if (descriptor.get) {
+        return descriptor.get.call(receiver);
+    }
+    return descriptor.value;
+}
+function _class_apply_descriptor_set(receiver, descriptor, value) {
+    if (descriptor.set) {
+        descriptor.set.call(receiver, value);
+    } else {
+        if (!descriptor.writable) {
+            throw new TypeError("attempted to set read only private field");
+        }
+        descriptor.value = value;
+    }
+}
+function _class_extract_field_descriptor(receiver, privateMap, action) {
+    if (!privateMap.has(receiver)) {
+        throw new TypeError("attempted to " + action + " private field on non-instance");
+    }
+    return privateMap.get(receiver);
+}
+function _class_private_field_get(receiver, privateMap) {
+    var descriptor = _class_extract_field_descriptor(receiver, privateMap, "get");
+    return _class_apply_descriptor_get(receiver, descriptor);
+}
+function _class_private_field_init(obj, privateMap, value) {
+    _check_private_redeclaration(obj, privateMap);
+    privateMap.set(obj, value);
+}
+function _class_private_field_set(receiver, privateMap, value) {
+    var descriptor = _class_extract_field_descriptor(receiver, privateMap, "set");
+    _class_apply_descriptor_set(receiver, descriptor, value);
+    return value;
+}
+var _teardownRef = /*#__PURE__*/ new WeakMap(), _ogResponse = /*#__PURE__*/ new WeakMap();
+/**
+ * This class wraps a Response object.
+ * That way, a teardown process can stop any processes left.
+ */ class ResponseWrapper {
+    get body() {
+        return _class_private_field_get(this, _ogResponse).body;
+    }
+    get bodyUsed() {
+        return _class_private_field_get(this, _ogResponse).bodyUsed;
+    }
+    get headers() {
+        return _class_private_field_get(this, _ogResponse).headers;
+    }
+    get ok() {
+        return _class_private_field_get(this, _ogResponse).ok;
+    }
+    get redirected() {
+        return _class_private_field_get(this, _ogResponse).redirected;
+    }
+    get status() {
+        return _class_private_field_get(this, _ogResponse).status;
+    }
+    get statusText() {
+        return _class_private_field_get(this, _ogResponse).statusText;
+    }
+    get type() {
+        return _class_private_field_get(this, _ogResponse).type;
+    }
+    get url() {
+        return _class_private_field_get(this, _ogResponse).url;
+    }
+    async text() {
+        return (0, _utils.withTeardown)(_class_private_field_get(this, _ogResponse).text(), this);
+    }
+    async arrayBuffer() {
+        return (0, _utils.withTeardown)(_class_private_field_get(this, _ogResponse).arrayBuffer(), this);
+    }
+    async blob() {
+        return (0, _utils.withTeardown)(_class_private_field_get(this, _ogResponse).blob(), this);
+    }
+    clone() {
+        const newResponse = _class_private_field_get(this, _ogResponse).clone();
+        return new ResponseWrapper(newResponse, _class_private_field_get(this, _teardownRef));
+    }
+    async formData() {
+        return (0, _utils.withTeardown)(_class_private_field_get(this, _ogResponse).formData(), this);
+    }
+    async json() {
+        return (0, _utils.withTeardown)(_class_private_field_get(this, _ogResponse).json(), this);
+    }
+    constructor(ogResponse, teardownRef){
+        _class_private_field_init(this, _teardownRef, {
+            writable: true,
+            value: void 0
+        });
+        _class_private_field_init(this, _ogResponse, {
+            writable: true,
+            value: void 0
+        });
+        _class_private_field_set(this, _ogResponse, ogResponse);
+        _class_private_field_set(this, _teardownRef, teardownRef);
+    }
+}
+/**
+ * Create a network endowment, consisting of a `fetch` function.
+ * This allows us to provide a teardown function, so that we can cancel
+ * any pending requests, connections, streams, etc. that may be open when a snap
+ * is terminated.
+ *
+ * This wraps the original implementation of `fetch`,
+ * to ensure that a bad actor cannot get access to the original function, thus
+ * potentially preventing the network requests from being torn down.
+ *
+ * @returns An object containing a wrapped `fetch`
+ * function, as well as a teardown function.
+ */ const createNetwork = ()=>{
+    // Open fetch calls or open body streams
+    const openConnections = new Set();
+    // Track last teardown count
+    const teardownRef = {
+        lastTeardown: 0
+    };
+    // Remove items from openConnections after they were garbage collected
+    const cleanup = new FinalizationRegistry(/* istanbul ignore next: can't test garbage collection without modifying node parameters */ (callback)=>callback());
+    const _fetch = async (input, init)=>{
+        const abortController = new AbortController();
+        if (init?.signal !== null && init?.signal !== undefined) {
+            const originalSignal = init.signal;
+            // Merge abort controllers
+            originalSignal.addEventListener('abort', ()=>{
+                abortController.abort(originalSignal.reason);
+            }, {
+                once: true
+            });
+        }
+        let res;
+        let openFetchConnection;
+        try {
+            const fetchPromise = fetch(input, {
+                ...init,
+                signal: abortController.signal
+            });
+            openFetchConnection = {
+                cancel: async ()=>{
+                    abortController.abort();
+                    try {
+                        await fetchPromise;
+                    } catch  {
+                    /* do nothing */ }
+                }
+            };
+            openConnections.add(openFetchConnection);
+            res = new ResponseWrapper(await (0, _utils.withTeardown)(fetchPromise, teardownRef), teardownRef);
+        } finally{
+            if (openFetchConnection !== undefined) {
+                openConnections.delete(openFetchConnection);
+            }
+        }
+        if (res.body !== null) {
+            const body = new WeakRef(res.body);
+            const openBodyConnection = {
+                cancel: /* istanbul ignore next: see it.todo('can be torn down during body read') test */ async ()=>{
+                    try {
+                        await body.deref()?.cancel();
+                    } catch  {
+                    /* do nothing */ }
+                }
+            };
+            openConnections.add(openBodyConnection);
+            cleanup.register(res.body, /* istanbul ignore next: can't test garbage collection without modifying node parameters */ ()=>openConnections.delete(openBodyConnection));
+        }
+        return harden(res);
+    };
+    const teardownFunction = async ()=>{
+        teardownRef.lastTeardown += 1;
+        const promises = [];
+        openConnections.forEach(({ cancel })=>promises.push(cancel()));
+        openConnections.clear();
+        await Promise.all(promises);
+    };
+    return {
+        fetch: harden(_fetch),
+        teardownFunction
+    };
+};
+const endowmentModule = {
+    names: [
+        'fetch'
+    ],
+    factory: createNetwork
+};
+const _default = endowmentModule;
+
+//# sourceMappingURL=network.js.map

package/dist/cjs/common/endowments/network.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/common/endowments/network.ts"],"sourcesContent":["import { withTeardown } from '../utils';\n\n/**\n * This class wraps a Response object.\n * That way, a teardown process can stop any processes left.\n */\nclass ResponseWrapper implements Response {\n  readonly #teardownRef: { lastTeardown: number };\n\n  #ogResponse: Response;\n\n  constructor(ogResponse: Response, teardownRef: { lastTeardown: number }) {\n    this.#ogResponse = ogResponse;\n    this.#teardownRef = teardownRef;\n  }\n\n  get body(): ReadableStream<Uint8Array> | null {\n    return this.#ogResponse.body;\n  }\n\n  get bodyUsed() {\n    return this.#ogResponse.bodyUsed;\n  }\n\n  get headers() {\n    return this.#ogResponse.headers;\n  }\n\n  get ok() {\n    return this.#ogResponse.ok;\n  }\n\n  get redirected() {\n    return this.#ogResponse.redirected;\n  }\n\n  get status() {\n    return this.#ogResponse.status;\n  }\n\n  get statusText() {\n    return this.#ogResponse.statusText;\n  }\n\n  get type() {\n    return this.#ogResponse.type;\n  }\n\n  get url() {\n    return this.#ogResponse.url;\n  }\n\n  async text() {\n    return withTeardown<string>(this.#ogResponse.text(), this as any);\n  }\n\n  async arrayBuffer(): Promise<ArrayBuffer> {\n    return withTeardown<ArrayBuffer>(\n      this.#ogResponse.arrayBuffer(),\n      this as any,\n    );\n  }\n\n  async blob(): Promise<Blob> {\n    return withTeardown<Blob>(this.#ogResponse.blob(), this as any);\n  }\n\n  clone(): Response {\n    const newResponse = this.#ogResponse.clone();\n    return new ResponseWrapper(newResponse, this.#teardownRef);\n  }\n\n  async formData(): Promise<FormData> {\n    return withTeardown<FormData>(this.#ogResponse.formData(), this as any);\n  }\n\n  async json(): Promise<any> {\n    return withTeardown(this.#ogResponse.json(), this as any);\n  }\n}\n\n/**\n * Create a network endowment, consisting of a `fetch` function.\n * This allows us to provide a teardown function, so that we can cancel\n * any pending requests, connections, streams, etc. that may be open when a snap\n * is terminated.\n *\n * This wraps the original implementation of `fetch`,\n * to ensure that a bad actor cannot get access to the original function, thus\n * potentially preventing the network requests from being torn down.\n *\n * @returns An object containing a wrapped `fetch`\n * function, as well as a teardown function.\n */\nconst createNetwork = () => {\n  // Open fetch calls or open body streams\n  const openConnections = new Set<{ cancel: () => Promise<void> }>();\n  // Track last teardown count\n  const teardownRef = { lastTeardown: 0 };\n\n  // Remove items from openConnections after they were garbage collected\n  const cleanup = new FinalizationRegistry<() => void>(\n    /* istanbul ignore next: can't test garbage collection without modifying node parameters */\n    (callback) => callback(),\n  );\n\n  const _fetch: typeof fetch = async (\n    input: RequestInfo | URL,\n    init?: RequestInit,\n  ): Promise<Response> => {\n    const abortController = new AbortController();\n    if (init?.signal !== null && init?.signal !== undefined) {\n      const originalSignal = init.signal;\n      // Merge abort controllers\n      originalSignal.addEventListener(\n        'abort',\n        () => {\n          abortController.abort((originalSignal as any).reason);\n        },\n        { once: true },\n      );\n    }\n\n    let res: Response;\n    let openFetchConnection: { cancel: () => Promise<void> } | undefined;\n    try {\n      const fetchPromise = fetch(input, {\n        ...init,\n        signal: abortController.signal,\n      });\n\n      openFetchConnection = {\n        cancel: async () => {\n          abortController.abort();\n          try {\n            await fetchPromise;\n          } catch {\n            /* do nothing */\n          }\n        },\n      };\n      openConnections.add(openFetchConnection);\n\n      res = new ResponseWrapper(\n        await withTeardown(fetchPromise, teardownRef),\n        teardownRef,\n      );\n    } finally {\n      if (openFetchConnection !== undefined) {\n        openConnections.delete(openFetchConnection);\n      }\n    }\n\n    if (res.body !== null) {\n      const body = new WeakRef<ReadableStream>(res.body);\n\n      const openBodyConnection = {\n        cancel:\n          /* istanbul ignore next: see it.todo('can be torn down during body read') test */\n          async () => {\n            try {\n              await body.deref()?.cancel();\n            } catch {\n              /* do nothing */\n            }\n          },\n      };\n      openConnections.add(openBodyConnection);\n      cleanup.register(\n        res.body,\n        /* istanbul ignore next: can't test garbage collection without modifying node parameters */\n        () => openConnections.delete(openBodyConnection),\n      );\n    }\n    return harden(res);\n  };\n\n  const teardownFunction = async () => {\n    teardownRef.lastTeardown += 1;\n    const promises: Promise<void>[] = [];\n    openConnections.forEach(({ cancel }) => promises.push(cancel()));\n    openConnections.clear();\n    await Promise.all(promises);\n  };\n\n  return {\n    fetch: harden(_fetch),\n    teardownFunction,\n  };\n};\n\nconst endowmentModule = {\n  names: ['fetch'] as const,\n  factory: createNetwork,\n};\nexport default endowmentModule;\n"],"names":["ResponseWrapper","body","ogResponse","bodyUsed","headers","ok","redirected","status","statusText","type","url","text","withTeardown","arrayBuffer","blob","clone","newResponse","teardownRef","formData","json","constructor","createNetwork","openConnections","Set","lastTeardown","cleanup","FinalizationRegistry","callback","_fetch","input","init","abortController","AbortController","signal","undefined","originalSignal","addEventListener","abort","reason","once","res","openFetchConnection","fetchPromise","fetch","cancel","add","delete","WeakRef","openBodyConnection","deref","register","harden","teardownFunction","promises","forEach","push","clear","Promise","all","endowmentModule","names","factory"],"mappings":"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"}

package/dist/cjs/common/endowments/textDecoder.js

@@ -0,0 +1,28 @@
+/**
+ * Creates TextDecoder function hardened by SES.
+ *
+ * @returns An object with the attenuated `TextDecoder` function.
+ */ "use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return _default;
+    }
+});
+const createTextDecoder = ()=>{
+    return {
+        TextDecoder: harden(TextDecoder)
+    };
+};
+const endowmentModule = {
+    names: [
+        'TextDecoder'
+    ],
+    factory: createTextDecoder
+};
+const _default = endowmentModule;
+
+//# sourceMappingURL=textDecoder.js.map

package/dist/cjs/common/endowments/textDecoder.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/common/endowments/textDecoder.ts"],"sourcesContent":["/**\n * Creates TextDecoder function hardened by SES.\n *\n * @returns An object with the attenuated `TextDecoder` function.\n */\nconst createTextDecoder = () => {\n  return {\n    TextDecoder: harden(TextDecoder),\n  } as const;\n};\n\nconst endowmentModule = {\n  names: ['TextDecoder'] as const,\n  factory: createTextDecoder,\n};\nexport default endowmentModule;\n"],"names":["createTextDecoder","TextDecoder","harden","endowmentModule","names","factory"],"mappings":"AAAA;;;;CAIC;;;;+BAWD;;;eAAA;;;AAVA,MAAMA,oBAAoB;IACxB,OAAO;QACLC,aAAaC,OAAOD;IACtB;AACF;AAEA,MAAME,kBAAkB;IACtBC,OAAO;QAAC;KAAc;IACtBC,SAASL;AACX;MACA,WAAeG"}

package/dist/cjs/common/endowments/textEncoder.js

@@ -0,0 +1,28 @@
+/**
+ * Creates TextEncoder function hardened by SES.
+ *
+ * @returns An object with the attenuated `TextEncoder` function.
+ */ "use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return _default;
+    }
+});
+const createTextEncoder = ()=>{
+    return {
+        TextEncoder: harden(TextEncoder)
+    };
+};
+const endowmentModule = {
+    names: [
+        'TextEncoder'
+    ],
+    factory: createTextEncoder
+};
+const _default = endowmentModule;
+
+//# sourceMappingURL=textEncoder.js.map

package/dist/cjs/common/endowments/textEncoder.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/common/endowments/textEncoder.ts"],"sourcesContent":["/**\n * Creates TextEncoder function hardened by SES.\n *\n * @returns An object with the attenuated `TextEncoder` function.\n */\nconst createTextEncoder = () => {\n  return {\n    TextEncoder: harden(TextEncoder),\n  } as const;\n};\n\nconst endowmentModule = {\n  names: ['TextEncoder'] as const,\n  factory: createTextEncoder,\n};\nexport default endowmentModule;\n"],"names":["createTextEncoder","TextEncoder","harden","endowmentModule","names","factory"],"mappings":"AAAA;;;;CAIC;;;;+BAWD;;;eAAA;;;AAVA,MAAMA,oBAAoB;IACxB,OAAO;QACLC,aAAaC,OAAOD;IACtB;AACF;AAEA,MAAME,kBAAkB;IACtBC,OAAO;QAAC;KAAc;IACtBC,SAASL;AACX;MACA,WAAeG"}

package/dist/cjs/common/endowments/timeout.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return _default;
+    }
+});
+const MINIMUM_TIMEOUT = 10;
+/**
+ * Creates a pair of `setTimeout` and `clearTimeout` functions attenuated such
+ * that:
+ * - `setTimeout` throws if its "handler" parameter is not a function.
+ * - `clearTimeout` only clears timeouts created by its sibling `setTimeout`,
+ * or else no-ops.
+ *
+ * @returns An object with the attenuated `setTimeout` and `clearTimeout`
+ * functions.
+ */ const createTimeout = ()=>{
+    const registeredHandles = new Map();
+    const _setTimeout = (handler, timeout)=>{
+        if (typeof handler !== 'function') {
+            throw new Error(`The timeout handler must be a function. Received: ${typeof handler}`);
+        }
+        harden(handler);
+        const handle = Object.freeze(Object.create(null));
+        const platformHandle = setTimeout(()=>{
+            registeredHandles.delete(handle);
+            handler();
+        }, Math.max(MINIMUM_TIMEOUT, timeout ?? 0));
+        registeredHandles.set(handle, platformHandle);
+        return handle;
+    };
+    const _clearTimeout = (handle)=>{
+        const platformHandle = registeredHandles.get(handle);
+        if (platformHandle !== undefined) {
+            clearTimeout(platformHandle);
+            registeredHandles.delete(handle);
+        }
+    };
+    const teardownFunction = ()=>{
+        for (const handle of registeredHandles.keys()){
+            _clearTimeout(handle);
+        }
+    };
+    return {
+        setTimeout: harden(_setTimeout),
+        clearTimeout: harden(_clearTimeout),
+        teardownFunction
+    };
+};
+const endowmentModule = {
+    names: [
+        'setTimeout',
+        'clearTimeout'
+    ],
+    factory: createTimeout
+};
+const _default = endowmentModule;
+
+//# sourceMappingURL=timeout.js.map

package/dist/cjs/common/endowments/timeout.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/common/endowments/timeout.ts"],"sourcesContent":["const MINIMUM_TIMEOUT = 10;\n\n/**\n * Creates a pair of `setTimeout` and `clearTimeout` functions attenuated such\n * that:\n * - `setTimeout` throws if its \"handler\" parameter is not a function.\n * - `clearTimeout` only clears timeouts created by its sibling `setTimeout`,\n * or else no-ops.\n *\n * @returns An object with the attenuated `setTimeout` and `clearTimeout`\n * functions.\n */\nconst createTimeout = () => {\n  const registeredHandles = new Map<unknown, unknown>();\n  const _setTimeout = (handler: TimerHandler, timeout?: number): unknown => {\n    if (typeof handler !== 'function') {\n      throw new Error(\n        `The timeout handler must be a function. Received: ${typeof handler}`,\n      );\n    }\n    harden(handler);\n    const handle = Object.freeze(Object.create(null));\n    const platformHandle = setTimeout(() => {\n      registeredHandles.delete(handle);\n      handler();\n    }, Math.max(MINIMUM_TIMEOUT, timeout ?? 0));\n\n    registeredHandles.set(handle, platformHandle);\n    return handle;\n  };\n\n  const _clearTimeout = (handle: unknown): void => {\n    const platformHandle = registeredHandles.get(handle);\n    if (platformHandle !== undefined) {\n      clearTimeout(platformHandle as any);\n      registeredHandles.delete(handle);\n    }\n  };\n\n  const teardownFunction = (): void => {\n    for (const handle of registeredHandles.keys()) {\n      _clearTimeout(handle);\n    }\n  };\n\n  return {\n    setTimeout: harden(_setTimeout),\n    clearTimeout: harden(_clearTimeout),\n    teardownFunction,\n  } as const;\n};\n\nconst endowmentModule = {\n  names: ['setTimeout', 'clearTimeout'] as const,\n  factory: createTimeout,\n};\nexport default endowmentModule;\n"],"names":["MINIMUM_TIMEOUT","createTimeout","registeredHandles","Map","_setTimeout","handler","timeout","Error","harden","handle","Object","freeze","create","platformHandle","setTimeout","delete","Math","max","set","_clearTimeout","get","undefined","clearTimeout","teardownFunction","keys","endowmentModule","names","factory"],"mappings":";;;;+BAwDA;;;eAAA;;;AAxDA,MAAMA,kBAAkB;AAExB;;;;;;;;;CASC,GACD,MAAMC,gBAAgB;IACpB,MAAMC,oBAAoB,IAAIC;IAC9B,MAAMC,cAAc,CAACC,SAAuBC;QAC1C,IAAI,OAAOD,YAAY,YAAY;YACjC,MAAM,IAAIE,MACR,CAAC,kDAAkD,EAAE,OAAOF,QAAQ,CAAC;QAEzE;QACAG,OAAOH;QACP,MAAMI,SAASC,OAAOC,MAAM,CAACD,OAAOE,MAAM,CAAC;QAC3C,MAAMC,iBAAiBC,WAAW;YAChCZ,kBAAkBa,MAAM,CAACN;YACzBJ;QACF,GAAGW,KAAKC,GAAG,CAACjB,iBAAiBM,WAAW;QAExCJ,kBAAkBgB,GAAG,CAACT,QAAQI;QAC9B,OAAOJ;IACT;IAEA,MAAMU,gBAAgB,CAACV;QACrB,MAAMI,iBAAiBX,kBAAkBkB,GAAG,CAACX;QAC7C,IAAII,mBAAmBQ,WAAW;YAChCC,aAAaT;YACbX,kBAAkBa,MAAM,CAACN;QAC3B;IACF;IAEA,MAAMc,mBAAmB;QACvB,KAAK,MAAMd,UAAUP,kBAAkBsB,IAAI,GAAI;YAC7CL,cAAcV;QAChB;IACF;IAEA,OAAO;QACLK,YAAYN,OAAOJ;QACnBkB,cAAcd,OAAOW;QACrBI;IACF;AACF;AAEA,MAAME,kBAAkB;IACtBC,OAAO;QAAC;QAAc;KAAe;IACrCC,SAAS1B;AACX;MACA,WAAewB"}

package/dist/cjs/common/globalEvents.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    addEventListener: function() {
+        return addEventListener;
+    },
+    removeEventListener: function() {
+        return removeEventListener;
+    }
+});
+const _globalObject = require("./globalObject");
+function addEventListener(event, listener) {
+    if ('addEventListener' in _globalObject.rootRealmGlobal && typeof _globalObject.rootRealmGlobal.addEventListener === 'function') {
+        return _globalObject.rootRealmGlobal.addEventListener(event.toLowerCase(), listener);
+    }
+    if (_globalObject.rootRealmGlobal.process && 'on' in _globalObject.rootRealmGlobal.process && typeof _globalObject.rootRealmGlobal.process.on === 'function') {
+        return _globalObject.rootRealmGlobal.process.on(event, listener);
+    }
+    throw new Error('Platform agnostic addEventListener failed');
+}
+function removeEventListener(event, listener) {
+    if ('removeEventListener' in _globalObject.rootRealmGlobal && typeof _globalObject.rootRealmGlobal.removeEventListener === 'function') {
+        return _globalObject.rootRealmGlobal.removeEventListener(event.toLowerCase(), listener);
+    }
+    if (_globalObject.rootRealmGlobal.process && 'removeListener' in _globalObject.rootRealmGlobal.process && typeof _globalObject.rootRealmGlobal.process.removeListener === 'function') {
+        return _globalObject.rootRealmGlobal.process.removeListener(event, listener);
+    }
+    throw new Error('Platform agnostic removeEventListener failed');
+}
+
+//# sourceMappingURL=globalEvents.js.map

package/dist/cjs/common/globalEvents.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/common/globalEvents.ts"],"sourcesContent":["import { rootRealmGlobal } from './globalObject';\n\n/**\n * Adds an event listener platform agnostically, trying both `globalThis.addEventListener` and `globalThis.process.on`\n *\n * @param event - The event to listen for.\n * @param listener - The listener to be triggered when the event occurs.\n * @returns The result of the platform agnostic operation if any.\n * @throws If none of the platform options are present.\n */\nexport function addEventListener(\n  event: string,\n  listener: (...args: any[]) => void,\n) {\n  if (\n    'addEventListener' in rootRealmGlobal &&\n    typeof rootRealmGlobal.addEventListener === 'function'\n  ) {\n    return rootRealmGlobal.addEventListener(event.toLowerCase(), listener);\n  }\n\n  if (\n    rootRealmGlobal.process &&\n    'on' in rootRealmGlobal.process &&\n    typeof rootRealmGlobal.process.on === 'function'\n  ) {\n    return rootRealmGlobal.process.on(event, listener);\n  }\n\n  throw new Error('Platform agnostic addEventListener failed');\n}\n\n/**\n * Removes an event listener platform agnostically, trying both `globalThis.removeEventListener` and `globalThis.process.removeListener`\n *\n * @param event - The event to remove the listener for.\n * @param listener - The currently attached listener.\n * @returns The result of the platform agnostic operation if any.\n * @throws If none of the platform options are present.\n */\nexport function removeEventListener(\n  event: string,\n  listener: (...args: any[]) => void,\n) {\n  if (\n    'removeEventListener' in rootRealmGlobal &&\n    typeof rootRealmGlobal.removeEventListener === 'function'\n  ) {\n    return rootRealmGlobal.removeEventListener(event.toLowerCase(), listener);\n  }\n\n  if (\n    rootRealmGlobal.process &&\n    'removeListener' in rootRealmGlobal.process &&\n    typeof rootRealmGlobal.process.removeListener === 'function'\n  ) {\n    return rootRealmGlobal.process.removeListener(event, listener);\n  }\n\n  throw new Error('Platform agnostic removeEventListener failed');\n}\n"],"names":["addEventListener","removeEventListener","event","listener","rootRealmGlobal","toLowerCase","process","on","Error","removeListener"],"mappings":";;;;;;;;;;;IAUgBA,gBAAgB;eAAhBA;;IA8BAC,mBAAmB;eAAnBA;;;8BAxCgB;AAUzB,SAASD,iBACdE,KAAa,EACbC,QAAkC;IAElC,IACE,sBAAsBC,6BAAe,IACrC,OAAOA,6BAAe,CAACJ,gBAAgB,KAAK,YAC5C;QACA,OAAOI,6BAAe,CAACJ,gBAAgB,CAACE,MAAMG,WAAW,IAAIF;IAC/D;IAEA,IACEC,6BAAe,CAACE,OAAO,IACvB,QAAQF,6BAAe,CAACE,OAAO,IAC/B,OAAOF,6BAAe,CAACE,OAAO,CAACC,EAAE,KAAK,YACtC;QACA,OAAOH,6BAAe,CAACE,OAAO,CAACC,EAAE,CAACL,OAAOC;IAC3C;IAEA,MAAM,IAAIK,MAAM;AAClB;AAUO,SAASP,oBACdC,KAAa,EACbC,QAAkC;IAElC,IACE,yBAAyBC,6BAAe,IACxC,OAAOA,6BAAe,CAACH,mBAAmB,KAAK,YAC/C;QACA,OAAOG,6BAAe,CAACH,mBAAmB,CAACC,MAAMG,WAAW,IAAIF;IAClE;IAEA,IACEC,6BAAe,CAACE,OAAO,IACvB,oBAAoBF,6BAAe,CAACE,OAAO,IAC3C,OAAOF,6BAAe,CAACE,OAAO,CAACG,cAAc,KAAK,YAClD;QACA,OAAOL,6BAAe,CAACE,OAAO,CAACG,cAAc,CAACP,OAAOC;IACvD;IAEA,MAAM,IAAIK,MAAM;AAClB"}

package/dist/cjs/common/globalObject.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    rootRealmGlobal: function() {
+        return rootRealmGlobal;
+    },
+    rootRealmGlobalName: function() {
+        return rootRealmGlobalName;
+    }
+});
+var GlobalObjectNames;
+(function(GlobalObjectNames) {
+    GlobalObjectNames[// The globalThis entry is incorrectly identified as shadowing the global
+    // globalThis.
+    /* eslint-disable @typescript-eslint/naming-convention */ // eslint-disable-next-line @typescript-eslint/no-shadow
+    "globalThis"] = "globalThis";
+    GlobalObjectNames["global"] = "global";
+    GlobalObjectNames["self"] = "self";
+    GlobalObjectNames["window"] = "window";
+})(GlobalObjectNames || (GlobalObjectNames = {}));
+let _rootRealmGlobal;
+let _rootRealmGlobalName;
+/* istanbul ignore next */ /* eslint-disable no-negated-condition */ if (typeof globalThis !== 'undefined') {
+    _rootRealmGlobal = globalThis;
+    _rootRealmGlobalName = GlobalObjectNames.globalThis;
+} else if (typeof self !== 'undefined') {
+    _rootRealmGlobal = self;
+    _rootRealmGlobalName = GlobalObjectNames.self;
+} else if (typeof window !== 'undefined') {
+    _rootRealmGlobal = window;
+    _rootRealmGlobalName = GlobalObjectNames.window;
+} else if (typeof global !== 'undefined') {
+    _rootRealmGlobal = global;
+    _rootRealmGlobalName = GlobalObjectNames.global;
+} else {
+    throw new Error('Unknown realm type; failed to identify global object.');
+}
+/* eslint-enable no-negated-condition */ /**
+ * A platform-agnostic alias for the root realm global object.
+ */ const rootRealmGlobal = _rootRealmGlobal;
+/**
+ * The string literal corresponding to the name of the root realm global object.
+ */ const rootRealmGlobalName = _rootRealmGlobalName;
+
+//# sourceMappingURL=globalObject.js.map

package/dist/{common → cjs/common}/globalObject.js.map

@@ -1 +1 @@
-{"version":3,"file":"globalObject.js","sourceRoot":"","sources":["../../src/common/globalObject.ts"],"names":[],"mappings":";;;AAAA,IAAK,iBAUJ;AAVD,WAAK,iBAAiB;IACpB,yEAAyE;IACzE,cAAc;IACd,yDAAyD;IACzD,wDAAwD;IACxD,8CAAyB,CAAA;IACzB,sCAAiB,CAAA;IACjB,kCAAa,CAAA;IACb,sCAAiB,CAAA;IACjB,wDAAwD;AAC1D,CAAC,EAVI,iBAAiB,KAAjB,iBAAiB,QAUrB;AAED,IAAI,gBAAmC,CAAC;AACxC,IAAI,oBAA4B,CAAC;AAEjC,0BAA0B;AAC1B,yCAAyC;AACzC,IAAI,OAAO,UAAU,KAAK,WAAW,EAAE;IACrC,gBAAgB,GAAG,UAAU,CAAC;IAC9B,oBAAoB,GAAG,iBAAiB,CAAC,UAAU,CAAC;CACrD;KAAM,IAAI,OAAO,IAAI,KAAK,WAAW,EAAE;IACtC,gBAAgB,GAAG,IAAI,CAAC;IACxB,oBAAoB,GAAG,iBAAiB,CAAC,IAAI,CAAC;CAC/C;KAAM,IAAI,OAAO,MAAM,KAAK,WAAW,EAAE;IACxC,gBAAgB,GAAG,MAAM,CAAC;IAC1B,oBAAoB,GAAG,iBAAiB,CAAC,MAAM,CAAC;CACjD;KAAM,IAAI,OAAO,MAAM,KAAK,WAAW,EAAE;IACxC,gBAAgB,GAAG,MAAM,CAAC;IAC1B,oBAAoB,GAAG,iBAAiB,CAAC,MAAM,CAAC;CACjD;KAAM;IACL,MAAM,IAAI,KAAK,CAAC,uDAAuD,CAAC,CAAC;CAC1E;AACD,wCAAwC;AAExC;;GAEG;AACH,MAAM,eAAe,GAAG,gBAAgB,CAAC;AAOhC,0CAAe;AALxB;;GAEG;AACH,MAAM,mBAAmB,GAAG,oBAAoB,CAAC;AAEvB,kDAAmB","sourcesContent":["enum GlobalObjectNames {\n  // The globalThis entry is incorrectly identified as shadowing the global\n  // globalThis.\n  /* eslint-disable @typescript-eslint/naming-convention */\n  // eslint-disable-next-line @typescript-eslint/no-shadow\n  globalThis = 'globalThis',\n  global = 'global',\n  self = 'self',\n  window = 'window',\n  /* eslint-enavle @typescript-eslint/naming-convention */\n}\n\nlet _rootRealmGlobal: typeof globalThis;\nlet _rootRealmGlobalName: string;\n\n/* istanbul ignore next */\n/* eslint-disable no-negated-condition */\nif (typeof globalThis !== 'undefined') {\n  _rootRealmGlobal = globalThis;\n  _rootRealmGlobalName = GlobalObjectNames.globalThis;\n} else if (typeof self !== 'undefined') {\n  _rootRealmGlobal = self;\n  _rootRealmGlobalName = GlobalObjectNames.self;\n} else if (typeof window !== 'undefined') {\n  _rootRealmGlobal = window;\n  _rootRealmGlobalName = GlobalObjectNames.window;\n} else if (typeof global !== 'undefined') {\n  _rootRealmGlobal = global;\n  _rootRealmGlobalName = GlobalObjectNames.global;\n} else {\n  throw new Error('Unknown realm type; failed to identify global object.');\n}\n/* eslint-enable no-negated-condition */\n\n/**\n * A platform-agnostic alias for the root realm global object.\n */\nconst rootRealmGlobal = _rootRealmGlobal;\n\n/**\n * The string literal corresponding to the name of the root realm global object.\n */\nconst rootRealmGlobalName = _rootRealmGlobalName;\n\nexport { rootRealmGlobal, rootRealmGlobalName };\n"]}
+{"version":3,"sources":["../../../src/common/globalObject.ts"],"sourcesContent":["enum GlobalObjectNames {\n  // The globalThis entry is incorrectly identified as shadowing the global\n  // globalThis.\n  /* eslint-disable @typescript-eslint/naming-convention */\n  // eslint-disable-next-line @typescript-eslint/no-shadow\n  globalThis = 'globalThis',\n  global = 'global',\n  self = 'self',\n  window = 'window',\n  /* eslint-enavle @typescript-eslint/naming-convention */\n}\n\nlet _rootRealmGlobal: typeof globalThis;\nlet _rootRealmGlobalName: string;\n\n/* istanbul ignore next */\n/* eslint-disable no-negated-condition */\nif (typeof globalThis !== 'undefined') {\n  _rootRealmGlobal = globalThis;\n  _rootRealmGlobalName = GlobalObjectNames.globalThis;\n} else if (typeof self !== 'undefined') {\n  _rootRealmGlobal = self;\n  _rootRealmGlobalName = GlobalObjectNames.self;\n} else if (typeof window !== 'undefined') {\n  _rootRealmGlobal = window;\n  _rootRealmGlobalName = GlobalObjectNames.window;\n} else if (typeof global !== 'undefined') {\n  _rootRealmGlobal = global;\n  _rootRealmGlobalName = GlobalObjectNames.global;\n} else {\n  throw new Error('Unknown realm type; failed to identify global object.');\n}\n/* eslint-enable no-negated-condition */\n\n/**\n * A platform-agnostic alias for the root realm global object.\n */\nconst rootRealmGlobal = _rootRealmGlobal;\n\n/**\n * The string literal corresponding to the name of the root realm global object.\n */\nconst rootRealmGlobalName = _rootRealmGlobalName;\n\nexport { rootRealmGlobal, rootRealmGlobalName };\n"],"names":["rootRealmGlobal","rootRealmGlobalName","GlobalObjectNames","globalThis","global","self","window","_rootRealmGlobal","_rootRealmGlobalName","Error"],"mappings":";;;;;;;;;;;IA4CSA,eAAe;eAAfA;;IAAiBC,mBAAmB;eAAnBA;;;IA5C1B;UAAKC,iBAAiB;IAAjBA,kBACH,yEAAyE;IACzE,cAAc;IACd,uDAAuD,GACvD,wDAAwD;IACxDC,gBAAAA;IALGD,kBAMHE,YAAAA;IANGF,kBAOHG,UAAAA;IAPGH,kBAQHI,YAAAA;GARGJ,sBAAAA;AAYL,IAAIK;AACJ,IAAIC;AAEJ,wBAAwB,GACxB,uCAAuC,GACvC,IAAI,OAAOL,eAAe,aAAa;IACrCI,mBAAmBJ;IACnBK,uBAAuBN,kBAAkBC,UAAU;AACrD,OAAO,IAAI,OAAOE,SAAS,aAAa;IACtCE,mBAAmBF;IACnBG,uBAAuBN,kBAAkBG,IAAI;AAC/C,OAAO,IAAI,OAAOC,WAAW,aAAa;IACxCC,mBAAmBD;IACnBE,uBAAuBN,kBAAkBI,MAAM;AACjD,OAAO,IAAI,OAAOF,WAAW,aAAa;IACxCG,mBAAmBH;IACnBI,uBAAuBN,kBAAkBE,MAAM;AACjD,OAAO;IACL,MAAM,IAAIK,MAAM;AAClB;AACA,sCAAsC,GAEtC;;CAEC,GACD,MAAMT,kBAAkBO;AAExB;;CAEC,GACD,MAAMN,sBAAsBO"}

package/dist/cjs/common/lockdown/lockdown-events.js

@@ -0,0 +1,74 @@
+// When creating a sandbox, limitation of the events from leaking
+// sensitive objects is required. This is done by overriding own properties
+// of prototypes of all existing events.
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "executeLockdownEvents", {
+    enumerable: true,
+    get: function() {
+        return executeLockdownEvents;
+    }
+});
+const _utils = require("@metamask/utils");
+/**
+ * Targeted Event objects and properties.
+ * Note: This is a map of the prototypes that inherit from Events with
+ * properties that are identified to leak sensitive objects.
+ * Not all browsers support all event types, so checking its existence is required.
+ */ const targetEvents = new Map();
+if ((0, _utils.hasProperty)(globalThis, 'UIEvent')) {
+    targetEvents.set(UIEvent.prototype, [
+        'view'
+    ]);
+}
+if ((0, _utils.hasProperty)(globalThis, 'MutationEvent')) {
+    targetEvents.set(MutationEvent.prototype, [
+        'relatedNode'
+    ]);
+}
+if ((0, _utils.hasProperty)(globalThis, 'MessageEvent')) {
+    targetEvents.set(MessageEvent.prototype, [
+        'source'
+    ]);
+}
+if ((0, _utils.hasProperty)(globalThis, 'FocusEvent')) {
+    targetEvents.set(FocusEvent.prototype, [
+        'relatedTarget'
+    ]);
+}
+if ((0, _utils.hasProperty)(globalThis, 'MouseEvent')) {
+    targetEvents.set(MouseEvent.prototype, [
+        'relatedTarget',
+        'fromElement',
+        'toElement'
+    ]);
+}
+if ((0, _utils.hasProperty)(globalThis, 'TouchEvent')) {
+    targetEvents.set(TouchEvent.prototype, [
+        'targetTouches',
+        'touches'
+    ]);
+}
+if ((0, _utils.hasProperty)(globalThis, 'Event')) {
+    targetEvents.set(Event.prototype, [
+        'target',
+        'currentTarget',
+        'srcElement',
+        'composedPath'
+    ]);
+}
+function executeLockdownEvents() {
+    targetEvents.forEach((properties, prototype)=>{
+        for (const property of properties){
+            Object.defineProperty(prototype, property, {
+                value: undefined,
+                configurable: false,
+                writable: false
+            });
+        }
+    });
+}
+
+//# sourceMappingURL=lockdown-events.js.map

package/dist/cjs/common/lockdown/lockdown-events.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/common/lockdown/lockdown-events.ts"],"sourcesContent":["// When creating a sandbox, limitation of the events from leaking\n// sensitive objects is required. This is done by overriding own properties\n// of prototypes of all existing events.\nimport { hasProperty } from '@metamask/utils';\n\n/**\n * Targeted Event objects and properties.\n * Note: This is a map of the prototypes that inherit from Events with\n * properties that are identified to leak sensitive objects.\n * Not all browsers support all event types, so checking its existence is required.\n */\nconst targetEvents = new Map();\nif (hasProperty(globalThis, 'UIEvent')) {\n  targetEvents.set(UIEvent.prototype, ['view']);\n}\nif (hasProperty(globalThis, 'MutationEvent')) {\n  targetEvents.set(MutationEvent.prototype, ['relatedNode']);\n}\nif (hasProperty(globalThis, 'MessageEvent')) {\n  targetEvents.set(MessageEvent.prototype, ['source']);\n}\nif (hasProperty(globalThis, 'FocusEvent')) {\n  targetEvents.set(FocusEvent.prototype, ['relatedTarget']);\n}\nif (hasProperty(globalThis, 'MouseEvent')) {\n  targetEvents.set(MouseEvent.prototype, [\n    'relatedTarget',\n    'fromElement',\n    'toElement',\n  ]);\n}\nif (hasProperty(globalThis, 'TouchEvent')) {\n  targetEvents.set(TouchEvent.prototype, ['targetTouches', 'touches']);\n}\nif (hasProperty(globalThis, 'Event')) {\n  targetEvents.set(Event.prototype, [\n    'target',\n    'currentTarget',\n    'srcElement',\n    'composedPath',\n  ]);\n}\n\n/**\n * Attenuate Event objects by replacing its own properties.\n */\nexport function executeLockdownEvents() {\n  targetEvents.forEach((properties, prototype) => {\n    for (const property of properties) {\n      Object.defineProperty(prototype, property, {\n        value: undefined,\n        configurable: false,\n        writable: false,\n      });\n    }\n  });\n}\n"],"names":["executeLockdownEvents","targetEvents","Map","hasProperty","globalThis","set","UIEvent","prototype","MutationEvent","MessageEvent","FocusEvent","MouseEvent","TouchEvent","Event","forEach","properties","property","Object","defineProperty","value","undefined","configurable","writable"],"mappings":"AAAA,iEAAiE;AACjE,2EAA2E;AAC3E,wCAAwC;;;;;+BA4CxBA;;;eAAAA;;;uBA3CY;AAE5B;;;;;CAKC,GACD,MAAMC,eAAe,IAAIC;AACzB,IAAIC,IAAAA,kBAAW,EAACC,YAAY,YAAY;IACtCH,aAAaI,GAAG,CAACC,QAAQC,SAAS,EAAE;QAAC;KAAO;AAC9C;AACA,IAAIJ,IAAAA,kBAAW,EAACC,YAAY,kBAAkB;IAC5CH,aAAaI,GAAG,CAACG,cAAcD,SAAS,EAAE;QAAC;KAAc;AAC3D;AACA,IAAIJ,IAAAA,kBAAW,EAACC,YAAY,iBAAiB;IAC3CH,aAAaI,GAAG,CAACI,aAAaF,SAAS,EAAE;QAAC;KAAS;AACrD;AACA,IAAIJ,IAAAA,kBAAW,EAACC,YAAY,eAAe;IACzCH,aAAaI,GAAG,CAACK,WAAWH,SAAS,EAAE;QAAC;KAAgB;AAC1D;AACA,IAAIJ,IAAAA,kBAAW,EAACC,YAAY,eAAe;IACzCH,aAAaI,GAAG,CAACM,WAAWJ,SAAS,EAAE;QACrC;QACA;QACA;KACD;AACH;AACA,IAAIJ,IAAAA,kBAAW,EAACC,YAAY,eAAe;IACzCH,aAAaI,GAAG,CAACO,WAAWL,SAAS,EAAE;QAAC;QAAiB;KAAU;AACrE;AACA,IAAIJ,IAAAA,kBAAW,EAACC,YAAY,UAAU;IACpCH,aAAaI,GAAG,CAACQ,MAAMN,SAAS,EAAE;QAChC;QACA;QACA;QACA;KACD;AACH;AAKO,SAASP;IACdC,aAAaa,OAAO,CAAC,CAACC,YAAYR;QAChC,KAAK,MAAMS,YAAYD,WAAY;YACjCE,OAAOC,cAAc,CAACX,WAAWS,UAAU;gBACzCG,OAAOC;gBACPC,cAAc;gBACdC,UAAU;YACZ;QACF;IACF;AACF"}