@metamask/snaps-execution-environments 4.0.1 → 5.0.0

package/dist/chunk-CCBKFCGG.js

@@ -0,0 +1,147 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+var _chunkXKY46YTJjs = require('./chunk-XKY46YTJ.js');
+
+// src/common/utils.ts
+var _rpcerrors = require('@metamask/rpc-errors');
+
+
+
+
+
+
+
+var _utils = require('@metamask/utils');
+var MAX_RESPONSE_JSON_SIZE = 64e6;
+async function withTeardown(originalPromise, teardownRef) {
+  const myTeardown = teardownRef.lastTeardown;
+  return new Promise((resolve, reject) => {
+    originalPromise.then((value) => {
+      if (teardownRef.lastTeardown === myTeardown) {
+        resolve(value);
+      } else {
+        _chunkXKY46YTJjs.log.call(void 0, 
+          "Late promise received after Snap finished execution. Promise will be dropped."
+        );
+      }
+    }).catch((reason) => {
+      if (teardownRef.lastTeardown === myTeardown) {
+        reject(reason);
+      } else {
+        _chunkXKY46YTJjs.log.call(void 0, 
+          "Late promise received after Snap finished execution. Promise will be dropped."
+        );
+      }
+    });
+  });
+}
+function proxyStreamProvider(provider, request) {
+  const proxy = new Proxy(
+    {},
+    {
+      has(_target, prop) {
+        return typeof prop === "string" && ["request", "on", "removeListener"].includes(prop);
+      },
+      get(_target, prop) {
+        if (prop === "request") {
+          return request;
+        } else if (["on", "removeListener"].includes(prop)) {
+          return provider[prop];
+        }
+        return void 0;
+      }
+    }
+  );
+  return proxy;
+}
+var BLOCKED_RPC_METHODS = Object.freeze([
+  "wallet_requestSnaps",
+  "wallet_requestPermissions",
+  "wallet_revokePermissions",
+  // We disallow all of these confirmations for now, since the screens are not ready for Snaps.
+  "eth_sendRawTransaction",
+  "eth_sendTransaction",
+  "eth_sign",
+  "eth_signTypedData",
+  "eth_signTypedData_v1",
+  "eth_signTypedData_v3",
+  "eth_signTypedData_v4",
+  "eth_decrypt",
+  "eth_getEncryptionPublicKey",
+  "wallet_addEthereumChain",
+  "wallet_switchEthereumChain",
+  "wallet_watchAsset",
+  "wallet_registerOnboarding",
+  "wallet_scanQRCode"
+]);
+function assertSnapOutboundRequest(args) {
+  _utils.assert.call(void 0, 
+    String.prototype.startsWith.call(args.method, "wallet_") || String.prototype.startsWith.call(args.method, "snap_"),
+    "The global Snap API only allows RPC methods starting with `wallet_*` and `snap_*`.",
+    _rpcerrors.rpcErrors.methodNotSupported
+  );
+  _utils.assert.call(void 0, 
+    !BLOCKED_RPC_METHODS.includes(args.method),
+    _rpcerrors.rpcErrors.methodNotFound({
+      data: {
+        method: args.method
+      }
+    })
+  );
+  _utils.assertStruct.call(void 0, 
+    args,
+    _utils.JsonStruct,
+    "Provided value is not JSON-RPC compatible",
+    _rpcerrors.rpcErrors.invalidParams
+  );
+}
+function assertEthereumOutboundRequest(args) {
+  _utils.assert.call(void 0, 
+    !String.prototype.startsWith.call(args.method, "snap_"),
+    _rpcerrors.rpcErrors.methodNotFound({
+      data: {
+        method: args.method
+      }
+    })
+  );
+  _utils.assert.call(void 0, 
+    !BLOCKED_RPC_METHODS.includes(args.method),
+    _rpcerrors.rpcErrors.methodNotFound({
+      data: {
+        method: args.method
+      }
+    })
+  );
+  _utils.assertStruct.call(void 0, 
+    args,
+    _utils.JsonStruct,
+    "Provided value is not JSON-RPC compatible",
+    _rpcerrors.rpcErrors.invalidParams
+  );
+}
+function sanitizeRequestArguments(value) {
+  const json = JSON.parse(JSON.stringify(value));
+  return _utils.getSafeJson.call(void 0, json);
+}
+function isValidResponse(response) {
+  if (!_utils.isObject.call(void 0, response)) {
+    return false;
+  }
+  try {
+    const size = _utils.getJsonSize.call(void 0, response);
+    return size < MAX_RESPONSE_JSON_SIZE;
+  } catch (e) {
+    return false;
+  }
+}
+
+
+
+
+
+
+
+
+
+exports.withTeardown = withTeardown; exports.proxyStreamProvider = proxyStreamProvider; exports.BLOCKED_RPC_METHODS = BLOCKED_RPC_METHODS; exports.assertSnapOutboundRequest = assertSnapOutboundRequest; exports.assertEthereumOutboundRequest = assertEthereumOutboundRequest; exports.sanitizeRequestArguments = sanitizeRequestArguments; exports.isValidResponse = isValidResponse;
+//# sourceMappingURL=chunk-CCBKFCGG.js.map

