@elliemae/pui-cli 9.0.0-next.6 → 9.0.0-next.61

package/dist/cjs/webpack/csp-plugin.js

@@ -0,0 +1,79 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var csp_plugin_exports = {};
+__export(csp_plugin_exports, {
+  CspPlugin: () => CspPlugin
+});
+module.exports = __toCommonJS(csp_plugin_exports);
+var import_html_webpack_plugin = __toESM(require("html-webpack-plugin"));
+var import_csp = require("./csp.js");
+const defaultOptions = {
+  enableUnsafeEval: false
+};
+class CspPlugin {
+  #options = defaultOptions;
+  /**
+   * @param {object} options Additional options for this module.
+   */
+  constructor(options) {
+    this.#options = { ...this.#options, ...options ?? {} };
+  }
+  /**
+   * Processes HtmlWebpackPlugin's html data by adding the CSP
+   * @param _compilation
+   * @param htmlPluginData
+   * @param htmlPluginData.html
+   * @param compileCb
+   * @returns {*}
+   */
+  processCsp(_compilation, htmlPluginData, compileCb) {
+    const cspModule = new import_csp.CSP(htmlPluginData.html);
+    cspModule.refactorSourcedScriptsForHashBasedCsp();
+    const scriptHashes = cspModule.hashAllInlineScripts();
+    const { enableUnsafeEval } = this.#options;
+    const strictCsp = import_csp.CSP.getStrictCsp(scriptHashes, {
+      enableUnsafeEval
+    });
+    cspModule.addMetaTag(strictCsp);
+    htmlPluginData.html = cspModule.serializeDom();
+    return compileCb(null, htmlPluginData);
+  }
+  /**
+   * Hooks into webpack to collect assets and hash them, build the policy, and add it into our HTML template
+   * @param compiler
+   */
+  apply(compiler) {
+    compiler.hooks.compilation.tap("CspPlugin", (compilation) => {
+      import_html_webpack_plugin.default.getCompilationHooks(compilation).beforeEmit.tapAsync(
+        "CspPlugin",
+        this.processCsp.bind(this, compilation)
+      );
+    });
+  }
+}

package/dist/cjs/webpack/csp.js

