@metamask/snaps-utils 6.1.0 → 7.0.1

package/dist/cjs/types.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../src/types.ts"],"sourcesContent":["import type { Json } from '@metamask/utils';\nimport { assertStruct, VersionStruct } from '@metamask/utils';\nimport type { Infer, Struct } from 'superstruct';\nimport {\n  instance,\n  is,\n  object,\n  optional,\n  pattern,\n  refine,\n  size,\n  string,\n  type,\n  union,\n  assert as assertSuperstruct,\n} from 'superstruct';\n\nimport type { SnapCaveatType } from './caveats';\nimport type { SnapFunctionExports, SnapRpcHookArgs } from './handlers';\nimport type { LocalizationFile } from './localization';\nimport type { SnapManifest } from './manifest';\nimport type { VirtualFile } from './virtual-file';\n\nexport enum NpmSnapFileNames {\n  PackageJson = 'package.json',\n  Manifest = 'snap.manifest.json',\n}\n\nexport const NameStruct = size(\n  pattern(\n    string(),\n    /^(?:@[a-z0-9-*~][a-z0-9-*._~]*\\/)?[a-z0-9-~][a-z0-9-._~]*$/u,\n  ),\n  1,\n  214,\n);\n\n// Note we use `type` instead of `object` here, because the latter does not\n// allow unknown keys.\nexport const NpmSnapPackageJsonStruct = type({\n  version: VersionStruct,\n  name: NameStruct,\n  main: optional(size(string(), 1, Infinity)),\n  repository: optional(\n    object({\n      type: size(string(), 1, Infinity),\n      url: size(string(), 1, Infinity),\n    }),\n  ),\n});\n\nexport type NpmSnapPackageJson = Infer<typeof NpmSnapPackageJsonStruct> &\n  Record<string, any>;\n\n/**\n * Check if the given value is a valid {@link NpmSnapPackageJson} object.\n *\n * @param value - The value to check.\n * @returns Whether the value is a valid {@link NpmSnapPackageJson} object.\n */\nexport function isNpmSnapPackageJson(\n  value: unknown,\n): value is NpmSnapPackageJson {\n  return is(value, NpmSnapPackageJsonStruct);\n}\n\n/**\n * Asserts that the given value is a valid {@link NpmSnapPackageJson} object.\n *\n * @param value - The value to check.\n * @throws If the value is not a valid {@link NpmSnapPackageJson} object.\n */\nexport function assertIsNpmSnapPackageJson(\n  value: unknown,\n): asserts value is NpmSnapPackageJson {\n  assertStruct(\n    value,\n    NpmSnapPackageJsonStruct,\n    `\"${NpmSnapFileNames.PackageJson}\" is invalid`,\n  );\n}\n\n/**\n * An object for storing parsed but unvalidated Snap file contents.\n */\nexport type UnvalidatedSnapFiles = {\n  manifest?: VirtualFile<Json>;\n  packageJson?: VirtualFile<Json>;\n  sourceCode?: VirtualFile;\n  svgIcon?: VirtualFile;\n  auxiliaryFiles: VirtualFile[];\n  localizationFiles: VirtualFile[];\n};\n\n/**\n * An object for storing the contents of Snap files that have passed JSON\n * Schema validation, or are non-empty if they are strings.\n */\nexport type SnapFiles = {\n  manifest: VirtualFile<SnapManifest>;\n  packageJson: VirtualFile<NpmSnapPackageJson>;\n  sourceCode: VirtualFile;\n  svgIcon?: VirtualFile;\n  auxiliaryFiles: VirtualFile[];\n  localizationFiles: VirtualFile<LocalizationFile>[];\n};\n\n/**\n * A subset of snap files extracted from a fetched snap.\n */\nexport type FetchedSnapFiles = Pick<\n  SnapFiles,\n  'manifest' | 'sourceCode' | 'svgIcon' | 'auxiliaryFiles' | 'localizationFiles'\n>;\n\n/**\n * The possible prefixes for snap ids.\n */\n/* eslint-disable @typescript-eslint/naming-convention */\nexport enum SnapIdPrefixes {\n  npm = 'npm:',\n  local = 'local:',\n}\n/* eslint-enable @typescript-eslint/naming-convention */\n\n/**\n * Snap validation failure reason codes that are programmatically fixable\n * if validation occurs during development.\n */\nexport enum SnapValidationFailureReason {\n  NameMismatch = '\"name\" field mismatch',\n  VersionMismatch = '\"version\" field mismatch',\n  RepositoryMismatch = '\"repository\" field mismatch',\n  ShasumMismatch = '\"shasum\" field mismatch',\n}\n\n/* eslint-disable @typescript-eslint/naming-convention */\nexport enum SNAP_STREAM_NAMES {\n  JSON_RPC = 'jsonRpc',\n  COMMAND = 'command',\n}\n/* eslint-enable @typescript-eslint/naming-convention */\n\n// The snap is the callee\nexport type SnapRpcHook = (options: SnapRpcHookArgs) => Promise<unknown>;\n\ntype ObjectParameters<\n  Type extends Record<string, (...args: any[]) => unknown>,\n> = Parameters<Type[keyof Type]>;\n\nexport type SnapExportsParameters = ObjectParameters<SnapFunctionExports>;\n\ntype UriOptions<Type extends string> = {\n  protocol?: Struct<Type>;\n  hash?: Struct<Type>;\n  port?: Struct<Type>;\n  hostname?: Struct<Type>;\n  pathname?: Struct<Type>;\n  search?: Struct<Type>;\n};\n\nexport const uri = (opts: UriOptions<any> = {}) =>\n  refine(union([string(), instance(URL)]), 'uri', (value) => {\n    try {\n      const url = new URL(value);\n\n      const UrlStruct = type(opts);\n      assertSuperstruct(url, UrlStruct);\n      return true;\n    } catch {\n      return `Expected URL, got \"${value.toString()}\".`;\n    }\n  });\n\n/**\n * Returns whether a given value is a valid URL.\n *\n * @param url - The value to check.\n * @param opts - Optional constraints for url checking.\n * @returns Whether `url` is valid URL or not.\n */\nexport function isValidUrl(\n  url: unknown,\n  opts: UriOptions<any> = {},\n): url is string | URL {\n  return is(url, uri(opts));\n}\n\n// redefining here to avoid circular dependency\nexport const WALLET_SNAP_PERMISSION_KEY = 'wallet_snap';\n\nexport type SnapsPermissionRequest = {\n  [WALLET_SNAP_PERMISSION_KEY]: {\n    caveats: [\n      {\n        type: SnapCaveatType.SnapIds;\n        value: Record<string, Json>;\n      },\n    ];\n  };\n};\n"],"names":["NameStruct","NpmSnapPackageJsonStruct","isNpmSnapPackageJson","assertIsNpmSnapPackageJson","uri","isValidUrl","WALLET_SNAP_PERMISSION_KEY","NpmSnapFileNames","PackageJson","Manifest","size","pattern","string","type","version","VersionStruct","name","main","optional","Infinity","repository","object","url","value","is","assertStruct","SnapIdPrefixes","npm","local","SnapValidationFailureReason","NameMismatch","VersionMismatch","RepositoryMismatch","ShasumMismatch","SNAP_STREAM_NAMES","JSON_RPC","COMMAND","opts","refine","union","instance","URL","UrlStruct","assertSuperstruct","toString"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;IA4BaA,UAAU;eAAVA;;IAWAC,wBAAwB;eAAxBA;;IAqBGC,oBAAoB;eAApBA;;IAYAC,0BAA0B;eAA1BA;;IAyFHC,GAAG;eAAHA;;IAoBGC,UAAU;eAAVA;;IAQHC,0BAA0B;eAA1BA;;;uBA5L+B;6BAcrC;IAQA;UAAKC,gBAAgB;IAAhBA,iBACVC,iBAAc;IADJD,iBAEVE,cAAW;GAFDF,qBAAAA;AAKL,MAAMP,aAAaU,IAAAA,iBAAI,EAC5BC,IAAAA,oBAAO,EACLC,IAAAA,mBAAM,KACN,gEAEF,GACA;AAKK,MAAMX,2BAA2BY,IAAAA,iBAAI,EAAC;IAC3CC,SAASC,oBAAa;IACtBC,MAAMhB;IACNiB,MAAMC,IAAAA,qBAAQ,EAACR,IAAAA,iBAAI,EAACE,IAAAA,mBAAM,KAAI,GAAGO;IACjCC,YAAYF,IAAAA,qBAAQ,EAClBG,IAAAA,mBAAM,EAAC;QACLR,MAAMH,IAAAA,iBAAI,EAACE,IAAAA,mBAAM,KAAI,GAAGO;QACxBG,KAAKZ,IAAAA,iBAAI,EAACE,IAAAA,mBAAM,KAAI,GAAGO;IACzB;AAEJ;AAWO,SAASjB,qBACdqB,KAAc;IAEd,OAAOC,IAAAA,eAAE,EAACD,OAAOtB;AACnB;AAQO,SAASE,2BACdoB,KAAc;IAEdE,IAAAA,mBAAY,EACVF,OACAtB,0BACA,CAAC,CAAC,EAAEM,iBAAiBC,WAAW,CAAC,YAAY,CAAC;AAElD;IAuCO;UAAKkB,cAAc;IAAdA,eACVC,SAAM;IADID,eAEVE,WAAQ;GAFEF,mBAAAA;IAUL;UAAKG,2BAA2B;IAA3BA,4BACVC,kBAAe;IADLD,4BAEVE,qBAAkB;IAFRF,4BAGVG,wBAAqB;IAHXH,4BAIVI,oBAAiB;GAJPJ,gCAAAA;IAQL;UAAKK,iBAAiB;IAAjBA,kBACVC,cAAW;IADDD,kBAEVE,aAAU;GAFAF,sBAAAA;AAwBL,MAAM9B,MAAM,CAACiC,OAAwB,CAAC,CAAC,GAC5CC,IAAAA,mBAAM,EAACC,IAAAA,kBAAK,EAAC;QAAC3B,IAAAA,mBAAM;QAAI4B,IAAAA,qBAAQ,EAACC;KAAK,GAAG,OAAO,CAAClB;QAC/C,IAAI;YACF,MAAMD,MAAM,IAAImB,IAAIlB;YAEpB,MAAMmB,YAAY7B,IAAAA,iBAAI,EAACwB;YACvBM,IAAAA,mBAAiB,EAACrB,KAAKoB;YACvB,OAAO;QACT,EAAE,OAAM;YACN,OAAO,CAAC,mBAAmB,EAAEnB,MAAMqB,QAAQ,GAAG,EAAE,CAAC;QACnD;IACF;AASK,SAASvC,WACdiB,GAAY,EACZe,OAAwB,CAAC,CAAC;IAE1B,OAAOb,IAAAA,eAAE,EAACF,KAAKlB,IAAIiC;AACrB;AAGO,MAAM/B,6BAA6B"}