package/dist/chunk-CCBKFCGG.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/common/utils.ts"],"names":[],"mappings":"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","sourcesContent":["import type { StreamProvider } from '@metamask/providers';\nimport type { RequestArguments } from '@metamask/providers/dist/BaseProvider';\nimport { rpcErrors } from '@metamask/rpc-errors';\nimport {\n  assert,\n  assertStruct,\n  getJsonSize,\n  getSafeJson,\n  isObject,\n  JsonStruct,\n} from '@metamask/utils';\n\nimport { log } from '../logging';\n\n// 64 MB - we chose this number because it is the size limit for postMessage\n// between the extension and the dapp enforced by Chrome.\nconst MAX_RESPONSE_JSON_SIZE = 64_000_000;\n\n/**\n * Make proxy for Promise and handle the teardown process properly.\n * If the teardown is called in the meanwhile, Promise result will not be\n * exposed to the snap anymore and warning will be logged to the console.\n *\n * @param originalPromise - Original promise.\n * @param teardownRef - Reference containing teardown count.\n * @param teardownRef.lastTeardown - Number of the last teardown.\n * @returns New proxy promise.\n */\nexport async function withTeardown<Type>(\n  originalPromise: Promise<Type>,\n  teardownRef: { lastTeardown: number },\n): Promise<Type> {\n  const myTeardown = teardownRef.lastTeardown;\n  return new Promise<Type>((resolve, reject) => {\n    originalPromise\n      .then((value) => {\n        if (teardownRef.lastTeardown === myTeardown) {\n          resolve(value);\n        } else {\n          log(\n            'Late promise received after Snap finished execution. Promise will be dropped.',\n          );\n        }\n      })\n      .catch((reason) => {\n        if (teardownRef.lastTeardown === myTeardown) {\n          reject(reason);\n        } else {\n          log(\n            'Late promise received after Snap finished execution. Promise will be dropped.',\n          );\n        }\n      });\n  });\n}\n\n/**\n * Returns a Proxy that narrows down (attenuates) the fields available on\n * the StreamProvider and replaces the request implementation.\n *\n * @param provider - Instance of a StreamProvider to be limited.\n * @param request - Custom attenuated request object.\n * @returns Proxy to the StreamProvider instance.\n */\nexport function proxyStreamProvider(\n  provider: StreamProvider,\n  request: unknown,\n): StreamProvider {\n  // Proxy target is intentionally set to be an empty object, to ensure\n  // that access to the prototype chain is not possible.\n  const proxy = new Proxy(\n    {},\n    {\n      has(_target: object, prop: string | symbol) {\n        return (\n          typeof prop === 'string' &&\n          ['request', 'on', 'removeListener'].includes(prop)\n        );\n      },\n      get(_target, prop: keyof StreamProvider) {\n        if (prop === 'request') {\n          return request;\n        } else if (['on', 'removeListener'].includes(prop)) {\n          return provider[prop];\n        }\n\n        return undefined;\n      },\n    },\n  );\n\n  return proxy as StreamProvider;\n}\n\n// We're blocking these RPC methods for v1, will revisit later.\nexport const BLOCKED_RPC_METHODS = Object.freeze([\n  'wallet_requestSnaps',\n  'wallet_requestPermissions',\n  'wallet_revokePermissions',\n  // We disallow all of these confirmations for now, since the screens are not ready for Snaps.\n  'eth_sendRawTransaction',\n  'eth_sendTransaction',\n  'eth_sign',\n  'eth_signTypedData',\n  'eth_signTypedData_v1',\n  'eth_signTypedData_v3',\n  'eth_signTypedData_v4',\n  'eth_decrypt',\n  'eth_getEncryptionPublicKey',\n  'wallet_addEthereumChain',\n  'wallet_switchEthereumChain',\n  'wallet_watchAsset',\n  'wallet_registerOnboarding',\n  'wallet_scanQRCode',\n]);\n\n/**\n * Asserts the validity of request arguments for a snap outbound request using the `snap.request` API.\n *\n * @param args - The arguments to validate.\n */\nexport function assertSnapOutboundRequest(args: RequestArguments) {\n  // Disallow any non `wallet_` or `snap_` methods for separation of concerns.\n  assert(\n    String.prototype.startsWith.call(args.method, 'wallet_') ||\n      String.prototype.startsWith.call(args.method, 'snap_'),\n    'The global Snap API only allows RPC methods starting with `wallet_*` and `snap_*`.',\n    rpcErrors.methodNotSupported,\n  );\n  assert(\n    !BLOCKED_RPC_METHODS.includes(args.method),\n    rpcErrors.methodNotFound({\n      data: {\n        method: args.method,\n      },\n    }),\n  );\n  assertStruct(\n    args,\n    JsonStruct,\n    'Provided value is not JSON-RPC compatible',\n    rpcErrors.invalidParams,\n  );\n}\n\n/**\n * Asserts the validity of request arguments for an ethereum outbound request using the `ethereum.request` API.\n *\n * @param args - The arguments to validate.\n */\nexport function assertEthereumOutboundRequest(args: RequestArguments) {\n  // Disallow snaps methods for separation of concerns.\n  assert(\n    !String.prototype.startsWith.call(args.method, 'snap_'),\n    rpcErrors.methodNotFound({\n      data: {\n        method: args.method,\n      },\n    }),\n  );\n  assert(\n    !BLOCKED_RPC_METHODS.includes(args.method),\n    rpcErrors.methodNotFound({\n      data: {\n        method: args.method,\n      },\n    }),\n  );\n  assertStruct(\n    args,\n    JsonStruct,\n    'Provided value is not JSON-RPC compatible',\n    rpcErrors.invalidParams,\n  );\n}\n\n/**\n * Gets a sanitized value to be used for passing to the underlying MetaMask provider.\n *\n * @param value - An unsanitized value from a snap.\n * @returns A sanitized value ready to be passed to a MetaMask provider.\n */\nexport function sanitizeRequestArguments(value: unknown): RequestArguments {\n  // Before passing to getSafeJson we run the value through JSON serialization.\n  // This lets request arguments contain undefined which is normally disallowed.\n  const json = JSON.parse(JSON.stringify(value));\n  return getSafeJson(json) as RequestArguments;\n}\n\n/**\n * Check if the input is a valid response.\n *\n * @param response - The response.\n * @returns True if the response is valid, otherwise false.\n */\nexport function isValidResponse(response: Record<string, unknown>) {\n  if (!isObject(response)) {\n    return false;\n  }\n\n  try {\n    // If the JSON is invalid this will throw and we should return false.\n    const size = getJsonSize(response);\n    return size < MAX_RESPONSE_JSON_SIZE;\n  } catch {\n    return false;\n  }\n}\n"]}

package/dist/chunk-CINBMYIQ.mjs