@@ -0,0 +1,158 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var csp_exports = {};
+__export(csp_exports, {
+  CSP: () => CSP
+});
+module.exports = __toCommonJS(csp_exports);
+var crypto = __toESM(require("node:crypto"));
+var cheerio = __toESM(require("cheerio"));
+class CSP {
+  static HASH_FUNCTION = "sha256";
+  static INLINE_SCRIPT_SELECTOR = "script:not([src])";
+  static SOURCED_SCRIPT_SELECTOR = "script[src]";
+  $;
+  constructor(html) {
+    this.$ = cheerio.load(html);
+  }
+  serializeDom() {
+    return this.$.root().html() ?? "";
+  }
+  /**
+   * Returns a strict Content Security Policy for mittigating XSS.
+   * For more details read csp.withgoogle.com.
+   * If you modify this CSP, make sure it has not become trivially bypassable by
+   * checking the policy using csp-evaluator.withgoogle.com.
+   * @param hashes A list of sha-256 hashes of trusted inline scripts.
+   * @param cspOptions
+   * @param enableTrustedTypes If Trusted Types should be enabled for scripts.
+   * @param enableBrowserFallbacks If fallbacks for older browsers should be
+   *   added. This is will not weaken the policy as modern browsers will ignore
+   *   the fallbacks.
+   * @param enableUnsafeEval If you cannot remove all uses of eval(), you can
+   *   still set a strict CSP, but you will have to use the 'unsafe-eval'
+   *   keyword which will make your policy slightly less secure.
+   * @param cspOptions.enableBrowserFallbacks
+   * @param cspOptions.enableTrustedTypes
+   * @param cspOptions.enableUnsafeEval
+   * @returns A strict Content Security Policy string.
+   */
+  static getStrictCsp(hashes, cspOptions = {
+    enableUnsafeEval: false
+  }) {
+    const strictCspTemplate = {
+      // 'strict-dynamic' allows hashed scripts to create new scripts.
+      "script-src": [`'strict-dynamic'`, ...hashes ?? []],
+      // Restricts `object-src` to disable dangerous plugins like Flash.
+      "object-src": [`'none'`],
+      // Restricts `base-uri` to block the injection of `<base>` tags. This
+      // prevents attackers from changing the locations of scripts loaded from
+      // relative URLs.
+      "base-uri": [`'self'`]
+    };
+    if (cspOptions.enableUnsafeEval) {
+      strictCspTemplate["script-src"].push(`'unsafe-eval'`);
+    }
+    return Object.entries(strictCspTemplate).map(([directive, values]) => `${directive} ${values.join(" ")};`).join("");
+  }
+  /**
+   * Enables a CSP via a meta tag at the beginning of the document.
+   * Warning: It's recommended to set CSP as HTTP response header instead of
+   * using a meta tag. Injections before the meta tag will not be covered by CSP
+   * and meta tags don't support CSP in report-only mode.
+   * @param csp A Content Security Policy string.
+   */
+  addMetaTag(csp) {
+    let metaTag = this.$('meta[http-equiv="Content-Security-Policy"]');
+    if (!metaTag.length) {
+      metaTag = cheerio.load('<meta http-equiv="Content-Security-Policy">')(
+        "meta"
+      );
+      metaTag.prependTo(this.$("head"));
+    }
+    metaTag.attr("content", csp);
+  }
+  /**
+   * Replaces all sourced scripts with a single inline script that can be hashed
+   */
+  refactorSourcedScriptsForHashBasedCsp() {
+    const scriptInfoList = this.$(CSP.SOURCED_SCRIPT_SELECTOR).map((_i, script) => {
+      const src = this.$(script).attr("src") ?? "";
+      const type = this.$(script).attr("type") ?? "";
+      this.$(script).remove();
+      return { src, type };
+    }).toArray().filter((info) => info.src);
+    const loaderScript = CSP.createLoaderScript(scriptInfoList);
+    if (!loaderScript) {
+      return;
+    }
+    const newScript = cheerio.load("<script>")("script");
+    newScript.text(loaderScript);
+    newScript.appendTo(this.$("body"));
+  }
+  /**
+   * Returns a list of hashes of all inline scripts found in the HTML document.
+   * @returns A list of sha-256 hashes of inline scripts.
+   */
+  hashAllInlineScripts() {
+    return this.$(CSP.INLINE_SCRIPT_SELECTOR).map((_i, elem) => CSP.hashInlineScript(this.$(elem).html() ?? "")).get();
+  }
+  /**
+   * Returns JS code for dynamically loading sourced (external) scripts.
+   * @param scriptInfoList A list of objects containing src and type for scripts that should be loaded
+   * @returns JS code for loading scripts.
+   */
+  static createLoaderScript(scriptInfoList) {
+    if (!scriptInfoList.length) {
+      return void 0;
+    }
+    return `
+    var scripts = ${JSON.stringify(scriptInfoList)};
+    scripts.forEach(function(scriptInfo) {
+      var s = document.createElement('script');
+      s.src = scriptInfo.src;
+      if (scriptInfo.type) {
+        s.type = scriptInfo.type;
+      }
+      s.async = false; // preserve execution order.
+      document.body.appendChild(s);
+    });
+    `;
+  }
+  /**
+   * Calculates a CSP compatible hash of an inline script.
+   * @param scriptText Text between opening and closing script tag. Has to
+   *     include whitespaces and newlines!
+   * @returns A sha-256 hash of the script.
+   */
+  static hashInlineScript(scriptText) {
+    const hash = crypto.createHash(CSP.HASH_FUNCTION).update(scriptText, "utf-8").digest("base64");
+    return `'${CSP.HASH_FUNCTION}-${hash}'`;
+  }
+}

package/dist/cjs/webpack/helpers.js