package/dist/cjs/ui.js

@@ -1,53 +0,0 @@
-"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, {
-    validateTextLinks: function() {
-        return validateTextLinks;
-    },
-    validateComponentLinks: function() {
-        return validateComponentLinks;
-    }
-});
-const _snapssdk = require("@metamask/snaps-sdk");
-const _utils = require("@metamask/utils");
-const MARKDOWN_LINK_REGEX = RegExp("\\[(?<name>[^\\]]*)\\]\\((?<url>[^)]+)\\)", "giu");
-const ALLOWED_PROTOCOLS = [
-    'https:',
-    'mailto:'
-];
-function validateTextLinks(text, isOnPhishingList) {
-    const matches = String.prototype.matchAll.call(text, MARKDOWN_LINK_REGEX);
-    for (const { groups } of matches){
-        const link = groups?.url;
-        /* This case should never happen with the regex but the TS type allows for undefined */ /* istanbul ignore next */ if (!link) {
-            continue;
-        }
-        try {
-            const url = new URL(link);
-            (0, _utils.assert)(ALLOWED_PROTOCOLS.includes(url.protocol), `Protocol must be one of: ${ALLOWED_PROTOCOLS.join(', ')}.`);
-            const hostname = url.protocol === 'mailto:' ? url.pathname.split('@')[1] : url.hostname;
-            (0, _utils.assert)(!isOnPhishingList(hostname), 'The specified URL is not allowed.');
-        } catch (error) {
-            throw new Error(`Invalid URL: ${error instanceof _utils.AssertionError ? error.message : 'Unable to parse URL.'}`);
-        }
-    }
-}
-function validateComponentLinks(component, isOnPhishingList) {
-    const { type } = component;
-    if (type === _snapssdk.NodeType.Panel) {
-        component.children.forEach((node)=>validateComponentLinks(node, isOnPhishingList));
-    }
-    if (type === _snapssdk.NodeType.Text) {
-        validateTextLinks(component.value, isOnPhishingList);
-    }
-}
-
-//# sourceMappingURL=ui.js.map

