@metamask/snaps-cli 1.0.2 → 2.0.0

package/dist/esm/webpack/config.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/webpack/config.ts"],"sourcesContent":["import SnapsWebpackPlugin from '@metamask/snaps-webpack-plugin';\nimport type { Ora } from 'ora';\nimport { resolve } from 'path';\nimport TerserPlugin from 'terser-webpack-plugin';\nimport type { Configuration } from 'webpack';\nimport { EnvironmentPlugin, ProgressPlugin, ProvidePlugin } from 'webpack';\n\nimport type { ProcessedWebpackConfig } from '../config';\nimport {\n  SnapsBuiltInResolver,\n  SnapsBundleWarningsPlugin,\n  SnapsStatsPlugin,\n  SnapsWatchPlugin,\n} from './plugins';\nimport {\n  BROWSERSLIST_FILE,\n  getDefaultLoader,\n  getDevTool,\n  getFallbacks,\n  getProgressHandler,\n} from './utils';\n\nexport type WebpackOptions = {\n  /**\n   * Whether to watch for changes.\n   */\n  watch?: boolean;\n\n  /**\n   * Whether to evaluate the bundle. If this is set, it will override the\n   * `evaluate` option in the config object.\n   */\n  evaluate?: boolean;\n\n  /**\n   * The spinner to use for logging.\n   */\n  spinner?: Ora;\n};\n\n/**\n * Get the default Webpack configuration. This is the configuration that will\n * be used if the user doesn't provide a custom Webpack configuration. The\n * configuration is based on the snap config.\n *\n * The default configuration includes:\n *\n * - `SWC` to transpile TypeScript and JavaScript files.\n * - `TerserPlugin` to minify the bundle.\n * - `SnapsWebpackPlugin` to validate the bundle and update the manifest.\n *\n * It can be customized through the `customizeWebpackConfig` function in the\n * snap config, but in most cases, you shouldn't need to do that.\n *\n * @param config - The processed snap Webpack config.\n * @param options - The Webpack options.\n * @returns The default Webpack configuration.\n */\nexport async function getDefaultConfiguration(\n  config: ProcessedWebpackConfig,\n  options: WebpackOptions = {\n    evaluate: config.evaluate,\n  },\n): Promise<Configuration> {\n  const spinnerText = options.spinner?.text;\n  const builtInResolver =\n    config.stats.builtIns &&\n    new SnapsBuiltInResolver(config.stats.builtIns, options.spinner);\n\n  return {\n    /**\n     * The target is set to `browserslist` so that Webpack will compile the\n     * bundle to support the browsers specified in the `.browserslistrc` file.\n     * This Browserslist file contains the browsers that are supported by\n     * MetaMask Snaps.\n     *\n     * @see https://webpack.js.org/configuration/target/\n     */\n    target: `browserslist:${BROWSERSLIST_FILE}`,\n\n    /**\n     * The mode is set to `production` by default, so that Webpack will minify\n     * and optimize the bundle.\n     *\n     * @see https://webpack.js.org/configuration/mode/\n     */\n    mode: 'production',\n\n    /**\n     * The entry point is set to the `input` value from the config object.\n     *\n     * @see https://webpack.js.org/configuration/entry-context/\n     */\n    entry: config.input,\n\n    /**\n     * The devtool option controls how source maps are generated. We set it to\n     * the `sourceMap` value from the config object.\n     *\n     * @see https://webpack.js.org/configuration/devtool/\n     */\n    devtool: getDevTool(config.sourceMap),\n\n    /**\n     * The stats option controls how much information is printed to the console\n     * when Webpack is running. We set it to `none` so that we can control the\n     * output ourselves.\n     *\n     * @see https://webpack.js.org/configuration/stats/\n     */\n    stats: 'none',\n\n    /**\n     * The output options.\n     *\n     * @see https://webpack.js.org/configuration/output/\n     */\n    output: {\n      /**\n       * This indicates whether Webpack should clear the output directory\n       * before building. We set it to the `clean` value from the config\n       * object.\n       *\n       * @see https://webpack.js.org/configuration/output/#outputclean\n       */\n      clean: config.output.clean,\n\n      /**\n       * The filename of the bundle. We set it to the `filename` value from\n       * the config object.\n       *\n       * @see https://webpack.js.org/configuration/output/#outputfilename\n       */\n      filename: config.output.filename,\n\n      /**\n       * The path to the output directory. We set it to the `path` value from\n       * the config object.\n       *\n       * @see https://webpack.js.org/configuration/output/#outputpath\n       */\n      path: config.output.path,\n\n      /**\n       * The public path of the bundle. We set it to `/` by default, so that\n       * the bundle can be loaded from the root of the server.\n       *\n       * @see https://webpack.js.org/configuration/output/#outputpublicpath\n       */\n      publicPath: '/',\n\n      /**\n       * The library configuration. This tells Webpack how to export the\n       * bundle.\n       *\n       * @see https://webpack.js.org/configuration/output/#outputlibrary\n       */\n      library: {\n        /**\n         * This tells Webpack to export the bundle as a CommonJS module. This\n         * is necessary for MetaMask Snaps.\n         *\n         * @see https://webpack.js.org/configuration/output/#outputlibrarytarget\n         */\n        type: 'commonjs',\n      },\n    },\n\n    /**\n     * The module configuration. This is where we tell Webpack how to handle\n     * different types of files.\n     *\n     * @see https://webpack.js.org/configuration/module/\n     */\n    module: {\n      rules: [\n        {\n          test: /\\.[tj]sx?$/u,\n          exclude: /node_modules/u,\n          use: await getDefaultLoader(config),\n        },\n\n        config.experimental.wasm && {\n          test: /\\.wasm$/u,\n          use: {\n            loader: resolve(__dirname, 'loaders', 'wasm'),\n          },\n        },\n      ],\n    },\n\n    /**\n     * The resolve configuration. This tells Webpack how to resolve imports.\n     * We set it to resolve `.js` and `.ts` files.\n     *\n     * @see https://webpack.js.org/configuration/resolve/\n     */\n    resolve: {\n      /**\n       * The extensions to resolve. We set it to resolve `.js` and `.ts`\n       * files.\n       */\n      extensions: ['.js', '.ts'],\n\n      /**\n       * The fallback options. This tells Webpack how to handle imports that\n       * aren't resolved. By default, we set Node.js built-ins to `false`, so\n       * that they are ignored.\n       */\n      fallback: getFallbacks(config.polyfills),\n\n      /**\n       * The plugins to use. We use the {@link SnapsBuiltInResolver} to show\n       * warnings about using Node.js built-ins, when no fallback is specified.\n       */\n      plugins: [builtInResolver],\n    },\n\n    /**\n     * The plugins to use.\n     *\n     * @see https://webpack.js.org/configuration/plugins/\n     */\n    plugins: [\n      /**\n       * The `SnapsWebpackPlugin` is a Webpack plugin that checks and updates\n       * the manifest file, and evaluates the bundle in SES. While not strictly\n       * required, it's highly recommended to use this plugin.\n       */\n      new SnapsWebpackPlugin({\n        manifestPath: config.manifest.path,\n        writeManifest: config.manifest.update,\n        eval: !options.watch && options.evaluate,\n      }),\n\n      /**\n       * The `SnapsStatsPlugin` is a Webpack plugin that handles the stats\n       * output. It's used to show the stats in the terminal, in a format that\n       * is easy to read.\n       */\n      new SnapsStatsPlugin({ verbose: config.stats.verbose }, options.spinner),\n\n      /**\n       * The `EnvironmentPlugin` is a Webpack plugin that adds environment\n       * variables to the bundle. We use it to add the `NODE_ENV` and `DEBUG`\n       * environment variables.\n       */\n      new EnvironmentPlugin(config.environment),\n\n      /**\n       * The `ProgressPlugin` is a Webpack plugin that logs the progress of\n       * the build. We set it to log the progress to the spinner.\n       */\n      new ProgressPlugin({\n        handler: getProgressHandler(options.spinner, spinnerText),\n      }),\n\n      /**\n       * The `SnapsBundleWarningPlugin` is a Webpack plugin that shows a\n       * warning when the bundle is potentially incompatible with MetaMask\n       * Snaps.\n       */\n      new SnapsBundleWarningsPlugin(\n        {\n          builtInResolver,\n          builtIns: Boolean(config.stats.builtIns),\n          buffer: config.stats.buffer,\n        },\n        options.spinner,\n      ),\n\n      /**\n       * The `WatchPlugin` is a Webpack plugin that adds extra files to watch\n       * for changes. This is useful for rebuilding the bundle when the\n       * manifest file changes.\n       */\n      options.watch &&\n        new SnapsWatchPlugin(\n          {\n            bundle: resolve(config.output.path, config.output.filename),\n            evaluate: options.evaluate,\n            files: [config.manifest.path],\n          },\n          options.spinner,\n        ),\n\n      /**\n       * The `ProviderPlugin` is a Webpack plugin that automatically load\n       * modules instead of having to import or require them everywhere.\n       */\n      (config.polyfills === true ||\n        (config.polyfills !== false && config.polyfills.buffer)) &&\n        new ProvidePlugin({\n          Buffer: ['buffer', 'Buffer'],\n        }),\n    ].filter(Boolean),\n\n    /**\n     * The optimization configuration. This tells Webpack how to optimize the\n     * bundle. Most of the time, you won't need to change this, as the default\n     * options set by the `mode` option are sufficient.\n     */\n    optimization: {\n      minimize: config.output.minimize,\n\n      /**\n       * The minimizer to use. We set it to use the `TerserPlugin`.\n       */\n      minimizer: [\n        new TerserPlugin({\n          parallel: true,\n        }),\n      ],\n    },\n\n    /**\n     * The infrastructure logging configuration. This tells Webpack how to\n     * log messages.\n     *\n     * @see https://webpack.js.org/configuration/infrastructure-logging\n     */\n    infrastructureLogging: {\n      /**\n       * The level of logging to use. We set it to `none`, so that we can\n       * control the output ourselves.\n       */\n      level: 'none',\n    },\n  };\n}\n"],"names":["SnapsWebpackPlugin","resolve","TerserPlugin","EnvironmentPlugin","ProgressPlugin","ProvidePlugin","SnapsBuiltInResolver","SnapsBundleWarningsPlugin","SnapsStatsPlugin","SnapsWatchPlugin","BROWSERSLIST_FILE","getDefaultLoader","getDevTool","getFallbacks","getProgressHandler","getDefaultConfiguration","config","options","evaluate","spinnerText","spinner","text","builtInResolver","stats","builtIns","target","mode","entry","input","devtool","sourceMap","output","clean","filename","path","publicPath","library","type","module","rules","test","exclude","use","experimental","wasm","loader","__dirname","extensions","fallback","polyfills","plugins","manifestPath","manifest","writeManifest","update","eval","watch","verbose","environment","handler","Boolean","buffer","bundle","files","Buffer","filter","optimization","minimize","minimizer","parallel","infrastructureLogging","level"],"mappings":"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"}

