@normed/bundle 4.7.1 → 4.8.2

package/bundles/esbuild-plugins/index.d.ts

@@ -1,5 +1,5 @@
 export { default as load_less } from "./load_less.ts";
-export { default as load_pug } from "./load_pug.ts";
+export { default as createLoadPugPlugin } from "./load_pug.ts";
 export { default as load_ts_js } from "./load_ts_js.ts";
 export { createCssExternalUrlsPlugin } from "./css_external_urls.ts";
 export { createCssUrlResolverPlugin } from "./css_url_resolver.ts";

package/bundles/esbuild-plugins/load_pug.d.ts

@@ -64,5 +64,25 @@ export declare function clearDiscoveredScriptReferences(): void;
  * Clear discovered package CSS references. Should be called before a new build.
  */
 export declare function clearDiscoveredPackageCssReferences(): void;
-declare const plugin: esbuild.Plugin;
-export default plugin;
+/**
+ * Compute the URL path to use in HTML for a given asset.
+ *
+ * When `webRoot` is set, the path is computed relative to the web root subdirectory,
+ * prefixed by `publicPath` (defaulting to "/"). This handles the case where outdir
+ * contains both server and client files, and the web server only serves a subdirectory.
+ *
+ * When `webRoot` is not set, falls back to the existing behavior:
+ * - With `publicPath`: prefix + hashedFilename
+ * - Without `publicPath`: path relative from htmlOutputDir to absoluteOutput
+ */
+export declare function computeHtmlAssetPath(opts: {
+    absoluteOutput: string;
+    hashedFilename: string;
+    htmlOutputDir: string;
+    outdir: string;
+    publicPath: string;
+    webRoot: string | undefined;
+}): string;
+export default function createLoadPugPlugin(opts?: {
+    webRoot?: string;
+}): esbuild.Plugin;

package/bundles/index.js

@@ -23672,31 +23672,31 @@ var require_abstract_plugin_loader = __commonJS({
           }
           return pluginObj;
         };
