@metamask/snaps-utils 1.0.1 → 2.0.0

package/dist/cjs/virtual-file/toVirtualFile.js

@@ -0,0 +1,33 @@
+"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, {
+    readVirtualFile: function() {
+        return readVirtualFile;
+    },
+    writeVirtualFile: function() {
+        return writeVirtualFile;
+    }
+});
+const _fs = require("fs");
+const _VirtualFile = require("./VirtualFile");
+async function readVirtualFile(path, encoding = null) {
+    return new _VirtualFile.VirtualFile({
+        path,
+        value: await _fs.promises.readFile(path, {
+            encoding
+        })
+    });
+}
+async function writeVirtualFile(vfile, options) {
+    return _fs.promises.writeFile(vfile.path, vfile.value, options);
+}
+
+//# sourceMappingURL=toVirtualFile.js.map

package/dist/cjs/virtual-file/toVirtualFile.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/virtual-file/toVirtualFile.ts"],"sourcesContent":["import { promises as fsPromises } from 'fs';\n\nimport { VirtualFile } from './VirtualFile';\n\n/**\n * Reads a file from filesystem and creates a vfile.\n *\n * @param path - Filesystem path to load the contents from.\n * @param encoding - Optional encoding to pass down to fs.readFile.\n * @returns Promise returning VFile with loaded file contents.\n */\nexport async function readVirtualFile(\n  path: string,\n  encoding: BufferEncoding | null = null,\n) {\n  return new VirtualFile({\n    path,\n    value: await fsPromises.readFile(path, { encoding }),\n  });\n}\n\ntype WriteVFileOptions = Exclude<\n  Parameters<typeof fsPromises['writeFile']>[2],\n  undefined\n>;\n\n/**\n * Writes vfile to filesystem.\n *\n * @param vfile - The vfile to write.\n * @param options - Options to pass down to fs.writeFile.\n */\nexport async function writeVirtualFile(\n  vfile: VirtualFile,\n  options?: WriteVFileOptions,\n) {\n  return fsPromises.writeFile(vfile.path, vfile.value, options);\n}\n"],"names":["readVirtualFile","writeVirtualFile","path","encoding","VirtualFile","value","fsPromises","readFile","vfile","options","writeFile"],"mappings":";;;;;;;;;;;IAWsBA,eAAe;eAAfA;;IAqBAC,gBAAgB;eAAhBA;;;oBAhCiB;6BAEX;AASrB,eAAeD,gBACpBE,IAAY,EACZC,WAAkC,IAAI;IAEtC,OAAO,IAAIC,wBAAW,CAAC;QACrBF;QACAG,OAAO,MAAMC,YAAU,CAACC,QAAQ,CAACL,MAAM;YAAEC;QAAS;IACpD;AACF;AAaO,eAAeF,iBACpBO,KAAkB,EAClBC,OAA2B;IAE3B,OAAOH,YAAU,CAACI,SAAS,CAACF,MAAMN,IAAI,EAAEM,MAAMH,KAAK,EAAEI;AACvD"}

package/dist/{array.js → esm/array.js}