package/dist/esm/webpack/index.js

@@ -0,0 +1,5 @@
+export * from './compiler';
+export * from './config';
+export * from './plugins';
+
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/webpack/index.ts"],"sourcesContent":["export * from './compiler';\nexport * from './config';\nexport * from './plugins';\n"],"names":[],"mappings":"AAAA,cAAc,aAAa;AAC3B,cAAc,WAAW;AACzB,cAAc,YAAY"}

package/dist/esm/webpack/loaders/browserify.js

@@ -0,0 +1,82 @@
+import browserify from 'browserify';
+import { Readable } from 'stream';
+import { TranspilationModes } from '../../builders';
+import { processDependencies } from '../../utils';
+import { getBrowserslistTargets } from '../utils';
+/**
+ * A Browserify loader for Webpack. This exists for backwards compatibility with
+ * the legacy configuration format, in order to support the `bundlerCustomizer`
+ * function.
+ *
+ * When this loader is used, the input file will be processed by Browserify, and
+ * written to disk by Webpack. Most processing will be handled by Browserify, so
+ * there are no benefits like tree-shaking.
+ *
+ * @param content - The input file contents as a string.
+ * @param sourceMap - The source map of the input file.
+ */ const loader = async function(content, sourceMap) {
+    const config = this.getOptions();
+    const { transpilationMode } = config;
+    const bundler = browserify({
+        extensions: [
+            '.js',
+            '.ts'
+        ],
+        debug: Boolean(sourceMap),
+        standalone: '<snap>'
+    });
+    if (transpilationMode !== TranspilationModes.None) {
+        const babelifyOptions = processDependencies(config);
+        // We need to statically import all Browserify transforms, and all Babel
+        // presets and plugins, and calling `require` is the sanest way to do that.
+        /* eslint-disable @typescript-eslint/no-require-imports, @typescript-eslint/no-var-requires, n/global-require */ bundler.transform(require('babelify'), {
+            global: transpilationMode === TranspilationModes.LocalAndDeps,
+            extensions: [
+                '.js',
+                '.ts'
+            ],
+            presets: [
+                require('@babel/preset-typescript'),
+                [
+                    require('@babel/preset-env'),
+                    {
+                        targets: {
+                            browsers: await getBrowserslistTargets()
+                        }
+                    }
+                ]
+            ],
+            plugins: [
+                require('@babel/plugin-transform-runtime'),
+                require('@babel/plugin-proposal-class-properties'),
+                require('@babel/plugin-proposal-private-methods'),
+                require('@babel/plugin-proposal-class-static-block'),
+                require('@babel/plugin-proposal-private-property-in-object')
+            ],
+            ...babelifyOptions
+        });
+    /* eslint-enable @typescript-eslint/no-require-imports, @typescript-eslint/no-var-requires, n/global-require */ }
+    config.bundlerCustomizer?.(bundler);
+    // Browserify doesn't accept a string as an entry point, so we need to convert
+    // it to a stream.
+    const stream = new Readable();
+    stream.push(content);
+    stream.push(null);
+    bundler.add(stream, {
+        file: this.resourcePath
+    });
+    return new Promise((resolve, reject)=>{
+        bundler.bundle((bundleError, buffer)=>{
+            if (bundleError) {
+                reject(bundleError);
+                return;
+            }
+            // Browserify inlines the source map, so we just pass the output buffer back
+            // to Webpack.
+            resolve(buffer);
+        });
+    });
+};
+export default loader;
+
+//# sourceMappingURL=browserify.js.map

