bun-dev-server 0.3.0 → 0.5.0

package/dist/index.js

@@ -0,0 +1,1354 @@
+// @bun
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __toESM = (mod, isNodeMode, target) => {
+  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: () => mod[key],
+        enumerable: true
+      });
+  return to;
+};
+var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
+
+// node_modules/ejs/lib/utils.js
+var require_utils = __commonJS((exports) => {
+  var regExpChars = /[|\\{}()[\]^$+*?.]/g;
+  var hasOwnProperty = Object.prototype.hasOwnProperty;
+  var hasOwn = function(obj, key) {
+    return hasOwnProperty.apply(obj, [key]);
+  };
+  exports.escapeRegExpChars = function(string) {
+    if (!string) {
+      return "";
+    }
+    return String(string).replace(regExpChars, "\\$&");
+  };
+  var _ENCODE_HTML_RULES = {
+    "&": "&",
+    "<": "&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;
+` + `};
+`;
+  exports.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(exports.escapeXML, "toString", { value: escapeXMLToString });
+    } else {
+      exports.escapeXML.toString = escapeXMLToString;
+    }
+  } catch (err) {
+    console.warn("Unable to set escapeXML.toString (is the Function prototype frozen?)");
+  }
+  exports.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;
+  };
+  exports.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;
+  };
+  exports.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 = {};
+    }
+  };
+  exports.hyphenToCamel = function(str) {
+    return str.replace(/-[a-z]/g, function(match) {
+      return match[1].toUpperCase();
+    });
+  };
+  exports.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 {};
+    };
+  }();
+  exports.hasOwnOnlyObject = function(obj) {
+    var o = exports.createNullProtoObjWherePossible();
+    for (var p in obj) {
+      if (hasOwn(obj, p)) {
+        o[p] = obj[p];
+      }
+    }
+    return o;
+  };
+});
+
+// node_modules/ejs/package.json
+var require_package = __commonJS((exports, module) => {
+  module.exports = {
+    name: "ejs",
+    description: "Embedded JavaScript templates",
+    keywords: [
+      "template",
+      "engine",
+      "ejs"
+    ],
+    version: "3.1.10",
+    author: "Matthew Eernisse <mde@fleegix.org> (http://fleegix.org)",
+    license: "Apache-2.0",
+    bin: {
+      ejs: "./bin/cli.js"
+    },
+    main: "./lib/ejs.js",
+    jsdelivr: "ejs.min.js",
+    unpkg: "ejs.min.js",
+    repository: {
+      type: "git",
+      url: "git://github.com/mde/ejs.git"
+    },
+    bugs: "https://github.com/mde/ejs/issues",
+    homepage: "https://github.com/mde/ejs",
+    dependencies: {
+      jake: "^10.8.5"
+    },
+    devDependencies: {
+      browserify: "^16.5.1",
+      eslint: "^6.8.0",
+      "git-directory-deploy": "^1.5.1",
+      jsdoc: "^4.0.2",
+      "lru-cache": "^4.0.1",
+      mocha: "^10.2.0",
+      "uglify-js": "^3.3.16"
+    },
+    engines: {
+      node: ">=0.10.0"
+    },
+    scripts: {
+      test: "npx jake test"
+    }
+  };
+});
+
+// node_modules/ejs/lib/ejs.js
+var require_ejs = __commonJS((exports) => {
+  var fs = import.meta.require("fs");
+  var path = import.meta.require("path");
+  var utils = require_utils();
+  var scopeOptionWarned = false;
+  var _VERSION_STRING = require_package().version;
+  var _DEFAULT_OPEN_DELIMITER = "<";
+  var _DEFAULT_CLOSE_DELIMITER = ">";
+  var _DEFAULT_DELIMITER = "%";
+  var _DEFAULT_LOCALS_NAME = "locals";
+  var _NAME = "ejs";
+  var _REGEX_STRING = "(<%%|%%>|<%=|<%-|<%_|<%#|<%|%>|-%>|_%>)";
+  var _OPTS_PASSABLE_WITH_DATA = [
+    "delimiter",
+    "scope",
+    "context",
+    "debug",
+    "compileDebug",
+    "client",
+    "_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_$]*$/;
+  exports.cache = utils.cache;
+  exports.fileLoader = fs.readFileSync;
+  exports.localsName = _DEFAULT_LOCALS_NAME;
+  exports.promiseImpl = new Function("return this;")().Promise;
+  exports.resolveInclude = function(name, filename, isDir) {
+    var dirname = path.dirname;
+    var extname = path.extname;
+    var resolve = path.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 = exports.resolveInclude(name, v, true);
+      return fs.existsSync(filePath);
+    })) {
+      return filePath;
+    }
+  }
+  function getIncludePath(path2, options) {
+    var includePath;
+    var filePath;
+    var views = options.views;
+    var 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 = exports.resolveInclude(path2, options.root || "/", true);
+      }
+    } else {
+      if (options.filename) {
+        filePath = exports.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) {
+    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 = exports.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 = exports.compile(template, options);
+    if (options.cache) {
+      exports.cache.set(filename, func);
+    }
+    return func;
+  }
+  function tryHandleCache(options, data, cb) {
+    var result;
+    if (!cb) {
+      if (typeof exports.promiseImpl == "function") {
+        return new exports.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 exports.fileLoader(filePath);
+  }
+  function includeFile(path2, options) {
+    var opts = utils.shallowCopy(utils.createNullProtoObjWherePossible(), options);
+    opts.filename = getIncludePath(path2, opts);
+    if (typeof options.includer === "function") {
+      var 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) {
+    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");
+  }
+  exports.compile = function compile(template, opts) {
+    var templ;
+    if (opts && opts.scope) {
+      if (!scopeOptionWarned) {
+        console.warn("`scope` option is deprecated and will be removed in EJS 3");
+        scopeOptionWarned = true;
+      }
+      if (!opts.context) {
+        opts.context = opts.scope;
+      }
+      delete opts.scope;
+    }
+    templ = new Template(template, opts);
+    return templ.compile();
+  };
+  exports.render = function(template, d, o) {
+    var data = d || utils.createNullProtoObjWherePossible();
+    var opts = o || utils.createNullProtoObjWherePossible();
+    if (arguments.length == 2) {
+      utils.shallowCopyFromList(opts, data, _OPTS_PASSABLE_WITH_DATA);
+    }
+    return handleCache(opts, template)(data);
+  };
+  exports.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.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.shallowCopy(opts, viewOpts);
+          }
+        }
+        utils.shallowCopyFromList(opts, data, _OPTS_PASSABLE_WITH_DATA_EXPRESS);
+      }
+      opts.filename = filename;
+    } else {
+      data = utils.createNullProtoObjWherePossible();
+    }
+    return tryHandleCache(opts, data, cb);
+  };
+  exports.Template = Template;
+  exports.clearCache = function() {
+    exports.cache.reset();
+  };
+  function Template(text, optsParam) {
+    var opts = utils.hasOwnOnlyObject(optsParam);
+    var options = utils.createNullProtoObjWherePossible();
+    this.templateText = text;
+    this.mode = null;
+    this.truncate = false;
+    this.currentLine = 1;
+    this.source = "";
+    options.client = opts.client || false;
+    options.escapeFunction = opts.escape || opts.escapeFunction || utils.escapeXML;
+    options.compileDebug = opts.compileDebug !== false;
+    options.debug = !!opts.debug;
+    options.filename = opts.filename;
+    options.openDelimiter = opts.openDelimiter || exports.openDelimiter || _DEFAULT_OPEN_DELIMITER;
+    options.closeDelimiter = opts.closeDelimiter || exports.closeDelimiter || _DEFAULT_CLOSE_DELIMITER;
+    options.delimiter = opts.delimiter || exports.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 || exports.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.escapeRegExpChars(this.opts.delimiter);
+      var open = utils.escapeRegExpChars(this.opts.openDelimiter);
+      var close = utils.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 += `  var __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 += "  var " + 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 = "  var __locals = (" + opts.localsName + ` || {}),
+`;
+          for (var i = 0;i < opts.destructuredLocals.length; i++) {
+            var 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 = "var __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.client) {
+        src = "escapeFn = escapeFn || " + escapeFn.toString() + ";" + `
+` + src;
+        if (opts.compileDebug) {
+          src = "rethrow = rethrow || " + rethrow.toString() + ";" + `
+` + src;
+        }
+      }
+      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 = opts.client ? fn : function anonymous(data) {
+        var include = function(path2, includeData) {
+          var d = utils.shallowCopy(utils.createNullProtoObjWherePossible(), data);
+          if (includeData) {
+            d = utils.shallowCopy(d, includeData);
+          }
+          return includeFile(path2, opts)(d);
+        };
+        return fn.apply(opts.context, [data || utils.createNullProtoObjWherePossible(), escapeFn, include, rethrow]);
+      };
+      if (opts.filename && typeof Object.defineProperty === "function") {
+        var filename = opts.filename;
+        var 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() {
+      var opts = this.opts;
+      if (opts.rmWhitespace) {
+        this.templateText = this.templateText.replace(/[\r\n]+/g, `
+`).replace(/^\s+|\s+$/gm, "");
+      }
+      this.templateText = this.templateText.replace(/[ \t]*<%_/gm, "<%_").replace(/_%>[ \t]*/gm, "_%>");
+      var self = this;
+      var matches = this.parseTemplateText();
+      var d = this.opts.delimiter;
+      var o = this.opts.openDelimiter;
+      var c = this.opts.closeDelimiter;
+      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 + '".');
+            }
+          }
+          self.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 self = 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 (self.opts.compileDebug && newLineCount) {
+        this.currentLine += newLineCount;
+        this.source += "    ; __line = " + this.currentLine + `
+`;
+      }
+    }
+  };
+  exports.escapeXML = utils.escapeXML;
+  exports.__express = exports.renderFile;
+  exports.VERSION = _VERSION_STRING;
+  exports.name = _NAME;
+  if (typeof window != "undefined") {
+    window.ejs = exports;
+  }
+});
+
+// node_modules/picocolors/picocolors.js
+var require_picocolors = __commonJS((exports, module) => {
+  var p = process || {};
+  var argv = p.argv || [];
+  var env = p.env || {};
+  var isColorSupported = !(!!env.NO_COLOR || argv.includes("--no-color")) && (!!env.FORCE_COLOR || argv.includes("--color") || p.platform === "win32" || (p.stdout || {}).isTTY && env.TERM !== "dumb" || !!env.CI);
+  var formatter = (open, close, replace = open) => (input) => {
+    let string = "" + input, index = string.indexOf(close, open.length);
+    return ~index ? open + replaceClose(string, close, replace, index) + close : open + string + close;
+  };
+  var replaceClose = (string, close, replace, index) => {
+    let result = "", cursor = 0;
+    do {
+      result += string.substring(cursor, index) + replace;
+      cursor = index + close.length;
+      index = string.indexOf(close, cursor);
+    } while (~index);
+    return result + string.substring(cursor);
+  };
+  var createColors = (enabled = isColorSupported) => {
+    let f = enabled ? formatter : () => String;
+    return {
+      isColorSupported: enabled,
+      reset: f("\x1B[0m", "\x1B[0m"),
+      bold: f("\x1B[1m", "\x1B[22m", "\x1B[22m\x1B[1m"),
+      dim: f("\x1B[2m", "\x1B[22m", "\x1B[22m\x1B[2m"),
+      italic: f("\x1B[3m", "\x1B[23m"),
+      underline: f("\x1B[4m", "\x1B[24m"),
+      inverse: f("\x1B[7m", "\x1B[27m"),
+      hidden: f("\x1B[8m", "\x1B[28m"),
+      strikethrough: f("\x1B[9m", "\x1B[29m"),
+      black: f("\x1B[30m", "\x1B[39m"),
+      red: f("\x1B[31m", "\x1B[39m"),
+      green: f("\x1B[32m", "\x1B[39m"),
+      yellow: f("\x1B[33m", "\x1B[39m"),
+      blue: f("\x1B[34m", "\x1B[39m"),
+      magenta: f("\x1B[35m", "\x1B[39m"),
+      cyan: f("\x1B[36m", "\x1B[39m"),
+      white: f("\x1B[37m", "\x1B[39m"),
+      gray: f("\x1B[90m", "\x1B[39m"),
+      bgBlack: f("\x1B[40m", "\x1B[49m"),
+      bgRed: f("\x1B[41m", "\x1B[49m"),
+      bgGreen: f("\x1B[42m", "\x1B[49m"),
+      bgYellow: f("\x1B[43m", "\x1B[49m"),
+      bgBlue: f("\x1B[44m", "\x1B[49m"),
+      bgMagenta: f("\x1B[45m", "\x1B[49m"),
+      bgCyan: f("\x1B[46m", "\x1B[49m"),
+      bgWhite: f("\x1B[47m", "\x1B[49m"),
+      blackBright: f("\x1B[90m", "\x1B[39m"),
+      redBright: f("\x1B[91m", "\x1B[39m"),
+      greenBright: f("\x1B[92m", "\x1B[39m"),
+      yellowBright: f("\x1B[93m", "\x1B[39m"),
+      blueBright: f("\x1B[94m", "\x1B[39m"),
+      magentaBright: f("\x1B[95m", "\x1B[39m"),
+      cyanBright: f("\x1B[96m", "\x1B[39m"),
+      whiteBright: f("\x1B[97m", "\x1B[39m"),
+      bgBlackBright: f("\x1B[100m", "\x1B[49m"),
+      bgRedBright: f("\x1B[101m", "\x1B[49m"),
+      bgGreenBright: f("\x1B[102m", "\x1B[49m"),
+      bgYellowBright: f("\x1B[103m", "\x1B[49m"),
+      bgBlueBright: f("\x1B[104m", "\x1B[49m"),
+      bgMagentaBright: f("\x1B[105m", "\x1B[49m"),
+      bgCyanBright: f("\x1B[106m", "\x1B[49m"),
+      bgWhiteBright: f("\x1B[107m", "\x1B[49m")
+    };
+  };
+  module.exports = createColors();
+  module.exports.createColors = createColors;
+});
+
+// node_modules/debounce/index.js
+var require_debounce = __commonJS((exports, module) => {
+  function debounce(function_, wait = 100, options = {}) {
+    if (typeof function_ !== "function") {
+      throw new TypeError(`Expected the first parameter to be a function, got \`${typeof function_}\`.`);
+    }
+    if (wait < 0) {
+      throw new RangeError("`wait` must not be negative.");
+    }
+    const { immediate } = typeof options === "boolean" ? { immediate: options } : options;
+    let storedContext;
+    let storedArguments;
+    let timeoutId;
+    let timestamp;
+    let result;
+    function run() {
+      const callContext = storedContext;
+      const callArguments = storedArguments;
+      storedContext = undefined;
+      storedArguments = undefined;
+      result = function_.apply(callContext, callArguments);
+      return result;
+    }
+    function later() {
+      const last = Date.now() - timestamp;
+      if (last < wait && last >= 0) {
+        timeoutId = setTimeout(later, wait - last);
+      } else {
+        timeoutId = undefined;
+        if (!immediate) {
+          result = run();
+        }
+      }
+    }
+    const debounced = function(...arguments_) {
+      if (storedContext && this !== storedContext && Object.getPrototypeOf(this) === Object.getPrototypeOf(storedContext)) {
+        throw new Error("Debounced method called with different contexts of the same prototype.");
+      }
+      storedContext = this;
+      storedArguments = arguments_;
+      timestamp = Date.now();
+      const callNow = immediate && !timeoutId;
+      if (!timeoutId) {
+        timeoutId = setTimeout(later, wait);
+      }
+      if (callNow) {
+        result = run();
+      }
+      return result;
+    };
+    Object.defineProperty(debounced, "isPending", {
+      get() {
+        return timeoutId !== undefined;
+      }
+    });
+    debounced.clear = () => {
+      if (!timeoutId) {
+        return;
+      }
+      clearTimeout(timeoutId);
+      timeoutId = undefined;
+    };
+    debounced.flush = () => {
+      if (!timeoutId) {
+        return;
+      }
+      debounced.trigger();
+    };
+    debounced.trigger = () => {
+      result = run();
+      debounced.clear();
+    };
+    return debounced;
+  }
+  exports.debounce = debounce;
+  module.exports = debounce;
+});
+
+// src/server.ts
+var import_ejs = __toESM(require_ejs(), 1);
+var Bun = globalThis.Bun;
+var {$: $2 } = Bun;
+
+// src/serveOutputTemplate.ejs
+var serveOutputTemplate_default = `<!DOCTYPE html>\r
+<html lang="en">\r
+\r
+  <head>\r
+    <meta charset="UTF-8" />\r
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />\r
+    <title>Document</title>\r
+  </head>\r
+\r
+  <body>\r
+    <a href="../">..</a>\r
+    <% dirs.forEach(element => { %> <br /><a href=".<%= element.requestPath %>/<%= element.name %>"><%= element.name %></a> <% }) %>\r
+    <% files.forEach(element => { %> <br /><a href=".<%= element.requestPath %>/<%= element.name %>"><%= element.name %></a> <% }) %>\r
+  </body>\r
+\r
+</html>`;
+
+// src/indexHTMLTemplate.ejs
+var indexHTMLTemplate_default = `<!DOCTYPE html>\r
+<html lang="en">\r
+  <head>\r
+    <meta charset="UTF-8" />\r
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />\r
+    <title>Bun HTML File</title>\r
+    <% for (const hashedJs of hashedImports) { %>\r
+    <script type="module" src="<%= hashedJs %>"></script>\r
+    <% } %>\r
+  </head>\r
+\r
+  <body>\r
+    <div id="app"></div>\r
+  </body>\r
+</html>\r
+`;
+
+// src/server.ts
+import { watch, readdir, exists, readFile as readFile2 } from "fs/promises";
+
+// src/bunClientHmr.ts
+function hotReload() {
+  if (!window.BUN_DEV_SERVER) {
+    window.BUN_DEV_SERVER = [];
+  }
+  const devServer = "[Bun Dev Server]";
+  const connectAddress = "[REPLACE_ENDPOINT]";
+  let foundServer = window.BUN_DEV_SERVER.find((server) => server.url === connectAddress);
+  if (!foundServer) {
+    foundServer = { url: connectAddress, socket: null };
+  }
+  if (foundServer.socket) {
+    return;
+  }
+  console.log(devServer, "Connecting to Bun Dev Server at", connectAddress);
+  foundServer.socket = new WebSocket(connectAddress);
+  window.BUN_DEV_SERVER.push(foundServer);
+  function errorHandler(err) {
+    console.error(devServer, "ERROR", err);
+  }
+  function messageHandler(msg) {
+    let parsed = msg.data;
+    try {
+      parsed = JSON.parse(msg.data);
+    } catch (e) {
+    }
+    if (parsed?.type === "message") {
+      console.log(devServer, parsed.message);
+      return;
+    }
+    if (parsed?.type === "output") {
+      console.table(devServer, parsed.message);
+      return;
+    }
+    if (parsed?.type === "reload") {
+      window.location.reload();
+      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");
+      }
+      newDiv.id = "bun-hmr-error";
+      newDiv.innerText += parsed.message;
+      if (!divExists) {
+        window.document.body.appendChild(newDiv);
+      }
+      return;
+    }
+  }
+  function closeHandler(ev) {
+    console.warn(devServer, "Connection closed. Will retry in 5 seconds...");
+    foundServer.socket?.removeEventListener("error", errorHandler);
+    foundServer.socket?.removeEventListener("message", messageHandler);
+    foundServer.socket?.removeEventListener("open", messageHandler);
+    foundServer.socket?.removeEventListener("close", closeHandler);
+    foundServer.socket = null;
+    setTimeout(function() {
+      console.log(devServer, "Attempting to reconnect...");
+      hotReload();
+    }, 5000);
+  }
+  function openHandler(ev) {
+    console.log(devServer, "Connected to Bun Dev Server");
+  }
+  foundServer.socket.addEventListener("error", errorHandler);
+  foundServer.socket.addEventListener("message", messageHandler);
+  foundServer.socket.addEventListener("close", closeHandler);
+  foundServer.socket.addEventListener("open", openHandler);
+}
+var DEFAULT_HMR_PATH = "/hmr-ws";
+function bunHotReload(bunServerConfig) {
+  const socketPath = bunServerConfig.websocketPath || DEFAULT_HMR_PATH;
+  const endPath = socketPath.startsWith("/") ? socketPath : `/${socketPath}`;
+  const path = `${bunServerConfig.secure ? "wss" : "ws"}://localhost:${bunServerConfig.port}${endPath}`;
+  return hotReload.toString().replace("[REPLACE_ENDPOINT]", path);
+}
+
+// src/bunHmrPlugin.ts
+import { readFile } from "fs/promises";
+function bunHotReloadPlugin(config) {
+  const bunHMRPlugin = {
+    name: "hmr",
+    target: "browser",
+    setup(build) {
+      const entryPoints = [];
+      const addedEnryPoints = new Set;
+      build.config.entrypoints.forEach((entry) => {
+        let entryPath = entry.replace(/^\.*/, "");
+        if (process.platform === "win32") {
+          entryPath = entryPath.replace(/\//g, "\\");
+        }
+        entryPoints.push(entryPath);
+      });
+      build.onLoad({ filter: /\.m?tsx?/ }, async (args) => {
+        const contents = await readFile(args.path, { encoding: "utf-8" });
+        const isTSx = /\.m?tsx$/.test(args.path);
+        const isJSx = /\.m?jsx$/.test(args.path);
+        const isJS = /\.m?js$/.test(args.path);
+        const isTS = /\.m?ts$/.test(args.path);
+        const loader = isTSx ? "tsx" : isJSx ? "jsx" : isTS ? "ts" : isJS ? "js" : "text";
+        const isEntry = entryPoints.some((entry) => args.path.endsWith(entry));
+        if (!addedEnryPoints.has(args.path) && isEntry) {
+          addedEnryPoints.add(args.path);
+          return { contents: `import "bun-hot-reload"
+` + contents, loader };
+        }
+        return { contents, loader };
+      });
+      build.onLoad({ filter: /./, namespace: "bun-hot-reload" }, async (args) => {
+        return { contents: `(${bunHotReload(config)})()
+`, loader: "ts" };
+      });
+      build.onResolve({ filter: /^bun-hot-reload$/ }, (args) => {
+        return { path: args.path, namespace: "bun-hot-reload" };
+      });
+    }
+  };
+  return bunHMRPlugin;
+}
+function getBunHMRFooter(config) {
+  return `;(${bunHotReload(config)})();`;
+}
+
+// src/bunManifest.ts
+var {write, pathToFileURL } = globalThis.Bun;
+function writeManifest(output, outdir, withHash = false, manifestName = "bunmanifest.txt") {
+  const entryPoints = output.outputs.filter((o) => o.kind === "entry-point");
+  const epTable = [];
+  for (const ep of entryPoints) {
+    const basePathUrl = pathToFileURL(outdir);
+    const epUrl = pathToFileURL(ep.path);
+    const relativePath = epUrl.href.replace(`${basePathUrl.href}/`, "");
+    const hashedImport = `${relativePath}${withHash ? `?${ep.hash}` : ``}`;
+    epTable.push(hashedImport);
+  }
+  const outObj = { js: epTable };
+  write(`${outdir}/${manifestName}`, JSON.stringify(outObj));
+}
+
+// src/tsChecker.ts
+var import_picocolors = __toESM(require_picocolors(), 1);
+var {$ } = globalThis.Bun;
+async function performTSC(finalConfig) {
+  if (finalConfig.enableTSC) {
+    console.log("Performing TSC check");
+    const tsc = await $`tsc`.nothrow().quiet();
+    if (tsc.exitCode === 0) {
+      console.log(import_picocolors.default.bgGreen("\u2714 [SUCCESS]"), "TSC check passed");
+      return true;
+    } else {
+      console.log(import_picocolors.default.bgRed("\u2718 [ERROR]"), `\r
+${tsc.stdout.toString()}`);
+      return false;
+    }
+  }
+  return true;
+}
+
+// src/server.ts
+var import_debounce = __toESM(require_debounce(), 1);
+var watchDelay = 1000;
+async function startBunDevServer(serverConfig) {
+  const defaultConfig = {
+    port: 3000,
+    websocketPath: DEFAULT_HMR_PATH,
+    serveOutputEjs: serveOutputTemplate_default,
+    serveOutputHtml: indexHTMLTemplate_default
+  };
+  const finalConfig = { ...defaultConfig, ...serverConfig };
+  if (finalConfig.watchDelay) {
+    watchDelay = finalConfig.watchDelay;
+  }
+  if (!finalConfig.watchDir) {
+    throw new Error("watchDir must be set");
+  }
+  const serveDestination = finalConfig.buildConfig.outdir ?? finalConfig.servePath ?? "dist";
+  const bunDestinationPath = Bun.pathToFileURL(serveDestination);
+  const bunWatchDirPath = Bun.pathToFileURL(finalConfig.watchDir);
+  const destinationPath = process.platform === "win32" ? bunDestinationPath.pathname.substring(1) : bunDestinationPath.pathname;
+  const srcWatch = process.platform === "win32" ? bunWatchDirPath.pathname.substring(1) : bunWatchDirPath.pathname;
+  try {
+    await readdir(destinationPath);
+  } catch (e) {
+    if (e.code === "ENOENT") {
+      console.log("Directory not found, creating it...");
+      await $2`mkdir ${destinationPath}`;
+    } else {
+      throw e;
+    }
+  }
+  const buncfg = { port: finalConfig.port, tls: finalConfig.tls, websocketPath: finalConfig.websocketPath };
+  const buildCfg = {
+    ...serverConfig.buildConfig,
+    outdir: destinationPath
+  };
+  if (finalConfig.hotReload === "footer") {
+    if (!buildCfg.footer) {
+      buildCfg.footer = "";
+    }
+    buildCfg.footer += getBunHMRFooter(buncfg);
+  }
+  if (finalConfig.hotReload === "plugin") {
+    if (!buildCfg.plugins) {
+      buildCfg.plugins = [];
+    }
+    buildCfg.plugins.push(bunHotReloadPlugin(buncfg));
+  }
+  if (serverConfig.cleanServePath) {
+    await cleanDirectory(destinationPath);
+  }
+  console.log("Starting Bun Dev Server on port", finalConfig.port);
+  const bunServer = Bun.serve({
+    port: finalConfig.port,
+    development: true,
+    tls: finalConfig.tls,
+    async fetch(req, server) {
+      if (req.method === "OPTIONS") {
+        const response = new Response("", { status: 200 });
+        augumentHeaders(req, response);
+        return response;
+      }
+      if (req.url.toLowerCase().endsWith("/favicon.ico")) {
+        const response = new Response("", { status: 404 });
+        augumentHeaders(req, response);
+        return response;
+      }
+      if (req.url.toLowerCase().endsWith(finalConfig.websocketPath)) {
+        if (server.upgrade(req)) {
+          return;
+        }
+      }
+      const url = new URL(req.url);
+      const requestPath = url.pathname;
+      const objThere = await exists(destinationPath + requestPath);
+      let isDirectory = false;
+      if (objThere) {
+        try {
+          await readFile2(destinationPath + requestPath);
+        } catch (e) {
+          if (e.code === "EISDIR") {
+            isDirectory = true;
+          } else {
+            throw e;
+          }
+        }
+      } else {
+        const response = new Response("", { status: 404 });
+        augumentHeaders(req, response);
+        return response;
+      }
+      if (!isDirectory) {
+        try {
+          const fl = Bun.file(destinationPath + requestPath);
+          const response = new Response(fl);
+          augumentHeaders(req, response);
+          return response;
+        } catch (e) {
+          if (e.code === "ENOENT") {
+            const response = new Response("", { status: 404 });
+            augumentHeaders(req, response);
+            return response;
+          } else {
+            throw e;
+          }
+        }
+      }
+      try {
+        const allEntries = await readdir(destinationPath + requestPath, {
+          withFileTypes: true
+        });
+        const dirs = allEntries.filter((entry) => entry.isDirectory()).map((entry) => {
+          return {
+            requestPath: requestPath === "/" ? "" : requestPath,
+            name: entry.name
+          };
+        });
+        const files = allEntries.filter((entry) => entry.isFile()).map((entry) => {
+          return {
+            requestPath: requestPath === "/" ? "" : requestPath,
+            name: entry.name
+          };
+        });
+        const rnd = import_ejs.render(finalConfig.serveOutputEjs, { dirs, files });
+        const response = new Response(rnd, { headers: { "Content-Type": "text/html" } });
+        augumentHeaders(req, response);
+        return response;
+      } catch {
+        const response = new Response("Not Found", { status: 404 });
+        augumentHeaders(req, response);
+        return response;
+      }
+    },
+    websocket: {
+      open(ws) {
+        ws.subscribe("message");
+      },
+      message(ws, message) {
+      },
+      sendPings: true
+    }
+  });
+  debouncedbuildAndNotify(finalConfig, destinationPath, buildCfg, bunServer, { filename: "Initial", eventType: "change" });
+  const watcher = watch(srcWatch, { recursive: true });
+  for await (const event of watcher) {
+    debouncedbuildAndNotify(finalConfig, destinationPath, buildCfg, bunServer, event);
+  }
+}
+var debouncedbuildAndNotify = import_debounce.default(async (finalConfig, destinationPath, buildCfg, bunServer, event) => {
+  if (finalConfig.cleanServePath) {
+    await cleanDirectory(destinationPath);
+  }
+  const output = await Bun.build(buildCfg);
+  publishOutputLogs(bunServer, output, event);
+  publishIndexHTML(destinationPath, finalConfig.serveOutputHtml, output, event);
+  if (finalConfig.writeManifest) {
+    writeManifest(output, destinationPath, finalConfig.manifestWithHash, finalConfig.manifestName);
+  }
+  const tscSuccess = await performTSC(finalConfig);
+  if (finalConfig.reloadOnChange && tscSuccess) {
+    bunServer.publish("message", JSON.stringify({ type: "reload" }));
+  }
+}, watchDelay, { immediate: true });
+function publishOutputLogs(bunServer, output, event) {
+  output.logs.forEach(console.log);
+  bunServer.publish("message", JSON.stringify({ type: "message", message: `[Bun HMR] ${event.filename} ${event.eventType}` }));
+  const outTable = output.outputs.filter((o) => o.kind !== "sourcemap").map((o) => {
+    const a = Bun.pathToFileURL(o.path);
+    const fileName = a.href.substring(a.href.lastIndexOf("/") + 1);
+    return {
+      name: fileName,
+      path: o.path,
+      size: convertBytes(o.size)
+    };
+  });
+  console.table(outTable);
+  bunServer.publish("message", JSON.stringify({ type: "output", message: outTable }));
+}
+function publishIndexHTML(destinationPath, template, output, _event) {
+  const eps = output.outputs.filter((o) => o.kind === "entry-point");
+  const hashedImports = [];
+  for (const ep of eps) {
+    const basePathUrl = Bun.pathToFileURL(destinationPath);
+    const epUrl = Bun.pathToFileURL(ep.path);
+    const hashedImport = `${epUrl.href.replace(basePathUrl.href, "")}?${ep.hash}`;
+    hashedImports.push(hashedImport);
+  }
+  Bun.write(destinationPath + "/index.html", import_ejs.render(template, { hashedImports }));
+}
+function augumentHeaders(request, response) {
+  response.headers.set("Access-Control-Allow-Origin", request.headers.get("origin") ?? "*");
+  response.headers.set("Access-Control-Allow-Methods", "GET, POST, PUT, DELETE, OPTIONS");
+  response.headers.set("Access-Control-Allow-Credentials", "true");
+}
+async function cleanDirectory(dst) {
+  const { stderr, exitCode } = await $2`rm -rf ${dst}/*`.nothrow();
+  if (exitCode !== 0) {
+    if (stderr.indexOf("no matches found") > -1) {
+      console.log("Directory is empty");
+    } else {
+      throw stderr;
+    }
+  }
+}
+function convertBytes(bytes) {
+  const sizes = ["Bytes", "KB", "MB", "GB", "TB"];
+  if (bytes == 0) {
+    return "n/a";
+  }
+  const floored = Math.floor(Math.log(bytes) / Math.log(1024));
+  const i = floored;
+  if (i == 0) {
+    return bytes + " " + sizes[i];
+  }
+  return (bytes / Math.pow(1024, i)).toFixed(1) + " " + sizes[i];
+}
+export {
+  startBunDevServer,
+  getBunHMRFooter,
+  bunHotReloadPlugin
+};