@@ -34,6 +34,7 @@ __export(helpers_exports, {
   getAlias: () => getAlias,
   getAppVersion: () => getAppVersion,
   getCompressionPlugins: () => getCompressionPlugins,
+  getLibraryAlias: () => getLibraryAlias,
   getLibraryName: () => getLibraryName,
   getLibraryVariableName: () => getLibraryVariableName,
   getMediaPath: () => getMediaPath,
@@ -46,11 +47,11 @@ __export(helpers_exports, {
   resolveExtensions: () => resolveExtensions
 });
 module.exports = __toCommonJS(helpers_exports);
-var import_node_path = __toESM(require("node:path"), 1);
-var import_node_fs = __toESM(require("node:fs"), 1);
-var import_lodash = __toESM(require("lodash"), 1);
-var import_compression_webpack_plugin = __toESM(require("compression-webpack-plugin"), 1);
-var import_zlib = __toESM(require("zlib"), 1);
+var import_node_path = __toESM(require("node:path"));
+var import_node_fs = __toESM(require("node:fs"));
+var import_zlib = __toESM(require("zlib"));
+var import_lodash = __toESM(require("lodash"));
+var import_compression_webpack_plugin = __toESM(require("compression-webpack-plugin"));
 var import_utils = require("../monorepo/utils.js");
 var import_utils2 = require("../utils.js");
 let pathSep = import_node_path.default.sep;
@@ -63,10 +64,9 @@ const getNodeModulesRegEx = (modules) => modules.map(
 const excludeNodeModulesExcept = (modules) => {
   const moduleRegExps = getNodeModulesRegEx(modules);
   return function(modulePath) {
-    if (/node_modules/.test(modulePath)) {
-      for (let i = 0; i < moduleRegExps.length; i += 1)
-        if (moduleRegExps[i].test(modulePath))
-          return false;
+    if (modulePath.includes("node_modules")) {
+      for (const moduleRegExp of moduleRegExps)
+        if (moduleRegExp.test(modulePath)) return false;
       return true;
     }
     return false;
@@ -80,7 +80,7 @@ const getLibraryName = () => {
   const modifiedLibName = `emui-${libraryName.replace("@elliemae/", "").replace("pui-", "")}`;
   return import_lodash.default.camelCase(modifiedLibName);
 };
-const getLibraryVariableName = () => (process.env.LIBRARY_VARIABLE_NAME || getLibraryName()).split(".");
+const getLibraryVariableName = () => (process.env.LIBRARY_VARIABLE_NAME ?? getLibraryName()).split(".");
 const mapToFolder = (dependencies, folder) => dependencies.reduce(
   (acc, dependency) => ({
     [dependency]: import_node_path.default.resolve(`${folder}/${dependency.replace("$", "")}`),
@@ -89,7 +89,7 @@ const mapToFolder = (dependencies, folder) => dependencies.reduce(
   {}
 );
 const getAlias = () => {
-  const monorepoRoot = (0, import_utils.findMonoRepoRoot)(process.cwd()) || "";
+  const monorepoRoot = (0, import_utils.findMonoRepoRoot)(process.cwd()) ?? "";
   return mapToFolder(
     [
       "@babel/runtime",
@@ -103,6 +103,8 @@ const getAlias = () => {
       "styled-components",
       "immer",
       "react-dates",
+      "react-select",
+      "react-spring",
       "react-transition-group",
       "@elliemae/pui-cli",
       "@elliemae/pui-app-sdk$",
@@ -111,6 +113,15 @@ const getAlias = () => {
     import_node_path.default.join(monorepoRoot, "./node_modules")
   );
 };
+const getLibraryAlias = (name, alias) => {
+  const monorepoRoot = (0, import_utils.findMonoRepoRoot)(process.cwd()) ?? "";
+  const aliasPath = import_node_path.default.resolve(
+    `${import_node_path.default.join(monorepoRoot, "./node_modules")}/${alias}`
+  );
+  return {
+    [name]: aliasPath
+  };
+};
 const modulesToTranspile = [
   "@elliemae/pui-*",
   "@elliemae/ds-*",
@@ -123,12 +134,11 @@ const getUserMonitoringFileName = () => {
     process.cwd(),
     "node_modules/@elliemae/pui-user-monitoring/dist/public/js"
   );
-  if (!import_node_fs.default.existsSync(userMonLibPath))
-    return `${libName}.js`;
+  if (!import_node_fs.default.existsSync(userMonLibPath)) return `${libName}.js`;
   const distJSFiles = import_node_fs.default.readdirSync(userMonLibPath);
-  return distJSFiles.filter(
-    (fName) => fName.match(/emuiUserMonitoring+((?!chunk).)*\.js$/)
-  )[0];
+  return distJSFiles.find(
+    (fName) => /emuiUserMonitoring+((?!chunk).)*\.js$/.exec(fName)
+  );
 };
 const getAppLoaderFileName = () => {
   const libName = "emuiAppLoader";
@@ -136,12 +146,11 @@ const getAppLoaderFileName = () => {
     process.cwd(),
     "node_modules/@elliemae/pui-app-loader/dist/public/js"
   );
-  if (!import_node_fs.default.existsSync(appLoaderLibPath))
-    return `${libName}.js`;
+  if (!import_node_fs.default.existsSync(appLoaderLibPath)) return `${libName}.js`;
   const distJSFiles = import_node_fs.default.readdirSync(appLoaderLibPath);
-  return distJSFiles.filter(
-    (fName) => fName.match(/emuiAppLoader+((?!chunk).)*\.js$/)
-  )[0];
+  return distJSFiles.find(
+    (fName) => /emuiAppLoader+((?!chunk).)*\.js$/.exec(fName)
+  );
 };
 const getDiagnosticsFileName = () => {
   const libName = "emuiDiagnostics";
@@ -149,12 +158,11 @@ const getDiagnosticsFileName = () => {
     process.cwd(),
     "node_modules/@elliemae/pui-diagnostics/dist/public/js"
   );
-  if (!import_node_fs.default.existsSync(libPath))
-    return `${libName}.js`;
+  if (!import_node_fs.default.existsSync(libPath)) return `${libName}.js`;
   const distJSFiles = import_node_fs.default.readdirSync(libPath);
-  return distJSFiles.filter(
-    (fName) => fName.match(/emuiDiagnostics+((?!chunk).)*\.js$/)
-  )[0];
+  return distJSFiles.find(
+    (fName) => /emuiDiagnostics+((?!chunk).)*\.js$/.exec(fName)
+  );
 };
 const getENCWLoaderFileName = () => {
   const libName = "emuiEncwLoader";
@@ -162,18 +170,16 @@ const getENCWLoaderFileName = () => {
     process.cwd(),
     "node_modules/@elliemae/encw-loader/dist/public/js"
   );
-  if (!import_node_fs.default.existsSync(appLoaderLibPath))
-    return `${libName}.js`;
+  if (!import_node_fs.default.existsSync(appLoaderLibPath)) return `${libName}.js`;
   const distJSFiles = import_node_fs.default.readdirSync(appLoaderLibPath);
-  return distJSFiles.filter(
-    (fName) => fName.match(/emuiEncwLoader+((?!chunk).)*\.js$/)
-  )[0];
+  return distJSFiles.find(
+    (fName) => /emuiEncwLoader+((?!chunk).)*\.js$/.exec(fName)
+  );
 };
 const getAppVersion = () => {
-  if (!process.env.APP_VERSION)
-    return LATEST_VERSION;
-  const match = process.env.APP_VERSION.match(/^v?(\d+\.\d+)\..*$/);
-  return match && match[1] || LATEST_VERSION;
+  if (!process.env.APP_VERSION) return LATEST_VERSION;
+  const match = /^v?(\d+\.\d+)\..*$/.exec(process.env.APP_VERSION);
+  return match?.[1] ?? LATEST_VERSION;
 };
 const getPaths = (latestVersion = true) => {
   const version = latestVersion ? LATEST_VERSION : getAppVersion();
@@ -208,9 +214,9 @@ const getCompressionPlugins = (isLibrary = false) => {
   ];
   const commonConfig = {
     test: /\.(js|css)$/,
-    exclude: !isLibrary ? excludeList : [],
     // we are compressing all files since in aws cloudfront edge lambda, we don't want to whitelist files that are not compressed due to below limits
-    minRatio: Infinity
+    minRatio: Infinity,
+    ...!isLibrary ? { exclude: excludeList } : {}
   };
   return [
     new import_compression_webpack_plugin.default({

package/dist/cjs/webpack/interceptor-middleware.js

@@ -0,0 +1,125 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var interceptor_middleware_exports = {};
+__export(interceptor_middleware_exports, {
+  addCSPNonceMiddleware: () => addCSPNonceMiddleware,
+  interceptorMiddleware: () => interceptorMiddleware
+});
+module.exports = __toCommonJS(interceptor_middleware_exports);
+const VALID_PARAMS = ["isInterceptable", "intercept", "afterSend"];
+const validateParams = (methods) => {
+  Object.keys(methods).forEach((k) => {
+    if (!VALID_PARAMS.includes(k)) {
+      throw new Error(`${k} isn't a valid param (${VALID_PARAMS.join(", ")})`);
+    }
+  });
+  if (!("isInterceptable" in methods)) {
+    throw new Error("isInterceptable is a required param (function)");
+  }
+};
+const interceptorMiddleware = (fn) => (req, res, next) => {
+  const methods = fn(req, res);
+  validateParams(methods);
+  const originalEnd = res.end;
+  const originalWrite = res.write;
+  const chunks = [];
+  let isIntercepting;
+  let isFirstWrite = true;
+  function intercept(rawChunk, encoding) {
+    if (isFirstWrite) {
+      isFirstWrite = false;
+      isIntercepting = methods.isInterceptable();
+    }
+    if (isIntercepting) {
+      if (rawChunk) {
+        let tempChunk = rawChunk;
+        if (rawChunk !== null && !Buffer.isBuffer(tempChunk)) {
+          if (!encoding) {
+            tempChunk = Buffer.from(rawChunk);
+          } else {
+            tempChunk = Buffer.from(
+              rawChunk,
+              encoding
+            );
+          }
+        }
+        chunks.push(tempChunk);
+      }
+    }
+    return isIntercepting;
+  }
+  const newResWrite = (...args) => {
+    if (!intercept(args[0], args[1])) {
+      return originalWrite.apply(res, args);
+    }
+    return true;
+  };
+  res.write = newResWrite;
+  const afterSend = (oldBody, newBody) => {
+    if (typeof methods.afterSend === "function") {
+      process.nextTick(() => {
+        methods.afterSend?.(oldBody, newBody);
+      });
+    }
+  };
+  const newResEnd = (...args) => {
+    if (intercept(args[0], args[1])) {
+      isIntercepting = false;
+      const oldBody = Buffer.concat(chunks).toString("utf-8");
+      if (methods.intercept) {
+        if (typeof methods.intercept !== "function") {
+          throw new Error(
+            "`send` must be a function with the body to be sent as the only param"
+          );
+        }
+        res.removeHeader("Content-Length");
+        methods.intercept(oldBody, (newBody) => {
+          args[0] = newBody;
+          originalEnd.apply(res, args);
+          afterSend(oldBody, newBody);
+        });
+      } else {
+        afterSend(oldBody, oldBody);
+        originalEnd.apply(res, args);
+      }
+    } else {
+      originalEnd.apply(res, args);
+    }
+  };
+  res.end = newResEnd;
+  next();
+};
+const addCSPNonceMiddleware = (middlewares) => {
+  const index = middlewares.findIndex(
+    (middleware) => middleware.name === "webpack-dev-middleware"
+  );
+  middlewares.splice(index, 0, {
+    name: "csp-nonce-middleware",
+    middleware: interceptorMiddleware((_req, res) => ({
+      // Only HTML responses will be intercepted
+      isInterceptable() {
+        return (res.get("Content-Type") ?? "").includes("text/html");
+      },
+      // Appends a paragraph at the end of the response body
+      intercept(body, send) {
+        send(body.replace(/__CSP_NONCE__/g, res.locals.cspNonce));
+      }
+    }))
+  });
+};

package/dist/cjs/webpack/webpack.base.babel.js

@@ -31,16 +31,16 @@ __export(webpack_base_babel_exports, {
   baseConfig: () => baseConfig
 });
 module.exports = __toCommonJS(webpack_base_babel_exports);
-var import_node_path = __toESM(require("node:path"), 1);
-var import_webpack = __toESM(require("webpack"), 1);
+var import_node_path = __toESM(require("node:path"));
+var import_webpack = __toESM(require("webpack"));
 var import_webpack_dev_server = require("webpack-dev-server");
-var import_mini_css_extract_plugin = __toESM(require("mini-css-extract-plugin"), 1);
-var import_postcss_preset_env = __toESM(require("postcss-preset-env"), 1);
-var import_copy_webpack_plugin = __toESM(require("copy-webpack-plugin"), 1);
-var import_moment_locales_webpack_plugin = __toESM(require("moment-locales-webpack-plugin"), 1);
+var import_mini_css_extract_plugin = __toESM(require("mini-css-extract-plugin"));
+var import_postcss_preset_env = __toESM(require("postcss-preset-env"));
+var import_copy_webpack_plugin = __toESM(require("copy-webpack-plugin"));
+var import_moment_locales_webpack_plugin = __toESM(require("moment-locales-webpack-plugin"));
 var import_webpack_manifest_plugin = require("webpack-manifest-plugin");
-var import_favicons_webpack_plugin = __toESM(require("favicons-webpack-plugin"), 1);
-var import_browserslist_to_esbuild = __toESM(require("browserslist-to-esbuild"), 1);
+var import_favicons_webpack_plugin = __toESM(require("favicons-webpack-plugin"));
+var import_browserslist_to_esbuild = __toESM(require("browserslist-to-esbuild"));
 var import_helpers = require("./helpers.js");
 const minicssLoader = {
   loader: import_mini_css_extract_plugin.default.loader,
@@ -129,14 +129,16 @@ const plugins = [
         noErrorOnMissing: true,
         globOptions: {
           ignore: ["readme.md"]
-        }
+        },
+        info: { minimized: true }
       },
       {
         from: "webroot",
         noErrorOnMissing: true,
         globOptions: {
           ignore: ["readme.md"]
-        }
+        },
+        info: { minimized: true }
       }
     ])
   }),
@@ -145,7 +147,7 @@ const plugins = [
     fileName: "./latest/manifest.json",
     publicPath: "",
     map: (file) => {
-      file.name = file.name.replace(/^latest\//, "");
+      file.name = file.name.replace(/^latest(\/|\\)/, "");
       return file;
     }
   }),
@@ -284,34 +286,18 @@ const baseConfig = (options) => ({
     mainFields: ["browser", "module", "main"],
     alias: {
       ...(0, import_helpers.getAlias)(),
-      ...(options.resolve || {}).alias || {}
+      ...options.resolve?.alias ?? {}
     }
   },
+  externalsPresets: {
+    web: true
+  },
   externals: {
     "@elliemae/pui-user-monitoring": "emuiUserMonitoring",
     "@elliemae/pui-app-loader": "emuiAppLoader",
-    "@elliemae/pui-diagnostics": "emuiDiagnostics",
-    react: "emuiAppReactDependencies.react",
-    "react-dom": "emuiAppReactDependencies.reactDOM",
-    "@reduxjs/toolkit": "emuiAppReactDependencies.rtk",
-    axios: "emuiAppReactDependencies.axios.default",
-    dompurify: "emuiAppReactDependencies.dompurify",
-    history: "emuiAppReactDependencies.history",
-    immer: "emuiAppReactDependencies.immer",
-    invariant: "emuiAppReactDependencies.invariant",
-    "pubsub-js": "emuiAppReactDependencies.pubsubjs",
-    "react-aria-live": "emuiAppReactDependencies.reactAriaLive",
-    "react-helmet": "emuiAppReactDependencies.reactHelmet",
-    "react-hook-form": "emuiAppReactDependencies.reactHookForm",
-    "react-redux": "emuiAppReactDependencies.reactRedux",
-    "react-router-dom": "emuiAppReactDependencies.reactRouterDOM",
-    reduxInjectors: "emuiAppReactDependencies.reduxInjectors",
-    reselect: "emuiAppReactDependencies.reselect",
-    // "styled-components": "emuiAppReactDependencies.styledComponents",
-    "styled-system": "emuiAppReactDependencies.styledSystem"
-    // "@xstyled/styled-components": "emuiAppReactDependencies.xstyled",
+    "@elliemae/pui-diagnostics": "emuiDiagnostics"
   },
-  devtool: options.devtool || "eval-source-map",
-  performance: options.performance || {},
-  devServer: options.devServer || {}
+  devtool: options.devtool ?? "eval-source-map",
+  performance: options.performance ?? {},
+  devServer: options.devServer ?? {}
 });