@metamask/snaps-utils 0.38.0-flask.1 → 1.0.0

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA,0CAAwB;AACxB,4CAA0B;AAC1B,4CAA0B;AAC1B,6CAA2B;AAC3B,+CAA6B;AAC7B,uDAAqC;AACrC,4CAA0B;AAC1B,yCAAuB;AACvB,uCAAqB;AACrB,6CAA2B;AAC3B,2CAAyB;AACzB,yCAAuB;AACvB,6CAA2B;AAC3B,4CAA0B;AAC1B,6CAA2B;AAC3B,yCAAuB;AACvB,8CAA4B;AAC5B,iDAA+B;AAC/B,wCAAsB;AACtB,yCAAuB;AACvB,iDAA+B;AAC/B,0CAAwB;AACxB,0CAAwB;AACxB,6CAA2B;AAC3B,iDAA+B","sourcesContent":["export * from './array';\nexport * from './caveats';\nexport * from './cronjob';\nexport * from './checksum';\nexport * from './deep-clone';\nexport * from './default-endowments';\nexport * from './entropy';\nexport * from './eval';\nexport * from './fs';\nexport * from './handlers';\nexport * from './iframe';\nexport * from './json';\nexport * from './json-rpc';\nexport * from './logging';\nexport * from './manifest';\nexport * from './mock';\nexport * from './namespace';\nexport * from './notification';\nexport * from './npm';\nexport * from './path';\nexport * from './post-process';\nexport * from './snaps';\nexport * from './types';\nexport * from './versions';\nexport * from './virtual-file';\n"]}

package/dist/{types/json-rpc.d.ts → json-rpc.d.ts}