package/dist/esm/webpack/loaders/browserify.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/webpack/loaders/browserify.ts"],"sourcesContent":["import browserify from 'browserify';\nimport { Readable } from 'stream';\nimport type { LoaderDefinitionFunction } from 'webpack';\n\nimport { TranspilationModes } from '../../builders';\nimport type { LegacyOptions } from '../../config';\nimport { processDependencies } from '../../utils';\nimport { getBrowserslistTargets } from '../utils';\n\n/**\n * A Browserify loader for Webpack. This exists for backwards compatibility with\n * the legacy configuration format, in order to support the `bundlerCustomizer`\n * function.\n *\n * When this loader is used, the input file will be processed by Browserify, and\n * written to disk by Webpack. Most processing will be handled by Browserify, so\n * there are no benefits like tree-shaking.\n *\n * @param content - The input file contents as a string.\n * @param sourceMap - The source map of the input file.\n */\nconst loader: LoaderDefinitionFunction<LegacyOptions> = async function (\n  content,\n  sourceMap,\n) {\n  const config = this.getOptions();\n\n  const { transpilationMode } = config;\n\n  const bundler = browserify({\n    extensions: ['.js', '.ts'],\n    debug: Boolean(sourceMap),\n    standalone: '<snap>',\n  });\n\n  if (transpilationMode !== TranspilationModes.None) {\n    const babelifyOptions = processDependencies(config);\n\n    // We need to statically import all Browserify transforms, and all Babel\n    // presets and plugins, and calling `require` is the sanest way to do that.\n    /* eslint-disable @typescript-eslint/no-require-imports, @typescript-eslint/no-var-requires, n/global-require */\n    bundler.transform(require('babelify'), {\n      global: transpilationMode === TranspilationModes.LocalAndDeps,\n      extensions: ['.js', '.ts'],\n      presets: [\n        require('@babel/preset-typescript'),\n        [\n          require('@babel/preset-env'),\n          {\n            targets: {\n              browsers: await getBrowserslistTargets(),\n            },\n          },\n        ],\n      ],\n      plugins: [\n        require('@babel/plugin-transform-runtime'),\n        require('@babel/plugin-proposal-class-properties'),\n        require('@babel/plugin-proposal-private-methods'),\n        require('@babel/plugin-proposal-class-static-block'),\n        require('@babel/plugin-proposal-private-property-in-object'),\n      ],\n      ...(babelifyOptions as any),\n    });\n    /* eslint-enable @typescript-eslint/no-require-imports, @typescript-eslint/no-var-requires, n/global-require */\n  }\n\n  config.bundlerCustomizer?.(bundler);\n\n  // Browserify doesn't accept a string as an entry point, so we need to convert\n  // it to a stream.\n  const stream = new Readable();\n  stream.push(content);\n  stream.push(null);\n\n  bundler.add(stream, {\n    file: this.resourcePath,\n  });\n\n  return new Promise<Buffer>((resolve, reject) => {\n    bundler.bundle((bundleError, buffer: Buffer) => {\n      if (bundleError) {\n        reject(bundleError);\n        return;\n      }\n\n      // Browserify inlines the source map, so we just pass the output buffer back\n      // to Webpack.\n      resolve(buffer);\n    });\n  });\n};\n\nexport default loader;\n"],"names":["browserify","Readable","TranspilationModes","processDependencies","getBrowserslistTargets","loader","content","sourceMap","config","getOptions","transpilationMode","bundler","extensions","debug","Boolean","standalone","None","babelifyOptions","transform","require","global","LocalAndDeps","presets","targets","browsers","plugins","bundlerCustomizer","stream","push","add","file","resourcePath","Promise","resolve","reject","bundle","bundleError","buffer"],"mappings":"AAAA,OAAOA,gBAAgB,aAAa;AACpC,SAASC,QAAQ,QAAQ,SAAS;AAGlC,SAASC,kBAAkB,QAAQ,iBAAiB;AAEpD,SAASC,mBAAmB,QAAQ,cAAc;AAClD,SAASC,sBAAsB,QAAQ,WAAW;AAElD;;;;;;;;;;;CAWC,GACD,MAAMC,SAAkD,eACtDC,OAAO,EACPC,SAAS;IAET,MAAMC,SAAS,IAAI,CAACC,UAAU;IAE9B,MAAM,EAAEC,iBAAiB,EAAE,GAAGF;IAE9B,MAAMG,UAAUX,WAAW;QACzBY,YAAY;YAAC;YAAO;SAAM;QAC1BC,OAAOC,QAAQP;QACfQ,YAAY;IACd;IAEA,IAAIL,sBAAsBR,mBAAmBc,IAAI,EAAE;QACjD,MAAMC,kBAAkBd,oBAAoBK;QAE5C,wEAAwE;QACxE,2EAA2E;QAC3E,8GAA8G,GAC9GG,QAAQO,SAAS,CAACC,QAAQ,aAAa;YACrCC,QAAQV,sBAAsBR,mBAAmBmB,YAAY;YAC7DT,YAAY;gBAAC;gBAAO;aAAM;YAC1BU,SAAS;gBACPH,QAAQ;gBACR;oBACEA,QAAQ;oBACR;wBACEI,SAAS;4BACPC,UAAU,MAAMpB;wBAClB;oBACF;iBACD;aACF;YACDqB,SAAS;gBACPN,QAAQ;gBACRA,QAAQ;gBACRA,QAAQ;gBACRA,QAAQ;gBACRA,QAAQ;aACT;YACD,GAAIF,eAAe;QACrB;IACA,6GAA6G,GAC/G;IAEAT,OAAOkB,iBAAiB,GAAGf;IAE3B,8EAA8E;IAC9E,kBAAkB;IAClB,MAAMgB,SAAS,IAAI1B;IACnB0B,OAAOC,IAAI,CAACtB;IACZqB,OAAOC,IAAI,CAAC;IAEZjB,QAAQkB,GAAG,CAACF,QAAQ;QAClBG,MAAM,IAAI,CAACC,YAAY;IACzB;IAEA,OAAO,IAAIC,QAAgB,CAACC,SAASC;QACnCvB,QAAQwB,MAAM,CAAC,CAACC,aAAaC;YAC3B,IAAID,aAAa;gBACfF,OAAOE;gBACP;YACF;YAEA,4EAA4E;YAC5E,cAAc;YACdH,QAAQI;QACV;IACF;AACF;AAEA,eAAehC,OAAO"}

package/dist/esm/webpack/loaders/wasm.js

@@ -0,0 +1,26 @@
+import { assert, stringToBytes } from '@metamask/utils';
+/**
+ * A Webpack loader that inlines the WASM module as a `Uint8Array`. This makes
+ * it possible to import the WASM module directly, and use it with the
+ * `WebAssembly.instantiate` function.
+ *
+ * This is useful, because snaps are not allowed to import assets from outside
+ * of their package. This loader allows you to inline the WASM module as a
+ * `Uint8Array`, which can then be passed to `WebAssembly.instantiate`.
+ *
+ * @param source - The WASM module as a string.
+ * @returns A string that exports the WASM module as a `Uint8Array`.
+ * @example
+ * ```ts
+ * import wasm from './program.wasm';
+ *
+ * const { instance } = await WebAssembly.instantiate(wasm, {});
+ * // Do something with the WASM module...
+ * ```
+ */ export default function loader(source) {
+    assert(typeof source === 'string', 'Expected source to be a string.');
+    const bytes = stringToBytes(source);
+    return `export default new Uint8Array(${JSON.stringify(Array.from(bytes))});`;
+}
+
+//# sourceMappingURL=wasm.js.map

package/dist/esm/webpack/loaders/wasm.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/webpack/loaders/wasm.ts"],"sourcesContent":["import { assert, stringToBytes } from '@metamask/utils';\n\n/**\n * A Webpack loader that inlines the WASM module as a `Uint8Array`. This makes\n * it possible to import the WASM module directly, and use it with the\n * `WebAssembly.instantiate` function.\n *\n * This is useful, because snaps are not allowed to import assets from outside\n * of their package. This loader allows you to inline the WASM module as a\n * `Uint8Array`, which can then be passed to `WebAssembly.instantiate`.\n *\n * @param source - The WASM module as a string.\n * @returns A string that exports the WASM module as a `Uint8Array`.\n * @example\n * ```ts\n * import wasm from './program.wasm';\n *\n * const { instance } = await WebAssembly.instantiate(wasm, {});\n * // Do something with the WASM module...\n * ```\n */\nexport default function loader(source: unknown) {\n  assert(typeof source === 'string', 'Expected source to be a string.');\n\n  const bytes = stringToBytes(source);\n  return `export default new Uint8Array(${JSON.stringify(Array.from(bytes))});`;\n}\n"],"names":["assert","stringToBytes","loader","source","bytes","JSON","stringify","Array","from"],"mappings":"AAAA,SAASA,MAAM,EAAEC,aAAa,QAAQ,kBAAkB;AAExD;;;;;;;;;;;;;;;;;;CAkBC,GACD,eAAe,SAASC,OAAOC,MAAe;IAC5CH,OAAO,OAAOG,WAAW,UAAU;IAEnC,MAAMC,QAAQH,cAAcE;IAC5B,OAAO,CAAC,8BAA8B,EAAEE,KAAKC,SAAS,CAACC,MAAMC,IAAI,CAACJ,QAAQ,EAAE,CAAC;AAC/E"}

package/dist/esm/webpack/plugins.js

@@ -0,0 +1,343 @@
+function _check_private_redeclaration(obj, privateCollection) {
+    if (privateCollection.has(obj)) {
+        throw new TypeError("Cannot initialize the same private elements twice on an object");
+    }
+}
+function _class_apply_descriptor_get(receiver, descriptor) {
+    if (descriptor.get) {
+        return descriptor.get.call(receiver);
+    }
+    return descriptor.value;
+}
+function _class_apply_descriptor_set(receiver, descriptor, value) {
+    if (descriptor.set) {
+        descriptor.set.call(receiver, value);
+    } else {
+        if (!descriptor.writable) {
+            throw new TypeError("attempted to set read only private field");
+        }
+        descriptor.value = value;
+    }
+}
+function _class_extract_field_descriptor(receiver, privateMap, action) {
+    if (!privateMap.has(receiver)) {
+        throw new TypeError("attempted to " + action + " private field on non-instance");
+    }
+    return privateMap.get(receiver);
+}
+function _class_private_field_get(receiver, privateMap) {
+    var descriptor = _class_extract_field_descriptor(receiver, privateMap, "get");
+    return _class_apply_descriptor_get(receiver, descriptor);
+}
+function _class_private_field_init(obj, privateMap, value) {
+    _check_private_redeclaration(obj, privateMap);
+    privateMap.set(obj, value);
+}
+function _class_private_field_set(receiver, privateMap, value) {
+    var descriptor = _class_extract_field_descriptor(receiver, privateMap, "set");
+    _class_apply_descriptor_set(receiver, descriptor, value);
+    return value;
+}
+function _class_private_method_get(receiver, privateSet, fn) {
+    if (!privateSet.has(receiver)) {
+        throw new TypeError("attempted to get private field on non-instance");
+    }
+    return fn;
+}
+function _class_private_method_init(obj, privateSet) {
+    _check_private_redeclaration(obj, privateSet);
+    privateSet.add(obj);
+}
+function _define_property(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+import { indent } from '@metamask/snaps-utils';
+import { assert, hasProperty, isObject } from '@metamask/utils';
+import { dim, red, yellow } from 'chalk';
+import { isBuiltin } from 'module';
+import { evaluate } from '../commands/eval';
+import { error, getErrorMessage, info, warn } from '../utils';
+import { pluralize } from './utils';
+var _spinner = /*#__PURE__*/ new WeakMap(), /**
+   * Get the error message for the given stats error.
+   *
+   * @param statsError - The stats error.
+   * @returns The error message.
+   */ _getStatsErrorMessage = /*#__PURE__*/ new WeakSet();
+/**
+ * A plugin that logs the stats after compilation. This is useful for logging
+ * the number of files compiled, and the time taken to compile them.
+ */ export class SnapsStatsPlugin {
+    /**
+   * Apply the plugin to the Webpack compiler.
+   *
+   * @param compiler - The Webpack compiler.
+   */ apply(compiler) {
+        compiler.hooks.afterDone.tap(this.constructor.name, (stats)=>{
+            if (!stats) {
+                return;
+            }
+            const { modules, time, errors } = stats.toJson();
+            assert(modules, 'Modules must be defined in stats.');
+            assert(time, 'Time must be defined in stats.');
+            if (errors?.length) {
+                const formattedErrors = errors.map(_class_private_method_get(this, _getStatsErrorMessage, getStatsErrorMessage).bind(this)).join('\n\n');
+                error(`Compiled ${modules.length} ${pluralize(modules.length, 'file')} in ${time}ms with ${errors.length} ${pluralize(errors.length, 'error')}.\n\n${formattedErrors}\n`, _class_private_field_get(this, _spinner));
+                _class_private_field_get(this, _spinner)?.stop();
+                process.exitCode = 1;
+                return;
+            }
+            info(`Compiled ${modules.length} ${pluralize(modules.length, 'file')} in ${time}ms.`, _class_private_field_get(this, _spinner));
+            if (compiler.watchMode) {
+                // The spinner may be restarted by the watch plugin, outside of the
+                // `executeSteps` flow, so we stop it here just in case.
+                _class_private_field_get(this, _spinner)?.succeed('Done!');
+            }
+        });
+    }
+    constructor(options = {
+        verbose: false
+    }, spinner){
+        _class_private_method_init(this, _getStatsErrorMessage);
+        /**
+   * The options for the plugin.
+   */ _define_property(this, "options", void 0);
+        /**
+   * The spinner to use for logging.
+   */ _class_private_field_init(this, _spinner, {
+            writable: true,
+            value: void 0
+        });
+        this.options = options;
+        _class_private_field_set(this, _spinner, spinner);
+    }
+}
+function getStatsErrorMessage(statsError) {
+    const baseMessage = this.options.verbose ? getErrorMessage(statsError) : statsError.message;
+    const [first, ...rest] = baseMessage.split('\n');
+    return [
+        indent(red(`• ${first}`), 2),
+        ...rest.map((message)=>indent(red(message), 4)),
+        statsError.details && indent(dim(statsError.details), 4)
+    ].filter(Boolean).join('\n');
+}
+var _spinner1 = /*#__PURE__*/ new WeakMap(), _safeEvaluate = /*#__PURE__*/ new WeakSet();
+/**
+ * A plugin that adds extra files to watch. This is useful for watching files
+ * that are not imported by the entry point, such as the `snap.manifest.json`
+ * file.
+ */ export class SnapsWatchPlugin {
+    /**
+   * Apply the plugin to the Webpack compiler.
+   *
+   * @param compiler - The Webpack compiler.
+   */ apply(compiler) {
+        compiler.hooks.invalid.tap(this.constructor.name, (file)=>{
+            _class_private_field_get(this, _spinner1)?.start();
+            info(`Changes detected in ${yellow(file)}, recompiling.`, _class_private_field_get(this, _spinner1));
+        });
+        compiler.hooks.afterEmit.tapPromise(this.constructor.name, async ({ fileDependencies })=>{
+            this.options.files?.forEach(fileDependencies.add.bind(fileDependencies));
+            if (this.options.bundle && this.options.evaluate) {
+                await _class_private_method_get(this, _safeEvaluate, safeEvaluate).call(this, this.options.bundle);
+            }
+        });
+    }
+    constructor(options, spinner){
+        /**
+   * Safely evaluate the bundle at the given path. If an error occurs, it will
+   * be logged to the console, rather than throwing an error.
+   *
+   * This function should never throw an error.
+   *
+   * @param bundlePath - The path to the bundle.
+   */ _class_private_method_init(this, _safeEvaluate);
+        /**
+   * The options for the plugin.
+   */ _define_property(this, "options", void 0);
+        /**
+   * The spinner to use for logging.
+   */ _class_private_field_init(this, _spinner1, {
+            writable: true,
+            value: void 0
+        });
+        this.options = options;
+        _class_private_field_set(this, _spinner1, spinner);
+    }
+}
+async function safeEvaluate(bundlePath) {
+    try {
+        await evaluate(bundlePath);
+        info(`Snap bundle evaluated successfully.`, _class_private_field_get(this, _spinner1));
+    } catch (evaluateError) {
+        error(evaluateError.message, _class_private_field_get(this, _spinner1));
+    }
+}
+var _source = /*#__PURE__*/ new WeakMap(), _spinner2 = /*#__PURE__*/ new WeakMap();
+/**
+ * A plugin that logs a message when a built-in module is not resolved. The
+ * MetaMask Snaps CLI does not support built-in modules by default, and this
+ * plugin is used to warn the user when they try to import a built-in module,
+ * when no fallback is configured.
+ */ export class SnapsBuiltInResolver {
+    /**
+   * Apply the plugin to the Webpack resolver.
+   *
+   * @param resolver - The Webpack resolver.
+   */ apply(resolver) {
+        resolver.getHook(_class_private_field_get(this, _source)).tapAsync(this.constructor.name, ({ module: isModule, request }, _, callback)=>{
+            if (!isModule || !request) {
+                return callback();
+            }
+            const baseRequest = request.split('/')[0];
+            if (isBuiltin(baseRequest) && !this.options.ignore?.includes(baseRequest)) {
+                const fallback = resolver.options.fallback.find(({ name })=>name === baseRequest);
+                if (fallback && !fallback.alias) {
+                    this.unresolvedModules.add(baseRequest);
+                }
+            }
+            return callback();
+        });
+    }
+    constructor(options = {
+        ignore: []
+    }, spinner){
+        /**
+   * The built-in modules that have been imported, but not resolved.
+   */ _define_property(this, "unresolvedModules", new Set());
+        /**
+   * The name of the resolver hook to tap into.
+   */ _class_private_field_init(this, _source, {
+            writable: true,
+            value: 'described-resolve'
+        });
+        /**
+   * The options for the plugin.
+   */ _define_property(this, "options", void 0);
+        /**
+   * The spinner to use for logging.
+   */ _class_private_field_init(this, _spinner2, {
+            writable: true,
+            value: void 0
+        });
+        this.options = options;
+        _class_private_field_set(this, _spinner2, spinner);
+    }
+}
+var _spinner3 = /*#__PURE__*/ new WeakMap(), /**
+   * Check if a built-in module is used, but not provided by Webpack's
+   * `fallback` configuration.
+   *
+   * @param compiler - The Webpack compiler.
+   */ _checkBuiltIns = /*#__PURE__*/ new WeakSet(), /**
+   * Check if the given instance is a `ProvidePlugin`. This is not guaranteed to
+   * be accurate, but it's good enough for our purposes. If we were to use
+   * `instanceof` instead, it might not work if multiple versions of Webpack are
+   * installed.
+   *
+   * @param instance - The instance to check.
+   * @returns Whether the instance is a `ProvidePlugin`, i.e., whether it's an
+   * object with the name `ProvidePlugin` and a `definitions` property.
+   */ _isProvidePlugin = /*#__PURE__*/ new WeakSet(), /**
+   * Check if the `Buffer` global is used, but not provided by Webpack's
+   * `DefinePlugin`.
+   *
+   * @param compiler - The Webpack compiler.
+   */ _checkBuffer = /*#__PURE__*/ new WeakSet();
+/**
+ * A plugin that logs a message when:
+ *
+ * - A built-in module is not resolved. The MetaMask Snaps CLI does not support
+ * built-in modules by default, and this plugin is used to warn the user when
+ * they try to import a built-in module, when no fallback is configured.
+ * - A snap uses the `Buffer` global. The MetaMask Snaps CLI does not support
+ * the `Buffer` global by default, and this plugin is used to warn the user when
+ * they try to use the `Buffer` global.
+ *
+ * We use both a resolver and a plugin, because the resolver is used to detect
+ * when a built-in module is imported, and the plugin is used to log a single
+ * message when the compilation is complete. We can't do everything in a single
+ * plugin, because the resolver doesn't have access to the compilation, and the
+ * plugin doesn't have access to the resolver.
+ */ export class SnapsBundleWarningsPlugin {
+    /**
+   * Apply the plugin to the Webpack compiler.
+   *
+   * @param compiler - The Webpack compiler.
+   */ apply(compiler) {
+        if (this.options.builtIns) {
+            _class_private_method_get(this, _checkBuiltIns, checkBuiltIns).call(this, compiler);
+        }
+        if (this.options.buffer) {
+            _class_private_method_get(this, _checkBuffer, checkBuffer).call(this, compiler);
+        }
+    }
+    constructor(options = {
+        buffer: true,
+        builtIns: true
+    }, spinner){
+        _class_private_method_init(this, _checkBuiltIns);
+        _class_private_method_init(this, _isProvidePlugin);
+        _class_private_method_init(this, _checkBuffer);
+        /**
+   * The spinner to use for logging.
+   */ _class_private_field_init(this, _spinner3, {
+            writable: true,
+            value: void 0
+        });
+        /**
+   * The options for the plugin.
+   */ _define_property(this, "options", void 0);
+        this.options = options;
+        _class_private_field_set(this, _spinner3, spinner);
+    }
+}
+function checkBuiltIns(compiler) {
+    compiler.hooks.afterCompile.tap(this.constructor.name, ()=>{
+        if (!this.options.builtInResolver) {
+            return;
+        }
+        const { unresolvedModules } = this.options.builtInResolver;
+        if (unresolvedModules.size === 0) {
+            return;
+        }
+        const formattedModules = new Array(...unresolvedModules).map((name)=>indent(`• ${name}`, 2)).join('\n');
+        warn(`The snap attempted to use one or more Node.js builtins, but no browser fallback has been provided.\n` + `The MetaMask Snaps CLI does not support Node.js builtins by default. If you want to use this module, you must set ${yellow(`polyfills`)} to ${yellow(`true`)} or an object with the builtins to polyfill as the key and ${yellow(`true`)} as the value.\n` + `To disable this warning, set ${yellow('`stats.builtIns`')} to ${yellow('`false`')} in your snap config file, or add the module to the ${yellow('`stats.builtIns.ignore`')} array.\n\n${formattedModules}\n`, _class_private_field_get(this, _spinner3));
+    });
+}
+function isProvidePlugin(instance) {
+    return isObject(instance) && instance.constructor.name === 'ProvidePlugin' && hasProperty(instance, 'definitions');
+}
+function checkBuffer(compiler) {
+    const plugin = compiler.options.plugins?.find((instance)=>_class_private_method_get(this, _isProvidePlugin, isProvidePlugin).call(this, instance));
+    // If the `ProvidePlugin` is configured to provide `Buffer`, then we don't
+    // need to warn the user.
+    if (plugin) {
+        const { definitions } = plugin;
+        if (definitions.Buffer) {
+            return;
+        }
+    }
+    compiler.hooks.compilation.tap(this.constructor.name, (compilation)=>{
+        compilation.hooks.afterProcessAssets.tap(this.constructor.name, (assets)=>{
+            // Check if assets use `Buffer`.
+            const bufferAssets = Object.entries(assets).filter(([name])=>name.endsWith('.js')).filter(([, asset])=>asset.source().includes('Buffer'));
+            if (bufferAssets.length === 0) {
+                return;
+            }
+            warn(`The snap attempted to use the Node.js Buffer global, which is not supported in the MetaMask Snaps CLI by default.\n` + `To use the Buffer global, you must polyfill Buffer by setting ${yellow(`buffer`)} to ${yellow(`true`)} in the ${yellow(`polyfills`)} config object in your snap config.\n` + `To disable this warning, set ${yellow('`stats.buffer`')} to ${yellow('`false`')} in your snap config file.`, _class_private_field_get(this, _spinner3));
+        });
+    });
+}
+
+//# sourceMappingURL=plugins.js.map

package/dist/esm/webpack/plugins.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/webpack/plugins.ts"],"sourcesContent":["import { indent } from '@metamask/snaps-utils';\nimport { assert, hasProperty, isObject } from '@metamask/utils';\nimport { dim, red, yellow } from 'chalk';\nimport { isBuiltin } from 'module';\nimport type { Ora } from 'ora';\nimport type {\n  Compiler,\n  ProvidePlugin,\n  ResolvePluginInstance,\n  Resolver,\n  StatsError,\n  WebpackPluginInstance,\n} from 'webpack';\n\nimport { evaluate } from '../commands/eval';\nimport { error, getErrorMessage, info, warn } from '../utils';\nimport { pluralize } from './utils';\n\nexport type SnapsStatsPluginOptions = {\n  /**\n   * Whether to log the verbose stats.\n   */\n  verbose?: boolean;\n};\n\n/**\n * A plugin that logs the stats after compilation. This is useful for logging\n * the number of files compiled, and the time taken to compile them.\n */\nexport class SnapsStatsPlugin implements WebpackPluginInstance {\n  /**\n   * The options for the plugin.\n   */\n  readonly options: SnapsStatsPluginOptions;\n\n  /**\n   * The spinner to use for logging.\n   */\n  readonly #spinner?: Ora;\n\n  constructor(\n    options: SnapsStatsPluginOptions = {\n      verbose: false,\n    },\n    spinner?: Ora,\n  ) {\n    this.options = options;\n    this.#spinner = spinner;\n  }\n\n  /**\n   * Apply the plugin to the Webpack compiler.\n   *\n   * @param compiler - The Webpack compiler.\n   */\n  apply(compiler: Compiler) {\n    compiler.hooks.afterDone.tap(this.constructor.name, (stats) => {\n      if (!stats) {\n        return;\n      }\n\n      const { modules, time, errors } = stats.toJson();\n\n      assert(modules, 'Modules must be defined in stats.');\n      assert(time, 'Time must be defined in stats.');\n\n      if (errors?.length) {\n        const formattedErrors = errors\n          .map(this.#getStatsErrorMessage.bind(this))\n          .join('\\n\\n');\n\n        error(\n          `Compiled ${modules.length} ${pluralize(\n            modules.length,\n            'file',\n          )} in ${time}ms with ${errors.length} ${pluralize(\n            errors.length,\n            'error',\n          )}.\\n\\n${formattedErrors}\\n`,\n          this.#spinner,\n        );\n\n        this.#spinner?.stop();\n\n        process.exitCode = 1;\n        return;\n      }\n\n      info(\n        `Compiled ${modules.length} ${pluralize(\n          modules.length,\n          'file',\n        )} in ${time}ms.`,\n        this.#spinner,\n      );\n\n      if (compiler.watchMode) {\n        // The spinner may be restarted by the watch plugin, outside of the\n        // `executeSteps` flow, so we stop it here just in case.\n        this.#spinner?.succeed('Done!');\n      }\n    });\n  }\n\n  /**\n   * Get the error message for the given stats error.\n   *\n   * @param statsError - The stats error.\n   * @returns The error message.\n   */\n  #getStatsErrorMessage(statsError: StatsError) {\n    const baseMessage = this.options.verbose\n      ? getErrorMessage(statsError)\n      : statsError.message;\n\n    const [first, ...rest] = baseMessage.split('\\n');\n\n    return [\n      indent(red(`• ${first}`), 2),\n      ...rest.map((message) => indent(red(message), 4)),\n      statsError.details && indent(dim(statsError.details), 4),\n    ]\n      .filter(Boolean)\n      .join('\\n');\n  }\n}\n\n/**\n * The options for the {@link SnapsWatchPlugin}.\n */\nexport type SnapsWatchPluginOptions = {\n  /**\n   * The bundle path. This is the file that will be evaluated, if the `evaluate`\n   * option is set.\n   */\n  bundle?: string;\n\n  /**\n   * Whether to evaluate the bundle. This only applies if the `bundle` option is\n   * set.\n   */\n  evaluate?: boolean;\n\n  /**\n   * The extra files to watch.\n   */\n  files?: string[];\n};\n\n/**\n * A plugin that adds extra files to watch. This is useful for watching files\n * that are not imported by the entry point, such as the `snap.manifest.json`\n * file.\n */\nexport class SnapsWatchPlugin implements WebpackPluginInstance {\n  /**\n   * The options for the plugin.\n   */\n  readonly options: SnapsWatchPluginOptions;\n\n  /**\n   * The spinner to use for logging.\n   */\n  readonly #spinner?: Ora;\n\n  constructor(options: SnapsWatchPluginOptions, spinner?: Ora) {\n    this.options = options;\n    this.#spinner = spinner;\n  }\n\n  /**\n   * Apply the plugin to the Webpack compiler.\n   *\n   * @param compiler - The Webpack compiler.\n   */\n  apply(compiler: Compiler) {\n    compiler.hooks.invalid.tap(this.constructor.name, (file) => {\n      this.#spinner?.start();\n      info(`Changes detected in ${yellow(file)}, recompiling.`, this.#spinner);\n    });\n\n    compiler.hooks.afterEmit.tapPromise(\n      this.constructor.name,\n      async ({ fileDependencies }) => {\n        this.options.files?.forEach(\n          fileDependencies.add.bind(fileDependencies),\n        );\n\n        if (this.options.bundle && this.options.evaluate) {\n          await this.#safeEvaluate(this.options.bundle);\n        }\n      },\n    );\n  }\n\n  /**\n   * Safely evaluate the bundle at the given path. If an error occurs, it will\n   * be logged to the console, rather than throwing an error.\n   *\n   * This function should never throw an error.\n   *\n   * @param bundlePath - The path to the bundle.\n   */\n  async #safeEvaluate(bundlePath: string) {\n    try {\n      await evaluate(bundlePath);\n      info(`Snap bundle evaluated successfully.`, this.#spinner);\n    } catch (evaluateError) {\n      error(evaluateError.message, this.#spinner);\n    }\n  }\n}\n\n/**\n * The options for the {@link SnapsBuiltInResolver}.\n */\nexport type SnapsBuiltInResolverOptions = {\n  /**\n   * The built-in modules to ignore.\n   */\n  ignore?: string[];\n};\n\n/**\n * A plugin that logs a message when a built-in module is not resolved. The\n * MetaMask Snaps CLI does not support built-in modules by default, and this\n * plugin is used to warn the user when they try to import a built-in module,\n * when no fallback is configured.\n */\nexport class SnapsBuiltInResolver implements ResolvePluginInstance {\n  /**\n   * The built-in modules that have been imported, but not resolved.\n   */\n  readonly unresolvedModules = new Set<string>();\n\n  /**\n   * The name of the resolver hook to tap into.\n   */\n  readonly #source = 'described-resolve';\n\n  /**\n   * The options for the plugin.\n   */\n  readonly options: SnapsBuiltInResolverOptions;\n\n  /**\n   * The spinner to use for logging.\n   */\n  readonly #spinner?: Ora;\n\n  constructor(\n    options: SnapsBuiltInResolverOptions = {\n      ignore: [],\n    },\n    spinner?: Ora,\n  ) {\n    this.options = options;\n    this.#spinner = spinner;\n  }\n\n  /**\n   * Apply the plugin to the Webpack resolver.\n   *\n   * @param resolver - The Webpack resolver.\n   */\n  apply(resolver: Resolver) {\n    resolver\n      .getHook(this.#source)\n      .tapAsync(\n        this.constructor.name,\n        ({ module: isModule, request }, _, callback) => {\n          if (!isModule || !request) {\n            return callback();\n          }\n\n          const baseRequest = request.split('/')[0];\n          if (\n            isBuiltin(baseRequest) &&\n            !this.options.ignore?.includes(baseRequest)\n          ) {\n            const fallback = resolver.options.fallback.find(\n              ({ name }) => name === baseRequest,\n            );\n\n            if (fallback && !fallback.alias) {\n              this.unresolvedModules.add(baseRequest);\n            }\n          }\n\n          return callback();\n        },\n      );\n  }\n}\n\n/**\n * The options for the {@link SnapsBundleWarningsPlugin}.\n */\nexport type SnapsBundleWarningsPluginOptions = {\n  /**\n   * The {@link SnapsBuiltInResolver} instance to use for detecting built-in\n   * modules.\n   */\n  builtInResolver?: SnapsBuiltInResolver | false;\n\n  /**\n   * Whether to show warnings if built-in modules are used, but not provided by\n   * Webpack's `fallback` configuration.\n   */\n  builtIns?: boolean;\n\n  /**\n   * Whether to show warnings if the `Buffer` global is used, but not provided\n   * by Webpack's `DefinePlugin`.\n   */\n  buffer?: boolean;\n};\n\n/**\n * A plugin that logs a message when:\n *\n * - A built-in module is not resolved. The MetaMask Snaps CLI does not support\n * built-in modules by default, and this plugin is used to warn the user when\n * they try to import a built-in module, when no fallback is configured.\n * - A snap uses the `Buffer` global. The MetaMask Snaps CLI does not support\n * the `Buffer` global by default, and this plugin is used to warn the user when\n * they try to use the `Buffer` global.\n *\n * We use both a resolver and a plugin, because the resolver is used to detect\n * when a built-in module is imported, and the plugin is used to log a single\n * message when the compilation is complete. We can't do everything in a single\n * plugin, because the resolver doesn't have access to the compilation, and the\n * plugin doesn't have access to the resolver.\n */\n\nexport class SnapsBundleWarningsPlugin implements WebpackPluginInstance {\n  /**\n   * The spinner to use for logging.\n   */\n  readonly #spinner?: Ora;\n\n  /**\n   * The options for the plugin.\n   */\n  readonly options: SnapsBundleWarningsPluginOptions;\n\n  constructor(\n    options: SnapsBundleWarningsPluginOptions = {\n      buffer: true,\n      builtIns: true,\n    },\n    spinner?: Ora,\n  ) {\n    this.options = options;\n    this.#spinner = spinner;\n  }\n\n  /**\n   * Apply the plugin to the Webpack compiler.\n   *\n   * @param compiler - The Webpack compiler.\n   */\n  apply(compiler: Compiler) {\n    if (this.options.builtIns) {\n      this.#checkBuiltIns(compiler);\n    }\n\n    if (this.options.buffer) {\n      this.#checkBuffer(compiler);\n    }\n  }\n\n  /**\n   * Check if a built-in module is used, but not provided by Webpack's\n   * `fallback` configuration.\n   *\n   * @param compiler - The Webpack compiler.\n   */\n  #checkBuiltIns(compiler: Compiler) {\n    compiler.hooks.afterCompile.tap(this.constructor.name, () => {\n      if (!this.options.builtInResolver) {\n        return;\n      }\n\n      const { unresolvedModules } = this.options.builtInResolver;\n      if (unresolvedModules.size === 0) {\n        return;\n      }\n\n      const formattedModules = new Array(...unresolvedModules)\n        .map((name) => indent(`• ${name}`, 2))\n        .join('\\n');\n\n      warn(\n        `The snap attempted to use one or more Node.js builtins, but no browser fallback has been provided.\\n` +\n          `The MetaMask Snaps CLI does not support Node.js builtins by default. If you want to use this module, you must set ${yellow(\n            `polyfills`,\n          )} to ${yellow(\n            `true`,\n          )} or an object with the builtins to polyfill as the key and ${yellow(\n            `true`,\n          )} as the value.\\n` +\n          `To disable this warning, set ${yellow(\n            '`stats.builtIns`',\n          )} to ${yellow(\n            '`false`',\n          )} in your snap config file, or add the module to the ${yellow(\n            '`stats.builtIns.ignore`',\n          )} array.\\n\\n${formattedModules}\\n`,\n        this.#spinner,\n      );\n    });\n  }\n\n  /**\n   * Check if the given instance is a `ProvidePlugin`. This is not guaranteed to\n   * be accurate, but it's good enough for our purposes. If we were to use\n   * `instanceof` instead, it might not work if multiple versions of Webpack are\n   * installed.\n   *\n   * @param instance - The instance to check.\n   * @returns Whether the instance is a `ProvidePlugin`, i.e., whether it's an\n   * object with the name `ProvidePlugin` and a `definitions` property.\n   */\n  #isProvidePlugin(instance: unknown): instance is ProvidePlugin {\n    return (\n      isObject(instance) &&\n      instance.constructor.name === 'ProvidePlugin' &&\n      hasProperty(instance, 'definitions')\n    );\n  }\n\n  /**\n   * Check if the `Buffer` global is used, but not provided by Webpack's\n   * `DefinePlugin`.\n   *\n   * @param compiler - The Webpack compiler.\n   */\n  #checkBuffer(compiler: Compiler) {\n    const plugin = compiler.options.plugins?.find((instance) =>\n      this.#isProvidePlugin(instance),\n    ) as ProvidePlugin | undefined;\n\n    // If the `ProvidePlugin` is configured to provide `Buffer`, then we don't\n    // need to warn the user.\n    if (plugin) {\n      const { definitions } = plugin;\n      if (definitions.Buffer) {\n        return;\n      }\n    }\n\n    compiler.hooks.compilation.tap(this.constructor.name, (compilation) => {\n      compilation.hooks.afterProcessAssets.tap(\n        this.constructor.name,\n        (assets) => {\n          // Check if assets use `Buffer`.\n          const bufferAssets = Object.entries(assets)\n            .filter(([name]) => name.endsWith('.js'))\n            .filter(([, asset]) => asset.source().includes('Buffer'));\n\n          if (bufferAssets.length === 0) {\n            return;\n          }\n\n          warn(\n            `The snap attempted to use the Node.js Buffer global, which is not supported in the MetaMask Snaps CLI by default.\\n` +\n              `To use the Buffer global, you must polyfill Buffer by setting ${yellow(\n                `buffer`,\n              )} to ${yellow(`true`)} in the ${yellow(\n                `polyfills`,\n              )} config object in your snap config.\\n` +\n              `To disable this warning, set ${yellow(\n                '`stats.buffer`',\n              )} to ${yellow('`false`')} in your snap config file.`,\n            this.#spinner,\n          );\n        },\n      );\n    });\n  }\n}\n"],"names":["indent","assert","hasProperty","isObject","dim","red","yellow","isBuiltin","evaluate","error","getErrorMessage","info","warn","pluralize","SnapsStatsPlugin","apply","compiler","hooks","afterDone","tap","constructor","name","stats","modules","time","errors","toJson","length","formattedErrors","map","getStatsErrorMessage","bind","join","spinner","stop","process","exitCode","watchMode","succeed","options","verbose","statsError","baseMessage","message","first","rest","split","details","filter","Boolean","SnapsWatchPlugin","invalid","file","start","afterEmit","tapPromise","fileDependencies","files","forEach","add","bundle","safeEvaluate","bundlePath","evaluateError","SnapsBuiltInResolver","resolver","getHook","source","tapAsync","module","isModule","request","_","callback","baseRequest","ignore","includes","fallback","find","alias","unresolvedModules","Set","SnapsBundleWarningsPlugin","builtIns","checkBuiltIns","buffer","checkBuffer","afterCompile","builtInResolver","size","formattedModules","Array","instance","plugin","plugins","isProvidePlugin","definitions","Buffer","compilation","afterProcessAssets","assets","bufferAssets","Object","entries","endsWith","asset"],"mappings":"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"}