bun-dev-server 1.0.4 → 1.1.0

package/dist/index.js

@@ -18,13 +18,15 @@ var __toESM = (mod, isNodeMode, target) => {
       return cached;
   }
   target = mod != null ? __create(__getProtoOf(mod)) : {};
-  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
-  for (let key of __getOwnPropNames(mod))
-    if (!__hasOwnProp.call(to, key))
-      __defProp(to, key, {
-        get: __accessProp.bind(mod, key),
-        enumerable: true
-      });
+  const to = isNodeMode || !mod || !mod.__esModule || !__hasOwnProp.call(mod, "default") ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  if (mod && typeof mod === "object" || typeof mod === "function") {
+    for (let key of __getOwnPropNames(mod))
+      if (!__hasOwnProp.call(to, key))
+        __defProp(to, key, {
+          get: __accessProp.bind(mod, key),
+          enumerable: true
+        });
+  }
   if (canCache)
     cache.set(mod, to);
   return to;
@@ -33,7 +35,7 @@ var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports,
 var __require = import.meta.require;
 
 // node_modules/picocolors/picocolors.js
-var require_picocolors = __commonJS((exports, module) => {
+var require_picocolors = __commonJS(function(exports, module) {
   var p = process || {};
   var argv = p.argv || [];
   var env = p.env || {};
@@ -103,7 +105,7 @@ var require_picocolors = __commonJS((exports, module) => {
 });
 
 // node_modules/ejs/ejs.js
-var require_ejs = __commonJS((exports, module) => {
+var require_ejs = __commonJS(function(exports, module) {
   (function(f) {
     if (typeof exports === "object" && typeof module !== "undefined") {
       module.exports = f();
@@ -126,35 +128,35 @@ var require_ejs = __commonJS((exports, module) => {
     var define2, module2, exports2;
     return function() {
       function r(e, n, t) {
-        function o(i2, f) {
-          if (!n[i2]) {
-            if (!e[i2]) {
+        function o(i, f) {
+          if (!n[i]) {
+            if (!e[i]) {
               var c = __require;
               if (!f && c)
-                return c(i2, true);
+                return c(i, true);
               if (u)
-                return u(i2, true);
-              var a = new Error("Cannot find module '" + i2 + "'");
+                return u(i, true);
+              var a = new Error("Cannot find module '" + i + "'");
               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);
+            var p = n[i] = { exports: {} };
+            e[i][0].call(p.exports, function(r) {
+              var n = e[i][1][r];
+              return o(n || r);
             }, p, p.exports, r, e, n, t);
           }
-          return n[i2].exports;
+          return n[i].exports;
         }
         for (var u = __require, i = 0;i < t.length; i++)
           o(t[i]);
         return o;
       }
       return r;
-    }()({ 1: [function(require2, module3, exports3) {
+    }()({ 1: [function(require2, module2, exports2) {
       var __importDefault = this && this.__importDefault || function(mod) {
         return mod && mod.__esModule ? mod : { default: mod };
       };
-      Object.defineProperty(exports3, "__esModule", { value: true });
+      Object.defineProperty(exports2, "__esModule", { value: true });
       var fs_1 = __importDefault(require2("fs"));
       var path_1 = __importDefault(require2("path"));
       var utils_js_1 = __importDefault(require2("./utils.js"));
@@ -165,19 +167,6 @@ var require_ejs = __commonJS((exports, module) => {
       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;
@@ -338,9 +327,6 @@ var require_ejs = __commonJS((exports, module) => {
       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() {
@@ -349,7 +335,6 @@ var require_ejs = __commonJS((exports, module) => {
         var cb;
         var opts = { filename };
         var data;
-        var viewOpts;
         if (typeof arguments[arguments.length - 1] == "function") {
           cb = args.pop();
         }
@@ -357,20 +342,13 @@ var require_ejs = __commonJS((exports, module) => {
           data = args.shift();
           if (args.length) {
             utils_js_1.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_js_1.default.shallowCopy(opts, viewOpts);
-              }
+          } 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;
             }
-            utils_js_1.default.shallowCopyFromList(opts, data, _OPTS_PASSABLE_WITH_DATA_EXPRESS);
           }
           opts.filename = filename;
         } else {
@@ -409,6 +387,7 @@ var require_ejs = __commonJS((exports, module) => {
         options.async = opts.async;
         options.destructuredLocals = opts.destructuredLocals;
         options.legacyInclude = typeof opts.legacyInclude != "undefined" ? !!opts.legacyInclude : true;
+        options.unsafePrototypeLocals = !!opts.unsafePrototypeLocals;
         if (options.strict) {
           options._with = false;
         } else {
@@ -550,7 +529,13 @@ var require_ejs = __commonJS((exports, module) => {
               }
               return includeFile(path, opts)(d);
             };
-            return fn.apply(opts.context, [data || utils_js_1.default.createNullProtoObjWherePossible(), escapeFn, include, rethrow]);
+            var locals;
+            if (opts.unsafePrototypeLocals) {
+              locals = data || utils_js_1.default.createNullProtoObjWherePossible();
+            } else {
+              locals = utils_js_1.default.shallowCopy(utils_js_1.default.createNullProtoObjWherePossible(), data);
+            }
+            return fn.apply(opts.context, [locals, escapeFn, include, rethrow]);
           };
           if (opts.filename && typeof Object.defineProperty === "function") {
             var filename = opts.filename;
@@ -719,18 +704,16 @@ var require_ejs = __commonJS((exports, module) => {
       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 });
+      module2.exports = ejs;
+    }, { "./utils.js": 2, fs: 3, path: 4 }], 2: [function(require2, module2, exports2) {
+      Object.defineProperty(exports2, "__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 "";
@@ -791,25 +774,6 @@ var require_ejs = __commonJS((exports, module) => {
         }
         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) {
@@ -854,11 +818,8 @@ var require_ejs = __commonJS((exports, module) => {
         }
         return o;
       };
-      if (typeof exports3 != "undefined") {
-        module3.exports = utils;
-      }
-      exports3.default = utils;
-    }, {}], 3: [function(require2, module3, exports3) {}, {}], 4: [function(require2, module3, exports3) {
+      module2.exports = utils;
+    }, {}], 3: [function(require2, module2, exports2) {}, {}], 4: [function(require2, module2, exports2) {
       (function(process2) {
         (function() {
           function assertPath(path) {
@@ -1275,11 +1236,11 @@ var require_ejs = __commonJS((exports, module) => {
             posix: null
           };
           posix.posix = posix;
-          module3.exports = posix;
+          module2.exports = posix;
         }).call(this);
       }).call(this, require2("_process"));
-    }, { _process: 5 }], 5: [function(require2, module3, exports3) {
-      var process2 = module3.exports = {};
+    }, { _process: 5 }], 5: [function(require2, module2, exports2) {
+      var process2 = module2.exports = {};
       var cachedSetTimeout;
       var cachedClearTimeout;
       function defaultSetTimout() {
@@ -1321,7 +1282,7 @@ var require_ejs = __commonJS((exports, module) => {
         } catch (e) {
           try {
             return cachedSetTimeout.call(null, fun, 0);
-          } catch (e2) {
+          } catch (e) {
             return cachedSetTimeout.call(this, fun, 0);
           }
         }
@@ -1339,7 +1300,7 @@ var require_ejs = __commonJS((exports, module) => {
         } catch (e) {
           try {
             return cachedClearTimeout.call(null, marker);
-          } catch (e2) {
+          } catch (e) {
             return cachedClearTimeout.call(this, marker);
           }
         }
@@ -1439,7 +1400,7 @@ var require_ejs = __commonJS((exports, module) => {
 });
 
 // node_modules/eventemitter3/index.js
-var require_eventemitter3 = __commonJS((exports, module) => {
+var require_eventemitter3 = __commonJS(function(exports, module) {
   var has = Object.prototype.hasOwnProperty;
   var prefix = "~";
   function Events() {}
@@ -1617,7 +1578,7 @@ var require_eventemitter3 = __commonJS((exports, module) => {
 });
 
 // src/server.ts
-var import_picocolors3 = __toESM(require_picocolors(), 1);
+var import_picocolors2 = __toESM(require_picocolors(), 1);
 
 // src/httpHandler.ts
 var import_ejs = __toESM(require_ejs(), 1);
@@ -1790,8 +1751,672 @@ var staticAssetRoutes = {
 // src/fileWatcher.ts
 import { watch } from "fs/promises";
 
+// node_modules/ejs/lib/esm/ejs.js
+import fs from "fs";
+import path from "path";
+
+// node_modules/ejs/lib/esm/utils.js
+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.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;
+};
+var utils_default = utils;
+
+// node_modules/ejs/lib/esm/ejs.js
+var DECLARATION_KEYWORD = "let";
+var ejs2 = {};
+var _DEFAULT_OPEN_DELIMITER = "<";
+var _DEFAULT_CLOSE_DELIMITER = ">";
+var _DEFAULT_DELIMITER = "%";
+var _DEFAULT_LOCALS_NAME = "locals";
+var _REGEX_STRING = "(<%%|%%>|<%=|<%-|<%_|<%#|<%|%>|-%>|_%>)";
+var _BOM = /^\uFEFF/;
+var _JS_IDENTIFIER = /^[a-zA-Z_$][0-9a-zA-Z_$]*$/;
+ejs2.cache = utils_default.cache;
+ejs2.fileLoader = fs.readFileSync;
+ejs2.localsName = _DEFAULT_LOCALS_NAME;
+ejs2.promiseImpl = new Function("return this;")().Promise;
+ejs2.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 = ejs2.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 = ejs2.resolveInclude(path2, options.root || "/", true);
+    }
+  } else {
+    if (options.filename) {
+      filePath = ejs2.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 = ejs2.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 = ejs2.compile(template, options);
+  if (options.cache) {
+    ejs2.cache.set(filename, func);
+  }
+  return func;
+}
+function tryHandleCache(options, data, cb) {
+  let result;
+  if (!cb) {
+    if (typeof ejs2.promiseImpl == "function") {
+      return new ejs2.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 ejs2.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");
+}
+ejs2.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();
+};
+ejs2.render = function(template, d, o) {
+  let data = d || utils_default.createNullProtoObjWherePossible();
+  let opts = o || utils_default.createNullProtoObjWherePossible();
+  return handleCache(opts, template)(data);
+};
+ejs2.renderFile = function() {
+  let args = Array.prototype.slice.call(arguments);
+  let filename = args.shift();
+  let cb;
+  let opts = { filename };
+  let data;
+  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 (utils_default.hasOwn(data, "settings") && data.settings) {
+      if (data.settings.views) {
+        opts.views = data.settings.views;
+      }
+      if (data.settings["view cache"]) {
+        opts.cache = true;
+      }
+    }
+    opts.filename = filename;
+  } else {
+    data = utils_default.createNullProtoObjWherePossible();
+  }
+  return tryHandleCache(opts, data, cb);
+};
+ejs2.Template = Template;
+ejs2.clearCache = function() {
+  ejs2.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 || ejs2.openDelimiter || _DEFAULT_OPEN_DELIMITER;
+  options.closeDelimiter = opts.closeDelimiter || ejs2.closeDelimiter || _DEFAULT_CLOSE_DELIMITER;
+  options.delimiter = opts.delimiter || ejs2.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 || ejs2.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;
+  options.unsafePrototypeLocals = !!opts.unsafePrototypeLocals;
+  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);
+      };
+      let locals;
+      if (opts.unsafePrototypeLocals) {
+        locals = data || utils_default.createNullProtoObjWherePossible();
+      } else {
+        locals = utils_default.shallowCopy(utils_default.createNullProtoObjWherePossible(), data);
+      }
+      return fn.apply(opts.context, [locals, 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 self2 = 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 + '".');
+          }
+        }
+        self2.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 self2 = 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 (self2.opts.compileDebug && newLineCount) {
+      this.currentLine += newLineCount;
+      this.source += "    ; __line = " + this.currentLine + `
+`;
+    }
+  }
+};
+ejs2.escapeXML = utils_default.escapeXML;
+ejs2.__express = ejs2.renderFile;
+if (typeof window != "undefined") {
+  window.ejs = ejs2;
+}
+var ejs_default = ejs2;
+
 // src/buildManager.ts
-var import_ejs2 = __toESM(require_ejs(), 1);
 var {build } = globalThis.Bun;
 
 // node_modules/eventemitter3/index.mjs
@@ -1816,12 +2441,13 @@ function pTimeout(promise, options) {
   } = options;
   let timer;
   let abortHandler;
-  const wrappedPromise = new Promise((resolve2, reject) => {
+  const wrappedPromise = new Promise((resolve, reject) => {
     if (typeof milliseconds !== "number" || Math.sign(milliseconds) !== 1) {
       throw new TypeError(`Expected \`milliseconds\` to be a positive number, got \`${milliseconds}\``);
     }
     if (signal?.aborted) {
       reject(getAbortedReason(signal));
+      promise.then(resolve, reject);
       return;
     }
     if (signal) {
@@ -1830,7 +2456,7 @@ function pTimeout(promise, options) {
       };
       signal.addEventListener("abort", abortHandler, { once: true });
     }
-    promise.then(resolve2, reject);
+    promise.then(resolve, reject);
     if (milliseconds === Number.POSITIVE_INFINITY) {
       return;
     }
@@ -1838,7 +2464,7 @@ function pTimeout(promise, options) {
     timer = customTimers.setTimeout.call(undefined, () => {
       if (fallback) {
         try {
-          resolve2(fallback());
+          resolve(fallback());
         } catch (error) {
           reject(error);
         }
@@ -1848,7 +2474,7 @@ function pTimeout(promise, options) {
         promise.cancel();
       }
       if (message === false) {
-        resolve2();
+        resolve();
       } else if (message instanceof Error) {
         reject(message);
       } else {
@@ -1888,39 +2514,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, index) => index >= 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, index) => {
+      if (index < 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;
   }
 }
 
@@ -1934,7 +2609,6 @@ class PQueue extends import__.default {
   #rateLimitFlushScheduled = false;
   #interval;
   #intervalEnd = 0;
-  #lastExecutionTime = 0;
   #intervalId;
   #timeoutId;
   #strict;
@@ -1947,6 +2621,7 @@ class PQueue extends import__.default {
   #isPaused;
   #idAssigner = 1n;
   #runningTasks = new Map;
+  #queueAbortListenerCleanupFunctions = new Set;
   timeout;
   constructor(options) {
     super();
@@ -2061,13 +2736,6 @@ class PQueue extends import__.default {
     if (this.#intervalId === undefined) {
       const delay = this.#intervalEnd - now;
       if (delay < 0) {
-        if (this.#lastExecutionTime > 0) {
-          const timeSinceLastExecution = now - this.#lastExecutionTime;
-          if (timeSinceLastExecution < this.#interval) {
-            this.#createIntervalTimeout(this.#interval - timeSinceLastExecution);
-            return true;
-          }
-        }
         this.#intervalCount = this.#carryoverIntervalCount ? this.#pending : 0;
       } else {
         this.#createIntervalTimeout(delay);
@@ -2120,11 +2788,11 @@ class PQueue extends import__.default {
           this.#consumeIntervalSlot(now);
           this.#scheduleRateLimitUpdate();
         }
-        this.emit("active");
-        job();
         if (canInitializeInterval) {
           this.#initializeIntervalIfNeeded();
         }
+        job();
+        this.emit("active");
         taskStarted = true;
       }
     }
@@ -2144,8 +2812,12 @@ class PQueue extends import__.default {
   }
   #onInterval() {
     if (!this.#strict) {
-      if (this.#intervalCount === 0 && this.#pending === 0 && this.#intervalId) {
-        this.#clearIntervalTimer();
+      if (this.#intervalId !== undefined) {
+        if (this.#intervalCount === 0 && this.#pending === 0) {
+          this.#clearIntervalTimer();
+        } else {
+          this.#intervalEnd = Date.now() + this.#interval;
+        }
       }
       this.#intervalCount = this.#carryoverIntervalCount ? this.#pending : 0;
     }
@@ -2177,9 +2849,16 @@ class PQueue extends import__.default {
       ...options,
       id: options.id ?? (this.#idAssigner++).toString()
     };
-    return new Promise((resolve2, reject) => {
+    if (options.timeout !== undefined && !(Number.isFinite(options.timeout) && options.timeout > 0)) {
+      throw new TypeError(`Expected \`timeout\` to be a positive finite number, got \`${options.timeout}\` (${typeof options.timeout})`);
+    }
+    return new Promise((resolve, 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,
@@ -2196,9 +2875,8 @@ class PQueue extends import__.default {
             this.#runningTasks.delete(taskSymbol);
             throw error;
           }
-          this.#lastExecutionTime = Date.now();
           let operation = function_({ signal: options.signal });
-          if (options.timeout) {
+          if (options.timeout !== undefined) {
             operation = pTimeout(Promise.resolve(operation), {
               milliseconds: options.timeout,
               message: `Task timed out after ${options.timeout}ms (queue has ${this.#pending} running, ${this.#queue.size} waiting)`
@@ -2206,15 +2884,15 @@ class PQueue extends import__.default {
           }
           if (options.signal) {
             const { signal } = options;
-            operation = Promise.race([operation, new Promise((_resolve, reject2) => {
+            operation = Promise.race([operation, new Promise((_resolve, reject) => {
               eventListener = () => {
-                reject2(signal.reason);
+                reject(signal.reason);
               };
               signal.addEventListener("abort", eventListener, { once: true });
             })]);
           }
           const result = await operation;
-          resolve2(result);
+          resolve(result);
           this.emit("completed", result);
         } catch (error) {
           reject(error);
@@ -2228,7 +2906,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();
     });
@@ -2248,6 +2954,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();
@@ -2268,7 +2977,7 @@ class PQueue extends import__.default {
     if (this.#queue.size < limit) {
       return;
     }
-    await this.#onEvent("next", () => this.#queue.size < limit);
+    await this.#onEvent(["next", "active"], () => this.#queue.size < limit);
   }
   async onIdle() {
     if (this.#pending === 0 && this.#queue.size === 0) {
@@ -2303,16 +3012,21 @@ class PQueue extends import__.default {
       this.on("error", handleError);
     });
   }
-  async#onEvent(event, filter) {
-    return new Promise((resolve2) => {
+  async#onEvent(events, filter) {
+    const eventList = Array.isArray(events) ? events : [events];
+    return new Promise((resolve) => {
       const listener = () => {
         if (filter && !filter()) {
           return;
         }
-        this.off(event, listener);
-        resolve2();
+        for (const event of eventList) {
+          this.off(event, listener);
+        }
+        resolve();
       };
-      this.on(event, listener);
+      for (const event of eventList) {
+        this.on(event, listener);
+      }
     });
   }
   get size() {
@@ -2387,39 +3101,15 @@ 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
+    }));
   }
 }
 
 // src/buildManager.ts
-var import_picocolors2 = __toESM(require_picocolors(), 1);
-
-// src/tsChecker.ts
 var import_picocolors = __toESM(require_picocolors(), 1);
-var {$: $2 } = globalThis.Bun;
-var success = {
-  error: false,
-  message: ""
-};
-async function performTSC(finalConfig, importMeta) {
-  if (finalConfig.enableTSC) {
-    console.log("Performing TSC check");
-    const tsc = await $2`tsc --noEmit --noErrorTruncation -p ${finalConfig.tscConfigPath}`.cwd(importMeta.dir).quiet().nothrow();
-    if (tsc.exitCode === 0) {
-      console.log(import_picocolors.default.bgGreen("\u2714 [SUCCESS]"), "TSC check passed");
-      return success;
-    } else {
-      const errOutput = tsc.stdout.toString();
-      console.log(import_picocolors.default.bgRed("\u2718 [ERROR]"), `\r
-${errOutput}`);
-      return {
-        error: true,
-        message: errOutput
-      };
-    }
-  }
-  return success;
-}
 
 // src/bunManifest.ts
 var {write, pathToFileURL } = globalThis.Bun;
@@ -2467,15 +3157,17 @@ async function cleanBuildAndNotify(importerMeta, finalConfig, paths, buildCfg, b
       writeManifest(output, paths.serveDestination, finalConfig.manifestWithHash, finalConfig.manifestName);
     }
     await finalConfig.afterBuild?.(output, buildEnv);
-    if (finalConfig.reloadOnChange && !finalConfig.waitForTSCSuccessBeforeReload) {
-      bunServer.publish("message", JSON.stringify({ type: "reload" }));
-    }
-    const tscSuccess = await performTSC(finalConfig, importerMeta);
-    if (finalConfig.reloadOnChange && finalConfig.waitForTSCSuccessBeforeReload && !tscSuccess.error) {
+    if (finalConfig.reloadOnChange && output.success) {
       bunServer.publish("message", JSON.stringify({ type: "reload" }));
     }
-    if (tscSuccess.error && finalConfig.broadcastTSCErrorToClient) {
-      bunServer.publish("message", JSON.stringify({ type: "tscerror", message: tscSuccess.message }));
+    if (finalConfig.broadcastBuildOutputToClient) {
+      if (output.success && output.logs.length > 0) {
+        bunServer.publish("message", JSON.stringify({ type: "message", message: output.logs.join(`
+`) }));
+      } else {
+        bunServer.publish("message", JSON.stringify({ type: "error", message: output.logs.join(`
+`) }));
+      }
     }
   } catch (e) {
     const errorMessage = e instanceof Error ? e.message : String(e);
@@ -2527,7 +3219,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", import_ejs2.default.render(template, { hashedImports, cssFiles }));
+  Bun.write(paths.buildDestination + "/index.html", ejs_default.render(template, { hashedImports, cssFiles }));
 }
 function printPrettyBuildOutput(outTable) {
   if (outTable.length === 0)
@@ -2535,24 +3227,24 @@ function printPrettyBuildOutput(outTable) {
   const totalFiles = outTable.length;
   const fileWord = totalFiles === 1 ? "file" : "files";
   console.log(`
-` + import_picocolors2.default.bold(import_picocolors2.default.cyan(`\uD83D\uDCE6 Build Output (${totalFiles} ${fileWord})`)));
+` + import_picocolors.default.bold(import_picocolors.default.cyan(`\uD83D\uDCE6 Build Output (${totalFiles} ${fileWord})`)));
   outTable.forEach((row) => {
-    const checkmark = import_picocolors2.default.green("  \u2713");
-    const filePath = import_picocolors2.default.white(row.path);
-    const size = import_picocolors2.default.dim(`(${row.size})`);
+    const checkmark = import_picocolors.default.green("  \u2713");
+    const filePath = import_picocolors.default.white(row.path);
+    const size = import_picocolors.default.dim(`(${row.size})`);
     console.log(`${checkmark} ${filePath} ${size}`);
   });
   console.log("");
 }
 
 // src/fileWatcher.ts
-async function startFileWatcher(srcWatch, importMeta, finalConfig, paths, buildCfg, bunServer) {
+async function startFileWatcher(srcWatch, importMeta, finalConfig, paths, buildCfg, bunServer, signal) {
   const queue = getThrottledBuildQueue(finalConfig);
   await queue.add(async () => {
     await cleanBuildAndNotify(importMeta, finalConfig, paths, buildCfg, bunServer, { filename: "Initial", eventType: "change" });
   });
-  const watcher = watch(srcWatch, { recursive: true });
   try {
+    const watcher = watch(srcWatch, { recursive: true, signal });
     for await (const event of watcher) {
       if (queue.pending > 0) {
         continue;
@@ -2569,6 +3261,9 @@ async function startFileWatcher(srcWatch, importMeta, finalConfig, paths, buildC
       }
     }
   } catch (e) {
+    if (signal?.aborted) {
+      return;
+    }
     if (e?.code !== "EPERM") {
       console.error("Error in file watcher", e);
     }
@@ -2621,19 +3316,30 @@ function hotReload() {
       window.location.reload();
       return;
     }
-    if (parsed?.type === "tscerror") {
-      console.error(parsed.message);
-      return;
-    }
     if (parsed?.type === "error") {
       console.error(parsed.message);
       let newDiv = window.document.getElementById("bun-hmr-error");
       const divExists = !!newDiv;
       if (!newDiv) {
         newDiv = window.document.createElement("div");
+      } else {
+        newDiv.remove();
       }
       newDiv.id = "bun-hmr-error";
       newDiv.innerText += parsed.message;
+      newDiv.style.position = "fixed";
+      newDiv.style.top = "25%";
+      newDiv.style.left = "25%";
+      newDiv.style.zIndex = "9999";
+      newDiv.style.width = "50%";
+      newDiv.style.height = "50%";
+      newDiv.style.backgroundColor = "rgb(0 0 0 / 85%)";
+      newDiv.style.color = "red";
+      newDiv.style.fontSize = "16px";
+      newDiv.style.textAlign = "center";
+      newDiv.style.alignContent = "center";
+      newDiv.style.border = "solid red 4px";
+      newDiv.style.borderRadius = "7px";
       if (!divExists) {
         window.document.body.appendChild(newDiv);
       }
@@ -2674,17 +3380,17 @@ function bunHotReloadPlugin(config) {
   const bunHMRPlugin = {
     name: "hmr",
     target: "browser",
-    setup(build2) {
+    setup(build) {
       const entryPoints = [];
       const addedEnryPoints = new Set;
-      build2.config.entrypoints.forEach((entry) => {
+      build.config.entrypoints.forEach((entry) => {
         let entryPath = entry.replace(/^\.*/, "");
         if (process.platform === "win32") {
           entryPath = entryPath.replace(/\//g, "\\");
         }
         entryPoints.push(entryPath);
       });
-      build2.onLoad({ filter: /\.m?(t|j)sx?/ }, async (args) => {
+      build.onLoad({ filter: /\.m?(t|j)sx?/ }, async (args) => {
         const contents = await readFile2(args.path, { encoding: "utf-8" });
         const isTSx = /\.m?tsx$/.test(args.path);
         const isJSx = /\.m?jsx$/.test(args.path);
@@ -2699,11 +3405,11 @@ function bunHotReloadPlugin(config) {
         }
         return { contents, loader };
       });
-      build2.onLoad({ filter: /./, namespace: "bun-hot-reload" }, async (args) => {
+      build.onLoad({ filter: /./, namespace: "bun-hot-reload" }, async (args) => {
         return { contents: `(${bunHotReload(config)})()
 `, loader: "ts" };
       });
-      build2.onResolve({ filter: /^bun-hot-reload$/ }, (args) => {
+      build.onResolve({ filter: /^bun-hot-reload$/ }, (args) => {
         return { path: args.path, namespace: "bun-hot-reload" };
       });
     }
@@ -2790,13 +3496,16 @@ async function prepareConfiguration(serverConfig, importMeta) {
 
 // src/server.ts
 async function startBunDevServer(serverConfig, importMeta) {
+  if (!Bun.semver.satisfies(Bun.version, ">=1.4.3")) {
+    throw new Error("This version of the server requires Bun version 1.4.3 or higher.");
+  }
   const { finalConfig, buildCfg, ...paths } = await prepareConfiguration(serverConfig, importMeta);
   const protocol = finalConfig.tls ? "https" : "http";
   const serverUrl = `${protocol}://localhost:${finalConfig.port}`;
-  const isTestMode = process.env.BUN_TEST === "true" || typeof Bun !== "undefined" && Bun.main.includes("test");
+  const isTestMode = process.env.BUN_TEST === "true";
   if (!isTestMode) {
-    console.log(import_picocolors3.default.bold(import_picocolors3.default.green("\uD83D\uDE80 Server running at")) + " " + import_picocolors3.default.cyan(import_picocolors3.default.underline(serverUrl)));
-    console.log(import_picocolors3.default.bold(import_picocolors3.default.green("\uD83D\uDCC1 Serving files from")) + " " + import_picocolors3.default.cyan(import_picocolors3.default.underline(paths.serveDestination)));
+    console.log(import_picocolors2.default.bold(import_picocolors2.default.green("\uD83D\uDE80 Server running at")) + " " + import_picocolors2.default.cyan(import_picocolors2.default.underline(serverUrl)));
+    console.log(import_picocolors2.default.bold(import_picocolors2.default.green("\uD83D\uDCC1 Serving files from")) + " " + import_picocolors2.default.cyan(import_picocolors2.default.underline(paths.serveDestination)));
   }
   await ensureDestinationDirectory(paths.serveDestination);
   let bunServer;
@@ -2848,10 +3557,10 @@ async function startBunDevServer(serverConfig, importMeta) {
   }
 }
 export {
-  startBunDevServer,
+  bunHotReloadPlugin,
   getBunHMRFooter,
-  bunHotReloadPlugin
+  startBunDevServer
 };
 
-//# debugId=CBC8475BE6C83F4364756E2164756E21
+//# debugId=7C706A42EA9FE48E64756E2164756E21
 //# sourceMappingURL=index.js.map