@@ -1,5 +1,5 @@
-import type { Json, JsonRpcSuccess, AssertionErrorConstructor } from '@metamask/utils';
-import type { Infer } from 'superstruct';
+import { Json, JsonRpcSuccess, AssertionErrorConstructor } from '@metamask/utils';
+import { Infer } from 'superstruct';
 export declare const RpcOriginsStruct: import("superstruct").Struct<{
     dapps?: boolean | undefined;
     snaps?: boolean | undefined;

package/dist/json-rpc.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assertIsJsonRpcSuccess = exports.assertIsRpcOrigins = exports.RpcOriginsStruct = void 0;
+const utils_1 = require("@metamask/utils");
+const superstruct_1 = require("superstruct");
+exports.RpcOriginsStruct = (0, superstruct_1.refine)((0, superstruct_1.object)({
+    dapps: (0, superstruct_1.optional)((0, superstruct_1.boolean)()),
+    snaps: (0, superstruct_1.optional)((0, superstruct_1.boolean)()),
+}), 'RPC origins', (value) => {
+    if (!Object.values(value).some(Boolean)) {
+        throw new Error('Must specify at least one JSON-RPC origin');
+    }
+    return true;
+});
+/**
+ * Asserts that the given value is a valid {@link RpcOrigins} object.
+ *
+ * @param value - The value to assert.
+ * @param ErrorWrapper - An optional error wrapper to use. Defaults to
+ * {@link AssertionError}.
+ * @throws If the value is not a valid {@link RpcOrigins} object.
+ */
+function assertIsRpcOrigins(value, 
+// eslint-disable-next-line @typescript-eslint/naming-convention
+ErrorWrapper) {
+    (0, utils_1.assertStruct)(value, exports.RpcOriginsStruct, 'Invalid JSON-RPC origins', ErrorWrapper);
+}
+exports.assertIsRpcOrigins = assertIsRpcOrigins;
+/**
+ * Assert that the given value is a successful JSON-RPC response. If the value
+ * is not a success response, an error is thrown. If the value is an JSON-RPC
+ * error, the error message is included in the thrown error.
+ *
+ * @param value - The value to check.
+ * @throws If the value is not a JSON-RPC success response.
+ */
+function assertIsJsonRpcSuccess(value) {
+    if (!(0, utils_1.isJsonRpcSuccess)(value)) {
+        if ((0, utils_1.isJsonRpcFailure)(value)) {
+            throw new Error(`JSON-RPC request failed: ${value.error.message}`);
+        }
+        throw new Error('Invalid JSON-RPC response.');
+    }
+}
+exports.assertIsJsonRpcSuccess = assertIsJsonRpcSuccess;
+//# sourceMappingURL=json-rpc.js.map

package/dist/json-rpc.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"json-rpc.js","sourceRoot":"","sources":["../src/json-rpc.ts"],"names":[],"mappings":";;;AAAA,2CAOyB;AACzB,6CAAuE;AAE1D,QAAA,gBAAgB,GAAG,IAAA,oBAAM,EACpC,IAAA,oBAAM,EAAC;IACL,KAAK,EAAE,IAAA,sBAAQ,EAAC,IAAA,qBAAO,GAAE,CAAC;IAC1B,KAAK,EAAE,IAAA,sBAAQ,EAAC,IAAA,qBAAO,GAAE,CAAC;CAC3B,CAAC,EACF,aAAa,EACb,CAAC,KAAK,EAAE,EAAE;IACR,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,IAAI,CAAC,OAAO,CAAC,EAAE;QACvC,MAAM,IAAI,KAAK,CAAC,2CAA2C,CAAC,CAAC;KAC9D;IAED,OAAO,IAAI,CAAC;AACd,CAAC,CACF,CAAC;AAIF;;;;;;;GAOG;AACH,SAAgB,kBAAkB,CAChC,KAAc;AACd,gEAAgE;AAChE,YAAwC;IAExC,IAAA,oBAAY,EACV,KAAK,EACL,wBAAgB,EAChB,0BAA0B,EAC1B,YAAY,CACb,CAAC;AACJ,CAAC;AAXD,gDAWC;AAED;;;;;;;GAOG;AACH,SAAgB,sBAAsB,CACpC,KAAc;IAEd,IAAI,CAAC,IAAA,wBAAgB,EAAC,KAAK,CAAC,EAAE;QAC5B,IAAI,IAAA,wBAAgB,EAAC,KAAK,CAAC,EAAE;YAC3B,MAAM,IAAI,KAAK,CAAC,4BAA4B,KAAK,CAAC,KAAK,CAAC,OAAO,EAAE,CAAC,CAAC;SACpE;QAED,MAAM,IAAI,KAAK,CAAC,4BAA4B,CAAC,CAAC;KAC/C;AACH,CAAC;AAVD,wDAUC","sourcesContent":["import {\n  isJsonRpcFailure,\n  isJsonRpcSuccess,\n  Json,\n  JsonRpcSuccess,\n  AssertionErrorConstructor,\n  assertStruct,\n} from '@metamask/utils';\nimport { boolean, Infer, object, optional, refine } from 'superstruct';\n\nexport const RpcOriginsStruct = refine(\n  object({\n    dapps: optional(boolean()),\n    snaps: optional(boolean()),\n  }),\n  'RPC origins',\n  (value) => {\n    if (!Object.values(value).some(Boolean)) {\n      throw new Error('Must specify at least one JSON-RPC origin');\n    }\n\n    return true;\n  },\n);\n\nexport type RpcOrigins = Infer<typeof RpcOriginsStruct>;\n\n/**\n * Asserts that the given value is a valid {@link RpcOrigins} object.\n *\n * @param value - The value to assert.\n * @param ErrorWrapper - An optional error wrapper to use. Defaults to\n * {@link AssertionError}.\n * @throws If the value is not a valid {@link RpcOrigins} object.\n */\nexport function assertIsRpcOrigins(\n  value: unknown,\n  // eslint-disable-next-line @typescript-eslint/naming-convention\n  ErrorWrapper?: AssertionErrorConstructor,\n): asserts value is RpcOrigins {\n  assertStruct(\n    value,\n    RpcOriginsStruct,\n    'Invalid JSON-RPC origins',\n    ErrorWrapper,\n  );\n}\n\n/**\n * Assert that the given value is a successful JSON-RPC response. If the value\n * is not a success response, an error is thrown. If the value is an JSON-RPC\n * error, the error message is included in the thrown error.\n *\n * @param value - The value to check.\n * @throws If the value is not a JSON-RPC success response.\n */\nexport function assertIsJsonRpcSuccess(\n  value: unknown,\n): asserts value is JsonRpcSuccess<Json> {\n  if (!isJsonRpcSuccess(value)) {\n    if (isJsonRpcFailure(value)) {\n      throw new Error(`JSON-RPC request failed: ${value.error.message}`);\n    }\n\n    throw new Error('Invalid JSON-RPC response.');\n  }\n}\n"]}

package/dist/json.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Parses JSON safely.
+ *
+ * Does multiple kinds of validation and strips unwanted properties like __proto__.
+ *
+ * @param json - A JSON string to be parsed.
+ * @returns The parsed JSON object.
+ */
+export declare function parseJson(json: string): import("@metamask/utils").Json;

package/dist/json.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseJson = void 0;
+const utils_1 = require("@metamask/utils");
+// TODO: Upstream this to @metamask/utils
+/**
+ * Parses JSON safely.
+ *
+ * Does multiple kinds of validation and strips unwanted properties like __proto__.
+ *
+ * @param json - A JSON string to be parsed.
+ * @returns The parsed JSON object.
+ */
+function parseJson(json) {
+    return (0, utils_1.getSafeJson)(JSON.parse(json));
+}
+exports.parseJson = parseJson;
+//# sourceMappingURL=json.js.map