package/dist/cjs/ui.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../src/ui.ts"],"sourcesContent":["import type { Component } from '@metamask/snaps-sdk';\nimport { NodeType } from '@metamask/snaps-sdk';\nimport { assert, AssertionError } from '@metamask/utils';\n\nconst MARKDOWN_LINK_REGEX = /\\[(?<name>[^\\]]*)\\]\\((?<url>[^)]+)\\)/giu;\n\nconst ALLOWED_PROTOCOLS = ['https:', 'mailto:'];\n\n/**\n * Searches for markdown links in a string and checks them against the phishing list.\n *\n * @param text - The text to verify.\n * @param isOnPhishingList - The function that checks the link against the\n * phishing list.\n * @throws If the text contains a link that is not allowed.\n */\nexport function validateTextLinks(\n  text: string,\n  isOnPhishingList: (url: string) => boolean,\n) {\n  const matches = String.prototype.matchAll.call(text, MARKDOWN_LINK_REGEX);\n\n  for (const { groups } of matches) {\n    const link = groups?.url;\n\n    /* This case should never happen with the regex but the TS type allows for undefined */\n    /* istanbul ignore next */\n    if (!link) {\n      continue;\n    }\n\n    try {\n      const url = new URL(link);\n      assert(\n        ALLOWED_PROTOCOLS.includes(url.protocol),\n        `Protocol must be one of: ${ALLOWED_PROTOCOLS.join(', ')}.`,\n      );\n\n      const hostname =\n        url.protocol === 'mailto:' ? url.pathname.split('@')[1] : url.hostname;\n\n      assert(!isOnPhishingList(hostname), 'The specified URL is not allowed.');\n    } catch (error) {\n      throw new Error(\n        `Invalid URL: ${\n          error instanceof AssertionError\n            ? error.message\n            : 'Unable to parse URL.'\n        }`,\n      );\n    }\n  }\n}\n\n/**\n * Search for links in UI components and check that the URL they are trying to\n * pass in is not in the phishing list.\n *\n * @param component - The custom UI component.\n * @param isOnPhishingList - The function that checks the link against the\n * phishing list.\n * @throws If the component contains a link that is not allowed.\n */\nexport function validateComponentLinks(\n  component: Component,\n  isOnPhishingList: (url: string) => boolean,\n) {\n  const { type } = component;\n  if (type === NodeType.Panel) {\n    component.children.forEach((node) =>\n      validateComponentLinks(node, isOnPhishingList),\n    );\n  }\n\n  if (type === NodeType.Text) {\n    validateTextLinks(component.value, isOnPhishingList);\n  }\n}\n"],"names":["validateTextLinks","validateComponentLinks","MARKDOWN_LINK_REGEX","ALLOWED_PROTOCOLS","text","isOnPhishingList","matches","String","prototype","matchAll","call","groups","link","url","URL","assert","includes","protocol","join","hostname","pathname","split","error","Error","AssertionError","message","component","type","NodeType","Panel","children","forEach","node","Text","value"],"mappings":";;;;;;;;;;;IAgBgBA,iBAAiB;eAAjBA;;IA+CAC,sBAAsB;eAAtBA;;;0BA9DS;uBACc;AAEvC,MAAMC,sBAAsB;AAE5B,MAAMC,oBAAoB;IAAC;IAAU;CAAU;AAUxC,SAASH,kBACdI,IAAY,EACZC,gBAA0C;IAE1C,MAAMC,UAAUC,OAAOC,SAAS,CAACC,QAAQ,CAACC,IAAI,CAACN,MAAMF;IAErD,KAAK,MAAM,EAAES,MAAM,EAAE,IAAIL,QAAS;QAChC,MAAMM,OAAOD,QAAQE;QAErB,qFAAqF,GACrF,wBAAwB,GACxB,IAAI,CAACD,MAAM;YACT;QACF;QAEA,IAAI;YACF,MAAMC,MAAM,IAAIC,IAAIF;YACpBG,IAAAA,aAAM,EACJZ,kBAAkBa,QAAQ,CAACH,IAAII,QAAQ,GACvC,CAAC,yBAAyB,EAAEd,kBAAkBe,IAAI,CAAC,MAAM,CAAC,CAAC;YAG7D,MAAMC,WACJN,IAAII,QAAQ,KAAK,YAAYJ,IAAIO,QAAQ,CAACC,KAAK,CAAC,IAAI,CAAC,EAAE,GAAGR,IAAIM,QAAQ;YAExEJ,IAAAA,aAAM,EAAC,CAACV,iBAAiBc,WAAW;QACtC,EAAE,OAAOG,OAAO;YACd,MAAM,IAAIC,MACR,CAAC,aAAa,EACZD,iBAAiBE,qBAAc,GAC3BF,MAAMG,OAAO,GACb,uBACL,CAAC;QAEN;IACF;AACF;AAWO,SAASxB,uBACdyB,SAAoB,EACpBrB,gBAA0C;IAE1C,MAAM,EAAEsB,IAAI,EAAE,GAAGD;IACjB,IAAIC,SAASC,kBAAQ,CAACC,KAAK,EAAE;QAC3BH,UAAUI,QAAQ,CAACC,OAAO,CAAC,CAACC,OAC1B/B,uBAAuB+B,MAAM3B;IAEjC;IAEA,IAAIsB,SAASC,kBAAQ,CAACK,IAAI,EAAE;QAC1BjC,kBAAkB0B,UAAUQ,KAAK,EAAE7B;IACrC;AACF"}

package/dist/cjs/validation.js

@@ -1,24 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-Object.defineProperty(exports, "validateFetchedSnap", {
-    enumerable: true,
-    get: function() {
-        return validateFetchedSnap;
-    }
-});
-const _icon = require("./icon");
-const _localization = require("./localization");
-const _validation = require("./manifest/validation");
-const _snaps = require("./snaps");
-async function validateFetchedSnap(files) {
-    (0, _validation.assertIsSnapManifest)(files.manifest.result);
-    await (0, _snaps.validateSnapShasum)(files);
-    (0, _localization.validateSnapManifestLocalizations)(files.manifest.result, files.localizationFiles.map((file)=>file.result));
-    if (files.svgIcon) {
-        (0, _icon.assertIsSnapIcon)(files.svgIcon);
-    }
-}
-
-//# sourceMappingURL=validation.js.map

package/dist/cjs/validation.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../src/validation.ts"],"sourcesContent":["import { assertIsSnapIcon } from './icon';\nimport { validateSnapManifestLocalizations } from './localization';\nimport { assertIsSnapManifest } from './manifest/validation';\nimport { validateSnapShasum } from './snaps';\nimport type { FetchedSnapFiles } from './types';\n\n/**\n * Validates the files contained in a fetched snap.\n *\n * @param files - All potentially included files in a fetched snap.\n * @throws If any of the files are considered invalid.\n */\nexport async function validateFetchedSnap(\n  files: FetchedSnapFiles,\n): Promise<void> {\n  assertIsSnapManifest(files.manifest.result);\n  await validateSnapShasum(files);\n  validateSnapManifestLocalizations(\n    files.manifest.result,\n    files.localizationFiles.map((file) => file.result),\n  );\n\n  if (files.svgIcon) {\n    assertIsSnapIcon(files.svgIcon);\n  }\n}\n"],"names":["validateFetchedSnap","files","assertIsSnapManifest","manifest","result","validateSnapShasum","validateSnapManifestLocalizations","localizationFiles","map","file","svgIcon","assertIsSnapIcon"],"mappings":";;;;+BAYsBA;;;eAAAA;;;sBAZW;8BACiB;4BACb;uBACF;AAS5B,eAAeA,oBACpBC,KAAuB;IAEvBC,IAAAA,gCAAoB,EAACD,MAAME,QAAQ,CAACC,MAAM;IAC1C,MAAMC,IAAAA,yBAAkB,EAACJ;IACzBK,IAAAA,+CAAiC,EAC/BL,MAAME,QAAQ,CAACC,MAAM,EACrBH,MAAMM,iBAAiB,CAACC,GAAG,CAAC,CAACC,OAASA,KAAKL,MAAM;IAGnD,IAAIH,MAAMS,OAAO,EAAE;QACjBC,IAAAA,sBAAgB,EAACV,MAAMS,OAAO;IAChC;AACF"}