@@ -0,0 +1,183 @@
+import {
+  __privateAdd,
+  __privateGet,
+  __privateMethod,
+  __privateSet
+} from "./chunk-YRZVIDCF.mjs";
+
+// src/webworker/pool/WebWorkerPool.ts
+import {
+  WebWorkerParentPostMessageStream,
+  WindowPostMessageStream
+} from "@metamask/post-message-stream";
+import { logError } from "@metamask/snaps-utils";
+import { assert } from "@metamask/utils";
+import { nanoid } from "nanoid/non-secure";
+var _poolSize, _stream, _url, _workerSourceURL, _onData, onData_fn, _initializeJob, initializeJob_fn, _terminateJob, terminateJob_fn, _getWorker, getWorker_fn, _updatePool, updatePool_fn, _createWorker, createWorker_fn, _getWorkerURL, getWorkerURL_fn;
+var _WebWorkerPool = class _WebWorkerPool {
+  constructor(stream, url, poolSize = 3) {
+    /**
+     * Handle an incoming message from the `WebWorkerExecutionService`. This
+     * assumes that the message contains a `jobId` property, and a JSON-RPC
+     * request in the `data` property.
+     *
+     * @param data - The message data.
+     * @param data.data - The JSON-RPC request.
+     * @param data.jobId - The job ID.
+     */
+    __privateAdd(this, _onData);
+    /**
+     * Create a new worker and set up a stream to communicate with it.
+     *
+     * @param jobId - The job ID.
+     * @returns The job.
+     */
+    __privateAdd(this, _initializeJob);
+    /**
+     * Terminate the job with the given ID. This will close the worker and delete
+     * the job from the internal job map.
+     *
+     * @param jobId - The job ID.
+     */
+    __privateAdd(this, _terminateJob);
+    /**
+     * Get a worker from the pool. A new worker will be created automatically.
+     *
+     * @returns The worker.
+     */
+    __privateAdd(this, _getWorker);
+    /**
+     * Update the pool of workers. This will create new workers if the pool is
+     * below the minimum size.
+     */
+    __privateAdd(this, _updatePool);
+    /**
+     * Create a new worker. This will fetch the worker source if it has not
+     * already been fetched.
+     *
+     * @returns The worker.
+     */
+    __privateAdd(this, _createWorker);
+    /**
+     * Get the URL of the worker source. This will fetch the worker source if it
+     * has not already been fetched.
+     *
+     * @returns The worker source URL, as a `blob:` URL.
+     */
+    __privateAdd(this, _getWorkerURL);
+    __privateAdd(this, _poolSize, void 0);
+    __privateAdd(this, _stream, void 0);
+    __privateAdd(this, _url, void 0);
+    this.pool = [];
+    this.jobs = /* @__PURE__ */ new Map();
+    __privateAdd(this, _workerSourceURL, void 0);
+    __privateSet(this, _stream, stream);
+    __privateSet(this, _url, url);
+    __privateSet(this, _poolSize, poolSize);
+    __privateGet(this, _stream).on("data", __privateMethod(this, _onData, onData_fn).bind(this));
+  }
+  /* istanbul ignore next - Constructor arguments. */
+  static initialize(stream = new WindowPostMessageStream({
+    name: "child",
+    target: "parent",
+    targetWindow: self.parent,
+    targetOrigin: "*"
+  }), url = "../executor/bundle.js", poolSize) {
+    return new _WebWorkerPool(stream, url, poolSize);
+  }
+};
+_poolSize = new WeakMap();
+_stream = new WeakMap();
+_url = new WeakMap();
+_workerSourceURL = new WeakMap();
+_onData = new WeakSet();
+onData_fn = function(data) {
+  const { jobId, data: request } = data;
+  const job = this.jobs.get(jobId);
+  if (!job) {
+    __privateMethod(this, _initializeJob, initializeJob_fn).call(this, jobId).then(() => {
+      __privateMethod(this, _onData, onData_fn).call(this, data);
+    }).catch((error) => {
+      logError("[Worker] Error initializing job:", error.toString());
+      __privateGet(this, _stream).write({
+        jobId,
+        data: {
+          name: "command",
+          data: {
+            jsonrpc: "2.0",
+            id: request.id ?? null,
+            error: {
+              code: -32e3,
+              message: "Internal error"
+            }
+          }
+        }
+      });
+    });
+    return;
+  }
+  if (request.method === "terminateJob") {
+    __privateMethod(this, _terminateJob, terminateJob_fn).call(this, jobId);
+    return;
+  }
+  job.stream.write(request);
+};
+_initializeJob = new WeakSet();
+initializeJob_fn = async function(jobId) {
+  const worker = await __privateMethod(this, _getWorker, getWorker_fn).call(this);
+  const jobStream = new WebWorkerParentPostMessageStream({
+    worker
+  });
+  jobStream.on("data", (data) => {
+    __privateGet(this, _stream).write({ data, jobId });
+  });
+  const job = { id: jobId, worker, stream: jobStream };
+  this.jobs.set(jobId, job);
+  return job;
+};
+_terminateJob = new WeakSet();
+terminateJob_fn = function(jobId) {
+  const job = this.jobs.get(jobId);
+  assert(job, `Job "${jobId}" not found.`);
+  job.stream.destroy();
+  job.worker.terminate();
+  this.jobs.delete(jobId);
+};
+_getWorker = new WeakSet();
+getWorker_fn = async function() {
+  if (this.pool.length === 0) {
+    await __privateMethod(this, _updatePool, updatePool_fn).call(this);
+  }
+  const worker = this.pool.shift();
+  assert(worker, "Worker not found.");
+  await __privateMethod(this, _updatePool, updatePool_fn).call(this);
+  return worker;
+};
+_updatePool = new WeakSet();
+updatePool_fn = async function() {
+  while (this.pool.length < __privateGet(this, _poolSize)) {
+    const worker = await __privateMethod(this, _createWorker, createWorker_fn).call(this);
+    this.pool.push(worker);
+  }
+};
+_createWorker = new WeakSet();
+createWorker_fn = async function() {
+  return new Worker(await __privateMethod(this, _getWorkerURL, getWorkerURL_fn).call(this), {
+    name: `worker-${nanoid()}`
+  });
+};
+_getWorkerURL = new WeakSet();
+getWorkerURL_fn = async function() {
+  if (__privateGet(this, _workerSourceURL)) {
+    return __privateGet(this, _workerSourceURL);
+  }
+  const blob = await fetch(__privateGet(this, _url)).then(async (response) => response.blob()).then(URL.createObjectURL.bind(URL));
+  __privateSet(this, _workerSourceURL, blob);
+  return blob;
+};
+var WebWorkerPool = _WebWorkerPool;
+
+export {
+  WebWorkerPool
+};
+//# sourceMappingURL=chunk-CINBMYIQ.mjs.map