package/dist/json.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"json.js","sourceRoot":"","sources":["../src/json.ts"],"names":[],"mappings":";;;AAAA,2CAA8C;AAE9C,yCAAyC;AAEzC;;;;;;;GAOG;AACH,SAAgB,SAAS,CAAC,IAAY;IACpC,OAAO,IAAA,mBAAW,EAAC,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,CAAC;AACvC,CAAC;AAFD,8BAEC","sourcesContent":["import { getSafeJson } from '@metamask/utils';\n\n// TODO: Upstream this to @metamask/utils\n\n/**\n * Parses JSON safely.\n *\n * Does multiple kinds of validation and strips unwanted properties like __proto__.\n *\n * @param json - A JSON string to be parsed.\n * @returns The parsed JSON object.\n */\nexport function parseJson(json: string) {\n  return getSafeJson(JSON.parse(json));\n}\n"]}

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

@@ -1,7 +1,10 @@
-import { createProjectLogger } from '@metamask/utils';
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.logWarning = exports.logError = exports.logInfo = exports.snapsLogger = void 0;
+const utils_1 = require("@metamask/utils");
 // The global logger used across the monorepo. Other projects should use this
 // to create a module logger.
-export const snapsLogger = createProjectLogger('snaps');
+exports.snapsLogger = (0, utils_1.createProjectLogger)('snaps');
 /**
  * Log a message. Currently, this is just a wrapper around `console.log`, but
  * the implementation may change in the future. These logs will be included in
@@ -13,10 +16,12 @@ export const snapsLogger = createProjectLogger('snaps');
  *
  * @param message - The message to log.
  * @param optionalParams - Additional parameters to pass to the logging.
- */ export function logInfo(message, ...optionalParams) {
+ */
+function logInfo(message, ...optionalParams) {
     // eslint-disable-next-line no-console
     console.log(message, ...optionalParams);
 }
+exports.logInfo = logInfo;
 /**
  * Log an error. Currently, this is just a wrapper around `console.error`, but
  * the implementation may change in the future. These logs will be included in
@@ -32,10 +37,12 @@ export const snapsLogger = createProjectLogger('snaps');
  *
  * @param error - The error to log.
  * @param optionalParams - Additional parameters to pass to the logging.
- */ export function logError(error, ...optionalParams) {
+ */
+function logError(error, ...optionalParams) {
     // eslint-disable-next-line no-console
     console.error(error, ...optionalParams);
 }
+exports.logError = logError;
 /**
  * Log a warning. Currently, this is just a wrapper around `console.warn`, but
  * the implementation may change in the future. These logs will be included in
@@ -51,9 +58,10 @@ export const snapsLogger = createProjectLogger('snaps');
  *
  * @param message - The message to log.
  * @param optionalParams - Additional parameters to pass to the logging.
- */ export function logWarning(message, ...optionalParams) {
+ */
+function logWarning(message, ...optionalParams) {
     // eslint-disable-next-line no-console
     console.warn(message, ...optionalParams);
 }
-
+exports.logWarning = logWarning;
 //# sourceMappingURL=logging.js.map

package/dist/logging.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"logging.js","sourceRoot":"","sources":["../src/logging.ts"],"names":[],"mappings":";;;AAAA,2CAAsD;AAEtD,6EAA6E;AAC7E,6BAA6B;AAChB,QAAA,WAAW,GAAG,IAAA,2BAAmB,EAAC,OAAO,CAAC,CAAC;AAExD;;;;;;;;;;;GAWG;AACH,SAAgB,OAAO,CAAC,OAAe,EAAE,GAAG,cAAyB;IACnE,sCAAsC;IACtC,OAAO,CAAC,GAAG,CAAC,OAAO,EAAE,GAAG,cAAc,CAAC,CAAC;AAC1C,CAAC;AAHD,0BAGC;AAED;;;;;;;;;;;;;;;GAeG;AACH,SAAgB,QAAQ,CAAC,KAAc,EAAE,GAAG,cAAyB;IACnE,sCAAsC;IACtC,OAAO,CAAC,KAAK,CAAC,KAAK,EAAE,GAAG,cAAc,CAAC,CAAC;AAC1C,CAAC;AAHD,4BAGC;AAED;;;;;;;;;;;;;;;GAeG;AACH,SAAgB,UAAU,CACxB,OAAe,EACf,GAAG,cAAyB;IAE5B,sCAAsC;IACtC,OAAO,CAAC,IAAI,CAAC,OAAO,EAAE,GAAG,cAAc,CAAC,CAAC;AAC3C,CAAC;AAND,gCAMC","sourcesContent":["import { createProjectLogger } from '@metamask/utils';\n\n// The global logger used across the monorepo. Other projects should use this\n// to create a module logger.\nexport const snapsLogger = createProjectLogger('snaps');\n\n/**\n * Log a message. Currently, this is just a wrapper around `console.log`, but\n * the implementation may change in the future. These logs will be included in\n * production builds, so they should be used sparingly, and not contain any\n * sensitive information.\n *\n * This function makes it easy to swap out the logging implementation in all\n * files at once.\n *\n * @param message - The message to log.\n * @param optionalParams - Additional parameters to pass to the logging.\n */\nexport function logInfo(message: string, ...optionalParams: unknown[]): void {\n  // eslint-disable-next-line no-console\n  console.log(message, ...optionalParams);\n}\n\n/**\n * Log an error. Currently, this is just a wrapper around `console.error`, but\n * the implementation may change in the future. These logs will be included in\n * production builds, so they should be used sparingly, and not contain any\n * sensitive information.\n *\n * These logs should always be visible, without requiring the user to enable\n * verbose logging (like setting a `DEBUG` environment variable), as they are\n * important for debugging snaps.\n *\n * This function makes it easy to swap out the logging implementation in all\n * files at once.\n *\n * @param error - The error to log.\n * @param optionalParams - Additional parameters to pass to the logging.\n */\nexport function logError(error: unknown, ...optionalParams: unknown[]): void {\n  // eslint-disable-next-line no-console\n  console.error(error, ...optionalParams);\n}\n\n/**\n * Log a warning. Currently, this is just a wrapper around `console.warn`, but\n * the implementation may change in the future. These logs will be included in\n * production builds, so they should be used sparingly, and not contain any\n * sensitive information.\n *\n * These logs should always be visible, without requiring the user to enable\n * verbose logging (like setting a `DEBUG` environment variable), as they are\n * important for debugging snaps.\n *\n * This function makes it easy to swap out the logging implementation in all\n * files at once.\n *\n * @param message - The message to log.\n * @param optionalParams - Additional parameters to pass to the logging.\n */\nexport function logWarning(\n  message: string,\n  ...optionalParams: unknown[]\n): void {\n  // eslint-disable-next-line no-console\n  console.warn(message, ...optionalParams);\n}\n"]}

package/dist/manifest/index.browser.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./validation"), exports);
+//# sourceMappingURL=index.browser.js.map

package/dist/manifest/index.browser.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.browser.js","sourceRoot":"","sources":["../../src/manifest/index.browser.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA,+CAA6B","sourcesContent":["export * from './validation';\n"]}

package/dist/manifest/index.js

@@ -0,0 +1,19 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./manifest"), exports);
+__exportStar(require("./validation"), exports);
+//# sourceMappingURL=index.js.map

package/dist/manifest/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/manifest/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA,6CAA2B;AAC3B,+CAA6B","sourcesContent":["export * from './manifest';\nexport * from './validation';\n"]}

package/dist/{types/manifest → manifest}/manifest.d.ts

@@ -1,8 +1,8 @@
-import type { Json } from '@metamask/utils';
+import { Json } from '@metamask/utils';
 import { ProgrammaticallyFixableSnapError } from '../snaps';
-import type { SnapFiles } from '../types';
+import { SnapFiles } from '../types';
 import { VirtualFile } from '../virtual-file';
-import type { SnapManifest } from './validation';
+import { SnapManifest } from './validation';
 /**
  * The result from the `checkManifest` function.
  *
@@ -23,7 +23,6 @@ export declare type CheckManifestResult = {
     warnings: string[];
     errors: string[];
 };
-export declare type WriteFileFunction = (path: string, data: string) => Promise<void>;
 /**
  * Validates a snap.manifest.json file. Attempts to fix the manifest and write
  * the fixed version to disk if `writeManifest` is true. Throws if validation
@@ -32,11 +31,10 @@ export declare type WriteFileFunction = (path: string, data: string) => Promise<
  * @param basePath - The path to the folder with the manifest files.
  * @param writeManifest - Whether to write the fixed manifest to disk.
  * @param sourceCode - The source code of the Snap.
- * @param writeFileFn - The function to use to write the manifest to disk.
  * @returns Whether the manifest was updated, and an array of warnings that
  * were encountered during processing of the manifest files.
  */
-export declare function checkManifest(basePath: string, writeManifest?: boolean, sourceCode?: string, writeFileFn?: WriteFileFunction): Promise<CheckManifestResult>;
+export declare function checkManifest(basePath: string, writeManifest?: boolean, sourceCode?: string): Promise<CheckManifestResult>;
 /**
  * Given the relevant Snap files (manifest, `package.json`, and bundle) and a
  * Snap manifest validation error, fixes the fault in the manifest that caused

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

@@ -1,22 +1,27 @@
-import { assertExhaustive, assert, isPlainObject } from '@metamask/utils';
-import deepEqual from 'fast-deep-equal';
-import { promises as fs } from 'fs';
-import pathUtils from 'path';
-import { deepClone } from '../deep-clone';
-import { readJsonFile } from '../fs';
-import { validateNpmSnap } from '../npm';
-import { getSnapChecksum, ProgrammaticallyFixableSnapError, validateSnapShasum } from '../snaps';
-import { NpmSnapFileNames, SnapValidationFailureReason } from '../types';
-import { readVirtualFile, VirtualFile } from '../virtual-file';
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateNpmSnapManifest = exports.getWritableManifest = exports.getSnapIcon = exports.getSnapSourceCode = exports.fixManifest = exports.checkManifest = void 0;
+const utils_1 = require("@metamask/utils");
+const fast_deep_equal_1 = __importDefault(require("fast-deep-equal"));
+const fs_1 = require("fs");
+const path_1 = __importDefault(require("path"));
+const deep_clone_1 = require("../deep-clone");
+const fs_2 = require("../fs");
+const npm_1 = require("../npm");
+const snaps_1 = require("../snaps");
+const types_1 = require("../types");
+const virtual_file_1 = require("../virtual-file");
 const MANIFEST_SORT_ORDER = {
-    $schema: 1,
-    version: 2,
-    description: 3,
-    proposedName: 4,
-    repository: 5,
-    source: 6,
-    initialPermissions: 7,
-    manifestVersion: 8
+    version: 1,
+    description: 2,
+    proposedName: 3,
+    repository: 4,
+    source: 5,
+    initialPermissions: 6,
+    manifestVersion: 7,
 };
 /**
  * Validates a snap.manifest.json file. Attempts to fix the manifest and write
@@ -26,73 +31,72 @@ const MANIFEST_SORT_ORDER = {
  * @param basePath - The path to the folder with the manifest files.
  * @param writeManifest - Whether to write the fixed manifest to disk.
  * @param sourceCode - The source code of the Snap.
- * @param writeFileFn - The function to use to write the manifest to disk.
  * @returns Whether the manifest was updated, and an array of warnings that
  * were encountered during processing of the manifest files.
- */ export async function checkManifest(basePath, writeManifest = true, sourceCode, writeFileFn = fs.writeFile) {
+ */
+async function checkManifest(basePath, writeManifest = true, sourceCode) {
     const warnings = [];
     const errors = [];
     let updated = false;
-    const manifestPath = pathUtils.join(basePath, NpmSnapFileNames.Manifest);
-    const manifestFile = await readJsonFile(manifestPath);
+    const manifestPath = path_1.default.join(basePath, types_1.NpmSnapFileNames.Manifest);
+    const manifestFile = await (0, fs_2.readJsonFile)(manifestPath);
     const unvalidatedManifest = manifestFile.result;
-    const packageFile = await readJsonFile(pathUtils.join(basePath, NpmSnapFileNames.PackageJson));
+    const packageFile = await (0, fs_2.readJsonFile)(path_1.default.join(basePath, types_1.NpmSnapFileNames.PackageJson));
     const snapFiles = {
         manifest: manifestFile,
         packageJson: packageFile,
         sourceCode: await getSnapSourceCode(basePath, unvalidatedManifest, sourceCode),
-        svgIcon: await getSnapIcon(basePath, unvalidatedManifest)
+        svgIcon: await getSnapIcon(basePath, unvalidatedManifest),
     };
     let manifest;
     try {
-        ({ manifest } = validateNpmSnap(snapFiles));
-    } catch (error) {
-        if (error instanceof ProgrammaticallyFixableSnapError) {
+        ({ manifest } = (0, npm_1.validateNpmSnap)(snapFiles));
+    }
+    catch (error) {
+        if (error instanceof snaps_1.ProgrammaticallyFixableSnapError) {
             errors.push(error.message);
             // If we get here, the files at least have the correct shape.
             const partiallyValidatedFiles = snapFiles;
             let isInvalid = true;
             let currentError = error;
-            const maxAttempts = Object.keys(SnapValidationFailureReason).length;
+            const maxAttempts = Object.keys(types_1.SnapValidationFailureReason).length;
             // Attempt to fix all fixable validation failure reasons. All such reasons
             // are enumerated by the `SnapValidationFailureReason` enum, so we only
             // attempt to fix the manifest the same amount of times as there are
             // reasons in the enum.
-            for(let attempts = 1; isInvalid && attempts <= maxAttempts; attempts++){
-                manifest = fixManifest(manifest ? {
-                    ...partiallyValidatedFiles,
-                    manifest
-                } : partiallyValidatedFiles, currentError);
+            for (let attempts = 1; isInvalid && attempts <= maxAttempts; attempts++) {
+                manifest = fixManifest(manifest
+                    ? { ...partiallyValidatedFiles, manifest }
+                    : partiallyValidatedFiles, currentError);
                 try {
-                    validateNpmSnapManifest({
-                        ...partiallyValidatedFiles,
-                        manifest
-                    });
+                    validateNpmSnapManifest({ ...partiallyValidatedFiles, manifest });
                     isInvalid = false;
-                } catch (nextValidationError) {
+                }
+                catch (nextValidationError) {
                     currentError = nextValidationError;
-                    /* istanbul ignore next: this should be impossible */ if (!(nextValidationError instanceof ProgrammaticallyFixableSnapError) || attempts === maxAttempts && !isInvalid) {
+                    /* istanbul ignore next: this should be impossible */
+                    if (!(nextValidationError instanceof snaps_1.ProgrammaticallyFixableSnapError) ||
+                        (attempts === maxAttempts && !isInvalid)) {
                         throw new Error(`Internal error: Failed to fix manifest. This is a bug, please report it. Reason:\n${error.message}`);
                     }
                     errors.push(currentError.message);
                 }
             }
             updated = true;
-        } else {
+        }
+        else {
             throw error;
         }
     }
     // TypeScript assumes `manifest` can still be undefined, that is not the case.
     // But we assert to keep TypeScript happy.
-    assert(manifest);
+    (0, utils_1.assert)(manifest);
     const validatedManifest = manifest.result;
     // Check presence of recommended keys
-    const recommendedFields = [
-        'repository'
-    ];
-    const missingRecommendedFields = recommendedFields.filter((key)=>!validatedManifest[key]);
+    const recommendedFields = ['repository'];
+    const missingRecommendedFields = recommendedFields.filter((key) => !validatedManifest[key]);
     if (missingRecommendedFields.length > 0) {
-        warnings.push(`Missing recommended package.json properties:\n${missingRecommendedFields.reduce((allMissing, currentField)=>{
+        warnings.push(`Missing recommended package.json properties:\n${missingRecommendedFields.reduce((allMissing, currentField) => {
             return `${allMissing}\t${currentField}\n`;
         }, '')}`);
     }
@@ -100,21 +104,18 @@ const MANIFEST_SORT_ORDER = {
         try {
             const newManifest = `${JSON.stringify(getWritableManifest(validatedManifest), null, 2)}\n`;
             if (updated || newManifest !== manifestFile.value) {
-                await writeFileFn(pathUtils.join(basePath, NpmSnapFileNames.Manifest), newManifest);
+                await fs_1.promises.writeFile(path_1.default.join(basePath, types_1.NpmSnapFileNames.Manifest), newManifest);
             }
-        } catch (error) {
+        }
+        catch (error) {
             // Note: This error isn't pushed to the errors array, because it's not an
             // error in the manifest itself.
             throw new Error(`Failed to update snap.manifest.json: ${error.message}`);
         }
     }
-    return {
-        manifest: validatedManifest,
-        updated,
-        warnings,
-        errors
-    };
+    return { manifest: validatedManifest, updated, warnings, errors };
 }
+exports.checkManifest = checkManifest;
 /**
  * Given the relevant Snap files (manifest, `package.json`, and bundle) and a
  * Snap manifest validation error, fixes the fault in the manifest that caused
@@ -123,30 +124,35 @@ const MANIFEST_SORT_ORDER = {
  * @param snapFiles - The contents of all Snap files.
  * @param error - The {@link ProgrammaticallyFixableSnapError} that was thrown.
  * @returns A copy of the manifest file where the cause of the error is fixed.
- */ export function fixManifest(snapFiles, error) {
+ */
+function fixManifest(snapFiles, error) {
     const { manifest, packageJson } = snapFiles;
     const clonedFile = manifest.clone();
     const manifestCopy = clonedFile.result;
-    switch(error.reason){
-        case SnapValidationFailureReason.NameMismatch:
+    switch (error.reason) {
+        case types_1.SnapValidationFailureReason.NameMismatch:
             manifestCopy.source.location.npm.packageName = packageJson.result.name;
             break;
-        case SnapValidationFailureReason.VersionMismatch:
+        case types_1.SnapValidationFailureReason.VersionMismatch:
             manifestCopy.version = packageJson.result.version;
             break;
-        case SnapValidationFailureReason.RepositoryMismatch:
-            manifestCopy.repository = packageJson.result.repository ? deepClone(packageJson.result.repository) : undefined;
+        case types_1.SnapValidationFailureReason.RepositoryMismatch:
+            manifestCopy.repository = packageJson.result.repository
+                ? (0, deep_clone_1.deepClone)(packageJson.result.repository)
+                : undefined;
             break;
-        case SnapValidationFailureReason.ShasumMismatch:
-            manifestCopy.source.shasum = getSnapChecksum(snapFiles);
+        case types_1.SnapValidationFailureReason.ShasumMismatch:
+            manifestCopy.source.shasum = (0, snaps_1.getSnapChecksum)(snapFiles);
             break;
-        /* istanbul ignore next */ default:
-            assertExhaustive(error.reason);
+        /* istanbul ignore next */
+        default:
+            (0, utils_1.assertExhaustive)(error.reason);
     }
     clonedFile.result = manifestCopy;
     clonedFile.value = JSON.stringify(manifestCopy);
     return clonedFile;
 }
+exports.fixManifest = fixManifest;
 /**
  * Given an unvalidated Snap manifest, attempts to extract the location of the
  * bundle source file location and read the file.
@@ -155,27 +161,31 @@ const MANIFEST_SORT_ORDER = {
  * @param manifest - The unvalidated Snap manifest file contents.
  * @param sourceCode - Override source code for plugins.
  * @returns The contents of the bundle file, if any.
- */ export async function getSnapSourceCode(basePath, manifest, sourceCode) {
-    if (!isPlainObject(manifest)) {
+ */
+async function getSnapSourceCode(basePath, manifest, sourceCode) {
+    if (!(0, utils_1.isPlainObject)(manifest)) {
         return undefined;
     }
-    const sourceFilePath = manifest.source?.location?.npm?.filePath;
+    const sourceFilePath = manifest.source?.location
+        ?.npm?.filePath;
     if (!sourceFilePath) {
         return undefined;
     }
     if (sourceCode) {
-        return new VirtualFile({
-            path: pathUtils.join(basePath, sourceFilePath),
-            value: sourceCode
+        return new virtual_file_1.VirtualFile({
+            path: path_1.default.join(basePath, sourceFilePath),
+            value: sourceCode,
         });
     }
     try {
-        const virtualFile = await readVirtualFile(pathUtils.join(basePath, sourceFilePath), 'utf8');
+        const virtualFile = await (0, virtual_file_1.readVirtualFile)(path_1.default.join(basePath, sourceFilePath), 'utf8');
         return virtualFile;
-    } catch (error) {
-        throw new Error(`Failed to read snap bundle file: ${error.message}`);
+    }
+    catch (error) {
+        throw new Error(`Failed to read Snap bundle file: ${error.message}`);
     }
 }
+exports.getSnapSourceCode = getSnapSourceCode;
 /**
  * Given an unvalidated Snap manifest, attempts to extract the location of the
  * icon and read the file.
@@ -183,39 +193,44 @@ const MANIFEST_SORT_ORDER = {
  * @param basePath - The path to the folder with the manifest files.
  * @param manifest - The unvalidated Snap manifest file contents.
  * @returns The contents of the icon, if any.
- */ export async function getSnapIcon(basePath, manifest) {
-    if (!isPlainObject(manifest)) {
+ */
+async function getSnapIcon(basePath, manifest) {
+    if (!(0, utils_1.isPlainObject)(manifest)) {
         return undefined;
     }
-    const iconPath = manifest.source?.location?.npm?.iconPath;
+    const iconPath = manifest.source?.location?.npm
+        ?.iconPath;
     if (!iconPath) {
         return undefined;
     }
     try {
-        const virtualFile = await readVirtualFile(pathUtils.join(basePath, iconPath), 'utf8');
+        const virtualFile = await (0, virtual_file_1.readVirtualFile)(path_1.default.join(basePath, iconPath), 'utf8');
         return virtualFile;
-    } catch (error) {
-        throw new Error(`Failed to read snap icon file: ${error.message}`);
+    }
+    catch (error) {
+        throw new Error(`Failed to read Snap icon file: ${error.message}`);
     }
 }
+exports.getSnapIcon = getSnapIcon;
 /**
  * Sorts the given manifest in our preferred sort order and removes the
  * `repository` field if it is falsy (it may be `null`).
  *
  * @param manifest - The manifest to sort and modify.
  * @returns The disk-ready manifest.
- */ export function getWritableManifest(manifest) {
+ */
+function getWritableManifest(manifest) {
     const { repository, ...remaining } = manifest;
-    const keys = Object.keys(repository ? {
-        ...remaining,
-        repository
-    } : remaining);
-    const writableManifest = keys.sort((a, b)=>MANIFEST_SORT_ORDER[a] - MANIFEST_SORT_ORDER[b]).reduce((result, key)=>({
-            ...result,
-            [key]: manifest[key]
-        }), {});
+    const keys = Object.keys(repository ? { ...remaining, repository } : remaining);
+    const writableManifest = keys
+        .sort((a, b) => MANIFEST_SORT_ORDER[a] - MANIFEST_SORT_ORDER[b])
+        .reduce((result, key) => ({
+        ...result,
+        [key]: manifest[key],
+    }), {});
     return writableManifest;
 }
+exports.getWritableManifest = getWritableManifest;
 /**
  * Validates the fields of an npm Snap manifest that has already passed JSON
  * Schema validation.
@@ -225,7 +240,8 @@ const MANIFEST_SORT_ORDER = {
  * @param snapFiles.packageJson - The npm Snap's `package.json`.
  * @param snapFiles.sourceCode - The Snap's source code.
  * @param snapFiles.svgIcon - The Snap's optional icon.
- */ export function validateNpmSnapManifest({ manifest, packageJson, sourceCode, svgIcon }) {
+ */
+function validateNpmSnapManifest({ manifest, packageJson, sourceCode, svgIcon, }) {
     const packageJsonName = packageJson.result.name;
     const packageJsonVersion = packageJson.result.version;
     const packageJsonRepository = packageJson.result.repository;
@@ -233,21 +249,19 @@ const MANIFEST_SORT_ORDER = {
     const manifestPackageVersion = manifest.result.version;
     const manifestRepository = manifest.result.repository;
     if (packageJsonName !== manifestPackageName) {
-        throw new ProgrammaticallyFixableSnapError(`"${NpmSnapFileNames.Manifest}" npm package name ("${manifestPackageName}") does not match the "${NpmSnapFileNames.PackageJson}" "name" field ("${packageJsonName}").`, SnapValidationFailureReason.NameMismatch);
+        throw new snaps_1.ProgrammaticallyFixableSnapError(`"${types_1.NpmSnapFileNames.Manifest}" npm package name ("${manifestPackageName}") does not match the "${types_1.NpmSnapFileNames.PackageJson}" "name" field ("${packageJsonName}").`, types_1.SnapValidationFailureReason.NameMismatch);
     }
     if (packageJsonVersion !== manifestPackageVersion) {
-        throw new ProgrammaticallyFixableSnapError(`"${NpmSnapFileNames.Manifest}" npm package version ("${manifestPackageVersion}") does not match the "${NpmSnapFileNames.PackageJson}" "version" field ("${packageJsonVersion}").`, SnapValidationFailureReason.VersionMismatch);
+        throw new snaps_1.ProgrammaticallyFixableSnapError(`"${types_1.NpmSnapFileNames.Manifest}" npm package version ("${manifestPackageVersion}") does not match the "${types_1.NpmSnapFileNames.PackageJson}" "version" field ("${packageJsonVersion}").`, types_1.SnapValidationFailureReason.VersionMismatch);
     }
-    if (// The repository may be `undefined` in package.json but can only be defined
+    if (
+    // The repository may be `undefined` in package.json but can only be defined
     // or `null` in the Snap manifest due to TS@<4.4 issues.
-    (packageJsonRepository || manifestRepository) && !deepEqual(packageJsonRepository, manifestRepository)) {
-        throw new ProgrammaticallyFixableSnapError(`"${NpmSnapFileNames.Manifest}" "repository" field does not match the "${NpmSnapFileNames.PackageJson}" "repository" field.`, SnapValidationFailureReason.RepositoryMismatch);
-    }
-    validateSnapShasum({
-        manifest,
-        sourceCode,
-        svgIcon
-    }, `"${NpmSnapFileNames.Manifest}" "shasum" field does not match computed shasum.`);
+    (packageJsonRepository || manifestRepository) &&
+        !(0, fast_deep_equal_1.default)(packageJsonRepository, manifestRepository)) {
+        throw new snaps_1.ProgrammaticallyFixableSnapError(`"${types_1.NpmSnapFileNames.Manifest}" "repository" field does not match the "${types_1.NpmSnapFileNames.PackageJson}" "repository" field.`, types_1.SnapValidationFailureReason.RepositoryMismatch);
+    }
+    (0, snaps_1.validateSnapShasum)({ manifest, sourceCode, svgIcon }, `"${types_1.NpmSnapFileNames.Manifest}" "shasum" field does not match computed shasum.`);
 }
-
+exports.validateNpmSnapManifest = validateNpmSnapManifest;
 //# sourceMappingURL=manifest.js.map