@@ -1,6 +1,3 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.isEqual = void 0;
 /**
  * Checks if array `a` is equal to array `b`. Note that this does not do a deep
  * equality check. It only checks if the arrays are the same length and if each
@@ -9,9 +6,8 @@ exports.isEqual = void 0;
  * @param a - The first array to compare.
  * @param b - The second array to compare.
  * @returns `true` if the arrays are equal, `false` otherwise.
- */
-function isEqual(a, b) {
-    return a.length === b.length && a.every((value, index) => value === b[index]);
+ */ export function isEqual(a, b) {
+    return a.length === b.length && a.every((value, index)=>value === b[index]);
 }
-exports.isEqual = isEqual;
+
 //# sourceMappingURL=array.js.map

package/dist/esm/array.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/array.ts"],"sourcesContent":["/**\n * Checks if array `a` is equal to array `b`. Note that this does not do a deep\n * equality check. It only checks if the arrays are the same length and if each\n * element in `a` is equal to (`===`) the corresponding element in `b`.\n *\n * @param a - The first array to compare.\n * @param b - The second array to compare.\n * @returns `true` if the arrays are equal, `false` otherwise.\n */\nexport function isEqual(a: unknown[], b: unknown[]): boolean {\n  return a.length === b.length && a.every((value, index) => value === b[index]);\n}\n"],"names":["isEqual","a","b","length","every","value","index"],"mappings":"AAAA;;;;;;;;CAQC,GACD,OAAO,SAASA,QAAQC,CAAY,EAAEC,CAAY;IAChD,OAAOD,EAAEE,MAAM,KAAKD,EAAEC,MAAM,IAAIF,EAAEG,KAAK,CAAC,CAACC,OAAOC,QAAUD,UAAUH,CAAC,CAACI,MAAM;AAC9E"}

package/dist/esm/caveats.js

@@ -0,0 +1,26 @@
+export var SnapCaveatType;
+(function(SnapCaveatType) {
+    SnapCaveatType[/**
+   * Permitted derivation paths, used by `snap_getBip32Entropy`.
+   */ "PermittedDerivationPaths"] = 'permittedDerivationPaths';
+    SnapCaveatType[/**
+   * Permitted coin types, used by `snap_getBip44Entropy`.
+   */ "PermittedCoinTypes"] = 'permittedCoinTypes';
+    SnapCaveatType[/**
+   * Caveat specifying a snap cronjob.
+   */ "SnapCronjob"] = 'snapCronjob';
+    SnapCaveatType[/**
+   * Caveat specifying access to the transaction origin, used by `endowment:transaction-insight`.
+   */ "TransactionOrigin"] = 'transactionOrigin';
+    SnapCaveatType[/**
+   * The origins that a Snap can receive JSON-RPC messages from.
+   */ "RpcOrigin"] = 'rpcOrigin';
+    SnapCaveatType[/**
+   * Caveat specifying the snap IDs that can be interacted with.
+   */ "SnapIds"] = 'snapIds';
+    SnapCaveatType[/**
+   * Caveat specifying the CAIP-2 chain IDs that a snap can service, currently limited to `endowment:name-lookup`.
+   */ "ChainIds"] = 'chainIds';
+})(SnapCaveatType || (SnapCaveatType = {}));
+
+//# sourceMappingURL=caveats.js.map

package/dist/esm/caveats.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/caveats.ts"],"sourcesContent":["export enum SnapCaveatType {\n  /**\n   * Permitted derivation paths, used by `snap_getBip32Entropy`.\n   */\n  PermittedDerivationPaths = 'permittedDerivationPaths',\n\n  /**\n   * Permitted coin types, used by `snap_getBip44Entropy`.\n   */\n  PermittedCoinTypes = 'permittedCoinTypes',\n\n  /**\n   * Caveat specifying a snap cronjob.\n   */\n  SnapCronjob = 'snapCronjob',\n\n  /**\n   * Caveat specifying access to the transaction origin, used by `endowment:transaction-insight`.\n   */\n  TransactionOrigin = 'transactionOrigin',\n\n  /**\n   * The origins that a Snap can receive JSON-RPC messages from.\n   */\n  RpcOrigin = 'rpcOrigin',\n\n  /**\n   * Caveat specifying the snap IDs that can be interacted with.\n   */\n  SnapIds = 'snapIds',\n\n  /**\n   * Caveat specifying the CAIP-2 chain IDs that a snap can service, currently limited to `endowment:name-lookup`.\n   */\n  ChainIds = 'chainIds',\n}\n"],"names":["SnapCaveatType","PermittedDerivationPaths","PermittedCoinTypes","SnapCronjob","TransactionOrigin","RpcOrigin","SnapIds","ChainIds"],"mappings":"WAAO;UAAKA,cAAc;IAAdA,eACV;;GAEC,GACDC,8BAA2B;IAJjBD,eAMV;;GAEC,GACDE,wBAAqB;IATXF,eAWV;;GAEC,GACDG,iBAAc;IAdJH,eAgBV;;GAEC,GACDI,uBAAoB;IAnBVJ,eAqBV;;GAEC,GACDK,eAAY;IAxBFL,eA0BV;;GAEC,GACDM,aAAU;IA7BAN,eA+BV;;GAEC,GACDO,cAAW;GAlCDP,mBAAAA"}

package/dist/esm/checksum.js

@@ -0,0 +1,36 @@
+import { assert, concatBytes } from '@metamask/utils';
+import { sha256 } from '@noble/hashes/sha256';
+import { VirtualFile } from './virtual-file/VirtualFile';
+/**
+ * Calculates checksum for a single byte array.
+ *
+ * @param bytes - The byte array to calculate the checksum for.
+ * @returns A single sha-256 checksum.
+ */ export function checksum(bytes) {
+    const value = bytes instanceof VirtualFile ? bytes.value : bytes;
+    return sha256(value);
+}
+/**
+ * Calculates checksum over multiple files in a reproducible way.
+ *
+ * 1. Sort all the files by their paths.
+ * 2. Calculate sha-256 checksum of each file separately.
+ * 3. Concatenate all the checksums into one buffer and sha-256 that buffer.
+ *
+ * The sorting of paths is done using {@link https://tc39.es/ecma262/#sec-islessthan UTF-16 Code Units}.
+ *
+ * @param files - The files over which to calculate the checksum.
+ * @returns A single sha-256 checksum.
+ */ export function checksumFiles(files) {
+    return checksum(concatBytes([
+        ...files
+    ].sort((a, b)=>{
+        assert(a.path !== b.path, 'Tried to sort files with non-unique paths.');
+        if (a.path < b.path) {
+            return -1;
+        }
+        return 1;
+    }).map((file)=>checksum(file))));
+}
+
+//# sourceMappingURL=checksum.js.map

package/dist/esm/checksum.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/checksum.ts"],"sourcesContent":["import { assert, concatBytes } from '@metamask/utils';\nimport { sha256 } from '@noble/hashes/sha256';\n\nimport { VirtualFile } from './virtual-file/VirtualFile';\n\n/**\n * Calculates checksum for a single byte array.\n *\n * @param bytes - The byte array to calculate the checksum for.\n * @returns A single sha-256 checksum.\n */\nexport function checksum(bytes: VirtualFile | Uint8Array | string): Uint8Array {\n  const value = bytes instanceof VirtualFile ? bytes.value : bytes;\n  return sha256(value);\n}\n\n/**\n * Calculates checksum over multiple files in a reproducible way.\n *\n * 1. Sort all the files by their paths.\n * 2. Calculate sha-256 checksum of each file separately.\n * 3. Concatenate all the checksums into one buffer and sha-256 that buffer.\n *\n * The sorting of paths is done using {@link https://tc39.es/ecma262/#sec-islessthan UTF-16 Code Units}.\n *\n * @param files - The files over which to calculate the checksum.\n * @returns A single sha-256 checksum.\n */\nexport function checksumFiles(files: VirtualFile[]) {\n  return checksum(\n    concatBytes(\n      [...files]\n        .sort((a, b) => {\n          assert(\n            a.path !== b.path,\n            'Tried to sort files with non-unique paths.',\n          );\n          if (a.path < b.path) {\n            return -1;\n          }\n          return 1;\n        })\n        .map((file) => checksum(file)),\n    ),\n  );\n}\n"],"names":["assert","concatBytes","sha256","VirtualFile","checksum","bytes","value","checksumFiles","files","sort","a","b","path","map","file"],"mappings":"AAAA,SAASA,MAAM,EAAEC,WAAW,QAAQ,kBAAkB;AACtD,SAASC,MAAM,QAAQ,uBAAuB;AAE9C,SAASC,WAAW,QAAQ,6BAA6B;AAEzD;;;;;CAKC,GACD,OAAO,SAASC,SAASC,KAAwC;IAC/D,MAAMC,QAAQD,iBAAiBF,cAAcE,MAAMC,KAAK,GAAGD;IAC3D,OAAOH,OAAOI;AAChB;AAEA;;;;;;;;;;;CAWC,GACD,OAAO,SAASC,cAAcC,KAAoB;IAChD,OAAOJ,SACLH,YACE;WAAIO;KAAM,CACPC,IAAI,CAAC,CAACC,GAAGC;QACRX,OACEU,EAAEE,IAAI,KAAKD,EAAEC,IAAI,EACjB;QAEF,IAAIF,EAAEE,IAAI,GAAGD,EAAEC,IAAI,EAAE;YACnB,OAAO,CAAC;QACV;QACA,OAAO;IACT,GACCC,GAAG,CAAC,CAACC,OAASV,SAASU;AAGhC"}

package/dist/esm/cronjob.js

@@ -0,0 +1,66 @@
+import { JsonRpcRequestStruct } from '@metamask/utils';
+import { parseExpression } from 'cron-parser';
+import { array, assign, coerce, create, object, omit, optional, partial, pick, refine, string } from 'superstruct';
+export const CronjobRpcRequestStruct = assign(partial(pick(JsonRpcRequestStruct, [
+    'id',
+    'jsonrpc'
+])), omit(JsonRpcRequestStruct, [
+    'id',
+    'jsonrpc'
+]));
+export const CronExpressionStruct = refine(coerce(string(), object({
+    minute: optional(string()),
+    hour: optional(string()),
+    dayOfMonth: optional(string()),
+    month: optional(string()),
+    dayOfWeek: optional(string())
+}), (value)=>`${value.minute ?? '*'} ${value.hour ?? '*'} ${value.dayOfMonth ?? '*'} ${value.month ?? '*'} ${value.dayOfWeek ?? '*'}`), 'CronExpression', (value)=>{
+    try {
+        parseExpression(value);
+        return true;
+    } catch  {
+        return false;
+    }
+});
+/**
+ * Parses a cron expression.
+ *
+ * @param expression - Expression to parse.
+ * @returns A CronExpression class instance.
+ */ export function parseCronExpression(expression) {
+    const ensureStringExpression = create(expression, CronExpressionStruct);
+    return parseExpression(ensureStringExpression);
+}
+export const CronjobSpecificationStruct = object({
+    expression: CronExpressionStruct,
+    request: CronjobRpcRequestStruct
+});
+/**
+ * Check if the given value is a {@link CronjobSpecification} object.
+ *
+ * @param value - The value to check.
+ * @returns Whether the value is a valid {@link CronjobSpecification} object.
+ */ export function isCronjobSpecification(value) {
+    try {
+        create(value, CronjobSpecificationStruct);
+        return true;
+    } catch  {
+        return false;
+    }
+}
+export const CronjobSpecificationArrayStruct = array(CronjobSpecificationStruct);
+/**
+ * Check if the given value is an array of {@link CronjobSpecification} objects.
+ *
+ * @param value - The value to check.
+ * @returns Whether the value is a valid array of {@link CronjobSpecification} objects.
+ */ export function isCronjobSpecificationArray(value) {
+    try {
+        create(value, CronjobSpecificationArrayStruct);
+        return true;
+    } catch  {
+        return false;
+    }
+}
+
+//# sourceMappingURL=cronjob.js.map

package/dist/esm/cronjob.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/cronjob.ts"],"sourcesContent":["import { JsonRpcRequestStruct } from '@metamask/utils';\nimport { parseExpression } from 'cron-parser';\nimport type { Infer } from 'superstruct';\nimport {\n  array,\n  assign,\n  coerce,\n  create,\n  object,\n  omit,\n  optional,\n  partial,\n  pick,\n  refine,\n  string,\n} from 'superstruct';\n\nexport const CronjobRpcRequestStruct = assign(\n  partial(pick(JsonRpcRequestStruct, ['id', 'jsonrpc'])),\n  omit(JsonRpcRequestStruct, ['id', 'jsonrpc']),\n);\nexport type CronjobRpcRequest = Infer<typeof CronjobRpcRequestStruct>;\n\nexport const CronExpressionStruct = refine(\n  coerce(\n    string(),\n    object({\n      minute: optional(string()),\n      hour: optional(string()),\n      dayOfMonth: optional(string()),\n      month: optional(string()),\n      dayOfWeek: optional(string()),\n    }),\n    (value) =>\n      `${value.minute ?? '*'} ${value.hour ?? '*'} ${value.dayOfMonth ?? '*'} ${\n        value.month ?? '*'\n      } ${value.dayOfWeek ?? '*'}`,\n  ),\n  'CronExpression',\n  (value) => {\n    try {\n      parseExpression(value);\n      return true;\n    } catch {\n      return false;\n    }\n  },\n);\n\nexport type CronExpression = Infer<typeof CronExpressionStruct>;\n\n/**\n * Parses a cron expression.\n *\n * @param expression - Expression to parse.\n * @returns A CronExpression class instance.\n */\nexport function parseCronExpression(expression: string | object) {\n  const ensureStringExpression = create(expression, CronExpressionStruct);\n  return parseExpression(ensureStringExpression);\n}\n\nexport const CronjobSpecificationStruct = object({\n  expression: CronExpressionStruct,\n  request: CronjobRpcRequestStruct,\n});\nexport type CronjobSpecification = Infer<typeof CronjobSpecificationStruct>;\n\n/**\n * Check if the given value is a {@link CronjobSpecification} object.\n *\n * @param value - The value to check.\n * @returns Whether the value is a valid {@link CronjobSpecification} object.\n */\nexport function isCronjobSpecification(value: unknown): boolean {\n  try {\n    create(value, CronjobSpecificationStruct);\n    return true;\n  } catch {\n    return false;\n  }\n}\n\nexport const CronjobSpecificationArrayStruct = array(\n  CronjobSpecificationStruct,\n);\n\n/**\n * Check if the given value is an array of {@link CronjobSpecification} objects.\n *\n * @param value - The value to check.\n * @returns Whether the value is a valid array of {@link CronjobSpecification} objects.\n */\nexport function isCronjobSpecificationArray(value: unknown): boolean {\n  try {\n    create(value, CronjobSpecificationArrayStruct);\n    return true;\n  } catch {\n    return false;\n  }\n}\n"],"names":["JsonRpcRequestStruct","parseExpression","array","assign","coerce","create","object","omit","optional","partial","pick","refine","string","CronjobRpcRequestStruct","CronExpressionStruct","minute","hour","dayOfMonth","month","dayOfWeek","value","parseCronExpression","expression","ensureStringExpression","CronjobSpecificationStruct","request","isCronjobSpecification","CronjobSpecificationArrayStruct","isCronjobSpecificationArray"],"mappings":"AAAA,SAASA,oBAAoB,QAAQ,kBAAkB;AACvD,SAASC,eAAe,QAAQ,cAAc;AAE9C,SACEC,KAAK,EACLC,MAAM,EACNC,MAAM,EACNC,MAAM,EACNC,MAAM,EACNC,IAAI,EACJC,QAAQ,EACRC,OAAO,EACPC,IAAI,EACJC,MAAM,EACNC,MAAM,QACD,cAAc;AAErB,OAAO,MAAMC,0BAA0BV,OACrCM,QAAQC,KAAKV,sBAAsB;IAAC;IAAM;CAAU,IACpDO,KAAKP,sBAAsB;IAAC;IAAM;CAAU,GAC5C;AAGF,OAAO,MAAMc,uBAAuBH,OAClCP,OACEQ,UACAN,OAAO;IACLS,QAAQP,SAASI;IACjBI,MAAMR,SAASI;IACfK,YAAYT,SAASI;IACrBM,OAAOV,SAASI;IAChBO,WAAWX,SAASI;AACtB,IACA,CAACQ,QACC,CAAC,EAAEA,MAAML,MAAM,IAAI,IAAI,CAAC,EAAEK,MAAMJ,IAAI,IAAI,IAAI,CAAC,EAAEI,MAAMH,UAAU,IAAI,IAAI,CAAC,EACtEG,MAAMF,KAAK,IAAI,IAChB,CAAC,EAAEE,MAAMD,SAAS,IAAI,IAAI,CAAC,GAEhC,kBACA,CAACC;IACC,IAAI;QACFnB,gBAAgBmB;QAChB,OAAO;IACT,EAAE,OAAM;QACN,OAAO;IACT;AACF,GACA;AAIF;;;;;CAKC,GACD,OAAO,SAASC,oBAAoBC,UAA2B;IAC7D,MAAMC,yBAAyBlB,OAAOiB,YAAYR;IAClD,OAAOb,gBAAgBsB;AACzB;AAEA,OAAO,MAAMC,6BAA6BlB,OAAO;IAC/CgB,YAAYR;IACZW,SAASZ;AACX,GAAG;AAGH;;;;;CAKC,GACD,OAAO,SAASa,uBAAuBN,KAAc;IACnD,IAAI;QACFf,OAAOe,OAAOI;QACd,OAAO;IACT,EAAE,OAAM;QACN,OAAO;IACT;AACF;AAEA,OAAO,MAAMG,kCAAkCzB,MAC7CsB,4BACA;AAEF;;;;;CAKC,GACD,OAAO,SAASI,4BAA4BR,KAAc;IACxD,IAAI;QACFf,OAAOe,OAAOO;QACd,OAAO;IACT,EAAE,OAAM;QACN,OAAO;IACT;AACF"}

package/dist/esm/deep-clone.js

@@ -0,0 +1,7 @@
+import rfdc from 'rfdc';
+export const deepClone = rfdc({
+    proto: false,
+    circles: false
+});
+
+//# sourceMappingURL=deep-clone.js.map

package/dist/esm/deep-clone.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/deep-clone.ts"],"sourcesContent":["import rfdc from 'rfdc';\n\nexport const deepClone = rfdc({ proto: false, circles: false });\n"],"names":["rfdc","deepClone","proto","circles"],"mappings":"AAAA,OAAOA,UAAU,OAAO;AAExB,OAAO,MAAMC,YAAYD,KAAK;IAAEE,OAAO;IAAOC,SAAS;AAAM,GAAG"}

package/dist/{default-endowments.js → esm/default-endowments.js}

@@ -1,10 +1,6 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.DEFAULT_ENDOWMENTS = void 0;
 /**
  * Global JavaScript APIs exposed by default to all snaps.
- */
-exports.DEFAULT_ENDOWMENTS = Object.freeze([
+ */ export const DEFAULT_ENDOWMENTS = Object.freeze([
     'atob',
     'btoa',
     'BigInt',
@@ -37,6 +33,7 @@ exports.DEFAULT_ENDOWMENTS = Object.freeze([
     // https://github.com/MetaMask/snaps-monorepo/issues/662
     // https://github.com/MetaMask/snaps-monorepo/discussions/678
     'AbortController',
-    'AbortSignal',
+    'AbortSignal'
 ]);
+
 //# sourceMappingURL=default-endowments.js.map

package/dist/esm/default-endowments.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/default-endowments.ts"],"sourcesContent":["/**\n * Global JavaScript APIs exposed by default to all snaps.\n */\nexport const DEFAULT_ENDOWMENTS: readonly string[] = Object.freeze([\n  'atob',\n  'btoa',\n  'BigInt',\n  'console',\n  'crypto',\n  'Date',\n  'Math',\n  'setTimeout',\n  'clearTimeout',\n  'SubtleCrypto',\n  'TextDecoder',\n  'TextEncoder',\n  'URL',\n  'setInterval',\n  'clearInterval',\n  'Int8Array',\n  'Uint8Array',\n  'Uint8ClampedArray',\n  'Int16Array',\n  'Uint16Array',\n  'Int32Array',\n  'Uint32Array',\n  'Float32Array',\n  'Float64Array',\n  'BigInt64Array',\n  'BigUint64Array',\n  'DataView',\n  'ArrayBuffer',\n  // Used by fetch, but also as API for some packages that don't do network connections\n  // https://github.com/MetaMask/snaps-monorepo/issues/662\n  // https://github.com/MetaMask/snaps-monorepo/discussions/678\n  'AbortController',\n  'AbortSignal',\n]);\n"],"names":["DEFAULT_ENDOWMENTS","Object","freeze"],"mappings":"AAAA;;CAEC,GACD,OAAO,MAAMA,qBAAwCC,OAAOC,MAAM,CAAC;IACjE;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA,qFAAqF;IACrF,wDAAwD;IACxD,6DAA6D;IAC7D;IACA;CACD,EAAE"}

package/dist/esm/entropy.js

@@ -0,0 +1,6 @@
+// 0xd36e6170 - 0x80000000
+export const SIP_6_MAGIC_VALUE = `1399742832'`;
+// `${bytesToNumber(keccak256('Snaps state encryption').slice(0, 4))}'`
+export const STATE_ENCRYPTION_MAGIC_VALUE = `572232532'`;
+
+//# sourceMappingURL=entropy.js.map

package/dist/esm/entropy.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/entropy.ts"],"sourcesContent":["// 0xd36e6170 - 0x80000000\nexport const SIP_6_MAGIC_VALUE = `1399742832'` as `${number}'`;\n\n// `${bytesToNumber(keccak256('Snaps state encryption').slice(0, 4))}'`\nexport const STATE_ENCRYPTION_MAGIC_VALUE = `572232532'` as `${number}'`;\n\nexport type MagicValue =\n  | typeof SIP_6_MAGIC_VALUE\n  | typeof STATE_ENCRYPTION_MAGIC_VALUE;\n"],"names":["SIP_6_MAGIC_VALUE","STATE_ENCRYPTION_MAGIC_VALUE"],"mappings":"AAAA,0BAA0B;AAC1B,OAAO,MAAMA,oBAAoB,CAAC,WAAW,CAAC,CAAiB;AAE/D,uEAAuE;AACvE,OAAO,MAAMC,+BAA+B,CAAC,UAAU,CAAC,CAAiB"}

package/dist/esm/enum.js

@@ -0,0 +1,12 @@
+import { literal } from './structs';
+/**
+ * Superstruct struct for validating an enum value. This allows using both the
+ * enum string values and the enum itself as values.
+ *
+ * @param constant - The enum to validate against.
+ * @returns The superstruct struct.
+ */ export function enumValue(constant) {
+    return literal(constant);
+}
+
+//# sourceMappingURL=enum.js.map

package/dist/esm/enum.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/enum.ts"],"sourcesContent":["import type { Struct } from 'superstruct';\n\nimport { literal } from './structs';\n\n/**\n * Get the enum values as union type. This allows using both the enum string\n * values and the enum itself as values.\n *\n * Note: This only works for string enums.\n *\n * @example\n * ```typescript\n * enum Foo {\n *   Bar = 'bar',\n *   Baz = 'baz',\n * }\n *\n * type FooValue = EnumToUnion<Foo>;\n * // FooValue is 'bar' | 'baz'\n *\n * const foo: FooValue = Foo.Bar; // Works\n * const foo: FooValue = 'bar'; // Also works\n * ```\n */\nexport type EnumToUnion<Type extends string> = `${Type}`;\n\n/**\n * Superstruct struct for validating an enum value. This allows using both the\n * enum string values and the enum itself as values.\n *\n * @param constant - The enum to validate against.\n * @returns The superstruct struct.\n */\nexport function enumValue<Type extends string>(\n  constant: Type,\n): Struct<EnumToUnion<Type>, null> {\n  return literal(constant as EnumToUnion<Type>);\n}\n"],"names":["literal","enumValue","constant"],"mappings":"AAEA,SAASA,OAAO,QAAQ,YAAY;AAwBpC;;;;;;CAMC,GACD,OAAO,SAASC,UACdC,QAAc;IAEd,OAAOF,QAAQE;AACjB"}

package/dist/esm/errors.js

@@ -0,0 +1,17 @@
+import { hasProperty, isObject } from '@metamask/utils';
+/**
+ * Get the error message from an unknown error type.
+ *
+ * - If the error is an object with a `message` property, return the message.
+ * - Otherwise, return the error converted to a string.
+ *
+ * @param error - The error to get the message from.
+ * @returns The error message.
+ */ export function getErrorMessage(error) {
+    if (isObject(error) && hasProperty(error, 'message') && typeof error.message === 'string') {
+        return error.message;
+    }
+    return String(error);
+}
+
+//# sourceMappingURL=errors.js.map

package/dist/esm/errors.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/errors.ts"],"sourcesContent":["import { hasProperty, isObject } from '@metamask/utils';\n\n/**\n * Get the error message from an unknown error type.\n *\n * - If the error is an object with a `message` property, return the message.\n * - Otherwise, return the error converted to a string.\n *\n * @param error - The error to get the message from.\n * @returns The error message.\n */\nexport function getErrorMessage(error: unknown) {\n  if (\n    isObject(error) &&\n    hasProperty(error, 'message') &&\n    typeof error.message === 'string'\n  ) {\n    return error.message;\n  }\n\n  return String(error);\n}\n"],"names":["hasProperty","isObject","getErrorMessage","error","message","String"],"mappings":"AAAA,SAASA,WAAW,EAAEC,QAAQ,QAAQ,kBAAkB;AAExD;;;;;;;;CAQC,GACD,OAAO,SAASC,gBAAgBC,KAAc;IAC5C,IACEF,SAASE,UACTH,YAAYG,OAAO,cACnB,OAAOA,MAAMC,OAAO,KAAK,UACzB;QACA,OAAOD,MAAMC,OAAO;IACtB;IAEA,OAAOC,OAAOF;AAChB"}

package/dist/esm/eval-worker.js

@@ -0,0 +1,47 @@
+// eslint-disable-next-line import/no-unassigned-import
+import 'ses/lockdown';
+import { readFileSync } from 'fs';
+import { generateMockEndowments } from './mock';
+import { SNAP_EXPORT_NAMES } from './types';
+lockdown({
+    consoleTaming: 'unsafe',
+    errorTaming: 'unsafe',
+    mathTaming: 'unsafe',
+    dateTaming: 'unsafe',
+    overrideTaming: 'severe',
+    // We disable domain taming, because it does not work in certain cases when
+    // running tests. This is unlikely to be a problem in production, because
+    // Node.js domains are deprecated.
+    domainTaming: 'unsafe'
+});
+/**
+ * Get mock endowments that don't do anything. This is useful for running the
+ * eval, for snaps that try to communicate with the extension on initialisation,
+ * for example.
+ *
+ * @returns The mock endowments.
+ */ function getMockEndowments() {
+    const endowments = generateMockEndowments();
+    return {
+        ...endowments,
+        window: endowments,
+        self: endowments
+    };
+}
+const snapFilePath = process.argv[2];
+const snapModule = {
+    exports: {}
+};
+new Compartment({
+    ...getMockEndowments(),
+    module: snapModule,
+    exports: snapModule.exports
+}).evaluate(readFileSync(snapFilePath, 'utf8'));
+const invalidExports = Object.keys(snapModule.exports).filter((snapExport)=>!SNAP_EXPORT_NAMES.includes(snapExport));
+if (invalidExports.length > 0) {
+    // eslint-disable-next-line no-console
+    console.warn(`Invalid snap exports detected:\n${invalidExports.join('\n')}`);
+}
+setTimeout(()=>process.exit(0), 1000); // Hack to ensure worker exits
+
+//# sourceMappingURL=eval-worker.js.map

package/dist/esm/eval-worker.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/eval-worker.ts"],"sourcesContent":["// eslint-disable-next-line import/no-unassigned-import\nimport 'ses/lockdown';\n\nimport { readFileSync } from 'fs';\n\nimport type { HandlerType } from './handlers';\nimport { generateMockEndowments } from './mock';\nimport { SNAP_EXPORT_NAMES } from './types';\n\ndeclare let lockdown: any, Compartment: any;\n\nlockdown({\n  consoleTaming: 'unsafe',\n  errorTaming: 'unsafe',\n  mathTaming: 'unsafe',\n  dateTaming: 'unsafe',\n  overrideTaming: 'severe',\n\n  // We disable domain taming, because it does not work in certain cases when\n  // running tests. This is unlikely to be a problem in production, because\n  // Node.js domains are deprecated.\n  domainTaming: 'unsafe',\n});\n\n/**\n * Get mock endowments that don't do anything. This is useful for running the\n * eval, for snaps that try to communicate with the extension on initialisation,\n * for example.\n *\n * @returns The mock endowments.\n */\nfunction getMockEndowments() {\n  const endowments = generateMockEndowments();\n  return {\n    ...endowments,\n    window: endowments,\n    self: endowments,\n  };\n}\n\nconst snapFilePath = process.argv[2];\n\nconst snapModule: { exports?: any } = { exports: {} };\n\nnew Compartment({\n  ...getMockEndowments(),\n  module: snapModule,\n  exports: snapModule.exports,\n}).evaluate(readFileSync(snapFilePath, 'utf8'));\n\nconst invalidExports = Object.keys(snapModule.exports).filter(\n  (snapExport) => !SNAP_EXPORT_NAMES.includes(snapExport as HandlerType),\n);\n\nif (invalidExports.length > 0) {\n  // eslint-disable-next-line no-console\n  console.warn(`Invalid snap exports detected:\\n${invalidExports.join('\\n')}`);\n}\n\nsetTimeout(() => process.exit(0), 1000); // Hack to ensure worker exits\n"],"names":["readFileSync","generateMockEndowments","SNAP_EXPORT_NAMES","lockdown","consoleTaming","errorTaming","mathTaming","dateTaming","overrideTaming","domainTaming","getMockEndowments","endowments","window","self","snapFilePath","process","argv","snapModule","exports","Compartment","module","evaluate","invalidExports","Object","keys","filter","snapExport","includes","length","console","warn","join","setTimeout","exit"],"mappings":"AAAA,uDAAuD;AACvD,OAAO,eAAe;AAEtB,SAASA,YAAY,QAAQ,KAAK;AAGlC,SAASC,sBAAsB,QAAQ,SAAS;AAChD,SAASC,iBAAiB,QAAQ,UAAU;AAI5CC,SAAS;IACPC,eAAe;IACfC,aAAa;IACbC,YAAY;IACZC,YAAY;IACZC,gBAAgB;IAEhB,2EAA2E;IAC3E,yEAAyE;IACzE,kCAAkC;IAClCC,cAAc;AAChB;AAEA;;;;;;CAMC,GACD,SAASC;IACP,MAAMC,aAAaV;IACnB,OAAO;QACL,GAAGU,UAAU;QACbC,QAAQD;QACRE,MAAMF;IACR;AACF;AAEA,MAAMG,eAAeC,QAAQC,IAAI,CAAC,EAAE;AAEpC,MAAMC,aAAgC;IAAEC,SAAS,CAAC;AAAE;AAEpD,IAAIC,YAAY;IACd,GAAGT,mBAAmB;IACtBU,QAAQH;IACRC,SAASD,WAAWC,OAAO;AAC7B,GAAGG,QAAQ,CAACrB,aAAac,cAAc;AAEvC,MAAMQ,iBAAiBC,OAAOC,IAAI,CAACP,WAAWC,OAAO,EAAEO,MAAM,CAC3D,CAACC,aAAe,CAACxB,kBAAkByB,QAAQ,CAACD;AAG9C,IAAIJ,eAAeM,MAAM,GAAG,GAAG;IAC7B,sCAAsC;IACtCC,QAAQC,IAAI,CAAC,CAAC,gCAAgC,EAAER,eAAeS,IAAI,CAAC,MAAM,CAAC;AAC7E;AAEAC,WAAW,IAAMjB,QAAQkB,IAAI,CAAC,IAAI,OAAO,8BAA8B"}

package/dist/esm/eval.js

@@ -0,0 +1,65 @@
+function _define_property(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+import { assert } from '@metamask/utils';
+import { fork } from 'child_process';
+import { join } from 'path';
+import { validateFilePath } from './fs';
+export class SnapEvalError extends Error {
+    constructor(message, output){
+        super(message);
+        _define_property(this, "output", void 0);
+        this.name = 'SnapEvalError';
+        this.output = output;
+    }
+}
+/**
+ * Spawn a new process to run the provided bundle in.
+ *
+ * @param bundlePath - The path to the bundle to run.
+ * @returns `null` if the worker ran successfully.
+ * @throws If the worker failed to run successfully.
+ */ export async function evalBundle(bundlePath) {
+    await validateFilePath(bundlePath);
+    return new Promise((resolve, reject)=>{
+        const worker = fork(join(__dirname, 'eval-worker.js'), [
+            bundlePath
+        ], {
+            // To avoid printing the output of the worker to the console, we set
+            // `stdio` to `pipe` and handle the output ourselves.
+            stdio: 'pipe'
+        });
+        let stdout = '';
+        let stderr = '';
+        assert(worker.stdout, '`stdout` should be defined.');
+        assert(worker.stderr, '`stderr` should be defined.');
+        worker.stdout.on('data', (data)=>{
+            stdout += data.toString();
+        });
+        worker.stderr.on('data', (data)=>{
+            stderr += data.toString();
+        });
+        worker.on('exit', (exitCode)=>{
+            const output = {
+                stdout,
+                stderr
+            };
+            if (exitCode === 0) {
+                return resolve(output);
+            }
+            return reject(new SnapEvalError(`Process exited with non-zero exit code: ${exitCode}.`, output));
+        });
+    });
+}
+
+//# sourceMappingURL=eval.js.map

package/dist/esm/eval.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/eval.ts"],"sourcesContent":["import { assert } from '@metamask/utils';\nimport { fork } from 'child_process';\nimport { join } from 'path';\n\nimport { validateFilePath } from './fs';\n\nexport type EvalOutput = {\n  stdout: string;\n  stderr: string;\n};\n\nexport class SnapEvalError extends Error {\n  readonly output: EvalOutput;\n\n  constructor(message: string, output: EvalOutput) {\n    super(message);\n\n    this.name = 'SnapEvalError';\n    this.output = output;\n  }\n}\n\n/**\n * Spawn a new process to run the provided bundle in.\n *\n * @param bundlePath - The path to the bundle to run.\n * @returns `null` if the worker ran successfully.\n * @throws If the worker failed to run successfully.\n */\nexport async function evalBundle(bundlePath: string): Promise<EvalOutput> {\n  await validateFilePath(bundlePath);\n\n  return new Promise((resolve, reject) => {\n    const worker = fork(join(__dirname, 'eval-worker.js'), [bundlePath], {\n      // To avoid printing the output of the worker to the console, we set\n      // `stdio` to `pipe` and handle the output ourselves.\n      stdio: 'pipe',\n    });\n\n    let stdout = '';\n    let stderr = '';\n\n    assert(worker.stdout, '`stdout` should be defined.');\n    assert(worker.stderr, '`stderr` should be defined.');\n\n    worker.stdout.on('data', (data: Buffer) => {\n      stdout += data.toString();\n    });\n\n    worker.stderr.on('data', (data: Buffer) => {\n      stderr += data.toString();\n    });\n\n    worker.on('exit', (exitCode: number) => {\n      const output = {\n        stdout,\n        stderr,\n      };\n\n      if (exitCode === 0) {\n        return resolve(output);\n      }\n\n      return reject(\n        new SnapEvalError(\n          `Process exited with non-zero exit code: ${exitCode}.`,\n          output,\n        ),\n      );\n    });\n  });\n}\n"],"names":["assert","fork","join","validateFilePath","SnapEvalError","Error","constructor","message","output","name","evalBundle","bundlePath","Promise","resolve","reject","worker","__dirname","stdio","stdout","stderr","on","data","toString","exitCode"],"mappings":";;;;;;;;;;;;;AAAA,SAASA,MAAM,QAAQ,kBAAkB;AACzC,SAASC,IAAI,QAAQ,gBAAgB;AACrC,SAASC,IAAI,QAAQ,OAAO;AAE5B,SAASC,gBAAgB,QAAQ,OAAO;AAOxC,OAAO,MAAMC,sBAAsBC;IAGjCC,YAAYC,OAAe,EAAEC,MAAkB,CAAE;QAC/C,KAAK,CAACD;QAHR,uBAASC,UAAT,KAAA;QAKE,IAAI,CAACC,IAAI,GAAG;QACZ,IAAI,CAACD,MAAM,GAAGA;IAChB;AACF;AAEA;;;;;;CAMC,GACD,OAAO,eAAeE,WAAWC,UAAkB;IACjD,MAAMR,iBAAiBQ;IAEvB,OAAO,IAAIC,QAAQ,CAACC,SAASC;QAC3B,MAAMC,SAASd,KAAKC,KAAKc,WAAW,mBAAmB;YAACL;SAAW,EAAE;YACnE,oEAAoE;YACpE,qDAAqD;YACrDM,OAAO;QACT;QAEA,IAAIC,SAAS;QACb,IAAIC,SAAS;QAEbnB,OAAOe,OAAOG,MAAM,EAAE;QACtBlB,OAAOe,OAAOI,MAAM,EAAE;QAEtBJ,OAAOG,MAAM,CAACE,EAAE,CAAC,QAAQ,CAACC;YACxBH,UAAUG,KAAKC,QAAQ;QACzB;QAEAP,OAAOI,MAAM,CAACC,EAAE,CAAC,QAAQ,CAACC;YACxBF,UAAUE,KAAKC,QAAQ;QACzB;QAEAP,OAAOK,EAAE,CAAC,QAAQ,CAACG;YACjB,MAAMf,SAAS;gBACbU;gBACAC;YACF;YAEA,IAAII,aAAa,GAAG;gBAClB,OAAOV,QAAQL;YACjB;YAEA,OAAOM,OACL,IAAIV,cACF,CAAC,wCAAwC,EAAEmB,SAAS,CAAC,CAAC,EACtDf;QAGN;IACF;AACF"}

package/dist/{fs.js → esm/fs.js}

@@ -1,14 +1,8 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.useTemporaryFile = exports.validateDirPath = exports.validateFilePath = exports.validateOutfileName = exports.getOutfilePath = exports.readJsonFile = exports.isFile = exports.isDirectory = void 0;
-const fs_1 = require("fs");
-const os_1 = __importDefault(require("os"));
-const path_1 = __importDefault(require("path"));
-const json_1 = require("./json");
-const virtual_file_1 = require("./virtual-file");
+import { promises as fs } from 'fs';
+import os from 'os';
+import pathUtils from 'path';
+import { parseJson } from './json';
+import { readVirtualFile } from './virtual-file';
 /**
  * Checks whether the given path string resolves to an existing directory, and
  * optionally creates the directory if it doesn't exist.
@@ -16,64 +10,57 @@ const virtual_file_1 = require("./virtual-file");
  * @param pathString - The path string to check.
  * @param createDir - Whether to create the directory if it doesn't exist.
  * @returns Whether the given path is an existing directory.
- */
-async function isDirectory(pathString, createDir) {
+ */ export async function isDirectory(pathString, createDir) {
     try {
-        const stats = await fs_1.promises.stat(pathString);
+        const stats = await fs.stat(pathString);
         return stats.isDirectory();
-    }
-    catch (error) {
+    } catch (error) {
         if (error.code === 'ENOENT') {
             if (!createDir) {
                 return false;
             }
-            await fs_1.promises.mkdir(pathString, { recursive: true });
+            await fs.mkdir(pathString, {
+                recursive: true
+            });
             return true;
         }
         return false;
     }
 }
-exports.isDirectory = isDirectory;
 /**
  * Checks whether the given path string resolves to an existing file.
  *
  * @param pathString - The path string to check.
  * @returns Whether the given path is an existing file.
- */
-async function isFile(pathString) {
+ */ export async function isFile(pathString) {
     try {
-        const stats = await fs_1.promises.stat(pathString);
+        const stats = await fs.stat(pathString);
         return stats.isFile();
-    }
-    catch (error) {
+    } catch (error) {
         return false;
     }
 }
-exports.isFile = isFile;
 /**
  * Reads a `.json` file, parses its contents, and returns them.
  *
  * @param pathString - The path to the JSON file.
  * @returns The parsed contents of the JSON file.
- */
-async function readJsonFile(pathString) {
+ */ export async function readJsonFile(pathString) {
     if (!pathString.endsWith('.json')) {
         throw new Error('The specified file must be a ".json" file.');
     }
     let file;
     try {
-        file = await (0, virtual_file_1.readVirtualFile)(pathString, 'utf8');
-    }
-    catch (error) {
+        file = await readVirtualFile(pathString, 'utf8');
+    } catch (error) {
         if (error.code === 'ENOENT') {
             throw new Error(`Could not find '${pathString}'. Please ensure that the file exists.`);
         }
         throw error;
     }
-    file.result = (0, json_1.parseJson)(file.toString());
+    file.result = parseJson(file.toString());
     return file;
 }
-exports.readJsonFile = readJsonFile;
 /**
  * Gets the complete out file path from an output file name and parent
  * directory path.
@@ -81,11 +68,9 @@ exports.readJsonFile = readJsonFile;
  * @param outDir - The path to the out file's parent directory.
  * @param outFileName - The out file's name.
  * @returns The complete path to the out file.
- */
-function getOutfilePath(outDir, outFileName) {
-    return path_1.default.join(outDir, outFileName || 'bundle.js');
+ */ export function getOutfilePath(outDir, outFileName) {
+    return pathUtils.join(outDir, outFileName || 'bundle.js');
 }
-exports.getOutfilePath = getOutfilePath;
 /**
  * Ensures that the outfile name is just a `.js` file name.
  * Throws on validation failure.
@@ -93,31 +78,25 @@ exports.getOutfilePath = getOutfilePath;
  * @param filename - The file name to validate.
  * @returns `true` if validation succeeded.
  * @throws If the file name is invalid.
- */
-function validateOutfileName(filename) {
-    if (!filename.endsWith('.js') ||
-        filename === '.js' ||
-        path_1.default.basename(filename) !== filename) {
+ */ export function validateOutfileName(filename) {
+    if (!filename.endsWith('.js') || filename === '.js' || pathUtils.basename(filename) !== filename) {
         throw new Error(`Invalid outfile name: ${filename}. Must be a .js file`);
     }
     return true;
 }
-exports.validateOutfileName = validateOutfileName;
 /**
  * Validates a file path. Throws on validation failure.
  *
  * @param filePath - The file path to validate.
  * @returns `true` if validation succeeded.
  * @throws If the path does not resolve to a file.
- */
-async function validateFilePath(filePath) {
+ */ export async function validateFilePath(filePath) {
     const exists = await isFile(filePath);
     if (!exists) {
         throw new Error(`Invalid params: '${filePath}' is not a file or does not exist.`);
     }
     return true;
 }
-exports.validateFilePath = validateFilePath;
 /**
  * Validates a directory path. Throws on validation failure.
  *
@@ -125,15 +104,13 @@ exports.validateFilePath = validateFilePath;
  * @param createDir - Whether to create the directory if it doesn't exist.
  * @returns `true` if validation succeeded or the directory was created.
  * @throws If the directory does not exist or could not be created.
- */
-async function validateDirPath(dirPath, createDir) {
+ */ export async function validateDirPath(dirPath, createDir) {
     const exists = await isDirectory(dirPath, createDir);
     if (!exists) {
         throw new Error(`Invalid params: '${dirPath}' is not a directory or could not be created.`);
     }
     return true;
 }
-exports.validateDirPath = validateDirPath;
 /**
  * Creates a temporary file with a given name and content, writes it to disk and calls the provided function.
  * This function handles deletion of the temporary file after usage.
@@ -141,19 +118,19 @@ exports.validateDirPath = validateDirPath;
  * @param fileName - The name of the temporary file.
  * @param fileContents - The content of the temporary file.
  * @param fn - The callback function to call when the temporary file has been created.
- */
-async function useTemporaryFile(fileName, fileContents, fn) {
-    const filePath = path_1.default.join(os_1.default.tmpdir(), fileName);
-    await fs_1.promises.mkdir(path_1.default.dirname(filePath), { recursive: true });
-    await fs_1.promises.writeFile(filePath, fileContents);
+ */ export async function useTemporaryFile(fileName, fileContents, fn) {
+    const filePath = pathUtils.join(os.tmpdir(), fileName);
+    await fs.mkdir(pathUtils.dirname(filePath), {
+        recursive: true
+    });
+    await fs.writeFile(filePath, fileContents);
     try {
         await fn(filePath);
-    }
-    finally {
+    } finally{
         if (await isFile(filePath)) {
-            await fs_1.promises.unlink(filePath);
+            await fs.unlink(filePath);
         }
     }
 }
-exports.useTemporaryFile = useTemporaryFile;
+
 //# sourceMappingURL=fs.js.map