package/dist/chunk-CINBMYIQ.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/webworker/pool/WebWorkerPool.ts"],"sourcesContent":["import type { BasePostMessageStream } from '@metamask/post-message-stream';\nimport {\n  WebWorkerParentPostMessageStream,\n  WindowPostMessageStream,\n} from '@metamask/post-message-stream';\nimport { logError } from '@metamask/snaps-utils';\nimport type { JsonRpcRequest } from '@metamask/utils';\nimport { assert } from '@metamask/utils';\nimport { nanoid } from 'nanoid/non-secure';\n\ntype ExecutorJob = {\n  id: string;\n  worker: Worker;\n  stream: WebWorkerParentPostMessageStream;\n};\n\n/**\n * A snap executor using the WebWorker API.\n *\n * This is not a traditional snap executor, as it does not execute snaps itself.\n * Instead, it creates a pool of webworkers for each snap execution, and sends\n * the snap execution request to the webworker. The webworker is responsible for\n * executing the snap.\n */\nexport class WebWorkerPool {\n  readonly #poolSize;\n\n  readonly #stream: BasePostMessageStream;\n\n  readonly #url: string;\n\n  readonly pool: Worker[] = [];\n\n  readonly jobs: Map<string, ExecutorJob> = new Map();\n\n  #workerSourceURL?: string;\n\n  /* istanbul ignore next - Constructor arguments. */\n  static initialize(\n    stream: BasePostMessageStream = new WindowPostMessageStream({\n      name: 'child',\n      target: 'parent',\n      targetWindow: self.parent,\n      targetOrigin: '*',\n    }),\n    url = '../executor/bundle.js',\n    poolSize?: number,\n  ) {\n    return new WebWorkerPool(stream, url, poolSize);\n  }\n\n  constructor(stream: BasePostMessageStream, url: string, poolSize = 3) {\n    this.#stream = stream;\n    this.#url = url;\n    this.#poolSize = poolSize;\n\n    this.#stream.on('data', this.#onData.bind(this));\n  }\n\n  /**\n   * Handle an incoming message from the `WebWorkerExecutionService`. This\n   * assumes that the message contains a `jobId` property, and a JSON-RPC\n   * request in the `data` property.\n   *\n   * @param data - The message data.\n   * @param data.data - The JSON-RPC request.\n   * @param data.jobId - The job ID.\n   */\n  #onData(data: { data: JsonRpcRequest; jobId: string }) {\n    const { jobId, data: request } = data;\n\n    const job = this.jobs.get(jobId);\n    if (!job) {\n      // This ensures that a job is initialized before it is used. To avoid\n      // code duplication, we call the `#onData` method again, which will\n      // run the rest of the logic after initialization.\n      this.#initializeJob(jobId)\n        .then(() => {\n          this.#onData(data);\n        })\n        .catch((error) => {\n          logError('[Worker] Error initializing job:', error.toString());\n\n          this.#stream.write({\n            jobId,\n            data: {\n              name: 'command',\n              data: {\n                jsonrpc: '2.0',\n                id: request.id ?? null,\n                error: {\n                  code: -32000,\n                  message: 'Internal error',\n                },\n              },\n            },\n          });\n        });\n\n      return;\n    }\n\n    // This is a method specific to the `WebWorkerPool`, as the service itself\n    // does not have access to the workers directly.\n    if (request.method === 'terminateJob') {\n      this.#terminateJob(jobId);\n      return;\n    }\n\n    job.stream.write(request);\n  }\n\n  /**\n   * Create a new worker and set up a stream to communicate with it.\n   *\n   * @param jobId - The job ID.\n   * @returns The job.\n   */\n  async #initializeJob(jobId: string): Promise<ExecutorJob> {\n    const worker = await this.#getWorker();\n    const jobStream = new WebWorkerParentPostMessageStream({\n      worker,\n    });\n\n    // Write messages from the worker to the parent, wrapped with the job ID.\n    jobStream.on('data', (data) => {\n      this.#stream.write({ data, jobId });\n    });\n\n    const job = { id: jobId, worker, stream: jobStream };\n    this.jobs.set(jobId, job);\n    return job;\n  }\n\n  /**\n   * Terminate the job with the given ID. This will close the worker and delete\n   * the job from the internal job map.\n   *\n   * @param jobId - The job ID.\n   */\n  #terminateJob(jobId: string) {\n    const job = this.jobs.get(jobId);\n    assert(job, `Job \"${jobId}\" not found.`);\n\n    job.stream.destroy();\n    job.worker.terminate();\n\n    this.jobs.delete(jobId);\n  }\n\n  /**\n   * Get a worker from the pool. A new worker will be created automatically.\n   *\n   * @returns The worker.\n   */\n  async #getWorker() {\n    // Lazily create the pool of workers.\n    if (this.pool.length === 0) {\n      await this.#updatePool();\n    }\n\n    const worker = this.pool.shift();\n    assert(worker, 'Worker not found.');\n\n    await this.#updatePool();\n\n    return worker;\n  }\n\n  /**\n   * Update the pool of workers. This will create new workers if the pool is\n   * below the minimum size.\n   */\n  async #updatePool() {\n    while (this.pool.length < this.#poolSize) {\n      const worker = await this.#createWorker();\n      this.pool.push(worker);\n    }\n  }\n\n  /**\n   * Create a new worker. This will fetch the worker source if it has not\n   * already been fetched.\n   *\n   * @returns The worker.\n   */\n  async #createWorker() {\n    return new Worker(await this.#getWorkerURL(), {\n      name: `worker-${nanoid()}`,\n    });\n  }\n\n  /**\n   * Get the URL of the worker source. This will fetch the worker source if it\n   * has not already been fetched.\n   *\n   * @returns The worker source URL, as a `blob:` URL.\n   */\n  async #getWorkerURL() {\n    if (this.#workerSourceURL) {\n      return this.#workerSourceURL;\n    }\n\n    const blob = await fetch(this.#url)\n      .then(async (response) => response.blob())\n      .then(URL.createObjectURL.bind(URL));\n\n    this.#workerSourceURL = blob;\n    return blob;\n  }\n}\n"],"mappings":"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","names":[]}

package/dist/chunk-EBECHU6M.js

@@ -0,0 +1,92 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+var _chunkL5U2LMZRjs = require('./chunk-L5U2LMZR.js');
+
+// src/common/endowments/console.ts
+var _utils = require('@metamask/utils');
+var consoleAttenuatedMethods = /* @__PURE__ */ new Set([
+  "log",
+  "assert",
+  "error",
+  "debug",
+  "info",
+  "warn"
+]);
+var consoleMethods = /* @__PURE__ */ new Set([
+  "debug",
+  "error",
+  "info",
+  "log",
+  "warn",
+  "dir",
+  "dirxml",
+  "table",
+  "trace",
+  "group",
+  "groupCollapsed",
+  "groupEnd",
+  "clear",
+  "count",
+  "countReset",
+  "assert",
+  "profile",
+  "profileEnd",
+  "time",
+  "timeLog",
+  "timeEnd",
+  "timeStamp",
+  "context"
+]);
+var consoleFunctions = ["log", "error", "debug", "info", "warn"];
+function getMessage(snapId, message, ...args) {
+  const prefix = `[Snap: ${snapId}]`;
+  if (typeof message === "string") {
+    return [`${prefix} ${message}`, ...args];
+  }
+  return [prefix, message, ...args];
+}
+function createConsole({ snapId } = {}) {
+  _utils.assert.call(void 0, snapId !== void 0);
+  const keys = Object.getOwnPropertyNames(
+    _chunkL5U2LMZRjs.rootRealmGlobal.console
+  );
+  const attenuatedConsole = keys.reduce((target, key) => {
+    if (consoleMethods.has(key) && !consoleAttenuatedMethods.has(key)) {
+      return { ...target, [key]: _chunkL5U2LMZRjs.rootRealmGlobal.console[key] };
+    }
+    return target;
+  }, {});
+  return harden({
+    console: {
+      ...attenuatedConsole,
+      assert: (value, message, ...optionalParams) => {
+        _chunkL5U2LMZRjs.rootRealmGlobal.console.assert(
+          value,
+          ...getMessage(snapId, message, ...optionalParams)
+        );
+      },
+      ...consoleFunctions.reduce((target, key) => {
+        return {
+          ...target,
+          [key]: (message, ...optionalParams) => {
+            _chunkL5U2LMZRjs.rootRealmGlobal.console[key](
+              ...getMessage(snapId, message, ...optionalParams)
+            );
+          }
+        };
+      }, {})
+    }
+  });
+}
+var endowmentModule = {
+  names: ["console"],
+  factory: createConsole
+};
+var console_default = endowmentModule;
+
+
+
+
+
+exports.consoleAttenuatedMethods = consoleAttenuatedMethods; exports.consoleMethods = consoleMethods; exports.console_default = console_default;
+//# sourceMappingURL=chunk-EBECHU6M.js.map

package/dist/chunk-EBECHU6M.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/common/endowments/console.ts"],"names":[],"mappings":";;;;;AAAA,SAAS,cAAc;AAKhB,IAAM,2BAA2B,oBAAI,IAAI;AAAA,EAC9C;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AACF,CAAC;AAMM,IAAM,iBAAiB,oBAAI,IAAI;AAAA,EACpC;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AACF,CAAC;AAED,IAAM,mBAAmB,CAAC,OAAO,SAAS,SAAS,QAAQ,MAAM;AAejE,SAAS,WAAW,QAAgB,YAAqB,MAAiB;AACxE,QAAM,SAAS,UAAU,MAAM;AAI/B,MAAI,OAAO,YAAY,UAAU;AAC/B,WAAO,CAAC,GAAG,MAAM,IAAI,OAAO,IAAI,GAAG,IAAI;AAAA,EACzC;AAIA,SAAO,CAAC,QAAQ,SAAS,GAAG,IAAI;AAClC;AAUA,SAAS,cAAc,EAAE,OAAO,IAA6B,CAAC,GAAG;AAC/D,SAAO,WAAW,MAAS;AAC3B,QAAM,OAAO,OAAO;AAAA,IAClB,gBAAgB;AAAA,EAClB;AAEA,QAAM,oBAAoB,KAAK,OAAO,CAAC,QAAQ,QAAQ;AACrD,QAAI,eAAe,IAAI,GAAG,KAAK,CAAC,yBAAyB,IAAI,GAAG,GAAG;AACjE,aAAO,EAAE,GAAG,QAAQ,CAAC,GAAG,GAAG,gBAAgB,QAAQ,GAAG,EAAE;AAAA,IAC1D;AAEA,WAAO;AAAA,EACT,GAAG,CAAC,CAAC;AAEL,SAAO,OAAO;AAAA,IACZ,SAAS;AAAA,MACP,GAAG;AAAA,MACH,QAAQ,CACN,OACA,YACG,mBACA;AACH,wBAAgB,QAAQ;AAAA,UACtB;AAAA,UACA,GAAG,WAAW,QAAQ,SAAS,GAAG,cAAc;AAAA,QAClD;AAAA,MACF;AAAA,MACA,GAAG,iBAAiB,OAAyB,CAAC,QAAQ,QAAQ;AAC5D,eAAO;AAAA,UACL,GAAG;AAAA,UACH,CAAC,GAAG,GAAG,CAAC,YAAsB,mBAA0B;AACtD,4BAAgB,QAAQ,GAAG;AAAA,cACzB,GAAG,WAAW,QAAQ,SAAS,GAAG,cAAc;AAAA,YAClD;AAAA,UACF;AAAA,QACF;AAAA,MACF,GAAG,CAAC,CAAqB;AAAA,IAC3B;AAAA,EACF,CAAC;AACH;AAEA,IAAM,kBAAkB;AAAA,EACtB,OAAO,CAAC,SAAS;AAAA,EACjB,SAAS;AACX;AAEA,IAAO,kBAAQ","sourcesContent":["import { assert } from '@metamask/utils';\n\nimport { rootRealmGlobal } from '../globalObject';\nimport type { EndowmentFactoryOptions } from './commonEndowmentFactory';\n\nexport const consoleAttenuatedMethods = new Set([\n  'log',\n  'assert',\n  'error',\n  'debug',\n  'info',\n  'warn',\n]);\n\n/**\n * A set of all the `console` values that will be passed to the snap. This has\n * all the values that are available in both the browser and Node.js.\n */\nexport const consoleMethods = new Set([\n  'debug',\n  'error',\n  'info',\n  'log',\n  'warn',\n  'dir',\n  'dirxml',\n  'table',\n  'trace',\n  'group',\n  'groupCollapsed',\n  'groupEnd',\n  'clear',\n  'count',\n  'countReset',\n  'assert',\n  'profile',\n  'profileEnd',\n  'time',\n  'timeLog',\n  'timeEnd',\n  'timeStamp',\n  'context',\n]);\n\nconst consoleFunctions = ['log', 'error', 'debug', 'info', 'warn'] as const;\n\ntype ConsoleFunctions = {\n  [Key in (typeof consoleFunctions)[number]]: (typeof rootRealmGlobal.console)[Key];\n};\n\n/**\n * Gets the appropriate (prepended) message to pass to one of the attenuated\n * method calls.\n *\n * @param snapId - Id of the snap that we're getting a message for.\n * @param message - The id of the snap that will interact with the endowment.\n * @param args - The array of additional arguments.\n * @returns An array of arguments to be passed into an attenuated console method call.\n */\nfunction getMessage(snapId: string, message: unknown, ...args: unknown[]) {\n  const prefix = `[Snap: ${snapId}]`;\n\n  // If the first argument is a string, prepend the prefix to the message, and keep the\n  // rest of the arguments as-is.\n  if (typeof message === 'string') {\n    return [`${prefix} ${message}`, ...args];\n  }\n\n  // Otherwise, the `message` is an object, array, etc., so add the prefix as a separate\n  // message to the arguments.\n  return [prefix, message, ...args];\n}\n\n/**\n * Create a a {@link console} object, with the same properties as the global\n * {@link console} object, but with some methods replaced.\n *\n * @param options - Factory options used in construction of the endowment.\n * @param options.snapId - The id of the snap that will interact with the endowment.\n * @returns The {@link console} object with the replaced methods.\n */\nfunction createConsole({ snapId }: EndowmentFactoryOptions = {}) {\n  assert(snapId !== undefined);\n  const keys = Object.getOwnPropertyNames(\n    rootRealmGlobal.console,\n  ) as (keyof typeof console)[];\n\n  const attenuatedConsole = keys.reduce((target, key) => {\n    if (consoleMethods.has(key) && !consoleAttenuatedMethods.has(key)) {\n      return { ...target, [key]: rootRealmGlobal.console[key] };\n    }\n\n    return target;\n  }, {});\n\n  return harden({\n    console: {\n      ...attenuatedConsole,\n      assert: (\n        value: any,\n        message?: string | undefined,\n        ...optionalParams: any[]\n      ) => {\n        rootRealmGlobal.console.assert(\n          value,\n          ...getMessage(snapId, message, ...optionalParams),\n        );\n      },\n      ...consoleFunctions.reduce<ConsoleFunctions>((target, key) => {\n        return {\n          ...target,\n          [key]: (message?: unknown, ...optionalParams: any[]) => {\n            rootRealmGlobal.console[key](\n              ...getMessage(snapId, message, ...optionalParams),\n            );\n          },\n        };\n      }, {} as ConsoleFunctions),\n    },\n  });\n}\n\nconst endowmentModule = {\n  names: ['console'] as const,\n  factory: createConsole,\n};\n\nexport default endowmentModule;\n"]}

package/dist/chunk-ETXAWW65.mjs

@@ -0,0 +1,86 @@
+import {
+  interval_default
+} from "./chunk-26EFJQDW.mjs";
+import {
+  math_default
+} from "./chunk-Z7FBBBME.mjs";
+import {
+  network_default
+} from "./chunk-XGCWN6ZD.mjs";
+import {
+  textDecoder_default
+} from "./chunk-FQBU72MW.mjs";
+import {
+  textEncoder_default
+} from "./chunk-RCPCISJD.mjs";
+import {
+  timeout_default
+} from "./chunk-YC3HWHJV.mjs";
+import {
+  console_default
+} from "./chunk-MOWPAP2K.mjs";
+import {
+  crypto_default
+} from "./chunk-A7NJQLUA.mjs";
+import {
+  date_default
+} from "./chunk-6GHFAQ54.mjs";
+import {
+  rootRealmGlobal
+} from "./chunk-Y7IEFWZU.mjs";
+
+// src/common/endowments/commonEndowmentFactory.ts
+var commonEndowments = [
+  { endowment: AbortController, name: "AbortController" },
+  { endowment: AbortSignal, name: "AbortSignal" },
+  { endowment: ArrayBuffer, name: "ArrayBuffer" },
+  { endowment: atob, name: "atob", bind: true },
+  { endowment: BigInt, name: "BigInt" },
+  { endowment: BigInt64Array, name: "BigInt64Array" },
+  { endowment: BigUint64Array, name: "BigUint64Array" },
+  { endowment: btoa, name: "btoa", bind: true },
+  { endowment: DataView, name: "DataView" },
+  { endowment: Float32Array, name: "Float32Array" },
+  { endowment: Float64Array, name: "Float64Array" },
+  { endowment: Int8Array, name: "Int8Array" },
+  { endowment: Int16Array, name: "Int16Array" },
+  { endowment: Int32Array, name: "Int32Array" },
+  { endowment: Uint8Array, name: "Uint8Array" },
+  { endowment: Uint8ClampedArray, name: "Uint8ClampedArray" },
+  { endowment: Uint16Array, name: "Uint16Array" },
+  { endowment: Uint32Array, name: "Uint32Array" },
+  { endowment: URL, name: "URL" },
+  { endowment: WebAssembly, name: "WebAssembly" }
+];
+var buildCommonEndowments = () => {
+  const endowmentFactories = [
+    crypto_default,
+    interval_default,
+    math_default,
+    network_default,
+    timeout_default,
+    textDecoder_default,
+    textEncoder_default,
+    date_default,
+    console_default
+  ];
+  commonEndowments.forEach((endowmentSpecification) => {
+    const endowment = {
+      names: [endowmentSpecification.name],
+      factory: () => {
+        const boundEndowment = typeof endowmentSpecification.endowment === "function" && endowmentSpecification.bind ? endowmentSpecification.endowment.bind(rootRealmGlobal) : endowmentSpecification.endowment;
+        return {
+          [endowmentSpecification.name]: harden(boundEndowment)
+        };
+      }
+    };
+    endowmentFactories.push(endowment);
+  });
+  return endowmentFactories;
+};
+var commonEndowmentFactory_default = buildCommonEndowments;
+
+export {
+  commonEndowmentFactory_default
+};
+//# sourceMappingURL=chunk-ETXAWW65.mjs.map

package/dist/chunk-ETXAWW65.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/common/endowments/commonEndowmentFactory.ts"],"sourcesContent":["import type { NotifyFunction } from '../BaseSnapExecutor';\nimport { rootRealmGlobal } from '../globalObject';\nimport consoleEndowment from './console';\nimport crypto from './crypto';\nimport date from './date';\nimport interval from './interval';\nimport math from './math';\nimport network from './network';\nimport textDecoder from './textDecoder';\nimport textEncoder from './textEncoder';\nimport timeout from './timeout';\n\nexport type EndowmentFactoryOptions = {\n  snapId?: string;\n  notify?: NotifyFunction;\n};\n\nexport type EndowmentFactory = {\n  names: readonly string[];\n  factory: (options?: EndowmentFactoryOptions) => { [key: string]: unknown };\n};\n\nexport type CommonEndowmentSpecification = {\n  endowment: unknown;\n  name: string;\n  bind?: boolean;\n};\n\n// Array of common endowments\nconst commonEndowments: CommonEndowmentSpecification[] = [\n  { endowment: AbortController, name: 'AbortController' },\n  { endowment: AbortSignal, name: 'AbortSignal' },\n  { endowment: ArrayBuffer, name: 'ArrayBuffer' },\n  { endowment: atob, name: 'atob', bind: true },\n  { endowment: BigInt, name: 'BigInt' },\n  { endowment: BigInt64Array, name: 'BigInt64Array' },\n  { endowment: BigUint64Array, name: 'BigUint64Array' },\n  { endowment: btoa, name: 'btoa', bind: true },\n  { endowment: DataView, name: 'DataView' },\n  { endowment: Float32Array, name: 'Float32Array' },\n  { endowment: Float64Array, name: 'Float64Array' },\n  { endowment: Int8Array, name: 'Int8Array' },\n  { endowment: Int16Array, name: 'Int16Array' },\n  { endowment: Int32Array, name: 'Int32Array' },\n  { endowment: Uint8Array, name: 'Uint8Array' },\n  { endowment: Uint8ClampedArray, name: 'Uint8ClampedArray' },\n  { endowment: Uint16Array, name: 'Uint16Array' },\n  { endowment: Uint32Array, name: 'Uint32Array' },\n  { endowment: URL, name: 'URL' },\n  { endowment: WebAssembly, name: 'WebAssembly' },\n];\n\n/**\n * Creates a consolidated collection of common endowments.\n * This function will return factories for all common endowments including\n * the additionally attenuated. All hardened with SES.\n *\n * @returns An object with common endowments.\n */\nconst buildCommonEndowments = (): EndowmentFactory[] => {\n  const endowmentFactories: EndowmentFactory[] = [\n    crypto,\n    interval,\n    math,\n    network,\n    timeout,\n    textDecoder,\n    textEncoder,\n    date,\n    consoleEndowment,\n  ];\n\n  commonEndowments.forEach((endowmentSpecification) => {\n    const endowment = {\n      names: [endowmentSpecification.name] as const,\n      factory: () => {\n        const boundEndowment =\n          typeof endowmentSpecification.endowment === 'function' &&\n          endowmentSpecification.bind\n            ? endowmentSpecification.endowment.bind(rootRealmGlobal)\n            : endowmentSpecification.endowment;\n        return {\n          [endowmentSpecification.name]: harden(boundEndowment),\n        } as const;\n      },\n    };\n    endowmentFactories.push(endowment);\n  });\n\n  return endowmentFactories;\n};\n\nexport default buildCommonEndowments;\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA6BA,IAAM,mBAAmD;AAAA,EACvD,EAAE,WAAW,iBAAiB,MAAM,kBAAkB;AAAA,EACtD,EAAE,WAAW,aAAa,MAAM,cAAc;AAAA,EAC9C,EAAE,WAAW,aAAa,MAAM,cAAc;AAAA,EAC9C,EAAE,WAAW,MAAM,MAAM,QAAQ,MAAM,KAAK;AAAA,EAC5C,EAAE,WAAW,QAAQ,MAAM,SAAS;AAAA,EACpC,EAAE,WAAW,eAAe,MAAM,gBAAgB;AAAA,EAClD,EAAE,WAAW,gBAAgB,MAAM,iBAAiB;AAAA,EACpD,EAAE,WAAW,MAAM,MAAM,QAAQ,MAAM,KAAK;AAAA,EAC5C,EAAE,WAAW,UAAU,MAAM,WAAW;AAAA,EACxC,EAAE,WAAW,cAAc,MAAM,eAAe;AAAA,EAChD,EAAE,WAAW,cAAc,MAAM,eAAe;AAAA,EAChD,EAAE,WAAW,WAAW,MAAM,YAAY;AAAA,EAC1C,EAAE,WAAW,YAAY,MAAM,aAAa;AAAA,EAC5C,EAAE,WAAW,YAAY,MAAM,aAAa;AAAA,EAC5C,EAAE,WAAW,YAAY,MAAM,aAAa;AAAA,EAC5C,EAAE,WAAW,mBAAmB,MAAM,oBAAoB;AAAA,EAC1D,EAAE,WAAW,aAAa,MAAM,cAAc;AAAA,EAC9C,EAAE,WAAW,aAAa,MAAM,cAAc;AAAA,EAC9C,EAAE,WAAW,KAAK,MAAM,MAAM;AAAA,EAC9B,EAAE,WAAW,aAAa,MAAM,cAAc;AAChD;AASA,IAAM,wBAAwB,MAA0B;AACtD,QAAM,qBAAyC;AAAA,IAC7C;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,EACF;AAEA,mBAAiB,QAAQ,CAAC,2BAA2B;AACnD,UAAM,YAAY;AAAA,MAChB,OAAO,CAAC,uBAAuB,IAAI;AAAA,MACnC,SAAS,MAAM;AACb,cAAM,iBACJ,OAAO,uBAAuB,cAAc,cAC5C,uBAAuB,OACnB,uBAAuB,UAAU,KAAK,eAAe,IACrD,uBAAuB;AAC7B,eAAO;AAAA,UACL,CAAC,uBAAuB,IAAI,GAAG,OAAO,cAAc;AAAA,QACtD;AAAA,MACF;AAAA,IACF;AACA,uBAAmB,KAAK,SAAS;AAAA,EACnC,CAAC;AAED,SAAO;AACT;AAEA,IAAO,iCAAQ;","names":[]}

package/dist/chunk-EXN2TFDJ.js

@@ -0,0 +1,38 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined")
+    return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+var __accessCheck = (obj, member, msg) => {
+  if (!member.has(obj))
+    throw TypeError("Cannot " + msg);
+};
+var __privateGet = (obj, member, getter) => {
+  __accessCheck(obj, member, "read from private field");
+  return getter ? getter.call(obj) : member.get(obj);
+};
+var __privateAdd = (obj, member, value) => {
+  if (member.has(obj))
+    throw TypeError("Cannot add the same private member more than once");
+  member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+};
+var __privateSet = (obj, member, value, setter) => {
+  __accessCheck(obj, member, "write to private field");
+  setter ? setter.call(obj, value) : member.set(obj, value);
+  return value;
+};
+var __privateMethod = (obj, member, method) => {
+  __accessCheck(obj, member, "access private method");
+  return method;
+};
+
+
+
+
+
+
+
+exports.__require = __require; exports.__privateGet = __privateGet; exports.__privateAdd = __privateAdd; exports.__privateSet = __privateSet; exports.__privateMethod = __privateMethod;
+//# sourceMappingURL=chunk-EXN2TFDJ.js.map

package/dist/chunk-EXN2TFDJ.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":""}

package/dist/chunk-FNRATYYY.mjs

@@ -0,0 +1,24 @@
+// src/common/sortParams.ts
+var sortParamKeys = (methodParams, params) => {
+  if (!params) {
+    return [];
+  }
+  if (params instanceof Array) {
+    return params;
+  }
+  const methodParamsOrder = methodParams.reduce(
+    (paramsOrderObj, paramsName, i) => ({
+      ...paramsOrderObj,
+      [paramsName]: i
+    }),
+    {}
+  );
+  return Object.entries(params).sort(
+    ([name1, _1], [name2, _2]) => methodParamsOrder[name1] - methodParamsOrder[name2]
+  ).map(([_, val]) => val);
+};
+
+export {
+  sortParamKeys
+};
+//# sourceMappingURL=chunk-FNRATYYY.mjs.map

package/dist/chunk-FNRATYYY.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/common/sortParams.ts"],"sourcesContent":["// original source sortParamKeys from: https://github.com/etclabscore/sig.tools/blob/master/src/postMessageServer/postMessageServer.ts#L75-L77\n\nimport type { JsonRpcParams } from '@metamask/utils';\n\n/**\n * Deterministically sort JSON-RPC parameter keys. This makes it possible to\n * support both arrays and objects as parameters. Objects are sorted and turned\n * into arrays, for easier consumption by the snap.\n *\n * The order is defined by the `method` parameter.\n *\n * @param methodParams - The parameters of the JSON-RPC method, which\n * determines the ordering for the parameters.\n * @param params - JSON-RPC parameters as object or array.\n * @returns The values for the sorted keys. If `params` is not provided, this\n * returns an empty array. If `params` is an array, this returns the same\n * `params`.\n */\nexport const sortParamKeys = (\n  methodParams: string[],\n  params?: JsonRpcParams,\n) => {\n  if (!params) {\n    return [];\n  }\n\n  if (params instanceof Array) {\n    return params;\n  }\n\n  const methodParamsOrder: { [k: string]: number } = methodParams.reduce(\n    (paramsOrderObj, paramsName, i) => ({\n      ...paramsOrderObj,\n      [paramsName]: i,\n    }),\n    {},\n  );\n\n  return Object.entries(params)\n    .sort(\n      ([name1, _1], [name2, _2]) =>\n        methodParamsOrder[name1] - methodParamsOrder[name2],\n    )\n    .map(([_, val]) => val);\n};\n"],"mappings":";AAkBO,IAAM,gBAAgB,CAC3B,cACA,WACG;AACH,MAAI,CAAC,QAAQ;AACX,WAAO,CAAC;AAAA,EACV;AAEA,MAAI,kBAAkB,OAAO;AAC3B,WAAO;AAAA,EACT;AAEA,QAAM,oBAA6C,aAAa;AAAA,IAC9D,CAAC,gBAAgB,YAAY,OAAO;AAAA,MAClC,GAAG;AAAA,MACH,CAAC,UAAU,GAAG;AAAA,IAChB;AAAA,IACA,CAAC;AAAA,EACH;AAEA,SAAO,OAAO,QAAQ,MAAM,EACzB;AAAA,IACC,CAAC,CAAC,OAAO,EAAE,GAAG,CAAC,OAAO,EAAE,MACtB,kBAAkB,KAAK,IAAI,kBAAkB,KAAK;AAAA,EACtD,EACC,IAAI,CAAC,CAAC,GAAG,GAAG,MAAM,GAAG;AAC1B;","names":[]}

package/dist/chunk-FQBU72MW.mjs

@@ -0,0 +1,16 @@
+// src/common/endowments/textDecoder.ts
+var createTextDecoder = () => {
+  return {
+    TextDecoder: harden(TextDecoder)
+  };
+};
+var endowmentModule = {
+  names: ["TextDecoder"],
+  factory: createTextDecoder
+};
+var textDecoder_default = endowmentModule;
+
+export {
+  textDecoder_default
+};
+//# sourceMappingURL=chunk-FQBU72MW.mjs.map

package/dist/chunk-FQBU72MW.mjs.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"],"mappings":";AAKA,IAAM,oBAAoB,MAAM;AAC9B,SAAO;AAAA,IACL,aAAa,OAAO,WAAW;AAAA,EACjC;AACF;AAEA,IAAM,kBAAkB;AAAA,EACtB,OAAO,CAAC,aAAa;AAAA,EACrB,SAAS;AACX;AACA,IAAO,sBAAQ;","names":[]}