package/dist/cjs/versions.js

@@ -1,47 +0,0 @@
-"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, {
-    DEFAULT_REQUESTED_SNAP_VERSION: function() {
-        return DEFAULT_REQUESTED_SNAP_VERSION;
-    },
-    getTargetVersion: function() {
-        return getTargetVersion;
-    },
-    resolveVersionRange: function() {
-        return resolveVersionRange;
-    }
-});
-const _utils = require("@metamask/utils");
-const _semver = require("semver");
-const _superstruct = require("superstruct");
-const DEFAULT_REQUESTED_SNAP_VERSION = '*';
-function getTargetVersion(versions, versionRange) {
-    const maxSatisfyingNonPreRelease = (0, _semver.maxSatisfying)(versions, versionRange);
-    // By default don't use pre-release versions
-    if (maxSatisfyingNonPreRelease) {
-        return maxSatisfyingNonPreRelease;
-    }
-    // If no satisfying release version is found by default, try pre-release versions
-    return (0, _semver.maxSatisfying)(versions, versionRange, {
-        includePrerelease: true
-    });
-}
-function resolveVersionRange(version) {
-    if (version === undefined || version === 'latest') {
-        return [
-            undefined,
-            DEFAULT_REQUESTED_SNAP_VERSION
-        ];
-    }
-    return (0, _superstruct.validate)(version, _utils.VersionRangeStruct);
-}
-
-//# sourceMappingURL=versions.js.map

