bun-dev-server 1.0.3 → 1.0.5

package/dist/index.js

@@ -30,19 +30,7 @@ var __toESM = (mod, isNodeMode, target) => {
   return to;
 };
 var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
-var __returnValue = (v) => v;
-function __exportSetter(name, newValue) {
-  this[name] = __returnValue.bind(null, newValue);
-}
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, {
-      get: all[name],
-      enumerable: true,
-      configurable: true,
-      set: __exportSetter.bind(all, name)
-    });
-};
+var __require = import.meta.require;
 
 // node_modules/picocolors/picocolors.js
 var require_picocolors = __commonJS((exports, module) => {
@@ -114,6 +102,1343 @@ var require_picocolors = __commonJS((exports, module) => {
   module.exports.createColors = createColors;
 });
 
+// node_modules/ejs/ejs.js
+var require_ejs = __commonJS((exports, module) => {
+  (function(f) {
+    if (typeof exports === "object" && typeof module !== "undefined") {
+      module.exports = f();
+    } else if (typeof define === "function" && define.amd) {
+      define([], f);
+    } else {
+      var g;
+      if (typeof window !== "undefined") {
+        g = window;
+      } else if (typeof global !== "undefined") {
+        g = global;
+      } else if (typeof self !== "undefined") {
+        g = self;
+      } else {
+        g = this;
+      }
+      g.ejs = f();
+    }
+  })(function() {
+    var define2, module2, exports2;
+    return function() {
+      function r(e, n, t) {
+        function o(i2, f) {
+          if (!n[i2]) {
+            if (!e[i2]) {
+              var c = __require;
+              if (!f && c)
+                return c(i2, true);
+              if (u)
+                return u(i2, true);
+              var a = new Error("Cannot find module '" + i2 + "'");
+              throw a.code = "MODULE_NOT_FOUND", a;
+            }
+            var p = n[i2] = { exports: {} };
+            e[i2][0].call(p.exports, function(r2) {
+              var n2 = e[i2][1][r2];
+              return o(n2 || r2);
+            }, p, p.exports, r, e, n, t);
+          }
+          return n[i2].exports;
+        }
+        for (var u = __require, i = 0;i < t.length; i++)
+          o(t[i]);
+        return o;
+      }
+      return r;
+    }()({ 1: [function(require2, module3, exports3) {
+      var __importDefault = this && this.__importDefault || function(mod) {
+        return mod && mod.__esModule ? mod : { default: mod };
+      };
+      Object.defineProperty(exports3, "__esModule", { value: true });
+      var fs_1 = __importDefault(require2("fs"));
+      var path_1 = __importDefault(require2("path"));
+      var utils_js_1 = __importDefault(require2("./utils.js"));
+      var DECLARATION_KEYWORD = "var";
+      var ejs = {};
+      var _DEFAULT_OPEN_DELIMITER = "<";
+      var _DEFAULT_CLOSE_DELIMITER = ">";
+      var _DEFAULT_DELIMITER = "%";
+      var _DEFAULT_LOCALS_NAME = "locals";
+      var _REGEX_STRING = "(<%%|%%>|<%=|<%-|<%_|<%#|<%|%>|-%>|_%>)";
+      var _OPTS_PASSABLE_WITH_DATA = [
+        "delimiter",
+        "scope",
+        "context",
+        "debug",
+        "compileDebug",
+        "_with",
+        "rmWhitespace",
+        "strict",
+        "filename",
+        "async"
+      ];
+      var _OPTS_PASSABLE_WITH_DATA_EXPRESS = _OPTS_PASSABLE_WITH_DATA.concat("cache");
+      var _BOM = /^\uFEFF/;
+      var _JS_IDENTIFIER = /^[a-zA-Z_$][0-9a-zA-Z_$]*$/;
+      ejs.cache = utils_js_1.default.cache;
+      ejs.fileLoader = fs_1.default.readFileSync;
+      ejs.localsName = _DEFAULT_LOCALS_NAME;
+      ejs.promiseImpl = new Function("return this;")().Promise;
+      ejs.resolveInclude = function(name, filename, isDir) {
+        var dirname = path_1.default.dirname;
+        var extname = path_1.default.extname;
+        var resolve = path_1.default.resolve;
+        var includePath = resolve(isDir ? filename : dirname(filename), name);
+        var ext = extname(name);
+        if (!ext) {
+          includePath += ".ejs";
+        }
+        return includePath;
+      };
+      function resolvePaths(name, paths) {
+        var filePath;
+        if (paths.some(function(v) {
+          filePath = ejs.resolveInclude(name, v, true);
+          return fs_1.default.existsSync(filePath);
+        })) {
+          return filePath;
+        }
+      }
+      function getIncludePath(path, options) {
+        var includePath;
+        var filePath;
+        var views = options.views;
+        var match = /^[A-Za-z]+:\\|^\//.exec(path);
+        if (match && match.length) {
+          path = path.replace(/^\/*/, "");
+          if (Array.isArray(options.root)) {
+            includePath = resolvePaths(path, options.root);
+          } else {
+            includePath = ejs.resolveInclude(path, options.root || "/", true);
+          }
+        } else {
+          if (options.filename) {
+            filePath = ejs.resolveInclude(path, options.filename);
+            if (fs_1.default.existsSync(filePath)) {
+              includePath = filePath;
+            }
+          }
+          if (!includePath && Array.isArray(views)) {
+            includePath = resolvePaths(path, views);
+          }
+          if (!includePath && typeof options.includer !== "function") {
+            throw new Error('Could not find the include file "' + options.escapeFunction(path) + '"');
+          }
+        }
+        return includePath;
+      }
+      function handleCache(options, template) {
+        var func;
+        var filename = options.filename;
+        var hasTemplate = arguments.length > 1;
+        if (options.cache) {
+          if (!filename) {
+            throw new Error("cache option requires a filename");
+          }
+          func = ejs.cache.get(filename);
+          if (func) {
+            return func;
+          }
+          if (!hasTemplate) {
+            template = fileLoader(filename).toString().replace(_BOM, "");
+          }
+        } else if (!hasTemplate) {
+          if (!filename) {
+            throw new Error("Internal EJS error: no file name or template " + "provided");
+          }
+          template = fileLoader(filename).toString().replace(_BOM, "");
+        }
+        func = ejs.compile(template, options);
+        if (options.cache) {
+          ejs.cache.set(filename, func);
+        }
+        return func;
+      }
+      function tryHandleCache(options, data, cb) {
+        var result;
+        if (!cb) {
+          if (typeof ejs.promiseImpl == "function") {
+            return new ejs.promiseImpl(function(resolve, reject) {
+              try {
+                result = handleCache(options)(data);
+                resolve(result);
+              } catch (err) {
+                reject(err);
+              }
+            });
+          } else {
+            throw new Error("Please provide a callback function");
+          }
+        } else {
+          try {
+            result = handleCache(options)(data);
+          } catch (err) {
+            return cb(err);
+          }
+          cb(null, result);
+        }
+      }
+      function fileLoader(filePath) {
+        return ejs.fileLoader(filePath);
+      }
+      function includeFile(path, options) {
+        var opts = utils_js_1.default.shallowCopy(utils_js_1.default.createNullProtoObjWherePossible(), options);
+        opts.filename = getIncludePath(path, opts);
+        if (typeof options.includer === "function") {
+          var includerResult = options.includer(path, opts.filename);
+          if (includerResult) {
+            if (includerResult.filename) {
+              opts.filename = includerResult.filename;
+            }
+            if (includerResult.template) {
+              return handleCache(opts, includerResult.template);
+            }
+          }
+        }
+        return handleCache(opts);
+      }
+      function rethrow(err, str, flnm, lineno, esc) {
+        var lines = str.split(`
+`);
+        var start = Math.max(lineno - 3, 0);
+        var end = Math.min(lines.length, lineno + 3);
+        var filename = esc(flnm);
+        var context = lines.slice(start, end).map(function(line, i) {
+          var curr = i + start + 1;
+          return (curr == lineno ? " >> " : "    ") + curr + "| " + line;
+        }).join(`
+`);
+        err.path = filename;
+        err.message = (filename || "ejs") + ":" + lineno + `
+` + context + `
+
+` + err.message;
+        throw err;
+      }
+      function stripSemi(str) {
+        return str.replace(/;(\s*$)/, "$1");
+      }
+      ejs.compile = function compile(template, opts) {
+        var templ;
+        if (opts && opts.scope) {
+          console.warn("`scope` option is deprecated and will be removed in future EJS");
+          if (!opts.context) {
+            opts.context = opts.scope;
+          }
+          delete opts.scope;
+        }
+        templ = new Template(template, opts);
+        return templ.compile();
+      };
+      ejs.render = function(template, d, o) {
+        var data = d || utils_js_1.default.createNullProtoObjWherePossible();
+        var opts = o || utils_js_1.default.createNullProtoObjWherePossible();
+        if (arguments.length == 2) {
+          utils_js_1.default.shallowCopyFromList(opts, data, _OPTS_PASSABLE_WITH_DATA);
+        }
+        return handleCache(opts, template)(data);
+      };
+      ejs.renderFile = function() {
+        var args = Array.prototype.slice.call(arguments);
+        var filename = args.shift();
+        var cb;
+        var opts = { filename };
+        var data;
+        var viewOpts;
+        if (typeof arguments[arguments.length - 1] == "function") {
+          cb = args.pop();
+        }
+        if (args.length) {
+          data = args.shift();
+          if (args.length) {
+            utils_js_1.default.shallowCopy(opts, args.pop());
+          } else {
+            if (utils_js_1.default.hasOwn(data, "settings") && data.settings) {
+              if (data.settings.views) {
+                opts.views = data.settings.views;
+              }
+              if (data.settings["view cache"]) {
+                opts.cache = true;
+              }
+              viewOpts = data.settings["view options"];
+              if (viewOpts) {
+                utils_js_1.default.shallowCopy(opts, viewOpts);
+              }
+            }
+            utils_js_1.default.shallowCopyFromList(opts, data, _OPTS_PASSABLE_WITH_DATA_EXPRESS);
+          }
+          opts.filename = filename;
+        } else {
+          data = utils_js_1.default.createNullProtoObjWherePossible();
+        }
+        return tryHandleCache(opts, data, cb);
+      };
+      ejs.Template = Template;
+      ejs.clearCache = function() {
+        ejs.cache.reset();
+      };
+      function Template(text, optsParam) {
+        var opts = utils_js_1.default.hasOwnOnlyObject(optsParam);
+        var options = utils_js_1.default.createNullProtoObjWherePossible();
+        this.templateText = text;
+        this.mode = null;
+        this.truncate = false;
+        this.currentLine = 1;
+        this.source = "";
+        options.escapeFunction = opts.escape || opts.escapeFunction || utils_js_1.default.escapeXML;
+        options.compileDebug = opts.compileDebug !== false;
+        options.debug = !!opts.debug;
+        options.filename = opts.filename;
+        options.openDelimiter = opts.openDelimiter || ejs.openDelimiter || _DEFAULT_OPEN_DELIMITER;
+        options.closeDelimiter = opts.closeDelimiter || ejs.closeDelimiter || _DEFAULT_CLOSE_DELIMITER;
+        options.delimiter = opts.delimiter || ejs.delimiter || _DEFAULT_DELIMITER;
+        options.strict = opts.strict || false;
+        options.context = opts.context;
+        options.cache = opts.cache || false;
+        options.rmWhitespace = opts.rmWhitespace;
+        options.root = opts.root;
+        options.includer = opts.includer;
+        options.outputFunctionName = opts.outputFunctionName;
+        options.localsName = opts.localsName || ejs.localsName || _DEFAULT_LOCALS_NAME;
+        options.views = opts.views;
+        options.async = opts.async;
+        options.destructuredLocals = opts.destructuredLocals;
+        options.legacyInclude = typeof opts.legacyInclude != "undefined" ? !!opts.legacyInclude : true;
+        if (options.strict) {
+          options._with = false;
+        } else {
+          options._with = typeof opts._with != "undefined" ? opts._with : true;
+        }
+        this.opts = options;
+        this.regex = this.createRegex();
+      }
+      Template.modes = {
+        EVAL: "eval",
+        ESCAPED: "escaped",
+        RAW: "raw",
+        COMMENT: "comment",
+        LITERAL: "literal"
+      };
+      Template.prototype = {
+        createRegex: function() {
+          var str = _REGEX_STRING;
+          var delim = utils_js_1.default.escapeRegExpChars(this.opts.delimiter);
+          var open = utils_js_1.default.escapeRegExpChars(this.opts.openDelimiter);
+          var close = utils_js_1.default.escapeRegExpChars(this.opts.closeDelimiter);
+          str = str.replace(/%/g, delim).replace(/</g, open).replace(/>/g, close);
+          return new RegExp(str);
+        },
+        compile: function() {
+          var src;
+          var fn;
+          var opts = this.opts;
+          var prepended = "";
+          var appended = "";
+          var escapeFn = opts.escapeFunction;
+          var ctor;
+          var sanitizedFilename = opts.filename ? JSON.stringify(opts.filename) : "undefined";
+          if (!this.source) {
+            this.generateSource();
+            prepended += "  ".concat(DECLARATION_KEYWORD, ` __output = "";
+`) + `  function __append(s) { if (s !== undefined && s !== null) __output += s }
+`;
+            if (opts.outputFunctionName) {
+              if (!_JS_IDENTIFIER.test(opts.outputFunctionName)) {
+                throw new Error("outputFunctionName is not a valid JS identifier.");
+              }
+              prepended += "  ".concat(DECLARATION_KEYWORD, " ") + opts.outputFunctionName + " = __append;" + `
+`;
+            }
+            if (opts.localsName && !_JS_IDENTIFIER.test(opts.localsName)) {
+              throw new Error("localsName is not a valid JS identifier.");
+            }
+            if (opts.destructuredLocals && opts.destructuredLocals.length) {
+              var destructuring = "  ".concat(DECLARATION_KEYWORD, " __locals = (") + opts.localsName + ` || {}),
+`;
+              for (var i = 0;i < opts.destructuredLocals.length; i++) {
+                var name_1 = opts.destructuredLocals[i];
+                if (!_JS_IDENTIFIER.test(name_1)) {
+                  throw new Error("destructuredLocals[" + i + "] is not a valid JS identifier.");
+                }
+                if (i > 0) {
+                  destructuring += `,
+  `;
+                }
+                destructuring += name_1 + " = __locals." + name_1;
+              }
+              prepended += destructuring + `;
+`;
+            }
+            if (opts._with !== false) {
+              prepended += "  with (" + opts.localsName + " || {}) {" + `
+`;
+              appended += "  }" + `
+`;
+            }
+            appended += "  return __output;" + `
+`;
+            this.source = prepended + this.source + appended;
+          }
+          if (opts.compileDebug) {
+            src = "".concat(DECLARATION_KEYWORD, " __line = 1") + `
+` + "  , __lines = " + JSON.stringify(this.templateText) + `
+` + "  , __filename = " + sanitizedFilename + ";" + `
+` + "try {" + `
+` + this.source + "} catch (e) {" + `
+` + "  rethrow(e, __lines, __filename, __line, escapeFn);" + `
+` + "}" + `
+`;
+          } else {
+            src = this.source;
+          }
+          if (opts.strict) {
+            src = `"use strict";
+` + src;
+          }
+          if (opts.debug) {
+            console.log(src);
+          }
+          if (opts.compileDebug && opts.filename) {
+            src = src + `
+` + "//# sourceURL=" + sanitizedFilename + `
+`;
+          }
+          try {
+            if (opts.async) {
+              try {
+                ctor = new Function("return (async function(){}).constructor;")();
+              } catch (e) {
+                if (e instanceof SyntaxError) {
+                  throw new Error("This environment does not support async/await");
+                } else {
+                  throw e;
+                }
+              }
+            } else {
+              ctor = Function;
+            }
+            fn = new ctor(opts.localsName + ", escapeFn, include, rethrow", src);
+          } catch (e) {
+            if (e instanceof SyntaxError) {
+              if (opts.filename) {
+                e.message += " in " + opts.filename;
+              }
+              e.message += ` while compiling ejs
+
+`;
+              e.message += `If the above error is not helpful, you may want to try EJS-Lint:
+`;
+              e.message += "https://github.com/RyanZim/EJS-Lint";
+              if (!opts.async) {
+                e.message += `
+`;
+                e.message += "Or, if you meant to create an async function, pass `async: true` as an option.";
+              }
+            }
+            throw e;
+          }
+          var returnedFn = function anonymous(data) {
+            var include = function(path, includeData) {
+              var d = utils_js_1.default.shallowCopy(utils_js_1.default.createNullProtoObjWherePossible(), data);
+              if (includeData) {
+                d = utils_js_1.default.shallowCopy(d, includeData);
+              }
+              return includeFile(path, opts)(d);
+            };
+            return fn.apply(opts.context, [data || utils_js_1.default.createNullProtoObjWherePossible(), escapeFn, include, rethrow]);
+          };
+          if (opts.filename && typeof Object.defineProperty === "function") {
+            var filename = opts.filename;
+            var basename = path_1.default.basename(filename, path_1.default.extname(filename));
+            try {
+              Object.defineProperty(returnedFn, "name", {
+                value: basename,
+                writable: false,
+                enumerable: false,
+                configurable: true
+              });
+            } catch (e) {}
+          }
+          return returnedFn;
+        },
+        generateSource: function() {
+          var opts = this.opts;
+          if (opts.rmWhitespace) {
+            this.templateText = this.templateText.replace(/[\r\n]+/g, `
+`).replace(/^\s+|\s+$/gm, "");
+          }
+          var self2 = this;
+          var d = this.opts.delimiter;
+          var o = this.opts.openDelimiter;
+          var c = this.opts.closeDelimiter;
+          var openWhitespaceSlurpTag = utils_js_1.default.escapeRegExpChars(o + d + "_");
+          var closeWhitespaceSlurpTag = utils_js_1.default.escapeRegExpChars("_" + d + c);
+          var openWhitespaceSlurpReplacement = o + d + "_";
+          var closeWhitespaceSlurpReplacement = "_" + d + c;
+          this.templateText = this.templateText.replace(new RegExp("[ \\t]*" + openWhitespaceSlurpTag, "gm"), openWhitespaceSlurpReplacement).replace(new RegExp(closeWhitespaceSlurpTag + "[ \\t]*", "gm"), closeWhitespaceSlurpReplacement);
+          var matches = this.parseTemplateText();
+          if (matches && matches.length) {
+            matches.forEach(function(line, index) {
+              var closing;
+              if (line.indexOf(o + d) === 0 && line.indexOf(o + d + d) !== 0) {
+                closing = matches[index + 2];
+                if (!(closing == d + c || closing == "-" + d + c || closing == "_" + d + c)) {
+                  throw new Error('Could not find matching close tag for "' + line + '".');
+                }
+              }
+              self2.scanLine(line);
+            });
+          }
+        },
+        parseTemplateText: function() {
+          var str = this.templateText;
+          var pat = this.regex;
+          var result = pat.exec(str);
+          var arr = [];
+          var firstPos;
+          while (result) {
+            firstPos = result.index;
+            if (firstPos !== 0) {
+              arr.push(str.substring(0, firstPos));
+              str = str.slice(firstPos);
+            }
+            arr.push(result[0]);
+            str = str.slice(result[0].length);
+            result = pat.exec(str);
+          }
+          if (str) {
+            arr.push(str);
+          }
+          return arr;
+        },
+        _addOutput: function(line) {
+          if (this.truncate) {
+            line = line.replace(/^(?:\r\n|\r|\n)/, "");
+            this.truncate = false;
+          }
+          if (!line) {
+            return line;
+          }
+          line = line.replace(/\\/g, "\\\\");
+          line = line.replace(/\n/g, "\\n");
+          line = line.replace(/\r/g, "\\r");
+          line = line.replace(/"/g, "\\\"");
+          this.source += '    ; __append("' + line + '")' + `
+`;
+        },
+        scanLine: function(line) {
+          var self2 = this;
+          var d = this.opts.delimiter;
+          var o = this.opts.openDelimiter;
+          var c = this.opts.closeDelimiter;
+          var newLineCount = 0;
+          newLineCount = line.split(`
+`).length - 1;
+          switch (line) {
+            case o + d:
+            case o + d + "_":
+              this.mode = Template.modes.EVAL;
+              break;
+            case o + d + "=":
+              this.mode = Template.modes.ESCAPED;
+              break;
+            case o + d + "-":
+              this.mode = Template.modes.RAW;
+              break;
+            case o + d + "#":
+              this.mode = Template.modes.COMMENT;
+              break;
+            case o + d + d:
+              this.mode = Template.modes.LITERAL;
+              this.source += '    ; __append("' + line.replace(o + d + d, o + d) + '")' + `
+`;
+              break;
+            case d + d + c:
+              this.mode = Template.modes.LITERAL;
+              this.source += '    ; __append("' + line.replace(d + d + c, d + c) + '")' + `
+`;
+              break;
+            case d + c:
+            case "-" + d + c:
+            case "_" + d + c:
+              if (this.mode == Template.modes.LITERAL) {
+                this._addOutput(line);
+              }
+              this.mode = null;
+              this.truncate = line.indexOf("-") === 0 || line.indexOf("_") === 0;
+              break;
+            default:
+              if (this.mode) {
+                switch (this.mode) {
+                  case Template.modes.EVAL:
+                  case Template.modes.ESCAPED:
+                  case Template.modes.RAW:
+                    if (line.lastIndexOf("//") > line.lastIndexOf(`
+`)) {
+                      line += `
+`;
+                    }
+                }
+                switch (this.mode) {
+                  case Template.modes.EVAL:
+                    this.source += "    ; " + line + `
+`;
+                    break;
+                  case Template.modes.ESCAPED:
+                    this.source += "    ; __append(escapeFn(" + stripSemi(line) + "))" + `
+`;
+                    break;
+                  case Template.modes.RAW:
+                    this.source += "    ; __append(" + stripSemi(line) + ")" + `
+`;
+                    break;
+                  case Template.modes.COMMENT:
+                    break;
+                  case Template.modes.LITERAL:
+                    this._addOutput(line);
+                    break;
+                }
+              } else {
+                this._addOutput(line);
+              }
+          }
+          if (self2.opts.compileDebug && newLineCount) {
+            this.currentLine += newLineCount;
+            this.source += "    ; __line = " + this.currentLine + `
+`;
+          }
+        }
+      };
+      ejs.escapeXML = utils_js_1.default.escapeXML;
+      ejs.__express = ejs.renderFile;
+      if (typeof window != "undefined") {
+        window.ejs = ejs;
+      }
+      if (typeof module3 != "undefined") {
+        module3.exports = ejs;
+      }
+      exports3.default = ejs;
+    }, { "./utils.js": 2, fs: 3, path: 4 }], 2: [function(require2, module3, exports3) {
+      Object.defineProperty(exports3, "__esModule", { value: true });
+      var utils = {};
+      var regExpChars = /[|\\{}()[\]^$+*?.]/g;
+      var hasOwnProperty = Object.prototype.hasOwnProperty;
+      var hasOwn = function(obj, key) {
+        return hasOwnProperty.apply(obj, [key]);
+      };
+      utils.hasOwn = hasOwn;
+      utils.escapeRegExpChars = function(string) {
+        if (!string) {
+          return "";
+        }
+        return String(string).replace(regExpChars, "\\$&");
+      };
+      var _ENCODE_HTML_RULES = {
+        "&": "&amp;",
+        "<": "&lt;",
+        ">": "&gt;",
+        '"': "&#34;",
+        "'": "&#39;"
+      };
+      var _MATCH_HTML = /[&<>'"]/g;
+      function encode_char(c) {
+        return _ENCODE_HTML_RULES[c] || c;
+      }
+      var escapeFuncStr = `var _ENCODE_HTML_RULES = {
+` + `      "&": "&amp;"
+` + `    , "<": "&lt;"
+` + `    , ">": "&gt;"
+` + `    , '"': "&#34;"
+` + `    , "'": "&#39;"
+` + `    }
+` + `  , _MATCH_HTML = /[&<>'"]/g;
+` + `function encode_char(c) {
+` + `  return _ENCODE_HTML_RULES[c] || c;
+` + `};
+`;
+      utils.escapeXML = function(markup) {
+        return markup == undefined ? "" : String(markup).replace(_MATCH_HTML, encode_char);
+      };
+      function escapeXMLToString() {
+        return Function.prototype.toString.call(this) + `;
+` + escapeFuncStr;
+      }
+      try {
+        if (typeof Object.defineProperty === "function") {
+          Object.defineProperty(utils.escapeXML, "toString", { value: escapeXMLToString });
+        } else {
+          utils.escapeXML.toString = escapeXMLToString;
+        }
+      } catch (err) {
+        console.warn("Unable to set escapeXML.toString (is the Function prototype frozen?)");
+      }
+      utils.shallowCopy = function(to, from) {
+        from = from || {};
+        if (to !== null && to !== undefined) {
+          for (var p in from) {
+            if (!hasOwn(from, p)) {
+              continue;
+            }
+            if (p === "__proto__" || p === "constructor") {
+              continue;
+            }
+            to[p] = from[p];
+          }
+        }
+        return to;
+      };
+      utils.shallowCopyFromList = function(to, from, list) {
+        list = list || [];
+        from = from || {};
+        if (to !== null && to !== undefined) {
+          for (var i = 0;i < list.length; i++) {
+            var p = list[i];
+            if (typeof from[p] != "undefined") {
+              if (!hasOwn(from, p)) {
+                continue;
+              }
+              if (p === "__proto__" || p === "constructor") {
+                continue;
+              }
+              to[p] = from[p];
+            }
+          }
+        }
+        return to;
+      };
+      utils.cache = {
+        _data: {},
+        set: function(key, val) {
+          this._data[key] = val;
+        },
+        get: function(key) {
+          return this._data[key];
+        },
+        remove: function(key) {
+          delete this._data[key];
+        },
+        reset: function() {
+          this._data = {};
+        }
+      };
+      utils.hyphenToCamel = function(str) {
+        return str.replace(/-[a-z]/g, function(match) {
+          return match[1].toUpperCase();
+        });
+      };
+      utils.createNullProtoObjWherePossible = function() {
+        if (typeof Object.create == "function") {
+          return function() {
+            return Object.create(null);
+          };
+        }
+        if (!({ __proto__: null } instanceof Object)) {
+          return function() {
+            return { __proto__: null };
+          };
+        }
+        return function() {
+          return {};
+        };
+      }();
+      utils.hasOwnOnlyObject = function(obj) {
+        var o = utils.createNullProtoObjWherePossible();
+        for (var p in obj) {
+          if (hasOwn(obj, p)) {
+            o[p] = obj[p];
+          }
+        }
+        return o;
+      };
+      if (typeof exports3 != "undefined") {
+        module3.exports = utils;
+      }
+      exports3.default = utils;
+    }, {}], 3: [function(require2, module3, exports3) {}, {}], 4: [function(require2, module3, exports3) {
+      (function(process2) {
+        (function() {
+          function assertPath(path) {
+            if (typeof path !== "string") {
+              throw new TypeError("Path must be a string. Received " + JSON.stringify(path));
+            }
+          }
+          function normalizeStringPosix(path, allowAboveRoot) {
+            var res = "";
+            var lastSegmentLength = 0;
+            var lastSlash = -1;
+            var dots = 0;
+            var code;
+            for (var i = 0;i <= path.length; ++i) {
+              if (i < path.length)
+                code = path.charCodeAt(i);
+              else if (code === 47)
+                break;
+              else
+                code = 47;
+              if (code === 47) {
+                if (lastSlash === i - 1 || dots === 1) {} else if (lastSlash !== i - 1 && dots === 2) {
+                  if (res.length < 2 || lastSegmentLength !== 2 || res.charCodeAt(res.length - 1) !== 46 || res.charCodeAt(res.length - 2) !== 46) {
+                    if (res.length > 2) {
+                      var lastSlashIndex = res.lastIndexOf("/");
+                      if (lastSlashIndex !== res.length - 1) {
+                        if (lastSlashIndex === -1) {
+                          res = "";
+                          lastSegmentLength = 0;
+                        } else {
+                          res = res.slice(0, lastSlashIndex);
+                          lastSegmentLength = res.length - 1 - res.lastIndexOf("/");
+                        }
+                        lastSlash = i;
+                        dots = 0;
+                        continue;
+                      }
+                    } else if (res.length === 2 || res.length === 1) {
+                      res = "";
+                      lastSegmentLength = 0;
+                      lastSlash = i;
+                      dots = 0;
+                      continue;
+                    }
+                  }
+                  if (allowAboveRoot) {
+                    if (res.length > 0)
+                      res += "/..";
+                    else
+                      res = "..";
+                    lastSegmentLength = 2;
+                  }
+                } else {
+                  if (res.length > 0)
+                    res += "/" + path.slice(lastSlash + 1, i);
+                  else
+                    res = path.slice(lastSlash + 1, i);
+                  lastSegmentLength = i - lastSlash - 1;
+                }
+                lastSlash = i;
+                dots = 0;
+              } else if (code === 46 && dots !== -1) {
+                ++dots;
+              } else {
+                dots = -1;
+              }
+            }
+            return res;
+          }
+          function _format(sep, pathObject) {
+            var dir = pathObject.dir || pathObject.root;
+            var base = pathObject.base || (pathObject.name || "") + (pathObject.ext || "");
+            if (!dir) {
+              return base;
+            }
+            if (dir === pathObject.root) {
+              return dir + base;
+            }
+            return dir + sep + base;
+          }
+          var posix = {
+            resolve: function resolve() {
+              var resolvedPath = "";
+              var resolvedAbsolute = false;
+              var cwd;
+              for (var i = arguments.length - 1;i >= -1 && !resolvedAbsolute; i--) {
+                var path;
+                if (i >= 0)
+                  path = arguments[i];
+                else {
+                  if (cwd === undefined)
+                    cwd = process2.cwd();
+                  path = cwd;
+                }
+                assertPath(path);
+                if (path.length === 0) {
+                  continue;
+                }
+                resolvedPath = path + "/" + resolvedPath;
+                resolvedAbsolute = path.charCodeAt(0) === 47;
+              }
+              resolvedPath = normalizeStringPosix(resolvedPath, !resolvedAbsolute);
+              if (resolvedAbsolute) {
+                if (resolvedPath.length > 0)
+                  return "/" + resolvedPath;
+                else
+                  return "/";
+              } else if (resolvedPath.length > 0) {
+                return resolvedPath;
+              } else {
+                return ".";
+              }
+            },
+            normalize: function normalize(path) {
+              assertPath(path);
+              if (path.length === 0)
+                return ".";
+              var isAbsolute = path.charCodeAt(0) === 47;
+              var trailingSeparator = path.charCodeAt(path.length - 1) === 47;
+              path = normalizeStringPosix(path, !isAbsolute);
+              if (path.length === 0 && !isAbsolute)
+                path = ".";
+              if (path.length > 0 && trailingSeparator)
+                path += "/";
+              if (isAbsolute)
+                return "/" + path;
+              return path;
+            },
+            isAbsolute: function isAbsolute(path) {
+              assertPath(path);
+              return path.length > 0 && path.charCodeAt(0) === 47;
+            },
+            join: function join() {
+              if (arguments.length === 0)
+                return ".";
+              var joined;
+              for (var i = 0;i < arguments.length; ++i) {
+                var arg = arguments[i];
+                assertPath(arg);
+                if (arg.length > 0) {
+                  if (joined === undefined)
+                    joined = arg;
+                  else
+                    joined += "/" + arg;
+                }
+              }
+              if (joined === undefined)
+                return ".";
+              return posix.normalize(joined);
+            },
+            relative: function relative(from, to) {
+              assertPath(from);
+              assertPath(to);
+              if (from === to)
+                return "";
+              from = posix.resolve(from);
+              to = posix.resolve(to);
+              if (from === to)
+                return "";
+              var fromStart = 1;
+              for (;fromStart < from.length; ++fromStart) {
+                if (from.charCodeAt(fromStart) !== 47)
+                  break;
+              }
+              var fromEnd = from.length;
+              var fromLen = fromEnd - fromStart;
+              var toStart = 1;
+              for (;toStart < to.length; ++toStart) {
+                if (to.charCodeAt(toStart) !== 47)
+                  break;
+              }
+              var toEnd = to.length;
+              var toLen = toEnd - toStart;
+              var length = fromLen < toLen ? fromLen : toLen;
+              var lastCommonSep = -1;
+              var i = 0;
+              for (;i <= length; ++i) {
+                if (i === length) {
+                  if (toLen > length) {
+                    if (to.charCodeAt(toStart + i) === 47) {
+                      return to.slice(toStart + i + 1);
+                    } else if (i === 0) {
+                      return to.slice(toStart + i);
+                    }
+                  } else if (fromLen > length) {
+                    if (from.charCodeAt(fromStart + i) === 47) {
+                      lastCommonSep = i;
+                    } else if (i === 0) {
+                      lastCommonSep = 0;
+                    }
+                  }
+                  break;
+                }
+                var fromCode = from.charCodeAt(fromStart + i);
+                var toCode = to.charCodeAt(toStart + i);
+                if (fromCode !== toCode)
+                  break;
+                else if (fromCode === 47)
+                  lastCommonSep = i;
+              }
+              var out = "";
+              for (i = fromStart + lastCommonSep + 1;i <= fromEnd; ++i) {
+                if (i === fromEnd || from.charCodeAt(i) === 47) {
+                  if (out.length === 0)
+                    out += "..";
+                  else
+                    out += "/..";
+                }
+              }
+              if (out.length > 0)
+                return out + to.slice(toStart + lastCommonSep);
+              else {
+                toStart += lastCommonSep;
+                if (to.charCodeAt(toStart) === 47)
+                  ++toStart;
+                return to.slice(toStart);
+              }
+            },
+            _makeLong: function _makeLong(path) {
+              return path;
+            },
+            dirname: function dirname(path) {
+              assertPath(path);
+              if (path.length === 0)
+                return ".";
+              var code = path.charCodeAt(0);
+              var hasRoot = code === 47;
+              var end = -1;
+              var matchedSlash = true;
+              for (var i = path.length - 1;i >= 1; --i) {
+                code = path.charCodeAt(i);
+                if (code === 47) {
+                  if (!matchedSlash) {
+                    end = i;
+                    break;
+                  }
+                } else {
+                  matchedSlash = false;
+                }
+              }
+              if (end === -1)
+                return hasRoot ? "/" : ".";
+              if (hasRoot && end === 1)
+                return "//";
+              return path.slice(0, end);
+            },
+            basename: function basename(path, ext) {
+              if (ext !== undefined && typeof ext !== "string")
+                throw new TypeError('"ext" argument must be a string');
+              assertPath(path);
+              var start = 0;
+              var end = -1;
+              var matchedSlash = true;
+              var i;
+              if (ext !== undefined && ext.length > 0 && ext.length <= path.length) {
+                if (ext.length === path.length && ext === path)
+                  return "";
+                var extIdx = ext.length - 1;
+                var firstNonSlashEnd = -1;
+                for (i = path.length - 1;i >= 0; --i) {
+                  var code = path.charCodeAt(i);
+                  if (code === 47) {
+                    if (!matchedSlash) {
+                      start = i + 1;
+                      break;
+                    }
+                  } else {
+                    if (firstNonSlashEnd === -1) {
+                      matchedSlash = false;
+                      firstNonSlashEnd = i + 1;
+                    }
+                    if (extIdx >= 0) {
+                      if (code === ext.charCodeAt(extIdx)) {
+                        if (--extIdx === -1) {
+                          end = i;
+                        }
+                      } else {
+                        extIdx = -1;
+                        end = firstNonSlashEnd;
+                      }
+                    }
+                  }
+                }
+                if (start === end)
+                  end = firstNonSlashEnd;
+                else if (end === -1)
+                  end = path.length;
+                return path.slice(start, end);
+              } else {
+                for (i = path.length - 1;i >= 0; --i) {
+                  if (path.charCodeAt(i) === 47) {
+                    if (!matchedSlash) {
+                      start = i + 1;
+                      break;
+                    }
+                  } else if (end === -1) {
+                    matchedSlash = false;
+                    end = i + 1;
+                  }
+                }
+                if (end === -1)
+                  return "";
+                return path.slice(start, end);
+              }
+            },
+            extname: function extname(path) {
+              assertPath(path);
+              var startDot = -1;
+              var startPart = 0;
+              var end = -1;
+              var matchedSlash = true;
+              var preDotState = 0;
+              for (var i = path.length - 1;i >= 0; --i) {
+                var code = path.charCodeAt(i);
+                if (code === 47) {
+                  if (!matchedSlash) {
+                    startPart = i + 1;
+                    break;
+                  }
+                  continue;
+                }
+                if (end === -1) {
+                  matchedSlash = false;
+                  end = i + 1;
+                }
+                if (code === 46) {
+                  if (startDot === -1)
+                    startDot = i;
+                  else if (preDotState !== 1)
+                    preDotState = 1;
+                } else if (startDot !== -1) {
+                  preDotState = -1;
+                }
+              }
+              if (startDot === -1 || end === -1 || preDotState === 0 || preDotState === 1 && startDot === end - 1 && startDot === startPart + 1) {
+                return "";
+              }
+              return path.slice(startDot, end);
+            },
+            format: function format(pathObject) {
+              if (pathObject === null || typeof pathObject !== "object") {
+                throw new TypeError('The "pathObject" argument must be of type Object. Received type ' + typeof pathObject);
+              }
+              return _format("/", pathObject);
+            },
+            parse: function parse(path) {
+              assertPath(path);
+              var ret = { root: "", dir: "", base: "", ext: "", name: "" };
+              if (path.length === 0)
+                return ret;
+              var code = path.charCodeAt(0);
+              var isAbsolute = code === 47;
+              var start;
+              if (isAbsolute) {
+                ret.root = "/";
+                start = 1;
+              } else {
+                start = 0;
+              }
+              var startDot = -1;
+              var startPart = 0;
+              var end = -1;
+              var matchedSlash = true;
+              var i = path.length - 1;
+              var preDotState = 0;
+              for (;i >= start; --i) {
+                code = path.charCodeAt(i);
+                if (code === 47) {
+                  if (!matchedSlash) {
+                    startPart = i + 1;
+                    break;
+                  }
+                  continue;
+                }
+                if (end === -1) {
+                  matchedSlash = false;
+                  end = i + 1;
+                }
+                if (code === 46) {
+                  if (startDot === -1)
+                    startDot = i;
+                  else if (preDotState !== 1)
+                    preDotState = 1;
+                } else if (startDot !== -1) {
+                  preDotState = -1;
+                }
+              }
+              if (startDot === -1 || end === -1 || preDotState === 0 || preDotState === 1 && startDot === end - 1 && startDot === startPart + 1) {
+                if (end !== -1) {
+                  if (startPart === 0 && isAbsolute)
+                    ret.base = ret.name = path.slice(1, end);
+                  else
+                    ret.base = ret.name = path.slice(startPart, end);
+                }
+              } else {
+                if (startPart === 0 && isAbsolute) {
+                  ret.name = path.slice(1, startDot);
+                  ret.base = path.slice(1, end);
+                } else {
+                  ret.name = path.slice(startPart, startDot);
+                  ret.base = path.slice(startPart, end);
+                }
+                ret.ext = path.slice(startDot, end);
+              }
+              if (startPart > 0)
+                ret.dir = path.slice(0, startPart - 1);
+              else if (isAbsolute)
+                ret.dir = "/";
+              return ret;
+            },
+            sep: "/",
+            delimiter: ":",
+            win32: null,
+            posix: null
+          };
+          posix.posix = posix;
+          module3.exports = posix;
+        }).call(this);
+      }).call(this, require2("_process"));
+    }, { _process: 5 }], 5: [function(require2, module3, exports3) {
+      var process2 = module3.exports = {};
+      var cachedSetTimeout;
+      var cachedClearTimeout;
+      function defaultSetTimout() {
+        throw new Error("setTimeout has not been defined");
+      }
+      function defaultClearTimeout() {
+        throw new Error("clearTimeout has not been defined");
+      }
+      (function() {
+        try {
+          if (typeof setTimeout === "function") {
+            cachedSetTimeout = setTimeout;
+          } else {
+            cachedSetTimeout = defaultSetTimout;
+          }
+        } catch (e) {
+          cachedSetTimeout = defaultSetTimout;
+        }
+        try {
+          if (typeof clearTimeout === "function") {
+            cachedClearTimeout = clearTimeout;
+          } else {
+            cachedClearTimeout = defaultClearTimeout;
+          }
+        } catch (e) {
+          cachedClearTimeout = defaultClearTimeout;
+        }
+      })();
+      function runTimeout(fun) {
+        if (cachedSetTimeout === setTimeout) {
+          return setTimeout(fun, 0);
+        }
+        if ((cachedSetTimeout === defaultSetTimout || !cachedSetTimeout) && setTimeout) {
+          cachedSetTimeout = setTimeout;
+          return setTimeout(fun, 0);
+        }
+        try {
+          return cachedSetTimeout(fun, 0);
+        } catch (e) {
+          try {
+            return cachedSetTimeout.call(null, fun, 0);
+          } catch (e2) {
+            return cachedSetTimeout.call(this, fun, 0);
+          }
+        }
+      }
+      function runClearTimeout(marker) {
+        if (cachedClearTimeout === clearTimeout) {
+          return clearTimeout(marker);
+        }
+        if ((cachedClearTimeout === defaultClearTimeout || !cachedClearTimeout) && clearTimeout) {
+          cachedClearTimeout = clearTimeout;
+          return clearTimeout(marker);
+        }
+        try {
+          return cachedClearTimeout(marker);
+        } catch (e) {
+          try {
+            return cachedClearTimeout.call(null, marker);
+          } catch (e2) {
+            return cachedClearTimeout.call(this, marker);
+          }
+        }
+      }
+      var queue = [];
+      var draining = false;
+      var currentQueue;
+      var queueIndex = -1;
+      function cleanUpNextTick() {
+        if (!draining || !currentQueue) {
+          return;
+        }
+        draining = false;
+        if (currentQueue.length) {
+          queue = currentQueue.concat(queue);
+        } else {
+          queueIndex = -1;
+        }
+        if (queue.length) {
+          drainQueue();
+        }
+      }
+      function drainQueue() {
+        if (draining) {
+          return;
+        }
+        var timeout = runTimeout(cleanUpNextTick);
+        draining = true;
+        var len = queue.length;
+        while (len) {
+          currentQueue = queue;
+          queue = [];
+          while (++queueIndex < len) {
+            if (currentQueue) {
+              currentQueue[queueIndex].run();
+            }
+          }
+          queueIndex = -1;
+          len = queue.length;
+        }
+        currentQueue = null;
+        draining = false;
+        runClearTimeout(timeout);
+      }
+      process2.nextTick = function(fun) {
+        var args = new Array(arguments.length - 1);
+        if (arguments.length > 1) {
+          for (var i = 1;i < arguments.length; i++) {
+            args[i - 1] = arguments[i];
+          }
+        }
+        queue.push(new Item(fun, args));
+        if (queue.length === 1 && !draining) {
+          runTimeout(drainQueue);
+        }
+      };
+      function Item(fun, array) {
+        this.fun = fun;
+        this.array = array;
+      }
+      Item.prototype.run = function() {
+        this.fun.apply(null, this.array);
+      };
+      process2.title = "browser";
+      process2.browser = true;
+      process2.env = {};
+      process2.argv = [];
+      process2.version = "";
+      process2.versions = {};
+      function noop() {}
+      process2.on = noop;
+      process2.addListener = noop;
+      process2.once = noop;
+      process2.off = noop;
+      process2.removeListener = noop;
+      process2.removeAllListeners = noop;
+      process2.emit = noop;
+      process2.prependListener = noop;
+      process2.prependOnceListener = noop;
+      process2.listeners = function(name) {
+        return [];
+      };
+      process2.binding = function(name) {
+        throw new Error("process.binding is not supported");
+      };
+      process2.cwd = function() {
+        return "/";
+      };
+      process2.chdir = function(dir) {
+        throw new Error("process.chdir is not supported");
+      };
+      process2.umask = function() {
+        return 0;
+      };
+    }, {}] }, {}, [1])(1);
+  });
+});
+
 // node_modules/eventemitter3/index.js
 var require_eventemitter3 = __commonJS((exports, module) => {
   var has = Object.prototype.hasOwnProperty;
@@ -295,717 +1620,8 @@ var require_eventemitter3 = __commonJS((exports, module) => {
 // src/server.ts
 var import_picocolors3 = __toESM(require_picocolors(), 1);
 
-// node_modules/ejs/lib/esm/ejs.js
-import fs from "fs";
-import path from "path";
-
-// node_modules/ejs/lib/esm/utils.js
-var exports_utils = {};
-__export(exports_utils, {
-  default: () => utils_default
-});
-var utils = {};
-var regExpChars = /[|\\{}()[\]^$+*?.]/g;
-var hasOwnProperty = Object.prototype.hasOwnProperty;
-var hasOwn = function(obj, key) {
-  return hasOwnProperty.apply(obj, [key]);
-};
-utils.escapeRegExpChars = function(string) {
-  if (!string) {
-    return "";
-  }
-  return String(string).replace(regExpChars, "\\$&");
-};
-var _ENCODE_HTML_RULES = {
-  "&": "&amp;",
-  "<": "&lt;",
-  ">": "&gt;",
-  '"': "&#34;",
-  "'": "&#39;"
-};
-var _MATCH_HTML = /[&<>'"]/g;
-function encode_char(c) {
-  return _ENCODE_HTML_RULES[c] || c;
-}
-var escapeFuncStr = `var _ENCODE_HTML_RULES = {
-` + `      "&": "&amp;"
-` + `    , "<": "&lt;"
-` + `    , ">": "&gt;"
-` + `    , '"': "&#34;"
-` + `    , "'": "&#39;"
-` + `    }
-` + `  , _MATCH_HTML = /[&<>'"]/g;
-` + `function encode_char(c) {
-` + `  return _ENCODE_HTML_RULES[c] || c;
-` + `};
-`;
-utils.escapeXML = function(markup) {
-  return markup == undefined ? "" : String(markup).replace(_MATCH_HTML, encode_char);
-};
-function escapeXMLToString() {
-  return Function.prototype.toString.call(this) + `;
-` + escapeFuncStr;
-}
-try {
-  if (typeof Object.defineProperty === "function") {
-    Object.defineProperty(utils.escapeXML, "toString", { value: escapeXMLToString });
-  } else {
-    utils.escapeXML.toString = escapeXMLToString;
-  }
-} catch (err) {
-  console.warn("Unable to set escapeXML.toString (is the Function prototype frozen?)");
-}
-utils.shallowCopy = function(to, from) {
-  from = from || {};
-  if (to !== null && to !== undefined) {
-    for (var p in from) {
-      if (!hasOwn(from, p)) {
-        continue;
-      }
-      if (p === "__proto__" || p === "constructor") {
-        continue;
-      }
-      to[p] = from[p];
-    }
-  }
-  return to;
-};
-utils.shallowCopyFromList = function(to, from, list) {
-  list = list || [];
-  from = from || {};
-  if (to !== null && to !== undefined) {
-    for (var i = 0;i < list.length; i++) {
-      var p = list[i];
-      if (typeof from[p] != "undefined") {
-        if (!hasOwn(from, p)) {
-          continue;
-        }
-        if (p === "__proto__" || p === "constructor") {
-          continue;
-        }
-        to[p] = from[p];
-      }
-    }
-  }
-  return to;
-};
-utils.cache = {
-  _data: {},
-  set: function(key, val) {
-    this._data[key] = val;
-  },
-  get: function(key) {
-    return this._data[key];
-  },
-  remove: function(key) {
-    delete this._data[key];
-  },
-  reset: function() {
-    this._data = {};
-  }
-};
-utils.hyphenToCamel = function(str) {
-  return str.replace(/-[a-z]/g, function(match) {
-    return match[1].toUpperCase();
-  });
-};
-utils.createNullProtoObjWherePossible = function() {
-  if (typeof Object.create == "function") {
-    return function() {
-      return Object.create(null);
-    };
-  }
-  if (!({ __proto__: null } instanceof Object)) {
-    return function() {
-      return { __proto__: null };
-    };
-  }
-  return function() {
-    return {};
-  };
-}();
-utils.hasOwnOnlyObject = function(obj) {
-  var o = utils.createNullProtoObjWherePossible();
-  for (var p in obj) {
-    if (hasOwn(obj, p)) {
-      o[p] = obj[p];
-    }
-  }
-  return o;
-};
-if (typeof exports_utils != "undefined") {
-  module_utils.exports = utils;
-}
-var utils_default = utils;
-
-// node_modules/ejs/lib/esm/ejs.js
-var DECLARATION_KEYWORD = "let";
-var ejs = {};
-var _DEFAULT_OPEN_DELIMITER = "<";
-var _DEFAULT_CLOSE_DELIMITER = ">";
-var _DEFAULT_DELIMITER = "%";
-var _DEFAULT_LOCALS_NAME = "locals";
-var _REGEX_STRING = "(<%%|%%>|<%=|<%-|<%_|<%#|<%|%>|-%>|_%>)";
-var _OPTS_PASSABLE_WITH_DATA = [
-  "delimiter",
-  "scope",
-  "context",
-  "debug",
-  "compileDebug",
-  "_with",
-  "rmWhitespace",
-  "strict",
-  "filename",
-  "async"
-];
-var _OPTS_PASSABLE_WITH_DATA_EXPRESS = _OPTS_PASSABLE_WITH_DATA.concat("cache");
-var _BOM = /^\uFEFF/;
-var _JS_IDENTIFIER = /^[a-zA-Z_$][0-9a-zA-Z_$]*$/;
-ejs.cache = utils_default.cache;
-ejs.fileLoader = fs.readFileSync;
-ejs.localsName = _DEFAULT_LOCALS_NAME;
-ejs.promiseImpl = new Function("return this;")().Promise;
-ejs.resolveInclude = function(name, filename, isDir) {
-  let dirname = path.dirname;
-  let extname = path.extname;
-  let resolve = path.resolve;
-  let includePath = resolve(isDir ? filename : dirname(filename), name);
-  let ext = extname(name);
-  if (!ext) {
-    includePath += ".ejs";
-  }
-  return includePath;
-};
-function resolvePaths(name, paths) {
-  let filePath;
-  if (paths.some(function(v) {
-    filePath = ejs.resolveInclude(name, v, true);
-    return fs.existsSync(filePath);
-  })) {
-    return filePath;
-  }
-}
-function getIncludePath(path2, options) {
-  let includePath;
-  let filePath;
-  let views = options.views;
-  let match = /^[A-Za-z]+:\\|^\//.exec(path2);
-  if (match && match.length) {
-    path2 = path2.replace(/^\/*/, "");
-    if (Array.isArray(options.root)) {
-      includePath = resolvePaths(path2, options.root);
-    } else {
-      includePath = ejs.resolveInclude(path2, options.root || "/", true);
-    }
-  } else {
-    if (options.filename) {
-      filePath = ejs.resolveInclude(path2, options.filename);
-      if (fs.existsSync(filePath)) {
-        includePath = filePath;
-      }
-    }
-    if (!includePath && Array.isArray(views)) {
-      includePath = resolvePaths(path2, views);
-    }
-    if (!includePath && typeof options.includer !== "function") {
-      throw new Error('Could not find the include file "' + options.escapeFunction(path2) + '"');
-    }
-  }
-  return includePath;
-}
-function handleCache(options, template) {
-  let func;
-  let filename = options.filename;
-  let hasTemplate = arguments.length > 1;
-  if (options.cache) {
-    if (!filename) {
-      throw new Error("cache option requires a filename");
-    }
-    func = ejs.cache.get(filename);
-    if (func) {
-      return func;
-    }
-    if (!hasTemplate) {
-      template = fileLoader(filename).toString().replace(_BOM, "");
-    }
-  } else if (!hasTemplate) {
-    if (!filename) {
-      throw new Error("Internal EJS error: no file name or template " + "provided");
-    }
-    template = fileLoader(filename).toString().replace(_BOM, "");
-  }
-  func = ejs.compile(template, options);
-  if (options.cache) {
-    ejs.cache.set(filename, func);
-  }
-  return func;
-}
-function tryHandleCache(options, data, cb) {
-  let result;
-  if (!cb) {
-    if (typeof ejs.promiseImpl == "function") {
-      return new ejs.promiseImpl(function(resolve, reject) {
-        try {
-          result = handleCache(options)(data);
-          resolve(result);
-        } catch (err) {
-          reject(err);
-        }
-      });
-    } else {
-      throw new Error("Please provide a callback function");
-    }
-  } else {
-    try {
-      result = handleCache(options)(data);
-    } catch (err) {
-      return cb(err);
-    }
-    cb(null, result);
-  }
-}
-function fileLoader(filePath) {
-  return ejs.fileLoader(filePath);
-}
-function includeFile(path2, options) {
-  let opts = utils_default.shallowCopy(utils_default.createNullProtoObjWherePossible(), options);
-  opts.filename = getIncludePath(path2, opts);
-  if (typeof options.includer === "function") {
-    let includerResult = options.includer(path2, opts.filename);
-    if (includerResult) {
-      if (includerResult.filename) {
-        opts.filename = includerResult.filename;
-      }
-      if (includerResult.template) {
-        return handleCache(opts, includerResult.template);
-      }
-    }
-  }
-  return handleCache(opts);
-}
-function rethrow(err, str, flnm, lineno, esc) {
-  let lines = str.split(`
-`);
-  let start = Math.max(lineno - 3, 0);
-  let end = Math.min(lines.length, lineno + 3);
-  let filename = esc(flnm);
-  let context = lines.slice(start, end).map(function(line, i) {
-    let curr = i + start + 1;
-    return (curr == lineno ? " >> " : "    ") + curr + "| " + line;
-  }).join(`
-`);
-  err.path = filename;
-  err.message = (filename || "ejs") + ":" + lineno + `
-` + context + `
-
-` + err.message;
-  throw err;
-}
-function stripSemi(str) {
-  return str.replace(/;(\s*$)/, "$1");
-}
-ejs.compile = function compile(template, opts) {
-  let templ;
-  if (opts && opts.scope) {
-    console.warn("`scope` option is deprecated and will be removed in future EJS");
-    if (!opts.context) {
-      opts.context = opts.scope;
-    }
-    delete opts.scope;
-  }
-  templ = new Template(template, opts);
-  return templ.compile();
-};
-ejs.render = function(template, d, o) {
-  let data = d || utils_default.createNullProtoObjWherePossible();
-  let opts = o || utils_default.createNullProtoObjWherePossible();
-  if (arguments.length == 2) {
-    utils_default.shallowCopyFromList(opts, data, _OPTS_PASSABLE_WITH_DATA);
-  }
-  return handleCache(opts, template)(data);
-};
-ejs.renderFile = function() {
-  let args = Array.prototype.slice.call(arguments);
-  let filename = args.shift();
-  let cb;
-  let opts = { filename };
-  let data;
-  let viewOpts;
-  if (typeof arguments[arguments.length - 1] == "function") {
-    cb = args.pop();
-  }
-  if (args.length) {
-    data = args.shift();
-    if (args.length) {
-      utils_default.shallowCopy(opts, args.pop());
-    } else {
-      if (data.settings) {
-        if (data.settings.views) {
-          opts.views = data.settings.views;
-        }
-        if (data.settings["view cache"]) {
-          opts.cache = true;
-        }
-        viewOpts = data.settings["view options"];
-        if (viewOpts) {
-          utils_default.shallowCopy(opts, viewOpts);
-        }
-      }
-      utils_default.shallowCopyFromList(opts, data, _OPTS_PASSABLE_WITH_DATA_EXPRESS);
-    }
-    opts.filename = filename;
-  } else {
-    data = utils_default.createNullProtoObjWherePossible();
-  }
-  return tryHandleCache(opts, data, cb);
-};
-ejs.Template = Template;
-ejs.clearCache = function() {
-  ejs.cache.reset();
-};
-function Template(text, optsParam) {
-  let opts = utils_default.hasOwnOnlyObject(optsParam);
-  let options = utils_default.createNullProtoObjWherePossible();
-  this.templateText = text;
-  this.mode = null;
-  this.truncate = false;
-  this.currentLine = 1;
-  this.source = "";
-  options.escapeFunction = opts.escape || opts.escapeFunction || utils_default.escapeXML;
-  options.compileDebug = opts.compileDebug !== false;
-  options.debug = !!opts.debug;
-  options.filename = opts.filename;
-  options.openDelimiter = opts.openDelimiter || ejs.openDelimiter || _DEFAULT_OPEN_DELIMITER;
-  options.closeDelimiter = opts.closeDelimiter || ejs.closeDelimiter || _DEFAULT_CLOSE_DELIMITER;
-  options.delimiter = opts.delimiter || ejs.delimiter || _DEFAULT_DELIMITER;
-  options.strict = opts.strict || false;
-  options.context = opts.context;
-  options.cache = opts.cache || false;
-  options.rmWhitespace = opts.rmWhitespace;
-  options.root = opts.root;
-  options.includer = opts.includer;
-  options.outputFunctionName = opts.outputFunctionName;
-  options.localsName = opts.localsName || ejs.localsName || _DEFAULT_LOCALS_NAME;
-  options.views = opts.views;
-  options.async = opts.async;
-  options.destructuredLocals = opts.destructuredLocals;
-  options.legacyInclude = typeof opts.legacyInclude != "undefined" ? !!opts.legacyInclude : true;
-  if (options.strict) {
-    options._with = false;
-  } else {
-    options._with = typeof opts._with != "undefined" ? opts._with : true;
-  }
-  this.opts = options;
-  this.regex = this.createRegex();
-}
-Template.modes = {
-  EVAL: "eval",
-  ESCAPED: "escaped",
-  RAW: "raw",
-  COMMENT: "comment",
-  LITERAL: "literal"
-};
-Template.prototype = {
-  createRegex: function() {
-    let str = _REGEX_STRING;
-    let delim = utils_default.escapeRegExpChars(this.opts.delimiter);
-    let open = utils_default.escapeRegExpChars(this.opts.openDelimiter);
-    let close = utils_default.escapeRegExpChars(this.opts.closeDelimiter);
-    str = str.replace(/%/g, delim).replace(/</g, open).replace(/>/g, close);
-    return new RegExp(str);
-  },
-  compile: function() {
-    let src;
-    let fn;
-    let opts = this.opts;
-    let prepended = "";
-    let appended = "";
-    let escapeFn = opts.escapeFunction;
-    let ctor;
-    let sanitizedFilename = opts.filename ? JSON.stringify(opts.filename) : "undefined";
-    if (!this.source) {
-      this.generateSource();
-      prepended += `  ${DECLARATION_KEYWORD} __output = "";
-` + `  function __append(s) { if (s !== undefined && s !== null) __output += s }
-`;
-      if (opts.outputFunctionName) {
-        if (!_JS_IDENTIFIER.test(opts.outputFunctionName)) {
-          throw new Error("outputFunctionName is not a valid JS identifier.");
-        }
-        prepended += `  ${DECLARATION_KEYWORD} ` + opts.outputFunctionName + " = __append;" + `
-`;
-      }
-      if (opts.localsName && !_JS_IDENTIFIER.test(opts.localsName)) {
-        throw new Error("localsName is not a valid JS identifier.");
-      }
-      if (opts.destructuredLocals && opts.destructuredLocals.length) {
-        let destructuring = `  ${DECLARATION_KEYWORD} __locals = (` + opts.localsName + ` || {}),
-`;
-        for (let i = 0;i < opts.destructuredLocals.length; i++) {
-          let name = opts.destructuredLocals[i];
-          if (!_JS_IDENTIFIER.test(name)) {
-            throw new Error("destructuredLocals[" + i + "] is not a valid JS identifier.");
-          }
-          if (i > 0) {
-            destructuring += `,
-  `;
-          }
-          destructuring += name + " = __locals." + name;
-        }
-        prepended += destructuring + `;
-`;
-      }
-      if (opts._with !== false) {
-        prepended += "  with (" + opts.localsName + " || {}) {" + `
-`;
-        appended += "  }" + `
-`;
-      }
-      appended += "  return __output;" + `
-`;
-      this.source = prepended + this.source + appended;
-    }
-    if (opts.compileDebug) {
-      src = `${DECLARATION_KEYWORD} __line = 1` + `
-` + "  , __lines = " + JSON.stringify(this.templateText) + `
-` + "  , __filename = " + sanitizedFilename + ";" + `
-` + "try {" + `
-` + this.source + "} catch (e) {" + `
-` + "  rethrow(e, __lines, __filename, __line, escapeFn);" + `
-` + "}" + `
-`;
-    } else {
-      src = this.source;
-    }
-    if (opts.strict) {
-      src = `"use strict";
-` + src;
-    }
-    if (opts.debug) {
-      console.log(src);
-    }
-    if (opts.compileDebug && opts.filename) {
-      src = src + `
-` + "//# sourceURL=" + sanitizedFilename + `
-`;
-    }
-    try {
-      if (opts.async) {
-        try {
-          ctor = new Function("return (async function(){}).constructor;")();
-        } catch (e) {
-          if (e instanceof SyntaxError) {
-            throw new Error("This environment does not support async/await");
-          } else {
-            throw e;
-          }
-        }
-      } else {
-        ctor = Function;
-      }
-      fn = new ctor(opts.localsName + ", escapeFn, include, rethrow", src);
-    } catch (e) {
-      if (e instanceof SyntaxError) {
-        if (opts.filename) {
-          e.message += " in " + opts.filename;
-        }
-        e.message += ` while compiling ejs
-
-`;
-        e.message += `If the above error is not helpful, you may want to try EJS-Lint:
-`;
-        e.message += "https://github.com/RyanZim/EJS-Lint";
-        if (!opts.async) {
-          e.message += `
-`;
-          e.message += "Or, if you meant to create an async function, pass `async: true` as an option.";
-        }
-      }
-      throw e;
-    }
-    let returnedFn = function anonymous(data) {
-      let include = function(path2, includeData) {
-        let d = utils_default.shallowCopy(utils_default.createNullProtoObjWherePossible(), data);
-        if (includeData) {
-          d = utils_default.shallowCopy(d, includeData);
-        }
-        return includeFile(path2, opts)(d);
-      };
-      return fn.apply(opts.context, [data || utils_default.createNullProtoObjWherePossible(), escapeFn, include, rethrow]);
-    };
-    if (opts.filename && typeof Object.defineProperty === "function") {
-      let filename = opts.filename;
-      let basename = path.basename(filename, path.extname(filename));
-      try {
-        Object.defineProperty(returnedFn, "name", {
-          value: basename,
-          writable: false,
-          enumerable: false,
-          configurable: true
-        });
-      } catch (e) {}
-    }
-    return returnedFn;
-  },
-  generateSource: function() {
-    let opts = this.opts;
-    if (opts.rmWhitespace) {
-      this.templateText = this.templateText.replace(/[\r\n]+/g, `
-`).replace(/^\s+|\s+$/gm, "");
-    }
-    let self = this;
-    let d = this.opts.delimiter;
-    let o = this.opts.openDelimiter;
-    let c = this.opts.closeDelimiter;
-    let openWhitespaceSlurpTag = utils_default.escapeRegExpChars(o + d + "_");
-    let closeWhitespaceSlurpTag = utils_default.escapeRegExpChars("_" + d + c);
-    let openWhitespaceSlurpReplacement = o + d + "_";
-    let closeWhitespaceSlurpReplacement = "_" + d + c;
-    this.templateText = this.templateText.replace(new RegExp("[ \\t]*" + openWhitespaceSlurpTag, "gm"), openWhitespaceSlurpReplacement).replace(new RegExp(closeWhitespaceSlurpTag + "[ \\t]*", "gm"), closeWhitespaceSlurpReplacement);
-    let matches = this.parseTemplateText();
-    if (matches && matches.length) {
-      matches.forEach(function(line, index) {
-        let closing;
-        if (line.indexOf(o + d) === 0 && line.indexOf(o + d + d) !== 0) {
-          closing = matches[index + 2];
-          if (!(closing == d + c || closing == "-" + d + c || closing == "_" + d + c)) {
-            throw new Error('Could not find matching close tag for "' + line + '".');
-          }
-        }
-        self.scanLine(line);
-      });
-    }
-  },
-  parseTemplateText: function() {
-    let str = this.templateText;
-    let pat = this.regex;
-    let result = pat.exec(str);
-    let arr = [];
-    let firstPos;
-    while (result) {
-      firstPos = result.index;
-      if (firstPos !== 0) {
-        arr.push(str.substring(0, firstPos));
-        str = str.slice(firstPos);
-      }
-      arr.push(result[0]);
-      str = str.slice(result[0].length);
-      result = pat.exec(str);
-    }
-    if (str) {
-      arr.push(str);
-    }
-    return arr;
-  },
-  _addOutput: function(line) {
-    if (this.truncate) {
-      line = line.replace(/^(?:\r\n|\r|\n)/, "");
-      this.truncate = false;
-    }
-    if (!line) {
-      return line;
-    }
-    line = line.replace(/\\/g, "\\\\");
-    line = line.replace(/\n/g, "\\n");
-    line = line.replace(/\r/g, "\\r");
-    line = line.replace(/"/g, "\\\"");
-    this.source += '    ; __append("' + line + '")' + `
-`;
-  },
-  scanLine: function(line) {
-    let self = this;
-    let d = this.opts.delimiter;
-    let o = this.opts.openDelimiter;
-    let c = this.opts.closeDelimiter;
-    let newLineCount = 0;
-    newLineCount = line.split(`
-`).length - 1;
-    switch (line) {
-      case o + d:
-      case o + d + "_":
-        this.mode = Template.modes.EVAL;
-        break;
-      case o + d + "=":
-        this.mode = Template.modes.ESCAPED;
-        break;
-      case o + d + "-":
-        this.mode = Template.modes.RAW;
-        break;
-      case o + d + "#":
-        this.mode = Template.modes.COMMENT;
-        break;
-      case o + d + d:
-        this.mode = Template.modes.LITERAL;
-        this.source += '    ; __append("' + line.replace(o + d + d, o + d) + '")' + `
-`;
-        break;
-      case d + d + c:
-        this.mode = Template.modes.LITERAL;
-        this.source += '    ; __append("' + line.replace(d + d + c, d + c) + '")' + `
-`;
-        break;
-      case d + c:
-      case "-" + d + c:
-      case "_" + d + c:
-        if (this.mode == Template.modes.LITERAL) {
-          this._addOutput(line);
-        }
-        this.mode = null;
-        this.truncate = line.indexOf("-") === 0 || line.indexOf("_") === 0;
-        break;
-      default:
-        if (this.mode) {
-          switch (this.mode) {
-            case Template.modes.EVAL:
-            case Template.modes.ESCAPED:
-            case Template.modes.RAW:
-              if (line.lastIndexOf("//") > line.lastIndexOf(`
-`)) {
-                line += `
-`;
-              }
-          }
-          switch (this.mode) {
-            case Template.modes.EVAL:
-              this.source += "    ; " + line + `
-`;
-              break;
-            case Template.modes.ESCAPED:
-              this.source += "    ; __append(escapeFn(" + stripSemi(line) + "))" + `
-`;
-              break;
-            case Template.modes.RAW:
-              this.source += "    ; __append(" + stripSemi(line) + ")" + `
-`;
-              break;
-            case Template.modes.COMMENT:
-              break;
-            case Template.modes.LITERAL:
-              this._addOutput(line);
-              break;
-          }
-        } else {
-          this._addOutput(line);
-        }
-    }
-    if (self.opts.compileDebug && newLineCount) {
-      this.currentLine += newLineCount;
-      this.source += "    ; __line = " + this.currentLine + `
-`;
-    }
-  }
-};
-ejs.escapeXML = utils_default.escapeXML;
-ejs.__express = ejs.renderFile;
-if (typeof window != "undefined") {
-  window.ejs = ejs;
-}
-if (typeof module_ejs != "undefined") {
-  module_ejs.exports = ejs;
-}
-var ejs_default = ejs;
-
 // src/httpHandler.ts
+var import_ejs = __toESM(require_ejs(), 1);
 import { readFile, readdir } from "fs/promises";
 
 // src/utils/cors.ts
@@ -1131,7 +1747,7 @@ async function handleDirectoryRequest(fsPath, requestPath, req, finalConfig) {
       };
     });
     const templatePath = requestPath === "/" ? "" : requestPath;
-    const rnd = ejs_default.render(finalConfig.serveOutputEjs, {
+    const rnd = import_ejs.default.render(finalConfig.serveOutputEjs, {
       dirs,
       files,
       requestPath: templatePath
@@ -1147,7 +1763,7 @@ async function handleDirectoryRequest(fsPath, requestPath, req, finalConfig) {
 import { resolve } from "path";
 
 // src/static/serveOutputStyles.css
-var serveOutputStyles_default = {};
+var serveOutputStyles_default = "./assets/serveOutputStyles.css";
 
 // src/static/file.svg
 var file_default = "./assets/file.svg";
@@ -1176,6 +1792,7 @@ var staticAssetRoutes = {
 import { watch } from "fs/promises";
 
 // src/buildManager.ts
+var import_ejs2 = __toESM(require_ejs(), 1);
 var {build } = globalThis.Bun;
 
 // node_modules/eventemitter3/index.mjs
@@ -1272,39 +1889,88 @@ function lowerBound(array, value, comparator) {
 }
 
 // node_modules/p-queue/dist/priority-queue.js
+var compactionThreshold = 100;
+
 class PriorityQueue {
   #queue = [];
+  #head = 0;
   enqueue(run, options) {
     const { priority = 0, id } = options ?? {};
+    const { size } = this;
     const element = {
       priority,
       id,
       run
     };
-    if (this.size === 0 || this.#queue[this.size - 1].priority >= priority) {
+    if (size === 0) {
+      this.#queue.length = 0;
+      this.#head = 0;
       this.#queue.push(element);
       return;
     }
+    if (this.#queue.at(-1).priority >= priority) {
+      this.#queue.push(element);
+      return;
+    }
+    this.#compact();
     const index = lowerBound(this.#queue, element, (a, b) => b.priority - a.priority);
     this.#queue.splice(index, 0, element);
   }
   setPriority(id, priority) {
-    const index = this.#queue.findIndex((element) => element.id === id);
+    const index = this.#queue.findIndex((element, index2) => index2 >= this.#head && element.id === id);
     if (index === -1) {
       throw new ReferenceError(`No promise function with the id "${id}" exists in the queue.`);
     }
     const [item] = this.#queue.splice(index, 1);
     this.enqueue(item.run, { priority, id });
   }
+  remove(idOrRun) {
+    const index = this.#queue.findIndex((element, index2) => {
+      if (index2 < this.#head) {
+        return false;
+      }
+      if (typeof idOrRun === "string") {
+        return element.id === idOrRun;
+      }
+      return element.run === idOrRun;
+    });
+    if (index !== -1) {
+      this.#queue.splice(index, 1);
+    }
+  }
   dequeue() {
-    const item = this.#queue.shift();
+    if (this.#head === this.#queue.length) {
+      return;
+    }
+    const item = this.#queue[this.#head];
+    this.#head++;
+    if (this.#head === this.#queue.length) {
+      this.#queue.length = 0;
+      this.#head = 0;
+    } else if (this.#head > compactionThreshold && this.#head > this.#queue.length / 2) {
+      this.#compact();
+    }
     return item?.run;
   }
   filter(options) {
-    return this.#queue.filter((element) => element.priority === options.priority).map((element) => element.run);
+    const result = [];
+    for (let index = this.#head;index < this.#queue.length; index++) {
+      const element = this.#queue[index];
+      if (element.priority === options.priority) {
+        result.push(element.run);
+      }
+    }
+    return result;
   }
   get size() {
-    return this.#queue.length;
+    return this.#queue.length - this.#head;
+  }
+  #compact() {
+    if (this.#head === 0) {
+      return;
+    }
+    this.#queue.splice(0, this.#head);
+    this.#head = 0;
   }
 }
 
@@ -1331,6 +1997,7 @@ class PQueue extends import__.default {
   #isPaused;
   #idAssigner = 1n;
   #runningTasks = new Map;
+  #queueAbortListenerCleanupFunctions = new Set;
   timeout;
   constructor(options) {
     super();
@@ -1563,7 +2230,11 @@ class PQueue extends import__.default {
     };
     return new Promise((resolve2, reject) => {
       const taskSymbol = Symbol(`task-${options.id}`);
-      this.#queue.enqueue(async () => {
+      let cleanupQueueAbortHandler = () => {
+        return;
+      };
+      const run = async () => {
+        cleanupQueueAbortHandler();
         this.#pending++;
         this.#runningTasks.set(taskSymbol, {
           id: options.id,
@@ -1612,7 +2283,35 @@ class PQueue extends import__.default {
             this.#next();
           });
         }
-      }, options);
+      };
+      this.#queue.enqueue(run, options);
+      const removeQueuedTask = () => {
+        if (this.#queue instanceof PriorityQueue) {
+          this.#queue.remove(run);
+          return;
+        }
+        this.#queue.remove?.(options.id);
+      };
+      if (options.signal) {
+        const { signal } = options;
+        const queueAbortHandler = () => {
+          cleanupQueueAbortHandler();
+          removeQueuedTask();
+          reject(signal.reason);
+          this.#tryToStartAnother();
+          this.emit("next");
+        };
+        cleanupQueueAbortHandler = () => {
+          signal.removeEventListener("abort", queueAbortHandler);
+          this.#queueAbortListenerCleanupFunctions.delete(cleanupQueueAbortHandler);
+        };
+        if (signal.aborted) {
+          queueAbortHandler();
+          return;
+        }
+        signal.addEventListener("abort", queueAbortHandler, { once: true });
+        this.#queueAbortListenerCleanupFunctions.add(cleanupQueueAbortHandler);
+      }
       this.emit("add");
       this.#tryToStartAnother();
     });
@@ -1632,6 +2331,9 @@ class PQueue extends import__.default {
     this.#isPaused = true;
   }
   clear() {
+    for (const cleanupQueueAbortHandler of this.#queueAbortListenerCleanupFunctions) {
+      cleanupQueueAbortHandler();
+    }
     this.#queue = new this.#queueClass;
     this.#clearIntervalTimer();
     this.#updateRateLimitState();
@@ -1771,7 +2473,10 @@ class PQueue extends import__.default {
     return this.#pending === this.#concurrency && this.#queue.size > 0 || this.isRateLimited && this.#queue.size > 0;
   }
   get runningTasks() {
-    return [...this.#runningTasks.values()].map((task) => ({ ...task }));
+    return [...this.#runningTasks.values()].map((task) => ({
+      ...task,
+      timeoutRemaining: task.timeout ? Math.max(0, task.startTime + task.timeout - Date.now()) : undefined
+    }));
   }
 }
 
@@ -1911,7 +2616,7 @@ function publishIndexHTML(paths, template, output, _event) {
     const hashedCss = `${cssUrl.href.replace(`${basePathUrl.href}/`, "./")}?${cssFile.hash}`;
     cssFiles.push(hashedCss);
   }
-  Bun.write(paths.buildDestination + "/index.html", ejs_default.render(template, { hashedImports, cssFiles }));
+  Bun.write(paths.buildDestination + "/index.html", import_ejs2.default.render(template, { hashedImports, cssFiles }));
 }
 function printPrettyBuildOutput(outTable) {
   if (outTable.length === 0)
@@ -2048,8 +2753,8 @@ var DEFAULT_HMR_PATH = "/hmr-ws";
 function bunHotReload(bunServerConfig) {
   const socketPath = bunServerConfig.websocketPath || DEFAULT_HMR_PATH;
   const endPath = socketPath.startsWith("/") ? socketPath : `/${socketPath}`;
-  const path2 = `${bunServerConfig.secure ? "wss" : "ws"}://localhost:${bunServerConfig.port}${endPath}`;
-  return hotReload.toString().replace("[REPLACE_ENDPOINT]", path2);
+  const path = `${bunServerConfig.secure ? "wss" : "ws"}://localhost:${bunServerConfig.port}${endPath}`;
+  return hotReload.toString().replace("[REPLACE_ENDPOINT]", path);
 }
 
 // src/bunHmrPlugin.ts
@@ -2236,3 +2941,6 @@ export {
   getBunHMRFooter,
   bunHotReloadPlugin
 };
+
+//# debugId=148C2DD0CFF66E3C64756E2164756E21
+//# sourceMappingURL=index.js.map