@metamask/snaps-cli 0.34.1-flask.1 → 0.35.0-flask.1

package/dist/{cmds → esm/cmds}/build/utils.js

@@ -1,10 +1,7 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.processInvalidTranspilation = exports.sanitizeDependencyPaths = exports.getDependencyRegExp = exports.processDependencies = exports.writeBundleFile = void 0;
-const snaps_utils_1 = require("@metamask/snaps-utils");
-const fs_1 = require("fs");
-const builders_1 = require("../../builders");
-const utils_1 = require("../../utils");
+import { logInfo } from '@metamask/snaps-utils';
+import { promises as fs } from 'fs';
+import { TranspilationModes } from '../../builders';
+import { writeError } from '../../utils';
 /**
  * Performs postprocessing on the bundle contents and writes them to disk.
  * Intended to be used in the callback passed to the Browserify `.bundle()`
@@ -18,69 +15,62 @@ const utils_1 = require("../../utils");
  * @param options.dest - The destination file path.
  * @param options.resolve - A {@link Promise} resolution function, so that we
  * can use promises and `async`/`await` even though Browserify uses callbacks.
- */
-async function writeBundleFile({ bundleError, bundleBuffer, src, dest, resolve, }) {
+ */ export async function writeBundleFile({ bundleError, bundleBuffer, src, dest, resolve }) {
     if (bundleError) {
-        await (0, utils_1.writeError)('Build error:', bundleError.message, bundleError);
+        await writeError('Build error:', bundleError.message, bundleError);
     }
     try {
-        await fs_1.promises.writeFile(dest, bundleBuffer?.toString());
-        (0, snaps_utils_1.logInfo)(`Build success: '${src}' bundled as '${dest}'!`);
+        await fs.writeFile(dest, bundleBuffer?.toString());
+        logInfo(`Build success: '${src}' bundled as '${dest}'!`);
         resolve(true);
-    }
-    catch (error) {
-        await (0, utils_1.writeError)('Write error:', error.message, error, dest);
+    } catch (error) {
+        await writeError('Write error:', error.message, error, dest);
     }
 }
-exports.writeBundleFile = writeBundleFile;
 /**
  * Processes dependencies and updates `argv` with an options object.
  *
  * @param argv - The Yargs arguments object.
  * @returns An object with options that can be passed to Babelify.
- */
-function processDependencies(argv) {
+ */ export function processDependencies(argv) {
     const { depsToTranspile, transpilationMode } = argv;
     const babelifyOptions = {};
-    if (transpilationMode === builders_1.TranspilationModes.LocalAndDeps) {
+    if (transpilationMode === TranspilationModes.LocalAndDeps) {
         const regexpStr = getDependencyRegExp(depsToTranspile);
         if (regexpStr !== null) {
-            babelifyOptions.ignore = [regexpStr];
+            babelifyOptions.ignore = [
+                regexpStr
+            ];
         }
     }
     return babelifyOptions;
 }
-exports.processDependencies = processDependencies;
 /**
  * Processes a string of space delimited dependencies into one RegExp string.
  *
  * @param dependencies - An array of dependencies to add to the RegExp.
  * @returns A RegExp object.
- */
-function getDependencyRegExp(dependencies) {
+ */ export function getDependencyRegExp(dependencies) {
     let regexp = null;
     if (!dependencies || dependencies.includes('.') || !dependencies.length) {
         return regexp;
     }
     const paths = sanitizeDependencyPaths(dependencies);
     regexp = `/node_modules/(?!${paths.shift() ?? ''}`;
-    paths.forEach((path) => (regexp += `|${path}`));
+    paths.forEach((path)=>regexp += `|${path}`);
     regexp += '/)';
     return RegExp(regexp, 'u');
 }
-exports.getDependencyRegExp = getDependencyRegExp;
 /**
  * Helper function remove any leading and trailing slashes from dependency list.
  *
  * @param dependencies - An array of dependencies to sanitize.
  * @returns An array of sanitized paths.
- */
-function sanitizeDependencyPaths(dependencies) {
-    return dependencies.map((dependency) => {
+ */ export function sanitizeDependencyPaths(dependencies) {
+    return dependencies.map((dependency)=>{
         return dependency.replace(/^[/\\]+/u, '').replace(/[/\\]+$/u, '');
     });
 }
-exports.sanitizeDependencyPaths = sanitizeDependencyPaths;
 /**
  * Check the Yargs argv object, to see if the provided options are valid. The
  * options are invalid if both `depsToTranspile` are provided, and
@@ -89,12 +79,10 @@ exports.sanitizeDependencyPaths = sanitizeDependencyPaths;
  * @param argv - The Yargs arguments object.
  * @throws If the `depsToTranspile` is set, and `transpilationMode` is not set
  * to `localAndDeps`.
- */
-function processInvalidTranspilation(argv) {
-    if (argv.depsToTranspile &&
-        argv.transpilationMode !== builders_1.TranspilationModes.LocalAndDeps) {
+ */ export function processInvalidTranspilation(argv) {
+    if (argv.depsToTranspile && argv.transpilationMode !== TranspilationModes.LocalAndDeps) {
         throw new Error('"depsToTranspile" can only be specified if "transpilationMode" is set to "localAndDeps" .');
     }
 }
-exports.processInvalidTranspilation = processInvalidTranspilation;
+
 //# sourceMappingURL=utils.js.map

package/dist/esm/cmds/build/utils.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/cmds/build/utils.ts"],"sourcesContent":["import { logInfo } from '@metamask/snaps-utils';\nimport { promises as fs } from 'fs';\n\nimport { TranspilationModes } from '../../builders';\nimport { YargsArgs } from '../../types/yargs';\nimport { writeError } from '../../utils';\n\ntype WriteBundleFileArgs = {\n  bundleError: Error;\n  bundleBuffer: Buffer;\n  src: string;\n  dest: string;\n  resolve: (value: boolean) => void;\n};\n\n/**\n * Performs postprocessing on the bundle contents and writes them to disk.\n * Intended to be used in the callback passed to the Browserify `.bundle()`\n * call.\n *\n * @param options - Options bag.\n * @param options.bundleError - Any error received from Browserify.\n * @param options.bundleBuffer - The {@link Buffer} with the bundle contents\n * from Browserify.\n * @param options.src - The source file path.\n * @param options.dest - The destination file path.\n * @param options.resolve - A {@link Promise} resolution function, so that we\n * can use promises and `async`/`await` even though Browserify uses callbacks.\n */\nexport async function writeBundleFile({\n  bundleError,\n  bundleBuffer,\n  src,\n  dest,\n  resolve,\n}: WriteBundleFileArgs) {\n  if (bundleError) {\n    await writeError('Build error:', bundleError.message, bundleError);\n  }\n\n  try {\n    await fs.writeFile(dest, bundleBuffer?.toString());\n    logInfo(`Build success: '${src}' bundled as '${dest}'!`);\n    resolve(true);\n  } catch (error) {\n    await writeError('Write error:', error.message, error, dest);\n  }\n}\n\n/**\n * Processes dependencies and updates `argv` with an options object.\n *\n * @param argv - The Yargs arguments object.\n * @returns An object with options that can be passed to Babelify.\n */\nexport function processDependencies(argv: YargsArgs) {\n  const { depsToTranspile, transpilationMode } = argv;\n  const babelifyOptions: Record<string, any> = {};\n  if (transpilationMode === TranspilationModes.LocalAndDeps) {\n    const regexpStr = getDependencyRegExp(depsToTranspile as string[]);\n    if (regexpStr !== null) {\n      babelifyOptions.ignore = [regexpStr];\n    }\n  }\n  return babelifyOptions;\n}\n\n/**\n * Processes a string of space delimited dependencies into one RegExp string.\n *\n * @param dependencies - An array of dependencies to add to the RegExp.\n * @returns A RegExp object.\n */\nexport function getDependencyRegExp(dependencies: string[]): RegExp | null {\n  let regexp: string | null = null;\n  if (!dependencies || dependencies.includes('.') || !dependencies.length) {\n    return regexp;\n  }\n  const paths: string[] = sanitizeDependencyPaths(dependencies);\n  regexp = `/node_modules/(?!${paths.shift() ?? ''}`;\n  paths.forEach((path) => (regexp += `|${path}`));\n  regexp += '/)';\n  return RegExp(regexp, 'u');\n}\n\n/**\n * Helper function remove any leading and trailing slashes from dependency list.\n *\n * @param dependencies - An array of dependencies to sanitize.\n * @returns An array of sanitized paths.\n */\nexport function sanitizeDependencyPaths(dependencies: string[]): string[] {\n  return dependencies.map((dependency) => {\n    return dependency.replace(/^[/\\\\]+/u, '').replace(/[/\\\\]+$/u, '');\n  });\n}\n\n/**\n * Check the Yargs argv object, to see if the provided options are valid. The\n * options are invalid if both `depsToTranspile` are provided, and\n * `transpilationMode` is not set to `localAndDeps`.\n *\n * @param argv - The Yargs arguments object.\n * @throws If the `depsToTranspile` is set, and `transpilationMode` is not set\n * to `localAndDeps`.\n */\nexport function processInvalidTranspilation(argv: YargsArgs) {\n  if (\n    argv.depsToTranspile &&\n    argv.transpilationMode !== TranspilationModes.LocalAndDeps\n  ) {\n    throw new Error(\n      '\"depsToTranspile\" can only be specified if \"transpilationMode\" is set to \"localAndDeps\" .',\n    );\n  }\n}\n"],"names":["logInfo","promises","fs","TranspilationModes","writeError","writeBundleFile","bundleError","bundleBuffer","src","dest","resolve","message","writeFile","toString","error","processDependencies","argv","depsToTranspile","transpilationMode","babelifyOptions","LocalAndDeps","regexpStr","getDependencyRegExp","ignore","dependencies","regexp","includes","length","paths","sanitizeDependencyPaths","shift","forEach","path","RegExp","map","dependency","replace","processInvalidTranspilation","Error"],"mappings":"AAAA,SAASA,OAAO,QAAQ,wBAAwB;AAChD,SAASC,YAAYC,EAAE,QAAQ,KAAK;AAEpC,SAASC,kBAAkB,QAAQ,iBAAiB;AAEpD,SAASC,UAAU,QAAQ,cAAc;AAUzC;;;;;;;;;;;;;CAaC,GACD,OAAO,eAAeC,gBAAgB,EACpCC,WAAW,EACXC,YAAY,EACZC,GAAG,EACHC,IAAI,EACJC,OAAO,EACa;IACpB,IAAIJ,aAAa;QACf,MAAMF,WAAW,gBAAgBE,YAAYK,OAAO,EAAEL;IACxD;IAEA,IAAI;QACF,MAAMJ,GAAGU,SAAS,CAACH,MAAMF,cAAcM;QACvCb,QAAQ,CAAC,gBAAgB,EAAEQ,IAAI,cAAc,EAAEC,KAAK,EAAE,CAAC;QACvDC,QAAQ;IACV,EAAE,OAAOI,OAAO;QACd,MAAMV,WAAW,gBAAgBU,MAAMH,OAAO,EAAEG,OAAOL;IACzD;AACF;AAEA;;;;;CAKC,GACD,OAAO,SAASM,oBAAoBC,IAAe;IACjD,MAAM,EAAEC,eAAe,EAAEC,iBAAiB,EAAE,GAAGF;IAC/C,MAAMG,kBAAuC,CAAC;IAC9C,IAAID,sBAAsBf,mBAAmBiB,YAAY,EAAE;QACzD,MAAMC,YAAYC,oBAAoBL;QACtC,IAAII,cAAc,MAAM;YACtBF,gBAAgBI,MAAM,GAAG;gBAACF;aAAU;QACtC;IACF;IACA,OAAOF;AACT;AAEA;;;;;CAKC,GACD,OAAO,SAASG,oBAAoBE,YAAsB;IACxD,IAAIC,SAAwB;IAC5B,IAAI,CAACD,gBAAgBA,aAAaE,QAAQ,CAAC,QAAQ,CAACF,aAAaG,MAAM,EAAE;QACvE,OAAOF;IACT;IACA,MAAMG,QAAkBC,wBAAwBL;IAChDC,SAAS,CAAC,iBAAiB,EAAEG,MAAME,KAAK,MAAM,GAAG,CAAC;IAClDF,MAAMG,OAAO,CAAC,CAACC,OAAUP,UAAU,CAAC,CAAC,EAAEO,KAAK,CAAC;IAC7CP,UAAU;IACV,OAAOQ,OAAOR,QAAQ;AACxB;AAEA;;;;;CAKC,GACD,OAAO,SAASI,wBAAwBL,YAAsB;IAC5D,OAAOA,aAAaU,GAAG,CAAC,CAACC;QACvB,OAAOA,WAAWC,OAAO,CAAC,YAAY,IAAIA,OAAO,CAAC,YAAY;IAChE;AACF;AAEA;;;;;;;;CAQC,GACD,OAAO,SAASC,4BAA4BrB,IAAe;IACzD,IACEA,KAAKC,eAAe,IACpBD,KAAKE,iBAAiB,KAAKf,mBAAmBiB,YAAY,EAC1D;QACA,MAAM,IAAIkB,MACR;IAEJ;AACF"}

package/dist/esm/cmds/eval/evalHandler.js

@@ -0,0 +1,20 @@
+import { evalBundle, logInfo } from '@metamask/snaps-utils';
+import { assert } from '@metamask/utils';
+/**
+ * Runs the snap in a worker, to ensure SES compatibility.
+ *
+ * @param argv - The Yargs arguments object.
+ * @returns A promise that resolves once the eval has finished.
+ * @throws If the eval failed.
+ */ export async function evalHandler(argv) {
+    const { bundle: bundlePath } = argv;
+    assert(typeof bundlePath === 'string');
+    try {
+        await evalBundle(bundlePath);
+        logInfo(`Eval Success: evaluated '${bundlePath}' in SES!`);
+    } catch (error) {
+        throw new Error(`Snap evaluation error: ${error.message}`);
+    }
+}
+
+//# sourceMappingURL=evalHandler.js.map

package/dist/esm/cmds/eval/evalHandler.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/cmds/eval/evalHandler.ts"],"sourcesContent":["import { evalBundle, logInfo } from '@metamask/snaps-utils';\nimport { assert } from '@metamask/utils';\n\nimport { YargsArgs } from '../../types/yargs';\n\n/**\n * Runs the snap in a worker, to ensure SES compatibility.\n *\n * @param argv - The Yargs arguments object.\n * @returns A promise that resolves once the eval has finished.\n * @throws If the eval failed.\n */\nexport async function evalHandler(argv: YargsArgs): Promise<void> {\n  const { bundle: bundlePath } = argv;\n\n  assert(typeof bundlePath === 'string');\n\n  try {\n    await evalBundle(bundlePath);\n    logInfo(`Eval Success: evaluated '${bundlePath}' in SES!`);\n  } catch (error) {\n    throw new Error(`Snap evaluation error: ${error.message}`);\n  }\n}\n"],"names":["evalBundle","logInfo","assert","evalHandler","argv","bundle","bundlePath","error","Error","message"],"mappings":"AAAA,SAASA,UAAU,EAAEC,OAAO,QAAQ,wBAAwB;AAC5D,SAASC,MAAM,QAAQ,kBAAkB;AAIzC;;;;;;CAMC,GACD,OAAO,eAAeC,YAAYC,IAAe;IAC/C,MAAM,EAAEC,QAAQC,UAAU,EAAE,GAAGF;IAE/BF,OAAO,OAAOI,eAAe;IAE7B,IAAI;QACF,MAAMN,WAAWM;QACjBL,QAAQ,CAAC,yBAAyB,EAAEK,WAAW,SAAS,CAAC;IAC3D,EAAE,OAAOC,OAAO;QACd,MAAM,IAAIC,MAAM,CAAC,uBAAuB,EAAED,MAAME,OAAO,CAAC,CAAC;IAC3D;AACF"}

package/dist/esm/cmds/eval/index.js

@@ -0,0 +1,16 @@
+import builders from '../../builders';
+import { evalHandler } from './evalHandler';
+const command = {
+    command: [
+        'eval',
+        'e'
+    ],
+    desc: 'Attempt to evaluate Snap bundle in SES',
+    builder: (yarg)=>{
+        yarg.option('bundle', builders.bundle);
+    },
+    handler: async (argv)=>evalHandler(argv)
+};
+export default command;
+
+//# sourceMappingURL=index.js.map

package/dist/esm/cmds/eval/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/cmds/eval/index.ts"],"sourcesContent":["import yargs from 'yargs';\n\nimport builders from '../../builders';\nimport { YargsArgs } from '../../types/yargs';\nimport { evalHandler } from './evalHandler';\n\nconst command = {\n  command: ['eval', 'e'],\n  desc: 'Attempt to evaluate Snap bundle in SES',\n  builder: (yarg: yargs.Argv) => {\n    yarg.option('bundle', builders.bundle);\n  },\n  handler: async (argv: YargsArgs) => evalHandler(argv),\n};\n\nexport default command;\n"],"names":["builders","evalHandler","command","desc","builder","yarg","option","bundle","handler","argv"],"mappings":"AAEA,OAAOA,cAAc,iBAAiB;AAEtC,SAASC,WAAW,QAAQ,gBAAgB;AAE5C,MAAMC,UAAU;IACdA,SAAS;QAAC;QAAQ;KAAI;IACtBC,MAAM;IACNC,SAAS,CAACC;QACRA,KAAKC,MAAM,CAAC,UAAUN,SAASO,MAAM;IACvC;IACAC,SAAS,OAAOC,OAAoBR,YAAYQ;AAClD;AAEA,eAAeP,QAAQ"}

package/dist/esm/cmds/index.js

@@ -0,0 +1,15 @@
+import build from './build';
+import evaluate from './eval';
+import manifest from './manifest';
+import serve from './serve';
+import watch from './watch';
+const commands = [
+    build,
+    evaluate,
+    manifest,
+    serve,
+    watch
+];
+export default commands;
+
+//# sourceMappingURL=index.js.map

package/dist/esm/cmds/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/cmds/index.ts"],"sourcesContent":["import build from './build';\nimport evaluate from './eval';\nimport manifest from './manifest';\nimport serve from './serve';\nimport watch from './watch';\n\nconst commands = [build, evaluate, manifest, serve, watch];\nexport default commands;\n"],"names":["build","evaluate","manifest","serve","watch","commands"],"mappings":"AAAA,OAAOA,WAAW,UAAU;AAC5B,OAAOC,cAAc,SAAS;AAC9B,OAAOC,cAAc,aAAa;AAClC,OAAOC,WAAW,UAAU;AAC5B,OAAOC,WAAW,UAAU;AAE5B,MAAMC,WAAW;IAACL;IAAOC;IAAUC;IAAUC;IAAOC;CAAM;AAC1D,eAAeC,SAAS"}

package/dist/esm/cmds/manifest/index.js

@@ -0,0 +1,29 @@
+import builders from '../../builders';
+import { logError } from '../../utils';
+import { manifestHandler } from './manifestHandler';
+const command = {
+    command: [
+        'manifest',
+        'm'
+    ],
+    desc: 'Validate the snap.manifest.json file',
+    builder: (yarg)=>{
+        yarg.option('writeManifest', {
+            ...builders.writeManifest,
+            alias: [
+                'fix'
+            ]
+        });
+    },
+    handler: async (argv)=>{
+        try {
+            await manifestHandler(argv);
+        } catch (error) {
+            logError(error.message, error);
+            throw error;
+        }
+    }
+};
+export default command;
+
+//# sourceMappingURL=index.js.map

package/dist/esm/cmds/manifest/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/cmds/manifest/index.ts"],"sourcesContent":["import yargs from 'yargs';\n\nimport builders from '../../builders';\nimport { YargsArgs } from '../../types/yargs';\nimport { logError } from '../../utils';\nimport { manifestHandler } from './manifestHandler';\n\nconst command = {\n  command: ['manifest', 'm'],\n  desc: 'Validate the snap.manifest.json file',\n  builder: (yarg: yargs.Argv) => {\n    yarg.option('writeManifest', { ...builders.writeManifest, alias: ['fix'] });\n  },\n  handler: async (argv: YargsArgs) => {\n    try {\n      await manifestHandler(argv);\n    } catch (error) {\n      logError(error.message, error);\n      throw error;\n    }\n  },\n};\n\nexport default command;\n"],"names":["builders","logError","manifestHandler","command","desc","builder","yarg","option","writeManifest","alias","handler","argv","error","message"],"mappings":"AAEA,OAAOA,cAAc,iBAAiB;AAEtC,SAASC,QAAQ,QAAQ,cAAc;AACvC,SAASC,eAAe,QAAQ,oBAAoB;AAEpD,MAAMC,UAAU;IACdA,SAAS;QAAC;QAAY;KAAI;IAC1BC,MAAM;IACNC,SAAS,CAACC;QACRA,KAAKC,MAAM,CAAC,iBAAiB;YAAE,GAAGP,SAASQ,aAAa;YAAEC,OAAO;gBAAC;aAAM;QAAC;IAC3E;IACAC,SAAS,OAAOC;QACd,IAAI;YACF,MAAMT,gBAAgBS;QACxB,EAAE,OAAOC,OAAO;YACdX,SAASW,MAAMC,OAAO,EAAED;YACxB,MAAMA;QACR;IACF;AACF;AAEA,eAAeT,QAAQ"}

package/dist/esm/cmds/manifest/manifestHandler.js

@@ -0,0 +1,43 @@
+import { checkManifest, logError, logWarning } from '@metamask/snaps-utils';
+const ERROR_PREFIX = 'Manifest Error: ';
+/**
+ * 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
+ * fails.
+ *
+ * @param argv - The Yargs `argv` object.
+ * @param argv.writeManifest - Whether to write the fixed manifest to disk.
+ */ export async function manifestHandler({ writeManifest }) {
+    try {
+        const { warnings, errors } = await checkManifest(process.cwd(), Boolean(writeManifest));
+        if (!writeManifest && errors.length > 0) {
+            logError(`${ERROR_PREFIX}The manifest is invalid.`);
+            errors.forEach(logManifestError);
+            process.exit(1);
+        }
+        if (warnings.length > 0) {
+            logWarning('Manifest Warning: Validation of snap.manifest.json completed with warnings.');
+            warnings.forEach(logManifestWarning);
+        }
+    } catch (error) {
+        throw new Error(`${ERROR_PREFIX}${error}`);
+    }
+}
+/**
+ * Logs a manifest warning, if `suppressWarnings` is not enabled.
+ *
+ * @param message - The message to log.
+ */ function logManifestWarning(message) {
+    if (!global.snaps.suppressWarnings) {
+        logWarning(`Manifest Warning: ${message}`);
+    }
+}
+/**
+ * Logs a manifest error.
+ *
+ * @param message - The message to log.
+ */ function logManifestError(message) {
+    logError(`${ERROR_PREFIX}${message}`);
+}
+
+//# sourceMappingURL=manifestHandler.js.map

package/dist/esm/cmds/manifest/manifestHandler.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/cmds/manifest/manifestHandler.ts"],"sourcesContent":["import { checkManifest, logError, logWarning } from '@metamask/snaps-utils';\n\nimport { YargsArgs } from '../../types/yargs';\n\nconst ERROR_PREFIX = 'Manifest Error: ';\n\n/**\n * Validates a snap.manifest.json file. Attempts to fix the manifest and write\n * the fixed version to disk if `writeManifest` is true. Throws if validation\n * fails.\n *\n * @param argv - The Yargs `argv` object.\n * @param argv.writeManifest - Whether to write the fixed manifest to disk.\n */\nexport async function manifestHandler({ writeManifest }: YargsArgs) {\n  try {\n    const { warnings, errors } = await checkManifest(\n      process.cwd(),\n      Boolean(writeManifest),\n    );\n\n    if (!writeManifest && errors.length > 0) {\n      logError(`${ERROR_PREFIX}The manifest is invalid.`);\n      errors.forEach(logManifestError);\n\n      process.exit(1);\n    }\n\n    if (warnings.length > 0) {\n      logWarning(\n        'Manifest Warning: Validation of snap.manifest.json completed with warnings.',\n      );\n      warnings.forEach(logManifestWarning);\n    }\n  } catch (error) {\n    throw new Error(`${ERROR_PREFIX}${error}`);\n  }\n}\n\n/**\n * Logs a manifest warning, if `suppressWarnings` is not enabled.\n *\n * @param message - The message to log.\n */\nfunction logManifestWarning(message: string) {\n  if (!global.snaps.suppressWarnings) {\n    logWarning(`Manifest Warning: ${message}`);\n  }\n}\n\n/**\n * Logs a manifest error.\n *\n * @param message - The message to log.\n */\nfunction logManifestError(message: string) {\n  logError(`${ERROR_PREFIX}${message}`);\n}\n"],"names":["checkManifest","logError","logWarning","ERROR_PREFIX","manifestHandler","writeManifest","warnings","errors","process","cwd","Boolean","length","forEach","logManifestError","exit","logManifestWarning","error","Error","message","global","snaps","suppressWarnings"],"mappings":"AAAA,SAASA,aAAa,EAAEC,QAAQ,EAAEC,UAAU,QAAQ,wBAAwB;AAI5E,MAAMC,eAAe;AAErB;;;;;;;CAOC,GACD,OAAO,eAAeC,gBAAgB,EAAEC,aAAa,EAAa;IAChE,IAAI;QACF,MAAM,EAAEC,QAAQ,EAAEC,MAAM,EAAE,GAAG,MAAMP,cACjCQ,QAAQC,GAAG,IACXC,QAAQL;QAGV,IAAI,CAACA,iBAAiBE,OAAOI,MAAM,GAAG,GAAG;YACvCV,SAAS,CAAC,EAAEE,aAAa,wBAAwB,CAAC;YAClDI,OAAOK,OAAO,CAACC;YAEfL,QAAQM,IAAI,CAAC;QACf;QAEA,IAAIR,SAASK,MAAM,GAAG,GAAG;YACvBT,WACE;YAEFI,SAASM,OAAO,CAACG;QACnB;IACF,EAAE,OAAOC,OAAO;QACd,MAAM,IAAIC,MAAM,CAAC,EAAEd,aAAa,EAAEa,MAAM,CAAC;IAC3C;AACF;AAEA;;;;CAIC,GACD,SAASD,mBAAmBG,OAAe;IACzC,IAAI,CAACC,OAAOC,KAAK,CAACC,gBAAgB,EAAE;QAClCnB,WAAW,CAAC,kBAAkB,EAAEgB,QAAQ,CAAC;IAC3C;AACF;AAEA;;;;CAIC,GACD,SAASL,iBAAiBK,OAAe;IACvCjB,SAAS,CAAC,EAAEE,aAAa,EAAEe,QAAQ,CAAC;AACtC"}

package/dist/esm/cmds/serve/index.js

@@ -0,0 +1,16 @@
+import builders from '../../builders';
+import { serve } from './serveHandler';
+const command = {
+    command: [
+        'serve',
+        's'
+    ],
+    desc: 'Locally serve Snap file(s) for testing',
+    builder: (yarg)=>{
+        yarg.option('root', builders.root).option('port', builders.port);
+    },
+    handler: async (argv)=>serve(argv)
+};
+export default command;
+
+//# sourceMappingURL=index.js.map

package/dist/esm/cmds/serve/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/cmds/serve/index.ts"],"sourcesContent":["import yargs from 'yargs';\n\nimport builders from '../../builders';\nimport { YargsArgs } from '../../types/yargs';\nimport { serve } from './serveHandler';\n\nconst command = {\n  command: ['serve', 's'],\n  desc: 'Locally serve Snap file(s) for testing',\n  builder: (yarg: yargs.Argv) => {\n    yarg.option('root', builders.root).option('port', builders.port);\n  },\n  handler: async (argv: YargsArgs) => serve(argv),\n};\n\nexport default command;\n"],"names":["builders","serve","command","desc","builder","yarg","option","root","port","handler","argv"],"mappings":"AAEA,OAAOA,cAAc,iBAAiB;AAEtC,SAASC,KAAK,QAAQ,iBAAiB;AAEvC,MAAMC,UAAU;IACdA,SAAS;QAAC;QAAS;KAAI;IACvBC,MAAM;IACNC,SAAS,CAACC;QACRA,KAAKC,MAAM,CAAC,QAAQN,SAASO,IAAI,EAAED,MAAM,CAAC,QAAQN,SAASQ,IAAI;IACjE;IACAC,SAAS,OAAOC,OAAoBT,MAAMS;AAC5C;AAEA,eAAeR,QAAQ"}

package/dist/esm/cmds/serve/serveHandler.js

@@ -0,0 +1,54 @@
+import { logInfo, validateDirPath } from '@metamask/snaps-utils';
+import http from 'http';
+import serveHandler from 'serve-handler';
+import { logRequest, logServerError, logServerListening } from './serveUtils';
+/**
+ * Starts a local, static HTTP server on the given port with the given root
+ * directory.
+ *
+ * @param argv - Arguments as an object generated by Yargs.
+ * @param argv.root - The root directory path string.
+ * @param argv.port - The server port.
+ */ export async function serve(argv) {
+    const { port, root: rootDir } = argv;
+    await validateDirPath(rootDir, true);
+    logInfo(`\nStarting server...`);
+    const server = http.createServer((req, res)=>{
+        serveHandler(req, res, {
+            public: rootDir,
+            headers: [
+                {
+                    source: '**/*',
+                    headers: [
+                        {
+                            key: 'Cache-Control',
+                            value: 'no-cache'
+                        },
+                        {
+                            key: 'Access-Control-Allow-Origin',
+                            value: '*'
+                        }
+                    ]
+                }
+            ]
+        })?.catch((error)=>{
+            logServerError(error, argv.port);
+            res.statusCode = 500;
+            res.end();
+        });
+    });
+    server.listen({
+        port
+    }, ()=>logServerListening(port));
+    server.on('request', (request)=>logRequest(request));
+    server.on('error', (error)=>{
+        logServerError(error, argv.port);
+        process.exitCode = 1;
+    });
+    server.on('close', ()=>{
+        logInfo('Server closed');
+        process.exitCode = 1;
+    });
+}
+
+//# sourceMappingURL=serveHandler.js.map

package/dist/esm/cmds/serve/serveHandler.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/cmds/serve/serveHandler.ts"],"sourcesContent":["import { logInfo, validateDirPath } from '@metamask/snaps-utils';\nimport http from 'http';\nimport serveHandler from 'serve-handler';\n\nimport { YargsArgs } from '../../types/yargs';\nimport { logRequest, logServerError, logServerListening } from './serveUtils';\n\n/**\n * Starts a local, static HTTP server on the given port with the given root\n * directory.\n *\n * @param argv - Arguments as an object generated by Yargs.\n * @param argv.root - The root directory path string.\n * @param argv.port - The server port.\n */\nexport async function serve(argv: YargsArgs): Promise<void> {\n  const { port, root: rootDir } = argv;\n\n  await validateDirPath(rootDir as string, true);\n\n  logInfo(`\\nStarting server...`);\n\n  const server = http.createServer((req, res) => {\n    serveHandler(req, res, {\n      public: rootDir as string,\n      headers: [\n        {\n          source: '**/*',\n          headers: [\n            {\n              key: 'Cache-Control',\n              value: 'no-cache',\n            },\n            {\n              key: 'Access-Control-Allow-Origin',\n              value: '*',\n            },\n          ],\n        },\n      ],\n    })?.catch((error) => {\n      logServerError(error, argv.port);\n      res.statusCode = 500;\n      res.end();\n    });\n  });\n\n  server.listen({ port }, () => logServerListening(port));\n\n  server.on('request', (request) => logRequest(request));\n\n  server.on('error', (error) => {\n    logServerError(error, argv.port);\n    process.exitCode = 1;\n  });\n\n  server.on('close', () => {\n    logInfo('Server closed');\n    process.exitCode = 1;\n  });\n}\n"],"names":["logInfo","validateDirPath","http","serveHandler","logRequest","logServerError","logServerListening","serve","argv","port","root","rootDir","server","createServer","req","res","public","headers","source","key","value","catch","error","statusCode","end","listen","on","request","process","exitCode"],"mappings":"AAAA,SAASA,OAAO,EAAEC,eAAe,QAAQ,wBAAwB;AACjE,OAAOC,UAAU,OAAO;AACxB,OAAOC,kBAAkB,gBAAgB;AAGzC,SAASC,UAAU,EAAEC,cAAc,EAAEC,kBAAkB,QAAQ,eAAe;AAE9E;;;;;;;CAOC,GACD,OAAO,eAAeC,MAAMC,IAAe;IACzC,MAAM,EAAEC,IAAI,EAAEC,MAAMC,OAAO,EAAE,GAAGH;IAEhC,MAAMP,gBAAgBU,SAAmB;IAEzCX,QAAQ,CAAC,oBAAoB,CAAC;IAE9B,MAAMY,SAASV,KAAKW,YAAY,CAAC,CAACC,KAAKC;QACrCZ,aAAaW,KAAKC,KAAK;YACrBC,QAAQL;YACRM,SAAS;gBACP;oBACEC,QAAQ;oBACRD,SAAS;wBACP;4BACEE,KAAK;4BACLC,OAAO;wBACT;wBACA;4BACED,KAAK;4BACLC,OAAO;wBACT;qBACD;gBACH;aACD;QACH,IAAIC,MAAM,CAACC;YACTjB,eAAeiB,OAAOd,KAAKC,IAAI;YAC/BM,IAAIQ,UAAU,GAAG;YACjBR,IAAIS,GAAG;QACT;IACF;IAEAZ,OAAOa,MAAM,CAAC;QAAEhB;IAAK,GAAG,IAAMH,mBAAmBG;IAEjDG,OAAOc,EAAE,CAAC,WAAW,CAACC,UAAYvB,WAAWuB;IAE7Cf,OAAOc,EAAE,CAAC,SAAS,CAACJ;QAClBjB,eAAeiB,OAAOd,KAAKC,IAAI;QAC/BmB,QAAQC,QAAQ,GAAG;IACrB;IAEAjB,OAAOc,EAAE,CAAC,SAAS;QACjB1B,QAAQ;QACR4B,QAAQC,QAAQ,GAAG;IACrB;AACF"}

package/dist/esm/cmds/serve/serveUtils.js

@@ -0,0 +1,30 @@
+import { logError, logInfo } from '@metamask/snaps-utils';
+/**
+ * Log a message with the URL and port of the server.
+ *
+ * @param port - The port that the server is running on.
+ */ export function logServerListening(port) {
+    logInfo(`Server listening on: http://localhost:${port}`);
+}
+/**
+ * Log a message with the request URL.
+ *
+ * @param request - The request object.
+ * @param request.url - The URL of the request.
+ */ export function logRequest(request) {
+    logInfo(`Handling incoming request for: ${request.url ?? 'unknown'}`);
+}
+/**
+ * Log an error message.
+ *
+ * @param error - The error to log.
+ * @param port - The port that the server is running on.
+ */ export function logServerError(error, port) {
+    if (error.code === 'EADDRINUSE') {
+        logError(`Server error: Port ${port} already in use.`);
+    } else {
+        logError(`Server error: ${error.message}`);
+    }
+}
+
+//# sourceMappingURL=serveUtils.js.map

package/dist/esm/cmds/serve/serveUtils.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/cmds/serve/serveUtils.ts"],"sourcesContent":["import { logError, logInfo } from '@metamask/snaps-utils';\n\n/**\n * Log a message with the URL and port of the server.\n *\n * @param port - The port that the server is running on.\n */\nexport function logServerListening(port: number) {\n  logInfo(`Server listening on: http://localhost:${port}`);\n}\n\n/**\n * Log a message with the request URL.\n *\n * @param request - The request object.\n * @param request.url - The URL of the request.\n */\nexport function logRequest(request: { url?: string }) {\n  logInfo(`Handling incoming request for: ${request.url ?? 'unknown'}`);\n}\n\n/**\n * Log an error message.\n *\n * @param error - The error to log.\n * @param port - The port that the server is running on.\n */\nexport function logServerError(error: Error, port: number) {\n  if ((error as any).code === 'EADDRINUSE') {\n    logError(`Server error: Port ${port} already in use.`);\n  } else {\n    logError(`Server error: ${error.message}`);\n  }\n}\n"],"names":["logError","logInfo","logServerListening","port","logRequest","request","url","logServerError","error","code","message"],"mappings":"AAAA,SAASA,QAAQ,EAAEC,OAAO,QAAQ,wBAAwB;AAE1D;;;;CAIC,GACD,OAAO,SAASC,mBAAmBC,IAAY;IAC7CF,QAAQ,CAAC,sCAAsC,EAAEE,KAAK,CAAC;AACzD;AAEA;;;;;CAKC,GACD,OAAO,SAASC,WAAWC,OAAyB;IAClDJ,QAAQ,CAAC,+BAA+B,EAAEI,QAAQC,GAAG,IAAI,UAAU,CAAC;AACtE;AAEA;;;;;CAKC,GACD,OAAO,SAASC,eAAeC,KAAY,EAAEL,IAAY;IACvD,IAAI,AAACK,MAAcC,IAAI,KAAK,cAAc;QACxCT,SAAS,CAAC,mBAAmB,EAAEG,KAAK,gBAAgB,CAAC;IACvD,OAAO;QACLH,SAAS,CAAC,cAAc,EAAEQ,MAAME,OAAO,CAAC,CAAC;IAC3C;AACF"}

package/dist/esm/cmds/watch/index.js

@@ -0,0 +1,17 @@
+import builders from '../../builders';
+import { processInvalidTranspilation } from '../build/utils';
+import { watch } from './watchHandler';
+const command = {
+    command: [
+        'watch',
+        'w'
+    ],
+    desc: 'Build Snap on change',
+    builder: (yarg)=>{
+        yarg.option('src', builders.src).option('eval', builders.eval).option('dist', builders.dist).option('outfileName', builders.outfileName).option('sourceMaps', builders.sourceMaps).option('stripComments', builders.stripComments).option('transpilationMode', builders.transpilationMode).option('depsToTranspile', builders.depsToTranspile).option('manifest', builders.manifest).option('writeManifest', builders.writeManifest).option('serve', builders.serve).option('root', builders.root).option('port', builders.port).implies('writeManifest', 'manifest').implies('depsToTranspile', 'transpilationMode').middleware((argv)=>processInvalidTranspilation(argv));
+    },
+    handler: async (argv)=>watch(argv)
+};
+export default command;
+
+//# sourceMappingURL=index.js.map

package/dist/esm/cmds/watch/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/cmds/watch/index.ts"],"sourcesContent":["import yargs from 'yargs';\n\nimport builders from '../../builders';\nimport { YargsArgs } from '../../types/yargs';\nimport { processInvalidTranspilation } from '../build/utils';\nimport { watch } from './watchHandler';\n\nconst command = {\n  command: ['watch', 'w'],\n  desc: 'Build Snap on change',\n  builder: (yarg: yargs.Argv) => {\n    yarg\n      .option('src', builders.src)\n      .option('eval', builders.eval)\n      .option('dist', builders.dist)\n      .option('outfileName', builders.outfileName)\n      .option('sourceMaps', builders.sourceMaps)\n      .option('stripComments', builders.stripComments)\n      .option('transpilationMode', builders.transpilationMode)\n      .option('depsToTranspile', builders.depsToTranspile)\n      .option('manifest', builders.manifest)\n      .option('writeManifest', builders.writeManifest)\n      .option('serve', builders.serve)\n      .option('root', builders.root)\n      .option('port', builders.port)\n      .implies('writeManifest', 'manifest')\n      .implies('depsToTranspile', 'transpilationMode')\n      .middleware((argv) => processInvalidTranspilation(argv as any));\n  },\n  handler: async (argv: YargsArgs) => watch(argv),\n};\n\nexport default command;\n"],"names":["builders","processInvalidTranspilation","watch","command","desc","builder","yarg","option","src","eval","dist","outfileName","sourceMaps","stripComments","transpilationMode","depsToTranspile","manifest","writeManifest","serve","root","port","implies","middleware","argv","handler"],"mappings":"AAEA,OAAOA,cAAc,iBAAiB;AAEtC,SAASC,2BAA2B,QAAQ,iBAAiB;AAC7D,SAASC,KAAK,QAAQ,iBAAiB;AAEvC,MAAMC,UAAU;IACdA,SAAS;QAAC;QAAS;KAAI;IACvBC,MAAM;IACNC,SAAS,CAACC;QACRA,KACGC,MAAM,CAAC,OAAOP,SAASQ,GAAG,EAC1BD,MAAM,CAAC,QAAQP,SAASS,IAAI,EAC5BF,MAAM,CAAC,QAAQP,SAASU,IAAI,EAC5BH,MAAM,CAAC,eAAeP,SAASW,WAAW,EAC1CJ,MAAM,CAAC,cAAcP,SAASY,UAAU,EACxCL,MAAM,CAAC,iBAAiBP,SAASa,aAAa,EAC9CN,MAAM,CAAC,qBAAqBP,SAASc,iBAAiB,EACtDP,MAAM,CAAC,mBAAmBP,SAASe,eAAe,EAClDR,MAAM,CAAC,YAAYP,SAASgB,QAAQ,EACpCT,MAAM,CAAC,iBAAiBP,SAASiB,aAAa,EAC9CV,MAAM,CAAC,SAASP,SAASkB,KAAK,EAC9BX,MAAM,CAAC,QAAQP,SAASmB,IAAI,EAC5BZ,MAAM,CAAC,QAAQP,SAASoB,IAAI,EAC5BC,OAAO,CAAC,iBAAiB,YACzBA,OAAO,CAAC,mBAAmB,qBAC3BC,UAAU,CAAC,CAACC,OAAStB,4BAA4BsB;IACtD;IACAC,SAAS,OAAOD,OAAoBrB,MAAMqB;AAC5C;AAEA,eAAepB,QAAQ"}

package/dist/esm/cmds/watch/watchHandler.js

@@ -0,0 +1,87 @@
+import { getOutfilePath, logError, logInfo, validateDirPath, validateFilePath, validateOutfileName, NpmSnapFileNames } from '@metamask/snaps-utils';
+import chokidar from 'chokidar';
+import pathUtils from 'path';
+import { CONFIG_FILE, loadConfig } from '../../utils';
+import { bundle } from '../build/bundle';
+import { evalHandler } from '../eval/evalHandler';
+import { manifestHandler } from '../manifest/manifestHandler';
+import { serve } from '../serve/serveHandler';
+/**
+ * Watch a directory and its subdirectories for changes, and build when files
+ * are added or changed.
+ *
+ * Ignores 'node_modules' and dotfiles.
+ * Creates destination directory if it doesn't exist.
+ *
+ * @param argv - Arguments as an object generated by Yargs.
+ * @param argv.src - The source file path.
+ * @param argv.dist - The output directory path.
+ * @param argv.'outfileName' - The output file name.
+ */ export async function watch(argv) {
+    const { dist, eval: shouldEval, manifest, outfileName, src, serve: shouldServe } = argv;
+    if (outfileName) {
+        validateOutfileName(outfileName);
+    }
+    await validateFilePath(src);
+    await validateDirPath(dist, true);
+    const srcDir = pathUtils.dirname(src);
+    const watchDirs = [
+        srcDir,
+        NpmSnapFileNames.Manifest,
+        CONFIG_FILE
+    ];
+    const outfilePath = getOutfilePath(dist, outfileName);
+    const buildSnap = async (path, logMessage)=>{
+        if (logMessage !== undefined) {
+            logInfo(logMessage);
+        }
+        try {
+            await bundle(src, outfilePath, argv, loadConfig().bundlerCustomizer);
+            if (manifest) {
+                await manifestHandler(argv);
+            }
+            if (shouldEval) {
+                await evalHandler({
+                    ...argv,
+                    bundle: outfilePath
+                });
+            }
+        } catch (error) {
+            logError(`Error ${path === undefined ? 'during initial build' : `while processing "${path}"`}.`, error);
+        }
+    };
+    chokidar.watch(watchDirs, {
+        ignoreInitial: true,
+        ignored: [
+            '**/node_modules/**',
+            `**/${dist}/**`,
+            `**/test/**`,
+            `**/tests/**`,
+            `**/*.test.js`,
+            `**/*.test.ts`,
+            /* istanbul ignore next */ (str)=>str !== '.' && str.startsWith('.')
+        ]
+    }).on('ready', ()=>{
+        buildSnap().then(()=>{
+            if (shouldServe) {
+                return serve(argv);
+            }
+            return undefined;
+        }).catch((error)=>{
+            logError('Error during initial build.', error);
+        });
+    }).on('add', (path)=>{
+        buildSnap(path, `File added: ${path}`).catch((error)=>{
+            logError(`Error while processing "${path}".`, error);
+        });
+    }).on('change', (path)=>{
+        buildSnap(path, `File changed: ${path}`).catch((error)=>{
+            logError(`Error while processing "${path}".`, error);
+        });
+    }).on('unlink', (path)=>logInfo(`File removed: ${path}`)).on('error', (error)=>{
+        logError(`Watcher error: ${error.message}`, error);
+    });
+    logInfo(`Watching ${watchDirs.map((dir)=>`'${dir}'`).join(', ')} for changes...`);
+}
+
+//# sourceMappingURL=watchHandler.js.map

package/dist/esm/cmds/watch/watchHandler.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/cmds/watch/watchHandler.ts"],"sourcesContent":["import {\n  getOutfilePath,\n  logError,\n  logInfo,\n  validateDirPath,\n  validateFilePath,\n  validateOutfileName,\n  NpmSnapFileNames,\n} from '@metamask/snaps-utils';\nimport chokidar from 'chokidar';\nimport pathUtils from 'path';\n\nimport { YargsArgs } from '../../types/yargs';\nimport { CONFIG_FILE, loadConfig } from '../../utils';\nimport { bundle } from '../build/bundle';\nimport { evalHandler } from '../eval/evalHandler';\nimport { manifestHandler } from '../manifest/manifestHandler';\nimport { serve } from '../serve/serveHandler';\n\n/**\n * Watch a directory and its subdirectories for changes, and build when files\n * are added or changed.\n *\n * Ignores 'node_modules' and dotfiles.\n * Creates destination directory if it doesn't exist.\n *\n * @param argv - Arguments as an object generated by Yargs.\n * @param argv.src - The source file path.\n * @param argv.dist - The output directory path.\n * @param argv.'outfileName' - The output file name.\n */\nexport async function watch(argv: YargsArgs): Promise<void> {\n  const {\n    dist,\n    eval: shouldEval,\n    manifest,\n    outfileName,\n    src,\n    serve: shouldServe,\n  } = argv;\n  if (outfileName) {\n    validateOutfileName(outfileName);\n  }\n  await validateFilePath(src);\n  await validateDirPath(dist, true);\n  const srcDir = pathUtils.dirname(src);\n  const watchDirs = [srcDir, NpmSnapFileNames.Manifest, CONFIG_FILE];\n  const outfilePath = getOutfilePath(dist, outfileName);\n\n  const buildSnap = async (path?: string, logMessage?: string) => {\n    if (logMessage !== undefined) {\n      logInfo(logMessage);\n    }\n\n    try {\n      await bundle(src, outfilePath, argv, loadConfig().bundlerCustomizer);\n\n      if (manifest) {\n        await manifestHandler(argv);\n      }\n\n      if (shouldEval) {\n        await evalHandler({ ...argv, bundle: outfilePath });\n      }\n    } catch (error) {\n      logError(\n        `Error ${\n          path === undefined\n            ? 'during initial build'\n            : `while processing \"${path}\"`\n        }.`,\n        error,\n      );\n    }\n  };\n\n  chokidar\n    .watch(watchDirs, {\n      ignoreInitial: true,\n      ignored: [\n        '**/node_modules/**',\n        `**/${dist}/**`,\n        `**/test/**`,\n        `**/tests/**`,\n        `**/*.test.js`,\n        `**/*.test.ts`,\n        /* istanbul ignore next */\n        (str: string) => str !== '.' && str.startsWith('.'),\n      ],\n    })\n\n    .on('ready', () => {\n      buildSnap()\n        .then(() => {\n          if (shouldServe) {\n            return serve(argv);\n          }\n\n          return undefined;\n        })\n        .catch((error) => {\n          logError('Error during initial build.', error);\n        });\n    })\n    .on('add', (path) => {\n      buildSnap(path, `File added: ${path}`).catch((error) => {\n        logError(`Error while processing \"${path}\".`, error);\n      });\n    })\n    .on('change', (path) => {\n      buildSnap(path, `File changed: ${path}`).catch((error) => {\n        logError(`Error while processing \"${path}\".`, error);\n      });\n    })\n    .on('unlink', (path) => logInfo(`File removed: ${path}`))\n    .on('error', (error: Error) => {\n      logError(`Watcher error: ${error.message}`, error);\n    });\n\n  logInfo(\n    `Watching ${watchDirs.map((dir) => `'${dir}'`).join(', ')} for changes...`,\n  );\n}\n"],"names":["getOutfilePath","logError","logInfo","validateDirPath","validateFilePath","validateOutfileName","NpmSnapFileNames","chokidar","pathUtils","CONFIG_FILE","loadConfig","bundle","evalHandler","manifestHandler","serve","watch","argv","dist","eval","shouldEval","manifest","outfileName","src","shouldServe","srcDir","dirname","watchDirs","Manifest","outfilePath","buildSnap","path","logMessage","undefined","bundlerCustomizer","error","ignoreInitial","ignored","str","startsWith","on","then","catch","message","map","dir","join"],"mappings":"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"}

package/dist/esm/index.js

@@ -0,0 +1,3 @@
+export * as utils from './utils';
+
+//# sourceMappingURL=index.js.map

package/dist/esm/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/index.ts"],"sourcesContent":["export * as utils from './utils';\n"],"names":["utils"],"mappings":"AAAA,OAAO,KAAKA,KAAK,MAAM,UAAU"}

package/dist/esm/main.js

@@ -0,0 +1,11 @@
+#!/usr/bin/env node
+import { cli } from './cli';
+import commands from './cmds';
+global.snaps = {
+    verboseErrors: false,
+    suppressWarnings: false,
+    isWatching: false
+};
+cli(process.argv, commands);
+
+//# sourceMappingURL=main.js.map

package/dist/esm/main.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/main.ts"],"sourcesContent":["#!/usr/bin/env node\n\nimport { cli } from './cli';\nimport commands from './cmds';\n\nglobal.snaps = {\n  verboseErrors: false,\n  suppressWarnings: false,\n  isWatching: false,\n};\n\ncli(process.argv, commands);\n"],"names":["cli","commands","global","snaps","verboseErrors","suppressWarnings","isWatching","process","argv"],"mappings":";AAEA,SAASA,GAAG,QAAQ,QAAQ;AAC5B,OAAOC,cAAc,SAAS;AAE9BC,OAAOC,KAAK,GAAG;IACbC,eAAe;IACfC,kBAAkB;IAClBC,YAAY;AACd;AAEAN,IAAIO,QAAQC,IAAI,EAAEP"}

package/dist/esm/utils/index.js

@@ -0,0 +1,4 @@
+export * from './misc';
+export * from './snap-config';
+
+//# sourceMappingURL=index.js.map

package/dist/esm/utils/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/utils/index.ts"],"sourcesContent":["export * from './misc';\nexport * from './snap-config';\n"],"names":[],"mappings":"AAAA,cAAc,SAAS;AACvB,cAAc,gBAAgB"}