package/dist/cjs/versions.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../src/versions.ts"],"sourcesContent":["import type { Json, SemVerVersion, SemVerRange } from '@metamask/utils';\nimport { VersionRangeStruct } from '@metamask/utils';\nimport { maxSatisfying as maxSatisfyingSemver } from 'semver';\nimport { validate } from 'superstruct';\n\nexport const DEFAULT_REQUESTED_SNAP_VERSION = '*' as SemVerRange;\n\n/**\n * Return the highest version in the list that satisfies the range, or `null` if\n * none of them do. For the satisfaction check, pre-release versions will only\n * be checked if no satisfactory non-prerelease version is found first.\n *\n * @param versions - The list of version to check.\n * @param versionRange - The SemVer version range to check against.\n * @returns The highest version in the list that satisfies the range,\n * or `null` if none of them do.\n */\nexport function getTargetVersion(\n  versions: SemVerVersion[],\n  versionRange: SemVerRange,\n): SemVerVersion | null {\n  const maxSatisfyingNonPreRelease = maxSatisfyingSemver(\n    versions,\n    versionRange,\n  );\n\n  // By default don't use pre-release versions\n  if (maxSatisfyingNonPreRelease) {\n    return maxSatisfyingNonPreRelease;\n  }\n\n  // If no satisfying release version is found by default, try pre-release versions\n  return maxSatisfyingSemver(versions, versionRange, {\n    includePrerelease: true,\n  });\n}\n\n/**\n * Parse a version received by some subject attempting to access a snap.\n *\n * @param version - The received version value.\n * @returns `*` if the version is `undefined` or `latest\", otherwise returns\n * the specified version.\n */\nexport function resolveVersionRange(\n  version?: Json,\n): [error: undefined, range: SemVerRange] | [error: Error, range: undefined] {\n  if (version === undefined || version === 'latest') {\n    return [undefined, DEFAULT_REQUESTED_SNAP_VERSION];\n  }\n  return validate(version, VersionRangeStruct);\n}\n"],"names":["DEFAULT_REQUESTED_SNAP_VERSION","getTargetVersion","resolveVersionRange","versions","versionRange","maxSatisfyingNonPreRelease","maxSatisfyingSemver","includePrerelease","version","undefined","validate","VersionRangeStruct"],"mappings":";;;;;;;;;;;IAKaA,8BAA8B;eAA9BA;;IAYGC,gBAAgB;eAAhBA;;IA2BAC,mBAAmB;eAAnBA;;;uBA3CmB;wBACkB;6BAC5B;AAElB,MAAMF,iCAAiC;AAYvC,SAASC,iBACdE,QAAyB,EACzBC,YAAyB;IAEzB,MAAMC,6BAA6BC,IAAAA,qBAAmB,EACpDH,UACAC;IAGF,4CAA4C;IAC5C,IAAIC,4BAA4B;QAC9B,OAAOA;IACT;IAEA,iFAAiF;IACjF,OAAOC,IAAAA,qBAAmB,EAACH,UAAUC,cAAc;QACjDG,mBAAmB;IACrB;AACF;AASO,SAASL,oBACdM,OAAc;IAEd,IAAIA,YAAYC,aAAaD,YAAY,UAAU;QACjD,OAAO;YAACC;YAAWT;SAA+B;IACpD;IACA,OAAOU,IAAAA,qBAAQ,EAACF,SAASG,yBAAkB;AAC7C"}

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

@@ -1,92 +0,0 @@
-// TODO(ritave): Move into separate package @metamask/vfile / @metamask/utils + @metamask/to-vfile when passes code review
-// TODO(ritave): Streaming vfile contents similar to vinyl maybe?
-// TODO(ritave): Move fixing manifest in cli and bundler plugins to write messages to vfile
-//               similar to unified instead of throwing "ProgrammaticallyFixableErrors".
-//
-// Using https://github.com/vfile/vfile would be helpful, but they only support ESM and we need to support CommonJS.
-// https://github.com/gulpjs/vinyl is also good, but they normalize paths, which we can't do, because
-// we're calculating checksums based on original path.
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-Object.defineProperty(exports, "VirtualFile", {
-    enumerable: true,
-    get: function() {
-        return VirtualFile;
-    }
-});
-const _utils = require("@metamask/utils");
-const _base = require("@scure/base");
-const _deepclone = require("../deep-clone");
-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;
-}
-class VirtualFile {
-    toString(encoding) {
-        if (typeof this.value === 'string') {
-            (0, _utils.assert)(encoding === undefined, 'Tried to encode string.');
-            return this.value;
-        } else if (this.value instanceof Uint8Array && encoding === 'hex') {
-            return (0, _utils.bytesToHex)(this.value);
-        } else if (this.value instanceof Uint8Array && encoding === 'base64') {
-            // For large files, this is quite slow, instead use `encodeBase64()`
-            // TODO: Use @metamask/utils for this
-            return _base.base64.encode(this.value);
-        }
-        const decoder = new TextDecoder(encoding);
-        return decoder.decode(this.value);
-    }
-    clone() {
-        const vfile = new VirtualFile();
-        if (typeof this.value === 'string') {
-            vfile.value = this.value;
-        } else {
-            // deep-clone doesn't clone Buffer properly, even if it's a sub-class of Uint8Array
-            vfile.value = this.value.slice(0);
-        }
-        vfile.result = (0, _deepclone.deepClone)(this.result);
-        vfile.data = (0, _deepclone.deepClone)(this.data);
-        vfile.path = this.path;
-        return vfile;
-    }
-    constructor(value){
-        _define_property(this, "value", void 0);
-        _define_property(this, "result", void 0);
-        _define_property(this, "data", void 0);
-        _define_property(this, "path", void 0);
-        let options;
-        if (typeof value === 'string' || value instanceof Uint8Array) {
-            options = {
-                value
-            };
-        } else {
-            options = value;
-        }
-        this.value = options?.value ?? '';
-        // This situations happens when there's no .result used,
-        // we expect the file to have default generic in that situation:
-        // VirtualFile<unknown> which will handle undefined properly
-        //
-        // While not 100% type safe, it'll be way less frustrating to work with.
-        // The alternative would be to have VirtualFile.result be Result | undefined
-        // and that would result in needing to branch out and check in all situations.
-        //
-        // In short, optimizing for most common use case.
-        this.result = options?.result ?? undefined;
-        this.data = options?.data ?? {};
-        this.path = options?.path ?? '/';
-    }
-}
-
-//# sourceMappingURL=VirtualFile.js.map

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

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../src/virtual-file/VirtualFile.ts"],"sourcesContent":["// TODO(ritave): Move into separate package @metamask/vfile / @metamask/utils + @metamask/to-vfile when passes code review\n// TODO(ritave): Streaming vfile contents similar to vinyl maybe?\n// TODO(ritave): Move fixing manifest in cli and bundler plugins to write messages to vfile\n//               similar to unified instead of throwing \"ProgrammaticallyFixableErrors\".\n//\n// Using https://github.com/vfile/vfile would be helpful, but they only support ESM and we need to support CommonJS.\n// https://github.com/gulpjs/vinyl is also good, but they normalize paths, which we can't do, because\n// we're calculating checksums based on original path.\nimport { assert, bytesToHex } from '@metamask/utils';\nimport { base64 } from '@scure/base';\n\nimport { deepClone } from '../deep-clone';\n\n/**\n * This map registers the type of the {@link VirtualFile.data} key of a {@link VirtualFile}.\n *\n * This type can be augmented to register custom `data` types.\n *\n * @example\n * declare module '@metamask/snaps-utils' {\n *   interface DataMap {\n *     // `file.data.name` is typed as `string`\n *     name: string\n *   }\n * }\n */\n// eslint-disable-next-line @typescript-eslint/consistent-type-definitions, @typescript-eslint/no-empty-interface\nexport interface DataMap {}\n\nexport type Value = string | Uint8Array;\nexport type Compatible<Result = unknown> =\n  | string\n  | Uint8Array\n  | Options<Result>;\nexport type Data = Record<string, unknown> & Partial<DataMap>;\nexport type Options<Result = unknown> = {\n  value: Value;\n  path?: string;\n  data?: Data;\n  result?: Result;\n};\n\nexport class VirtualFile<Result = unknown> {\n  constructor(value?: Compatible<Result>) {\n    let options: Options | undefined;\n    if (typeof value === 'string' || value instanceof Uint8Array) {\n      options = { value };\n    } else {\n      options = value;\n    }\n\n    this.value = options?.value ?? '';\n    // This situations happens when there's no .result used,\n    // we expect the file to have default generic in that situation:\n    // VirtualFile<unknown> which will handle undefined properly\n    //\n    // While not 100% type safe, it'll be way less frustrating to work with.\n    // The alternative would be to have VirtualFile.result be Result | undefined\n    // and that would result in needing to branch out and check in all situations.\n    //\n    // In short, optimizing for most common use case.\n    this.result = options?.result ?? (undefined as any);\n    this.data = options?.data ?? {};\n    this.path = options?.path ?? '/';\n  }\n\n  value: Value;\n\n  result: Result;\n\n  data: Data;\n\n  path: string;\n\n  toString(encoding?: string) {\n    if (typeof this.value === 'string') {\n      assert(encoding === undefined, 'Tried to encode string.');\n      return this.value;\n    } else if (this.value instanceof Uint8Array && encoding === 'hex') {\n      return bytesToHex(this.value);\n    } else if (this.value instanceof Uint8Array && encoding === 'base64') {\n      // For large files, this is quite slow, instead use `encodeBase64()`\n      // TODO: Use @metamask/utils for this\n      return base64.encode(this.value);\n    }\n    const decoder = new TextDecoder(encoding);\n    return decoder.decode(this.value);\n  }\n\n  clone() {\n    const vfile = new VirtualFile<Result>();\n    if (typeof this.value === 'string') {\n      vfile.value = this.value;\n    } else {\n      // deep-clone doesn't clone Buffer properly, even if it's a sub-class of Uint8Array\n      vfile.value = this.value.slice(0);\n    }\n    vfile.result = deepClone(this.result);\n    vfile.data = deepClone(this.data);\n    vfile.path = this.path;\n    return vfile;\n  }\n}\n"],"names":["VirtualFile","toString","encoding","value","assert","undefined","Uint8Array","bytesToHex","base64","encode","decoder","TextDecoder","decode","clone","vfile","slice","result","deepClone","data","path","constructor","options"],"mappings":"AAAA,0HAA0H;AAC1H,iEAAiE;AACjE,2FAA2F;AAC3F,wFAAwF;AACxF,EAAE;AACF,oHAAoH;AACpH,qGAAqG;AACrG,sDAAsD;;;;;+BAmCzCA;;;eAAAA;;;uBAlCsB;sBACZ;2BAEG;;;;;;;;;;;;;;AA+BnB,MAAMA;IAgCXC,SAASC,QAAiB,EAAE;QAC1B,IAAI,OAAO,IAAI,CAACC,KAAK,KAAK,UAAU;YAClCC,IAAAA,aAAM,EAACF,aAAaG,WAAW;YAC/B,OAAO,IAAI,CAACF,KAAK;QACnB,OAAO,IAAI,IAAI,CAACA,KAAK,YAAYG,cAAcJ,aAAa,OAAO;YACjE,OAAOK,IAAAA,iBAAU,EAAC,IAAI,CAACJ,KAAK;QAC9B,OAAO,IAAI,IAAI,CAACA,KAAK,YAAYG,cAAcJ,aAAa,UAAU;YACpE,oEAAoE;YACpE,qCAAqC;YACrC,OAAOM,YAAM,CAACC,MAAM,CAAC,IAAI,CAACN,KAAK;QACjC;QACA,MAAMO,UAAU,IAAIC,YAAYT;QAChC,OAAOQ,QAAQE,MAAM,CAAC,IAAI,CAACT,KAAK;IAClC;IAEAU,QAAQ;QACN,MAAMC,QAAQ,IAAId;QAClB,IAAI,OAAO,IAAI,CAACG,KAAK,KAAK,UAAU;YAClCW,MAAMX,KAAK,GAAG,IAAI,CAACA,KAAK;QAC1B,OAAO;YACL,mFAAmF;YACnFW,MAAMX,KAAK,GAAG,IAAI,CAACA,KAAK,CAACY,KAAK,CAAC;QACjC;QACAD,MAAME,MAAM,GAAGC,IAAAA,oBAAS,EAAC,IAAI,CAACD,MAAM;QACpCF,MAAMI,IAAI,GAAGD,IAAAA,oBAAS,EAAC,IAAI,CAACC,IAAI;QAChCJ,MAAMK,IAAI,GAAG,IAAI,CAACA,IAAI;QACtB,OAAOL;IACT;IA1DAM,YAAYjB,KAA0B,CAAE;QAuBxCA,uBAAAA,SAAAA,KAAAA;QAEAa,uBAAAA,UAAAA,KAAAA;QAEAE,uBAAAA,QAAAA,KAAAA;QAEAC,uBAAAA,QAAAA,KAAAA;QA5BE,IAAIE;QACJ,IAAI,OAAOlB,UAAU,YAAYA,iBAAiBG,YAAY;YAC5De,UAAU;gBAAElB;YAAM;QACpB,OAAO;YACLkB,UAAUlB;QACZ;QAEA,IAAI,CAACA,KAAK,GAAGkB,SAASlB,SAAS;QAC/B,wDAAwD;QACxD,gEAAgE;QAChE,4DAA4D;QAC5D,EAAE;QACF,wEAAwE;QACxE,4EAA4E;QAC5E,8EAA8E;QAC9E,EAAE;QACF,iDAAiD;QACjD,IAAI,CAACa,MAAM,GAAGK,SAASL,UAAWX;QAClC,IAAI,CAACa,IAAI,GAAGG,SAASH,QAAQ,CAAC;QAC9B,IAAI,CAACC,IAAI,GAAGE,SAASF,QAAQ;IAC/B;AAsCF"}