-        AbstractPluginLoader2.prototype.trySetOptions = function(plugin4, filename, name3, options) {
-          if (options && !plugin4.setOptions) {
+        AbstractPluginLoader2.prototype.trySetOptions = function(plugin3, filename, name3, options) {
+          if (options && !plugin3.setOptions) {
             return new less_error_1.default({
               message: "Options have been provided but the plugin ".concat(name3, " does not support any options.")
             });
           }
           try {
-            plugin4.setOptions && plugin4.setOptions(options);
+            plugin3.setOptions && plugin3.setOptions(options);
           } catch (e) {
             return new less_error_1.default(e);
           }
         };
-        AbstractPluginLoader2.prototype.validatePlugin = function(plugin4, filename, name3) {
-          if (plugin4) {
-            if (typeof plugin4 === "function") {
-              plugin4 = new plugin4();
+        AbstractPluginLoader2.prototype.validatePlugin = function(plugin3, filename, name3) {
+          if (plugin3) {
+            if (typeof plugin3 === "function") {
+              plugin3 = new plugin3();
             }
-            if (plugin4.minVersion) {
-              if (this.compareVersion(plugin4.minVersion, this.less.version) < 0) {
+            if (plugin3.minVersion) {
+              if (this.compareVersion(plugin3.minVersion, this.less.version) < 0) {
                 return new less_error_1.default({
-                  message: "Plugin ".concat(name3, " requires version ").concat(this.versionToString(plugin4.minVersion))
+                  message: "Plugin ".concat(name3, " requires version ").concat(this.versionToString(plugin3.minVersion))
                 });
               }
             }
-            return plugin4;
+            return plugin3;
           }
           return null;
         };
@@ -23721,9 +23721,9 @@ var require_abstract_plugin_loader = __commonJS({
         };
         AbstractPluginLoader2.prototype.printUsage = function(plugins) {
           for (var i = 0; i < plugins.length; i++) {
-            var plugin4 = plugins[i];
-            if (plugin4.printUsage) {
-              plugin4.printUsage();
+            var plugin3 = plugins[i];
+            if (plugin3.printUsage) {
+              plugin3.printUsage();
             }
           }
         };
@@ -25010,13 +25010,13 @@ var require_plugin_manager = __commonJS({
             }
           }
         };
-        PluginManager2.prototype.addPlugin = function(plugin4, filename, functionRegistry) {
-          this.installedPlugins.push(plugin4);
+        PluginManager2.prototype.addPlugin = function(plugin3, filename, functionRegistry) {
+          this.installedPlugins.push(plugin3);
           if (filename) {
-            this.pluginCache[filename] = plugin4;
+            this.pluginCache[filename] = plugin3;
           }
-          if (plugin4.install) {
-            plugin4.install(this.less, this, functionRegistry || this.less.functions.functionRegistry);
+          if (plugin3.install) {
+            plugin3.install(this.less, this, functionRegistry || this.less.functions.functionRegistry);
           }
         };
         PluginManager2.prototype.get = function(filename) {
@@ -25478,7 +25478,7 @@ var require_import_manager = __commonJS({
               return;
             }
             var loadFileCallback = function(loadedFile2) {
-              var plugin4;
+              var plugin3;
               var resolvedFilename = loadedFile2.filename;
               var contents = loadedFile2.contents.replace(/^\uFEFF/, "");
               newFileInfo.currentDirectory = fileManager.getPath(resolvedFilename);
@@ -25496,11 +25496,11 @@ var require_import_manager = __commonJS({
                 newFileInfo.reference = true;
               }
               if (importOptions.isPlugin) {
-                plugin4 = pluginLoader.evalPlugin(contents, newEnv, importManager, importOptions.pluginArgs, newFileInfo);
-                if (plugin4 instanceof less_error_1.default) {
-                  fileParsedFunc(plugin4, null, resolvedFilename);
+                plugin3 = pluginLoader.evalPlugin(contents, newEnv, importManager, importOptions.pluginArgs, newFileInfo);
+                if (plugin3 instanceof less_error_1.default) {
+                  fileParsedFunc(plugin3, null, resolvedFilename);
                 } else {
-                  fileParsedFunc(null, plugin4, resolvedFilename);
+                  fileParsedFunc(null, plugin3, resolvedFilename);
                 }
               } else if (importOptions.inline) {
                 fileParsedFunc(null, contents, resolvedFilename);
@@ -25615,16 +25615,16 @@ var require_parse2 = __commonJS({
           var imports_1 = new ImportManager(this, context_1, rootFileInfo);
           this.importManager = imports_1;
           if (options.plugins) {
-            options.plugins.forEach(function(plugin4) {
+            options.plugins.forEach(function(plugin3) {
               var evalResult, contents;
-              if (plugin4.fileContent) {
-                contents = plugin4.fileContent.replace(/^\uFEFF/, "");
-                evalResult = pluginManager_1.Loader.evalPlugin(contents, context_1, imports_1, plugin4.options, plugin4.filename);
+              if (plugin3.fileContent) {
+                contents = plugin3.fileContent.replace(/^\uFEFF/, "");
+                evalResult = pluginManager_1.Loader.evalPlugin(contents, context_1, imports_1, plugin3.options, plugin3.filename);
                 if (evalResult instanceof less_error_1.default) {
                   return callback(evalResult);
                 }
               } else {
-                pluginManager_1.addPlugin(plugin4);
+                pluginManager_1.addPlugin(plugin3);
               }
             });
           }
@@ -33351,8 +33351,8 @@ var require_pug_lexer = __commonJS({
         }
         var pluginArgs = [this].concat(rest);
         for (var i = 0; i < this.plugins.length; i++) {
-          var plugin4 = this.plugins[i];
-          if (plugin4[func] && plugin4[func].apply(plugin4, pluginArgs)) {
+          var plugin3 = this.plugins[i];
+          if (plugin3[func] && plugin3[func].apply(plugin3, pluginArgs)) {
             return true;
           }
         }
@@ -33665,13 +33665,13 @@ var require_pug_parser = __commonJS({
         }
         var pluginContext;
         for (var i = 0; i < this.plugins.length; i++) {
-          var plugin4 = this.plugins[i];
-          if (plugin4[context] && plugin4[context][tok.type]) {
+          var plugin3 = this.plugins[i];
+          if (plugin3[context] && plugin3[context][tok.type]) {
             if (pluginContext)
               throw new Error(
                 "Multiple plugin handlers found for context " + JSON.stringify(context) + ", token type " + JSON.stringify(tok.type)
               );
-            pluginContext = plugin4[context];
+            pluginContext = plugin3[context];
           }
         }
         if (pluginContext)
@@ -38645,9 +38645,9 @@ var require_lib7 = __commonJS({
           return true;
         }
       }
-      getPluginOption(plugin4, name3) {
+      getPluginOption(plugin3, name3) {
         var _this$plugins$get;
-        return (_this$plugins$get = this.plugins.get(plugin4)) == null ? void 0 : _this$plugins$get[name3];
+        return (_this$plugins$get = this.plugins.get(plugin3)) == null ? void 0 : _this$plugins$get[name3];
       }
     };
     function setTrailingComments(node, comments) {
@@ -47133,15 +47133,15 @@ var require_lib7 = __commonJS({
       });
     }
     function getPluginOption(plugins, name3, option) {
-      const plugin4 = plugins.find((plugin5) => {
-        if (Array.isArray(plugin5)) {
-          return plugin5[0] === name3;
+      const plugin3 = plugins.find((plugin4) => {
+        if (Array.isArray(plugin4)) {
+          return plugin4[0] === name3;
         } else {
-          return plugin5 === name3;
+          return plugin4 === name3;
         }
       });
-      if (plugin4 && Array.isArray(plugin4) && plugin4.length > 1) {
-        return plugin4[1][option];
+      if (plugin3 && Array.isArray(plugin3) && plugin3.length > 1) {
+        return plugin3[1][option];
       }
       return null;
     }
@@ -50943,8 +50943,8 @@ var require_lib7 = __commonJS({
     };
     function pluginsMap(plugins) {
       const pluginMap = /* @__PURE__ */ new Map();
-      for (const plugin4 of plugins) {
-        const [name3, options] = Array.isArray(plugin4) ? plugin4 : [plugin4, {}];
+      for (const plugin3 of plugins) {
+        const [name3, options] = Array.isArray(plugin3) ? plugin3 : [plugin3, {}];
         if (!pluginMap.has(name3)) pluginMap.set(name3, options || {});
       }
       return pluginMap;
@@ -51012,8 +51012,8 @@ var require_lib7 = __commonJS({
       let cls = parserClassCache[key];
       if (!cls) {
         cls = Parser;
-        for (const plugin4 of pluginList) {
-          cls = mixinPlugins[plugin4](cls);
+        for (const plugin3 of pluginList) {
+          cls = mixinPlugins[plugin3](cls);
         }
         parserClassCache[key] = cls;
       }
@@ -67743,13 +67743,13 @@ var require_lib14 = __commonJS({
     exports.runtime = runtime;
     exports.cache = {};
     function applyPlugins(value, options, plugins, name3) {
-      return plugins.reduce(function(value2, plugin4) {
-        return plugin4[name3] ? plugin4[name3](value2, options) : value2;
+      return plugins.reduce(function(value2, plugin3) {
+        return plugin3[name3] ? plugin3[name3](value2, options) : value2;
       }, value);
     }
     function findReplacementFunc(plugins, name3) {
-      var eligiblePlugins = plugins.filter(function(plugin4) {
-        return plugin4[name3];
+      var eligiblePlugins = plugins.filter(function(plugin3) {
+        return plugin3[name3];
       });
       if (eligiblePlugins.length > 1) {
         throw new Error("Two or more plugins all implement " + name3 + " method.");
@@ -67772,10 +67772,10 @@ var require_lib14 = __commonJS({
           Object.keys(options2).forEach(function(key) {
             lexOptions[key] = options2[key];
           });
-          lexOptions.plugins = plugins.filter(function(plugin4) {
-            return !!plugin4.lex;
-          }).map(function(plugin4) {
-            return plugin4.lex;
+          lexOptions.plugins = plugins.filter(function(plugin3) {
+            return !!plugin3.lex;
+          }).map(function(plugin3) {
+            return plugin3.lex;
           });
           var contents = applyPlugins(
             str2,
@@ -67807,10 +67807,10 @@ var require_lib14 = __commonJS({
           Object.keys(options2).forEach(function(key) {
             parseOptions[key] = options2[key];
           });
-          parseOptions.plugins = plugins.filter(function(plugin4) {
-            return !!plugin4.parse;
-          }).map(function(plugin4) {
-            return plugin4.parse;
+          parseOptions.plugins = plugins.filter(function(plugin3) {
+            return !!plugin3.parse;
+          }).map(function(plugin3) {
+            return plugin3.parse;
           });
           return applyPlugins(
             applyPlugins(
@@ -68348,6 +68348,9 @@ var refinePackageJSONBuildConfig = makePartialRefinement({
       root: (0, import_refinements2.refineAny)(import_refinements2.refineUndefined, import_refinements2.refineString)
     })
   ),
+  webRoot: (0, import_refinements2.refineAny)(import_refinements2.refineUndefined, import_refinements2.refineString),
+  publicPath: (0, import_refinements2.refineAny)(import_refinements2.refineUndefined, import_refinements2.refineString),
+  assetNames: (0, import_refinements2.refineAny)(import_refinements2.refineUndefined, import_refinements2.refineString),
   // TODO: this shouldn't need to be casted to remove the undefined from the Value portion ({[modifier: string]: EntryConfig} | undefined})
   modifiers: (0, import_refinements2.refineObjectOf)(
     import_refinements2.refineString,
@@ -68892,7 +68895,18 @@ function applyAssetNamesTemplate(template, originalPath, hash, baseDir) {
   const relativeDir = dir.startsWith(baseDir) ? dir.slice(baseDir.length).replace(/^\//, "") : dir;
   return template.replace(/\[name\]/g, name3).replace(/\[hash\]/g, hash).replace(/\[ext\]/g, ext).replace(/\[dir\]/g, relativeDir) + "." + ext;
 }
-async function processHtmlAssets(html, pugFilePath, options) {
+function computeHtmlAssetPath(opts) {
+  if (opts.webRoot) {
+    const webRootDir = path5.join(opts.outdir, opts.webRoot);
+    const prefix = (opts.publicPath || "/").replace(/\/$/, "");
+    return prefix + "/" + path5.relative(webRootDir, opts.absoluteOutput);
+  }
+  if (opts.publicPath) {
+    return opts.publicPath.replace(/\/$/, "") + "/" + opts.hashedFilename;
+  }
+  return path5.relative(opts.htmlOutputDir, opts.absoluteOutput);
+}
+async function processHtmlAssets(html, pugFilePath, options, webRoot) {
   const assets = [];
   const pugReferences = [];
   const lessReferences = [];
@@ -68955,7 +68969,8 @@ async function processHtmlAssets(html, pugFilePath, options) {
             assetNames,
             publicPath,
             assets,
-            processedAssets
+            processedAssets,
+            webRoot
           );
           if (hashedPath) {
             newParts.push(
@@ -69052,7 +69067,8 @@ async function processHtmlAssets(html, pugFilePath, options) {
             assetNames,
             publicPath,
             assets,
-            processedAssets
+            processedAssets,
+            webRoot
           );
           if (hashedPath) {
             newValue = hashedPath;
@@ -69097,7 +69113,8 @@ async function processHtmlAssets(html, pugFilePath, options) {
           assetNames,
           publicPath,
           assets,
-          processedAssets
+          processedAssets,
+          webRoot
         );
         if (hashedPath) {
           newValue = hashedPath;
@@ -69113,7 +69130,8 @@ async function processHtmlAssets(html, pugFilePath, options) {
         assetNames,
         publicPath,
         assets,
-        processedAssets
+        processedAssets,
+        webRoot
       );
       if (hashedPath) {
         newValue = hashedPath;
@@ -69133,7 +69151,7 @@ async function processHtmlAssets(html, pugFilePath, options) {
     packageCssReferences
   };
 }
-async function processAsset(assetPath, pugDir, pugFilePath, outdir, outbase, assetNames, publicPath, assets, processedAssets) {
+async function processAsset(assetPath, pugDir, pugFilePath, outdir, outbase, assetNames, publicPath, assets, processedAssets, webRoot) {
   const absoluteSource = path5.resolve(pugDir, assetPath);
   if (processedAssets.has(absoluteSource)) {
     return processedAssets.get(absoluteSource);
@@ -69158,12 +69176,14 @@ async function processAsset(assetPath, pugDir, pugFilePath, outdir, outbase, ass
     const pugRelativeToOutbase = path5.relative(outbase, pugFilePath);
     const htmlOutputPath = path5.join(outdir, pugRelativeToOutbase);
     const htmlOutputDir = path5.dirname(htmlOutputPath);
-    let htmlPath;
-    if (publicPath) {
-      htmlPath = publicPath.replace(/\/$/, "") + "/" + hashedFilename;
-    } else {
-      htmlPath = path5.relative(htmlOutputDir, absoluteOutput);
-    }
+    const htmlPath = computeHtmlAssetPath({
+      absoluteOutput,
+      hashedFilename,
+      htmlOutputDir,
+      outdir,
+      publicPath,
+      webRoot
+    });
     assets.push({
       originalPath: assetPath,
       hashedPath: htmlPath,
@@ -69176,7 +69196,7 @@ async function processAsset(assetPath, pugDir, pugFilePath, outdir, outbase, ass
     return null;
   }
 }
-async function processPackageAsset(absoluteSource, packageSpecifier, pugFilePath, outdir, outbase, assetNames, publicPath, assets, processedAssets) {
+async function processPackageAsset(absoluteSource, packageSpecifier, pugFilePath, outdir, outbase, assetNames, publicPath, assets, processedAssets, webRoot) {
   if (processedAssets.has(absoluteSource)) {
     return processedAssets.get(absoluteSource);
   }
@@ -69199,12 +69219,14 @@ async function processPackageAsset(absoluteSource, packageSpecifier, pugFilePath
     const pugRelativeToOutbase = path5.relative(outbase, pugFilePath);
     const htmlOutputPath = path5.join(outdir, pugRelativeToOutbase);
     const htmlOutputDir = path5.dirname(htmlOutputPath);
-    let htmlPath;
-    if (publicPath) {
-      htmlPath = publicPath.replace(/\/$/, "") + "/" + hashedFilename;
-    } else {
-      htmlPath = path5.relative(htmlOutputDir, absoluteOutput);
-    }
+    const htmlPath = computeHtmlAssetPath({
+      absoluteOutput,
+      hashedFilename,
+      htmlOutputDir,
+      outdir,
+      publicPath,
+      webRoot
+    });
     assets.push({
       originalPath: packageSpecifier,
       hashedPath: htmlPath,
@@ -69364,7 +69386,7 @@ async function loadAsHtml(filepath, options) {
     loader: "js"
   };
 }
-async function loadAsEntrypoint(filepath, options) {
+async function loadAsEntrypoint(filepath, options, webRoot) {
   const fileData = await fs6.promises.readFile(filepath, "utf8");
   let contents = import_pug.default.render(fileData, {
     filename: filepath,
@@ -69385,7 +69407,7 @@ async function loadAsEntrypoint(filepath, options) {
     lessReferences,
     scriptReferences,
     packageCssReferences
-  } = await processHtmlAssets(contents, filepath, options);
+  } = await processHtmlAssets(contents, filepath, options, webRoot);
   contents = processedHtml;
   if (pugReferences.length > 0) {
     discoveredPugReferences.set(filepath, pugReferences);
@@ -69422,70 +69444,72 @@ async function loadAsFile(filepath, options) {
   };
 }
 var name2 = "load_pug";
-var plugin2 = {
-  name: name2,
-  setup(build2) {
-    const filter2 = /.*\.pug$/;
-    build2.onResolve(
-      { filter: filter2 },
-      async (args) => {
-        const resolvedPath = path5.resolve(args.resolveDir, args.path);
-        if (fs6.existsSync(resolvedPath)) {
-          return {
-            sideEffects: false,
-            path: path5.resolve(args.resolveDir, args.path),
-            pluginData: Object.assign({}, args.pluginData, {
-              [name2]: {
-                entrypoint: args.kind === "entry-point"
-              }
-            })
-          };
-        } else {
-          return {};
-        }
-      }
-    );
-    build2.onLoad(
-      { filter: filter2 },
-      async ({
-        path: filepath,
-        with: withArg,
-        pluginData
-      }) => {
-        const isEntryPoint = pluginData?.[name2]?.entrypoint;
-        if (isEntryPoint) {
-          return loadAsEntrypoint(filepath, build2.initialOptions);
+function createLoadPugPlugin(opts) {
+  const webRoot = opts?.webRoot;
+  return {
+    name: name2,
+    setup(build2) {
+      const filter2 = /.*\.pug$/;
+      build2.onResolve(
+        { filter: filter2 },
+        async (args) => {
+          const resolvedPath = path5.resolve(args.resolveDir, args.path);
+          if (fs6.existsSync(resolvedPath)) {
+            return {
+              sideEffects: false,
+              path: path5.resolve(args.resolveDir, args.path),
+              pluginData: Object.assign({}, args.pluginData, {
+                [name2]: {
+                  entrypoint: args.kind === "entry-point"
+                }
+              })
+            };
+          } else {
+            return {};
+          }
         }
-        const type = withArg?.["type"] ?? "js";
-        switch (type) {
-          // Load pug as html by doing "import template from './file.pug' with { type: 'html' }"
-          // This gives a string of the pug already rendered to html
-          // TODO: could support passing options to pug.render via the with clause
-          case "html":
-            return loadAsHtml(filepath, build2.initialOptions);
-          // Load pug as a text file by doing "import template from './file.pug' with { type: 'text' }"
-          // This gives a string of the raw pug file, which can be used as pug - e.g. as a template string
-          case "pug":
-          case "text":
-            return loadAsText2(filepath);
-          // Load pug as a render function by doing "import render from './file.pug' with { type: 'js' }"
-          // This is the default behaviour if no with clause is used, or no type is specified.
-          case "js":
-            return loadAsJS2(filepath, build2.initialOptions);
-          // Load pug as a file by doing "import template from './file.pug' with { type: 'file' }"
-          // This will render the pug file to a file, and return the path to that file.
-          // The path is going to contain a hash, so it is not going to be the same as the original file.
-          case "file":
-            return loadAsFile(filepath, build2.initialOptions);
-          // In the case that the type is not recognised, throw an error
-          default:
-            throw new Error(`Unsupported type: ${type}`);
+      );
+      build2.onLoad(
+        { filter: filter2 },
+        async ({
+          path: filepath,
+          with: withArg,
+          pluginData
+        }) => {
+          const isEntryPoint = pluginData?.[name2]?.entrypoint;
+          if (isEntryPoint) {
+            return loadAsEntrypoint(filepath, build2.initialOptions, webRoot);
+          }
+          const type = withArg?.["type"] ?? "js";
+          switch (type) {
+            // Load pug as html by doing "import template from './file.pug' with { type: 'html' }"
+            // This gives a string of the pug already rendered to html
+            // TODO: could support passing options to pug.render via the with clause
+            case "html":
+              return loadAsHtml(filepath, build2.initialOptions);
+            // Load pug as a text file by doing "import template from './file.pug' with { type: 'text' }"
+            // This gives a string of the raw pug file, which can be used as pug - e.g. as a template string
+            case "pug":
+            case "text":
+              return loadAsText2(filepath);
+            // Load pug as a render function by doing "import render from './file.pug' with { type: 'js' }"
+            // This is the default behaviour if no with clause is used, or no type is specified.
+            case "js":
+              return loadAsJS2(filepath, build2.initialOptions);
+            // Load pug as a file by doing "import template from './file.pug' with { type: 'file' }"
+            // This will render the pug file to a file, and return the path to that file.
+            // The path is going to contain a hash, so it is not going to be the same as the original file.
+            case "file":
+              return loadAsFile(filepath, build2.initialOptions);
+            // In the case that the type is not recognised, throw an error
+            default:
+              throw new Error(`Unsupported type: ${type}`);
+          }
         }
-      }
-    );
-  }
-};
-var load_pug_default = plugin2;
+      );
+    }
+  };
+}
 
 // pnp:/builds/normed/bundle/packages/bundle/src/esbuild-plugins/load_ts_js.ts
 import fs7 from "fs";
@@ -69512,7 +69536,7 @@ function quoteString(string) {
 function regexEscape(s) {
   return s.replace(/[-\/\\^$*+?.()|[\]{}]/g, "\\$&");
 }
-var plugin3 = (options) => {
+var plugin2 = (options) => {
   const { sourceRelativeDirnameFilename, basedir } = Object.assign(
     {
       sourceRelativeDirnameFilename: true
@@ -69553,7 +69577,7 @@ var plugin3 = (options) => {
     }
   };
 };
-var load_ts_js_default = plugin3;
+var load_ts_js_default = plugin2;
 
 // pnp:/builds/normed/bundle/packages/bundle/src/esbuild-plugins/css_external_urls.ts
 function createCssExternalUrlsPlugin(patterns) {
@@ -69769,7 +69793,9 @@ var esbuilder = {
         plugins: [
           ...baseConfig.plugins ?? [],
           load_less_default,
-          load_pug_default,
+          createLoadPugPlugin(
+            exampleFile.entryconfig.webRoot ? { webRoot: exampleFile.entryconfig.webRoot } : void 0
+          ),
           load_ts_js_default({ sourceRelativeDirnameFilename: true, basedir: indir }),
           ...externalUrlsPlugin ? [externalUrlsPlugin] : [],
           createCssUrlResolverPlugin(),
@@ -71471,6 +71497,33 @@ async function getBuildConfig(options) {
       buildConfig.modifiers = newModifiers;
       buildConfig.baseConfig = newBaseConfig;
     }
+    if (bundle3.webRoot !== void 0) {
+      buildConfig.webRoot = bundle3.webRoot;
+    }
+    const esbuildConfig = buildConfig.baseConfig.javascript?.esbuild;
+    const hasEsbuildObj = typeof esbuildConfig === "object" && esbuildConfig !== null;
+    if (bundle3.publicPath !== void 0) {
+      buildConfig.publicPath = bundle3.publicPath;
+      if (hasEsbuildObj) {
+        esbuildConfig["publicPath"] = bundle3.publicPath;
+      }
+    } else if (hasEsbuildObj && esbuildConfig["publicPath"] !== void 0) {
+      log_default.warn(
+        "bundle.baseConfig.javascript.esbuild.publicPath is deprecated. Use bundle.publicPath instead."
+      );
+      buildConfig.publicPath = esbuildConfig["publicPath"];
+    }
+    if (bundle3.assetNames !== void 0) {
+      buildConfig.assetNames = bundle3.assetNames;
+      if (hasEsbuildObj) {
+        esbuildConfig["assetNames"] = bundle3.assetNames;
+      }
+    } else if (hasEsbuildObj && esbuildConfig["assetNames"] !== void 0) {
+      log_default.warn(
+        "bundle.baseConfig.javascript.esbuild.assetNames is deprecated. Use bundle.assetNames instead."
+      );
+      buildConfig.assetNames = esbuildConfig["assetNames"];
+    }
   }
   log_default.verbose(
     "Build Config - post reading package.json",
@@ -71512,6 +71565,11 @@ async function bundle(options = {}, plugins = {}) {
       "Failed to discover entrypoints"
     );
   }
+  if (buildConfig.webRoot) {
+    for (const ep of entrypoints) {
+      ep.entryconfig.webRoot = buildConfig.webRoot;
+    }
+  }
   let grouped = keyBy(entrypoints, {
     builder: (entrypoint) => entrypoint.builder
   });