package/dist/cjs/virtual-file/index.browser.js

@@ -1,20 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-_export_star(require("./VirtualFile"), exports);
-function _export_star(from, to) {
-    Object.keys(from).forEach(function(k) {
-        if (k !== "default" && !Object.prototype.hasOwnProperty.call(to, k)) {
-            Object.defineProperty(to, k, {
-                enumerable: true,
-                get: function() {
-                    return from[k];
-                }
-            });
-        }
-    });
-    return from;
-}
-
-//# sourceMappingURL=index.browser.js.map

package/dist/cjs/virtual-file/index.browser.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../src/virtual-file/index.browser.ts"],"sourcesContent":["export * from './VirtualFile';\n"],"names":[],"mappings":";;;;qBAAc"}

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

@@ -1,21 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-_export_star(require("./toVirtualFile"), exports);
-_export_star(require("./VirtualFile"), exports);
-function _export_star(from, to) {
-    Object.keys(from).forEach(function(k) {
-        if (k !== "default" && !Object.prototype.hasOwnProperty.call(to, k)) {
-            Object.defineProperty(to, k, {
-                enumerable: true,
-                get: function() {
-                    return from[k];
-                }
-            });
-        }
-    });
-    return from;
-}
-
-//# sourceMappingURL=index.js.map

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

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../src/virtual-file/index.ts"],"sourcesContent":["export * from './toVirtualFile';\nexport * from './VirtualFile';\n"],"names":[],"mappings":";;;;qBAAc;qBACA"}

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

@@ -1,33 +0,0 @@
-"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

@@ -1 +0,0 @@
-{"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/esm/array.js

@@ -1,13 +0,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
- * element in `a` is equal to (`===`) the corresponding element in `b`.
- *
- * @param a - The first array to compare.
- * @param b - The second array to compare.
- * @returns `true` if the arrays are equal, `false` otherwise.
- */ export function isEqual(a, b) {
-    return a.length === b.length && a.every((value, index)=>value === b[index]);
-}
-
-//# sourceMappingURL=array.js.map

package/dist/esm/array.js.map

@@ -1 +0,0 @@
-{"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/auxiliary-files.js

@@ -1,23 +0,0 @@
-import { AuxiliaryFileEncoding } from '@metamask/snaps-sdk';
-import { bytesToHex, bytesToString } from '@metamask/utils';
-import { decodeBase64 } from './base64';
-/**
- * Re-encodes an auxiliary file if needed depending on the requested file encoding.
- *
- * @param value - The base64 value stored for the auxiliary file.
- * @param encoding - The chosen encoding.
- * @returns The file encoded in the requested encoding.
- */ export async function encodeAuxiliaryFile(value, encoding) {
-    // Input is assumed to be the stored file in base64.
-    if (encoding === AuxiliaryFileEncoding.Base64) {
-        return value;
-    }
-    // TODO: Use @metamask/utils for this
-    const decoded = await decodeBase64(value);
-    if (encoding === AuxiliaryFileEncoding.Utf8) {
-        return bytesToString(decoded);
-    }
-    return bytesToHex(decoded);
-}
-
-//# sourceMappingURL=auxiliary-files.js.map

package/dist/esm/auxiliary-files.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../src/auxiliary-files.ts"],"sourcesContent":["import { AuxiliaryFileEncoding } from '@metamask/snaps-sdk';\nimport { bytesToHex, bytesToString } from '@metamask/utils';\n\nimport { decodeBase64 } from './base64';\n\n/**\n * Re-encodes an auxiliary file if needed depending on the requested file encoding.\n *\n * @param value - The base64 value stored for the auxiliary file.\n * @param encoding - The chosen encoding.\n * @returns The file encoded in the requested encoding.\n */\nexport async function encodeAuxiliaryFile(\n  value: string,\n  encoding: AuxiliaryFileEncoding,\n) {\n  // Input is assumed to be the stored file in base64.\n  if (encoding === AuxiliaryFileEncoding.Base64) {\n    return value;\n  }\n\n  // TODO: Use @metamask/utils for this\n  const decoded = await decodeBase64(value);\n  if (encoding === AuxiliaryFileEncoding.Utf8) {\n    return bytesToString(decoded);\n  }\n\n  return bytesToHex(decoded);\n}\n"],"names":["AuxiliaryFileEncoding","bytesToHex","bytesToString","decodeBase64","encodeAuxiliaryFile","value","encoding","Base64","decoded","Utf8"],"mappings":"AAAA,SAASA,qBAAqB,QAAQ,sBAAsB;AAC5D,SAASC,UAAU,EAAEC,aAAa,QAAQ,kBAAkB;AAE5D,SAASC,YAAY,QAAQ,WAAW;AAExC;;;;;;CAMC,GACD,OAAO,eAAeC,oBACpBC,KAAa,EACbC,QAA+B;IAE/B,oDAAoD;IACpD,IAAIA,aAAaN,sBAAsBO,MAAM,EAAE;QAC7C,OAAOF;IACT;IAEA,qCAAqC;IACrC,MAAMG,UAAU,MAAML,aAAaE;IACnC,IAAIC,aAAaN,sBAAsBS,IAAI,EAAE;QAC3C,OAAOP,cAAcM;IACvB;IAEA,OAAOP,WAAWO;AACpB"}

package/dist/esm/base64.js

@@ -1,36 +0,0 @@
-import { bytesToBase64 } from '@metamask/utils';
-import { getBytes } from './bytes';
-/**
- * Provides fast, asynchronous base64 encoding.
- *
- * @param input - The input value, assumed to be coercable to bytes.
- * @returns A base64 string.
- */ export async function encodeBase64(input) {
-    const bytes = getBytes(input);
-    // In the browser, FileReader is much faster than bytesToBase64.
-    if ('FileReader' in globalThis) {
-        return await new Promise((resolve, reject)=>{
-            const reader = Object.assign(new FileReader(), {
-                onload: ()=>resolve(reader.result.replace('data:application/octet-stream;base64,', '')),
-                onerror: ()=>reject(reader.error)
-            });
-            reader.readAsDataURL(new File([
-                bytes
-            ], '', {
-                type: 'application/octet-stream'
-            }));
-        });
-    }
-    return bytesToBase64(bytes);
-}
-/**
- * Provides fast, asynchronous base64 decoding.
- *
- * @param base64 - A base64 string.
- * @returns A Uint8Array of bytes.
- */ export async function decodeBase64(base64) {
-    const response = await fetch(`data:application/octet-stream;base64,${base64}`);
-    return new Uint8Array(await response.arrayBuffer());
-}
-
-//# sourceMappingURL=base64.js.map

package/dist/esm/base64.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../src/base64.ts"],"sourcesContent":["import { bytesToBase64 } from '@metamask/utils';\n\nimport { getBytes } from './bytes';\nimport type { VirtualFile } from './virtual-file';\n\n/**\n * Provides fast, asynchronous base64 encoding.\n *\n * @param input - The input value, assumed to be coercable to bytes.\n * @returns A base64 string.\n */\nexport async function encodeBase64(input: Uint8Array | VirtualFile | string) {\n  const bytes = getBytes(input);\n  // In the browser, FileReader is much faster than bytesToBase64.\n  if ('FileReader' in globalThis) {\n    return await new Promise((resolve, reject) => {\n      const reader = Object.assign(new FileReader(), {\n        onload: () =>\n          resolve(\n            (reader.result as string).replace(\n              'data:application/octet-stream;base64,',\n              '',\n            ),\n          ),\n        onerror: () => reject(reader.error),\n      });\n      reader.readAsDataURL(\n        new File([bytes], '', { type: 'application/octet-stream' }),\n      );\n    });\n  }\n  return bytesToBase64(bytes);\n}\n\n/**\n * Provides fast, asynchronous base64 decoding.\n *\n * @param base64 - A base64 string.\n * @returns A Uint8Array of bytes.\n */\nexport async function decodeBase64(base64: string) {\n  const response = await fetch(\n    `data:application/octet-stream;base64,${base64}`,\n  );\n  return new Uint8Array(await response.arrayBuffer());\n}\n"],"names":["bytesToBase64","getBytes","encodeBase64","input","bytes","globalThis","Promise","resolve","reject","reader","Object","assign","FileReader","onload","result","replace","onerror","error","readAsDataURL","File","type","decodeBase64","base64","response","fetch","Uint8Array","arrayBuffer"],"mappings":"AAAA,SAASA,aAAa,QAAQ,kBAAkB;AAEhD,SAASC,QAAQ,QAAQ,UAAU;AAGnC;;;;;CAKC,GACD,OAAO,eAAeC,aAAaC,KAAwC;IACzE,MAAMC,QAAQH,SAASE;IACvB,gEAAgE;IAChE,IAAI,gBAAgBE,YAAY;QAC9B,OAAO,MAAM,IAAIC,QAAQ,CAACC,SAASC;YACjC,MAAMC,SAASC,OAAOC,MAAM,CAAC,IAAIC,cAAc;gBAC7CC,QAAQ,IACNN,QACE,AAACE,OAAOK,MAAM,CAAYC,OAAO,CAC/B,yCACA;gBAGNC,SAAS,IAAMR,OAAOC,OAAOQ,KAAK;YACpC;YACAR,OAAOS,aAAa,CAClB,IAAIC,KAAK;gBAACf;aAAM,EAAE,IAAI;gBAAEgB,MAAM;YAA2B;QAE7D;IACF;IACA,OAAOpB,cAAcI;AACvB;AAEA;;;;;CAKC,GACD,OAAO,eAAeiB,aAAaC,MAAc;IAC/C,MAAMC,WAAW,MAAMC,MACrB,CAAC,qCAAqC,EAAEF,OAAO,CAAC;IAElD,OAAO,IAAIG,WAAW,MAAMF,SAASG,WAAW;AAClD"}

package/dist/esm/bytes.js

@@ -1,18 +0,0 @@
-import { stringToBytes } from '@metamask/utils';
-import { VirtualFile } from './virtual-file';
-/**
- * Convert a bytes-like input value to a Uint8Array.
- *
- * @param bytes - A bytes-like value.
- * @returns The input value converted to a Uint8Array if necessary.
- */ export function getBytes(bytes) {
-    // Unwrap VirtualFiles to extract the content
-    // The content is then either a string or Uint8Array
-    const unwrapped = bytes instanceof VirtualFile ? bytes.value : bytes;
-    if (typeof unwrapped === 'string') {
-        return stringToBytes(unwrapped);
-    }
-    return unwrapped;
-}
-
-//# sourceMappingURL=bytes.js.map

package/dist/esm/bytes.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../src/bytes.ts"],"sourcesContent":["import { stringToBytes } from '@metamask/utils';\n\nimport { VirtualFile } from './virtual-file';\n\n/**\n * Convert a bytes-like input value to a Uint8Array.\n *\n * @param bytes - A bytes-like value.\n * @returns The input value converted to a Uint8Array if necessary.\n */\nexport function getBytes(bytes: VirtualFile | Uint8Array | string): Uint8Array {\n  // Unwrap VirtualFiles to extract the content\n  // The content is then either a string or Uint8Array\n  const unwrapped = bytes instanceof VirtualFile ? bytes.value : bytes;\n\n  if (typeof unwrapped === 'string') {\n    return stringToBytes(unwrapped);\n  }\n\n  return unwrapped;\n}\n"],"names":["stringToBytes","VirtualFile","getBytes","bytes","unwrapped","value"],"mappings":"AAAA,SAASA,aAAa,QAAQ,kBAAkB;AAEhD,SAASC,WAAW,QAAQ,iBAAiB;AAE7C;;;;;CAKC,GACD,OAAO,SAASC,SAASC,KAAwC;IAC/D,6CAA6C;IAC7C,oDAAoD;IACpD,MAAMC,YAAYD,iBAAiBF,cAAcE,MAAME,KAAK,GAAGF;IAE/D,IAAI,OAAOC,cAAc,UAAU;QACjC,OAAOJ,cAAcI;IACvB;IAEA,OAAOA;AACT"}

package/dist/esm/caveats.js

@@ -1,38 +0,0 @@
-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[/**
-   * Caveat specifying access to the signature origin, used by `endowment:signature-insight`.
-   */ "SignatureOrigin"] = 'signatureOrigin';
-    SnapCaveatType[/**
-   * The origins that a Snap can receive JSON-RPC messages from.
-   */ "RpcOrigin"] = 'rpcOrigin';
-    SnapCaveatType[/**
-   * The origins that a Snap can receive keyring messages from.
-   */ "KeyringOrigin"] = 'keyringOrigin';
-    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[/**
-   * Caveat specifying the input that a name lookup snap can service, currently limited to `endowment:name-lookup`.
-   */ "LookupMatchers"] = 'lookupMatchers';
-    SnapCaveatType[/**
-   * Caveat specifying the max request time for a handler endowment.
-   */ "MaxRequestTime"] = 'maxRequestTime';
-})(SnapCaveatType || (SnapCaveatType = {}));
-
-//# sourceMappingURL=caveats.js.map

package/dist/esm/caveats.js.map

@@ -1 +0,0 @@
-{"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   * Caveat specifying access to the signature origin, used by `endowment:signature-insight`.\n   */\n  SignatureOrigin = 'signatureOrigin',\n\n  /**\n   * The origins that a Snap can receive JSON-RPC messages from.\n   */\n  RpcOrigin = 'rpcOrigin',\n\n  /**\n   * The origins that a Snap can receive keyring messages from.\n   */\n  KeyringOrigin = 'keyringOrigin',\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  /**\n   * Caveat specifying the input that a name lookup snap can service, currently limited to `endowment:name-lookup`.\n   */\n  LookupMatchers = 'lookupMatchers',\n\n  /**\n   * Caveat specifying the max request time for a handler endowment.\n   */\n  MaxRequestTime = 'maxRequestTime',\n}\n"],"names":["SnapCaveatType","PermittedDerivationPaths","PermittedCoinTypes","SnapCronjob","TransactionOrigin","SignatureOrigin","RpcOrigin","KeyringOrigin","SnapIds","ChainIds","LookupMatchers","MaxRequestTime"],"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,qBAAkB;IAxBRL,eA0BV;;GAEC,GACDM,eAAY;IA7BFN,eA+BV;;GAEC,GACDO,mBAAgB;IAlCNP,eAoCV;;GAEC,GACDQ,aAAU;IAvCAR,eAyCV;;GAEC,GACDS,cAAW;IA5CDT,eA8CV;;GAEC,GACDU,oBAAiB;IAjDPV,eAmDV;;GAEC,GACDW,oBAAiB;GAtDPX,mBAAAA"}

package/dist/esm/checksum.js

@@ -1,41 +0,0 @@
-import { assert, concatBytes } from '@metamask/utils';
-import { sha256 } from '@noble/hashes/sha256';
-import { getBytes } from './bytes';
-/**
- * Calculates checksum for a single byte array.
- *
- * @param bytes - The byte array to calculate the checksum for.
- * @returns A single sha-256 checksum.
- */ export async function checksum(bytes) {
-    const value = getBytes(bytes);
-    // Use crypto.subtle.digest whenever possible as it is faster.
-    if ('crypto' in globalThis && typeof globalThis.crypto === 'object' && crypto.subtle?.digest) {
-        return new Uint8Array(await crypto.subtle.digest('SHA-256', value));
-    }
-    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 async function checksumFiles(files) {
-    const checksums = await Promise.all([
-        ...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(async (file)=>checksum(file)));
-    return checksum(concatBytes(checksums));
-}
-
-//# sourceMappingURL=checksum.js.map

package/dist/esm/checksum.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../src/checksum.ts"],"sourcesContent":["import { assert, concatBytes } from '@metamask/utils';\nimport { sha256 } from '@noble/hashes/sha256';\n\nimport { getBytes } from './bytes';\nimport type { 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 async function checksum(\n  bytes: VirtualFile | Uint8Array | string,\n): Promise<Uint8Array> {\n  const value = getBytes(bytes);\n  // Use crypto.subtle.digest whenever possible as it is faster.\n  if (\n    'crypto' in globalThis &&\n    typeof globalThis.crypto === 'object' &&\n    crypto.subtle?.digest\n  ) {\n    return new Uint8Array(await crypto.subtle.digest('SHA-256', value));\n  }\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 async function checksumFiles(files: VirtualFile[]) {\n  const checksums = await Promise.all(\n    [...files]\n      .sort((a, b) => {\n        assert(a.path !== b.path, 'Tried to sort files with non-unique paths.');\n        if (a.path < b.path) {\n          return -1;\n        }\n        return 1;\n      })\n      .map(async (file) => checksum(file)),\n  );\n\n  return checksum(concatBytes(checksums));\n}\n"],"names":["assert","concatBytes","sha256","getBytes","checksum","bytes","value","globalThis","crypto","subtle","digest","Uint8Array","checksumFiles","files","checksums","Promise","all","sort","a","b","path","map","file"],"mappings":"AAAA,SAASA,MAAM,EAAEC,WAAW,QAAQ,kBAAkB;AACtD,SAASC,MAAM,QAAQ,uBAAuB;AAE9C,SAASC,QAAQ,QAAQ,UAAU;AAGnC;;;;;CAKC,GACD,OAAO,eAAeC,SACpBC,KAAwC;IAExC,MAAMC,QAAQH,SAASE;IACvB,8DAA8D;IAC9D,IACE,YAAYE,cACZ,OAAOA,WAAWC,MAAM,KAAK,YAC7BA,OAAOC,MAAM,EAAEC,QACf;QACA,OAAO,IAAIC,WAAW,MAAMH,OAAOC,MAAM,CAACC,MAAM,CAAC,WAAWJ;IAC9D;IACA,OAAOJ,OAAOI;AAChB;AAEA;;;;;;;;;;;CAWC,GACD,OAAO,eAAeM,cAAcC,KAAoB;IACtD,MAAMC,YAAY,MAAMC,QAAQC,GAAG,CACjC;WAAIH;KAAM,CACPI,IAAI,CAAC,CAACC,GAAGC;QACRnB,OAAOkB,EAAEE,IAAI,KAAKD,EAAEC,IAAI,EAAE;QAC1B,IAAIF,EAAEE,IAAI,GAAGD,EAAEC,IAAI,EAAE;YACnB,OAAO,CAAC;QACV;QACA,OAAO;IACT,GACCC,GAAG,CAAC,OAAOC,OAASlB,SAASkB;IAGlC,OAAOlB,SAASH,YAAYa;AAC9B"}