bun-dev-server 1.0.2 → 1.0.4

package/dist/index.js

@@ -4,18 +4,33 @@ var __getProtoOf = Object.getPrototypeOf;
 var __defProp = Object.defineProperty;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
+function __accessProp(key) {
+  return this[key];
+}
+var __toESMCache_node;
+var __toESMCache_esm;
 var __toESM = (mod, isNodeMode, target) => {
+  var canCache = mod != null && typeof mod === "object";
+  if (canCache) {
+    var cache = isNodeMode ? __toESMCache_node ??= new WeakMap : __toESMCache_esm ??= new WeakMap;
+    var cached = cache.get(mod);
+    if (cached)
+      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: () => mod[key],
+        get: __accessProp.bind(mod, key),
         enumerable: true
       });
+  if (canCache)
+    cache.set(mod, to);
   return to;
 };
 var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
+var __require = import.meta.require;
 
 // node_modules/picocolors/picocolors.js
 var require_picocolors = __commonJS((exports, module) => {
@@ -87,523 +102,390 @@ var require_picocolors = __commonJS((exports, module) => {
   module.exports.createColors = createColors;
 });
 
-// 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 });
+// node_modules/ejs/ejs.js
+var require_ejs = __commonJS((exports, module) => {
+  (function(f) {
+    if (typeof exports === "object" && typeof module !== "undefined") {
+      module.exports = f();
+    } else if (typeof define === "function" && define.amd) {
+      define([], f);
     } else {
-      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];
+      var g;
+      if (typeof window !== "undefined") {
+        g = window;
+      } else if (typeof global !== "undefined") {
+        g = global;
+      } else if (typeof self !== "undefined") {
+        g = self;
+      } else {
+        g = this;
       }
+      g.ejs = f();
     }
-    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;
+  })(function() {
+    var define2, module2, exports2;
+    return function() {
+      function r(e, n, t) {
+        function o(i2, f) {
+          if (!n[i2]) {
+            if (!e[i2]) {
+              var c = __require;
+              if (!f && c)
+                return c(i2, true);
+              if (u)
+                return u(i2, true);
+              var a = new Error("Cannot find module '" + i2 + "'");
+              throw a.code = "MODULE_NOT_FOUND", a;
+            }
+            var p = n[i2] = { exports: {} };
+            e[i2][0].call(p.exports, function(r2) {
+              var n2 = e[i2][1][r2];
+              return o(n2 || r2);
+            }, p, p.exports, r, e, n, t);
           }
-          to[p] = from[p];
+          return n[i2].exports;
         }
+        for (var u = __require, i = 0;i < t.length; i++)
+          o(t[i]);
+        return o;
       }
-    }
-    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);
+      return r;
+    }()({ 1: [function(require2, module3, exports3) {
+      var __importDefault = this && this.__importDefault || function(mod) {
+        return mod && mod.__esModule ? mod : { default: mod };
       };
-    }
-    if (!({ __proto__: null } instanceof Object)) {
-      return function() {
-        return { __proto__: null };
+      Object.defineProperty(exports3, "__esModule", { value: true });
+      var fs_1 = __importDefault(require2("fs"));
+      var path_1 = __importDefault(require2("path"));
+      var utils_js_1 = __importDefault(require2("./utils.js"));
+      var DECLARATION_KEYWORD = "var";
+      var ejs = {};
+      var _DEFAULT_OPEN_DELIMITER = "<";
+      var _DEFAULT_CLOSE_DELIMITER = ">";
+      var _DEFAULT_DELIMITER = "%";
+      var _DEFAULT_LOCALS_NAME = "locals";
+      var _REGEX_STRING = "(<%%|%%>|<%=|<%-|<%_|<%#|<%|%>|-%>|_%>)";
+      var _OPTS_PASSABLE_WITH_DATA = [
+        "delimiter",
+        "scope",
+        "context",
+        "debug",
+        "compileDebug",
+        "_with",
+        "rmWhitespace",
+        "strict",
+        "filename",
+        "async"
+      ];
+      var _OPTS_PASSABLE_WITH_DATA_EXPRESS = _OPTS_PASSABLE_WITH_DATA.concat("cache");
+      var _BOM = /^\uFEFF/;
+      var _JS_IDENTIFIER = /^[a-zA-Z_$][0-9a-zA-Z_$]*$/;
+      ejs.cache = utils_js_1.default.cache;
+      ejs.fileLoader = fs_1.default.readFileSync;
+      ejs.localsName = _DEFAULT_LOCALS_NAME;
+      ejs.promiseImpl = new Function("return this;")().Promise;
+      ejs.resolveInclude = function(name, filename, isDir) {
+        var dirname = path_1.default.dirname;
+        var extname = path_1.default.extname;
+        var resolve = path_1.default.resolve;
+        var includePath = resolve(isDir ? filename : dirname(filename), name);
+        var ext = extname(name);
+        if (!ext) {
+          includePath += ".ejs";
+        }
+        return includePath;
       };
-    }
-    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;
+      function resolvePaths(name, paths) {
+        var filePath;
+        if (paths.some(function(v) {
+          filePath = ejs.resolveInclude(name, v, true);
+          return fs_1.default.existsSync(filePath);
+        })) {
+          return filePath;
         }
       }
-      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");
+      function getIncludePath(path, options) {
+        var includePath;
+        var filePath;
+        var views = options.views;
+        var match = /^[A-Za-z]+:\\|^\//.exec(path);
+        if (match && match.length) {
+          path = path.replace(/^\/*/, "");
+          if (Array.isArray(options.root)) {
+            includePath = resolvePaths(path, options.root);
+          } else {
+            includePath = ejs.resolveInclude(path, options.root || "/", true);
+          }
+        } else {
+          if (options.filename) {
+            filePath = ejs.resolveInclude(path, options.filename);
+            if (fs_1.default.existsSync(filePath)) {
+              includePath = filePath;
+            }
+          }
+          if (!includePath && Array.isArray(views)) {
+            includePath = resolvePaths(path, views);
+          }
+          if (!includePath && typeof options.includer !== "function") {
+            throw new Error('Could not find the include file "' + options.escapeFunction(path) + '"');
+          }
+        }
+        return includePath;
       }
-      func = exports.cache.get(filename);
-      if (func) {
+      function handleCache(options, template) {
+        var func;
+        var filename = options.filename;
+        var hasTemplate = arguments.length > 1;
+        if (options.cache) {
+          if (!filename) {
+            throw new Error("cache option requires a filename");
+          }
+          func = ejs.cache.get(filename);
+          if (func) {
+            return func;
+          }
+          if (!hasTemplate) {
+            template = fileLoader(filename).toString().replace(_BOM, "");
+          }
+        } else if (!hasTemplate) {
+          if (!filename) {
+            throw new Error("Internal EJS error: no file name or template " + "provided");
+          }
+          template = fileLoader(filename).toString().replace(_BOM, "");
+        }
+        func = ejs.compile(template, options);
+        if (options.cache) {
+          ejs.cache.set(filename, func);
+        }
         return func;
       }
-      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) {
+      function tryHandleCache(options, data, cb) {
+        var result;
+        if (!cb) {
+          if (typeof ejs.promiseImpl == "function") {
+            return new ejs.promiseImpl(function(resolve, reject) {
+              try {
+                result = handleCache(options)(data);
+                resolve(result);
+              } catch (err) {
+                reject(err);
+              }
+            });
+          } else {
+            throw new Error("Please provide a callback function");
+          }
+        } else {
           try {
             result = handleCache(options)(data);
-            resolve(result);
           } catch (err) {
-            reject(err);
+            return cb(err);
           }
-        });
-      } else {
-        throw new Error("Please provide a callback function");
+          cb(null, result);
+        }
       }
-    } else {
-      try {
-        result = handleCache(options)(data);
-      } catch (err) {
-        return cb(err);
+      function fileLoader(filePath) {
+        return ejs.fileLoader(filePath);
       }
-      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);
+      function includeFile(path, options) {
+        var opts = utils_js_1.default.shallowCopy(utils_js_1.default.createNullProtoObjWherePossible(), options);
+        opts.filename = getIncludePath(path, opts);
+        if (typeof options.includer === "function") {
+          var includerResult = options.includer(path, opts.filename);
+          if (includerResult) {
+            if (includerResult.filename) {
+              opts.filename = includerResult.filename;
+            }
+            if (includerResult.template) {
+              return handleCache(opts, includerResult.template);
+            }
+          }
         }
+        return handleCache(opts);
       }
-    }
-    return handleCache(opts);
-  }
-  function rethrow(err, str, flnm, lineno, esc) {
-    var lines = str.split(`
+      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(`
+        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 + `
+        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;
+        throw err;
       }
-      if (!opts.context) {
-        opts.context = opts.scope;
+      function stripSemi(str) {
+        return str.replace(/;(\s*$)/, "$1");
       }
-      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);
+      ejs.compile = function compile(template, opts) {
+        var templ;
+        if (opts && opts.scope) {
+          console.warn("`scope` option is deprecated and will be removed in future EJS");
+          if (!opts.context) {
+            opts.context = opts.scope;
           }
+          delete opts.scope;
         }
-        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.");
+        templ = new Template(template, opts);
+        return templ.compile();
+      };
+      ejs.render = function(template, d, o) {
+        var data = d || utils_js_1.default.createNullProtoObjWherePossible();
+        var opts = o || utils_js_1.default.createNullProtoObjWherePossible();
+        if (arguments.length == 2) {
+          utils_js_1.default.shallowCopyFromList(opts, data, _OPTS_PASSABLE_WITH_DATA);
+        }
+        return handleCache(opts, template)(data);
+      };
+      ejs.renderFile = function() {
+        var args = Array.prototype.slice.call(arguments);
+        var filename = args.shift();
+        var cb;
+        var opts = { filename };
+        var data;
+        var viewOpts;
+        if (typeof arguments[arguments.length - 1] == "function") {
+          cb = args.pop();
+        }
+        if (args.length) {
+          data = args.shift();
+          if (args.length) {
+            utils_js_1.default.shallowCopy(opts, args.pop());
+          } else {
+            if (data.settings) {
+              if (data.settings.views) {
+                opts.views = data.settings.views;
+              }
+              if (data.settings["view cache"]) {
+                opts.cache = true;
+              }
+              viewOpts = data.settings["view options"];
+              if (viewOpts) {
+                utils_js_1.default.shallowCopy(opts, viewOpts);
+              }
+            }
+            utils_js_1.default.shallowCopyFromList(opts, data, _OPTS_PASSABLE_WITH_DATA_EXPRESS);
           }
-          prepended += "  var " + opts.outputFunctionName + " = __append;" + `
-`;
+          opts.filename = filename;
+        } else {
+          data = utils_js_1.default.createNullProtoObjWherePossible();
         }
-        if (opts.localsName && !_JS_IDENTIFIER.test(opts.localsName)) {
-          throw new Error("localsName is not a valid JS identifier.");
+        return tryHandleCache(opts, data, cb);
+      };
+      ejs.Template = Template;
+      ejs.clearCache = function() {
+        ejs.cache.reset();
+      };
+      function Template(text, optsParam) {
+        var opts = utils_js_1.default.hasOwnOnlyObject(optsParam);
+        var options = utils_js_1.default.createNullProtoObjWherePossible();
+        this.templateText = text;
+        this.mode = null;
+        this.truncate = false;
+        this.currentLine = 1;
+        this.source = "";
+        options.escapeFunction = opts.escape || opts.escapeFunction || utils_js_1.default.escapeXML;
+        options.compileDebug = opts.compileDebug !== false;
+        options.debug = !!opts.debug;
+        options.filename = opts.filename;
+        options.openDelimiter = opts.openDelimiter || ejs.openDelimiter || _DEFAULT_OPEN_DELIMITER;
+        options.closeDelimiter = opts.closeDelimiter || ejs.closeDelimiter || _DEFAULT_CLOSE_DELIMITER;
+        options.delimiter = opts.delimiter || ejs.delimiter || _DEFAULT_DELIMITER;
+        options.strict = opts.strict || false;
+        options.context = opts.context;
+        options.cache = opts.cache || false;
+        options.rmWhitespace = opts.rmWhitespace;
+        options.root = opts.root;
+        options.includer = opts.includer;
+        options.outputFunctionName = opts.outputFunctionName;
+        options.localsName = opts.localsName || ejs.localsName || _DEFAULT_LOCALS_NAME;
+        options.views = opts.views;
+        options.async = opts.async;
+        options.destructuredLocals = opts.destructuredLocals;
+        options.legacyInclude = typeof opts.legacyInclude != "undefined" ? !!opts.legacyInclude : true;
+        if (options.strict) {
+          options._with = false;
+        } else {
+          options._with = typeof opts._with != "undefined" ? opts._with : true;
         }
-        if (opts.destructuredLocals && opts.destructuredLocals.length) {
-          var destructuring = "  var __locals = (" + opts.localsName + ` || {}),
+        this.opts = options;
+        this.regex = this.createRegex();
+      }
+      Template.modes = {
+        EVAL: "eval",
+        ESCAPED: "escaped",
+        RAW: "raw",
+        COMMENT: "comment",
+        LITERAL: "literal"
+      };
+      Template.prototype = {
+        createRegex: function() {
+          var str = _REGEX_STRING;
+          var delim = utils_js_1.default.escapeRegExpChars(this.opts.delimiter);
+          var open = utils_js_1.default.escapeRegExpChars(this.opts.openDelimiter);
+          var close = utils_js_1.default.escapeRegExpChars(this.opts.closeDelimiter);
+          str = str.replace(/%/g, delim).replace(/</g, open).replace(/>/g, close);
+          return new RegExp(str);
+        },
+        compile: function() {
+          var src;
+          var fn;
+          var opts = this.opts;
+          var prepended = "";
+          var appended = "";
+          var escapeFn = opts.escapeFunction;
+          var ctor;
+          var sanitizedFilename = opts.filename ? JSON.stringify(opts.filename) : "undefined";
+          if (!this.source) {
+            this.generateSource();
+            prepended += "  ".concat(DECLARATION_KEYWORD, ` __output = "";
+`) + `  function __append(s) { if (s !== undefined && s !== null) __output += s }
+`;
+            if (opts.outputFunctionName) {
+              if (!_JS_IDENTIFIER.test(opts.outputFunctionName)) {
+                throw new Error("outputFunctionName is not a valid JS identifier.");
+              }
+              prepended += "  ".concat(DECLARATION_KEYWORD, " ") + opts.outputFunctionName + " = __append;" + `
 `;
-          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 += `,
-  `;
+            if (opts.localsName && !_JS_IDENTIFIER.test(opts.localsName)) {
+              throw new Error("localsName is not a valid JS identifier.");
             }
-            destructuring += name + " = __locals." + name;
-          }
-          prepended += destructuring + `;
+            if (opts.destructuredLocals && opts.destructuredLocals.length) {
+              var destructuring = "  ".concat(DECLARATION_KEYWORD, " __locals = (") + opts.localsName + ` || {}),
 `;
-        }
-        if (opts._with !== false) {
-          prepended += "  with (" + opts.localsName + " || {}) {" + `
+              for (var i = 0;i < opts.destructuredLocals.length; i++) {
+                var name_1 = opts.destructuredLocals[i];
+                if (!_JS_IDENTIFIER.test(name_1)) {
+                  throw new Error("destructuredLocals[" + i + "] is not a valid JS identifier.");
+                }
+                if (i > 0) {
+                  destructuring += `,
+  `;
+                }
+                destructuring += name_1 + " = __locals." + name_1;
+              }
+              prepended += destructuring + `;
+`;
+            }
+            if (opts._with !== false) {
+              prepended += "  with (" + opts.localsName + " || {}) {" + `
 `;
-          appended += "  }" + `
+              appended += "  }" + `
 `;
-        }
-        appended += "  return __output;" + `
+            }
+            appended += "  return __output;" + `
 `;
-        this.source = prepended + this.source + appended;
-      }
-      if (opts.compileDebug) {
-        src = "var __line = 1" + `
+            this.source = prepended + this.source + appended;
+          }
+          if (opts.compileDebug) {
+            src = "".concat(DECLARATION_KEYWORD, " __line = 1") + `
 ` + "  , __lines = " + JSON.stringify(this.templateText) + `
 ` + "  , __filename = " + sanitizedFilename + ";" + `
 ` + "try {" + `
@@ -611,247 +493,956 @@ var require_ejs = __commonJS((exports) => {
 ` + "  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";
+          } else {
+            src = this.source;
+          }
+          if (opts.strict) {
+            src = `"use strict";
 ` + src;
-      }
-      if (opts.debug) {
-        console.log(src);
-      }
-      if (opts.compileDebug && opts.filename) {
-        src = 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");
+            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 {
-              throw e;
+              ctor = Function;
             }
-          }
-        } 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
+            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 += `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 += "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.";
+                e.message += "Or, if you meant to create an async function, pass `async: true` as an option.";
+              }
+            }
+            throw e;
           }
-        }
-        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);
+          var returnedFn = function anonymous(data) {
+            var include = function(path, includeData) {
+              var d = utils_js_1.default.shallowCopy(utils_js_1.default.createNullProtoObjWherePossible(), data);
+              if (includeData) {
+                d = utils_js_1.default.shallowCopy(d, includeData);
+              }
+              return includeFile(path, opts)(d);
+            };
+            return fn.apply(opts.context, [data || utils_js_1.default.createNullProtoObjWherePossible(), escapeFn, include, rethrow]);
+          };
+          if (opts.filename && typeof Object.defineProperty === "function") {
+            var filename = opts.filename;
+            var basename = path_1.default.basename(filename, path_1.default.extname(filename));
+            try {
+              Object.defineProperty(returnedFn, "name", {
+                value: basename,
+                writable: false,
+                enumerable: false,
+                configurable: true
+              });
+            } catch (e) {}
           }
-          return 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, `
+          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 + '".');
+          }
+          var self2 = this;
+          var d = this.opts.delimiter;
+          var o = this.opts.openDelimiter;
+          var c = this.opts.closeDelimiter;
+          var openWhitespaceSlurpTag = utils_js_1.default.escapeRegExpChars(o + d + "_");
+          var closeWhitespaceSlurpTag = utils_js_1.default.escapeRegExpChars("_" + d + c);
+          var openWhitespaceSlurpReplacement = o + d + "_";
+          var closeWhitespaceSlurpReplacement = "_" + d + c;
+          this.templateText = this.templateText.replace(new RegExp("[ \\t]*" + openWhitespaceSlurpTag, "gm"), openWhitespaceSlurpReplacement).replace(new RegExp(closeWhitespaceSlurpTag + "[ \\t]*", "gm"), closeWhitespaceSlurpReplacement);
+          var matches = this.parseTemplateText();
+          if (matches && matches.length) {
+            matches.forEach(function(line, index) {
+              var closing;
+              if (line.indexOf(o + d) === 0 && line.indexOf(o + d + d) !== 0) {
+                closing = matches[index + 2];
+                if (!(closing == d + c || closing == "-" + d + c || closing == "_" + d + c)) {
+                  throw new Error('Could not find matching close tag for "' + line + '".');
+                }
+              }
+              self2.scanLine(line);
+            });
+          }
+        },
+        parseTemplateText: function() {
+          var str = this.templateText;
+          var pat = this.regex;
+          var result = pat.exec(str);
+          var arr = [];
+          var firstPos;
+          while (result) {
+            firstPos = result.index;
+            if (firstPos !== 0) {
+              arr.push(str.substring(0, firstPos));
+              str = str.slice(firstPos);
             }
+            arr.push(result[0]);
+            str = str.slice(result[0].length);
+            result = pat.exec(str);
           }
-          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 + '")' + `
+          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(`
+        },
+        scanLine: function(line) {
+          var self2 = this;
+          var d = this.opts.delimiter;
+          var o = this.opts.openDelimiter;
+          var c = this.opts.closeDelimiter;
+          var newLineCount = 0;
+          newLineCount = line.split(`
 `).length - 1;
-      switch (line) {
-        case o + d:
-        case o + d + "_":
-          this.mode = Template.modes.EVAL;
-          break;
-        case o + d + "=":
-          this.mode = Template.modes.ESCAPED;
-          break;
-        case o + d + "-":
-          this.mode = Template.modes.RAW;
-          break;
-        case o + d + "#":
-          this.mode = Template.modes.COMMENT;
-          break;
-        case o + d + d:
-          this.mode = Template.modes.LITERAL;
-          this.source += '    ; __append("' + line.replace(o + d + d, o + d) + '")' + `
+          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 + 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(`
+              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 += `
+                      line += `
 `;
+                    }
                 }
-            }
-            switch (this.mode) {
-              case Template.modes.EVAL:
-                this.source += "    ; " + 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.ESCAPED:
+                    this.source += "    ; __append(escapeFn(" + stripSemi(line) + "))" + `
 `;
-                break;
-              case Template.modes.RAW:
-                this.source += "    ; __append(" + stripSemi(line) + ")" + `
+                    break;
+                  case Template.modes.RAW:
+                    this.source += "    ; __append(" + stripSemi(line) + ")" + `
 `;
-                break;
-              case Template.modes.COMMENT:
-                break;
-              case Template.modes.LITERAL:
+                    break;
+                  case Template.modes.COMMENT:
+                    break;
+                  case Template.modes.LITERAL:
+                    this._addOutput(line);
+                    break;
+                }
+              } else {
                 this._addOutput(line);
+              }
+          }
+          if (self2.opts.compileDebug && newLineCount) {
+            this.currentLine += newLineCount;
+            this.source += "    ; __line = " + this.currentLine + `
+`;
+          }
+        }
+      };
+      ejs.escapeXML = utils_js_1.default.escapeXML;
+      ejs.__express = ejs.renderFile;
+      if (typeof window != "undefined") {
+        window.ejs = ejs;
+      }
+      if (typeof module3 != "undefined") {
+        module3.exports = ejs;
+      }
+      exports3.default = ejs;
+    }, { "./utils.js": 2, fs: 3, path: 4 }], 2: [function(require2, module3, exports3) {
+      Object.defineProperty(exports3, "__esModule", { value: true });
+      var utils = {};
+      var regExpChars = /[|\\{}()[\]^$+*?.]/g;
+      var hasOwnProperty = Object.prototype.hasOwnProperty;
+      var hasOwn = function(obj, key) {
+        return hasOwnProperty.apply(obj, [key]);
+      };
+      utils.escapeRegExpChars = function(string) {
+        if (!string) {
+          return "";
+        }
+        return String(string).replace(regExpChars, "\\$&");
+      };
+      var _ENCODE_HTML_RULES = {
+        "&": "&amp;",
+        "<": "&lt;",
+        ">": "&gt;",
+        '"': "&#34;",
+        "'": "&#39;"
+      };
+      var _MATCH_HTML = /[&<>'"]/g;
+      function encode_char(c) {
+        return _ENCODE_HTML_RULES[c] || c;
+      }
+      var escapeFuncStr = `var _ENCODE_HTML_RULES = {
+` + `      "&": "&amp;"
+` + `    , "<": "&lt;"
+` + `    , ">": "&gt;"
+` + `    , '"': "&#34;"
+` + `    , "'": "&#39;"
+` + `    }
+` + `  , _MATCH_HTML = /[&<>'"]/g;
+` + `function encode_char(c) {
+` + `  return _ENCODE_HTML_RULES[c] || c;
+` + `};
+`;
+      utils.escapeXML = function(markup) {
+        return markup == undefined ? "" : String(markup).replace(_MATCH_HTML, encode_char);
+      };
+      function escapeXMLToString() {
+        return Function.prototype.toString.call(this) + `;
+` + escapeFuncStr;
+      }
+      try {
+        if (typeof Object.defineProperty === "function") {
+          Object.defineProperty(utils.escapeXML, "toString", { value: escapeXMLToString });
+        } else {
+          utils.escapeXML.toString = escapeXMLToString;
+        }
+      } catch (err) {
+        console.warn("Unable to set escapeXML.toString (is the Function prototype frozen?)");
+      }
+      utils.shallowCopy = function(to, from) {
+        from = from || {};
+        if (to !== null && to !== undefined) {
+          for (var p in from) {
+            if (!hasOwn(from, p)) {
+              continue;
+            }
+            if (p === "__proto__" || p === "constructor") {
+              continue;
+            }
+            to[p] = from[p];
+          }
+        }
+        return to;
+      };
+      utils.shallowCopyFromList = function(to, from, list) {
+        list = list || [];
+        from = from || {};
+        if (to !== null && to !== undefined) {
+          for (var i = 0;i < list.length; i++) {
+            var p = list[i];
+            if (typeof from[p] != "undefined") {
+              if (!hasOwn(from, p)) {
+                continue;
+              }
+              if (p === "__proto__" || p === "constructor") {
+                continue;
+              }
+              to[p] = from[p];
+            }
+          }
+        }
+        return to;
+      };
+      utils.cache = {
+        _data: {},
+        set: function(key, val) {
+          this._data[key] = val;
+        },
+        get: function(key) {
+          return this._data[key];
+        },
+        remove: function(key) {
+          delete this._data[key];
+        },
+        reset: function() {
+          this._data = {};
+        }
+      };
+      utils.hyphenToCamel = function(str) {
+        return str.replace(/-[a-z]/g, function(match) {
+          return match[1].toUpperCase();
+        });
+      };
+      utils.createNullProtoObjWherePossible = function() {
+        if (typeof Object.create == "function") {
+          return function() {
+            return Object.create(null);
+          };
+        }
+        if (!({ __proto__: null } instanceof Object)) {
+          return function() {
+            return { __proto__: null };
+          };
+        }
+        return function() {
+          return {};
+        };
+      }();
+      utils.hasOwnOnlyObject = function(obj) {
+        var o = utils.createNullProtoObjWherePossible();
+        for (var p in obj) {
+          if (hasOwn(obj, p)) {
+            o[p] = obj[p];
+          }
+        }
+        return o;
+      };
+      if (typeof exports3 != "undefined") {
+        module3.exports = utils;
+      }
+      exports3.default = utils;
+    }, {}], 3: [function(require2, module3, exports3) {}, {}], 4: [function(require2, module3, exports3) {
+      (function(process2) {
+        (function() {
+          function assertPath(path) {
+            if (typeof path !== "string") {
+              throw new TypeError("Path must be a string. Received " + JSON.stringify(path));
+            }
+          }
+          function normalizeStringPosix(path, allowAboveRoot) {
+            var res = "";
+            var lastSegmentLength = 0;
+            var lastSlash = -1;
+            var dots = 0;
+            var code;
+            for (var i = 0;i <= path.length; ++i) {
+              if (i < path.length)
+                code = path.charCodeAt(i);
+              else if (code === 47)
                 break;
+              else
+                code = 47;
+              if (code === 47) {
+                if (lastSlash === i - 1 || dots === 1) {} else if (lastSlash !== i - 1 && dots === 2) {
+                  if (res.length < 2 || lastSegmentLength !== 2 || res.charCodeAt(res.length - 1) !== 46 || res.charCodeAt(res.length - 2) !== 46) {
+                    if (res.length > 2) {
+                      var lastSlashIndex = res.lastIndexOf("/");
+                      if (lastSlashIndex !== res.length - 1) {
+                        if (lastSlashIndex === -1) {
+                          res = "";
+                          lastSegmentLength = 0;
+                        } else {
+                          res = res.slice(0, lastSlashIndex);
+                          lastSegmentLength = res.length - 1 - res.lastIndexOf("/");
+                        }
+                        lastSlash = i;
+                        dots = 0;
+                        continue;
+                      }
+                    } else if (res.length === 2 || res.length === 1) {
+                      res = "";
+                      lastSegmentLength = 0;
+                      lastSlash = i;
+                      dots = 0;
+                      continue;
+                    }
+                  }
+                  if (allowAboveRoot) {
+                    if (res.length > 0)
+                      res += "/..";
+                    else
+                      res = "..";
+                    lastSegmentLength = 2;
+                  }
+                } else {
+                  if (res.length > 0)
+                    res += "/" + path.slice(lastSlash + 1, i);
+                  else
+                    res = path.slice(lastSlash + 1, i);
+                  lastSegmentLength = i - lastSlash - 1;
+                }
+                lastSlash = i;
+                dots = 0;
+              } else if (code === 46 && dots !== -1) {
+                ++dots;
+              } else {
+                dots = -1;
+              }
+            }
+            return res;
+          }
+          function _format(sep, pathObject) {
+            var dir = pathObject.dir || pathObject.root;
+            var base = pathObject.base || (pathObject.name || "") + (pathObject.ext || "");
+            if (!dir) {
+              return base;
             }
+            if (dir === pathObject.root) {
+              return dir + base;
+            }
+            return dir + sep + base;
+          }
+          var posix = {
+            resolve: function resolve() {
+              var resolvedPath = "";
+              var resolvedAbsolute = false;
+              var cwd;
+              for (var i = arguments.length - 1;i >= -1 && !resolvedAbsolute; i--) {
+                var path;
+                if (i >= 0)
+                  path = arguments[i];
+                else {
+                  if (cwd === undefined)
+                    cwd = process2.cwd();
+                  path = cwd;
+                }
+                assertPath(path);
+                if (path.length === 0) {
+                  continue;
+                }
+                resolvedPath = path + "/" + resolvedPath;
+                resolvedAbsolute = path.charCodeAt(0) === 47;
+              }
+              resolvedPath = normalizeStringPosix(resolvedPath, !resolvedAbsolute);
+              if (resolvedAbsolute) {
+                if (resolvedPath.length > 0)
+                  return "/" + resolvedPath;
+                else
+                  return "/";
+              } else if (resolvedPath.length > 0) {
+                return resolvedPath;
+              } else {
+                return ".";
+              }
+            },
+            normalize: function normalize(path) {
+              assertPath(path);
+              if (path.length === 0)
+                return ".";
+              var isAbsolute = path.charCodeAt(0) === 47;
+              var trailingSeparator = path.charCodeAt(path.length - 1) === 47;
+              path = normalizeStringPosix(path, !isAbsolute);
+              if (path.length === 0 && !isAbsolute)
+                path = ".";
+              if (path.length > 0 && trailingSeparator)
+                path += "/";
+              if (isAbsolute)
+                return "/" + path;
+              return path;
+            },
+            isAbsolute: function isAbsolute(path) {
+              assertPath(path);
+              return path.length > 0 && path.charCodeAt(0) === 47;
+            },
+            join: function join() {
+              if (arguments.length === 0)
+                return ".";
+              var joined;
+              for (var i = 0;i < arguments.length; ++i) {
+                var arg = arguments[i];
+                assertPath(arg);
+                if (arg.length > 0) {
+                  if (joined === undefined)
+                    joined = arg;
+                  else
+                    joined += "/" + arg;
+                }
+              }
+              if (joined === undefined)
+                return ".";
+              return posix.normalize(joined);
+            },
+            relative: function relative(from, to) {
+              assertPath(from);
+              assertPath(to);
+              if (from === to)
+                return "";
+              from = posix.resolve(from);
+              to = posix.resolve(to);
+              if (from === to)
+                return "";
+              var fromStart = 1;
+              for (;fromStart < from.length; ++fromStart) {
+                if (from.charCodeAt(fromStart) !== 47)
+                  break;
+              }
+              var fromEnd = from.length;
+              var fromLen = fromEnd - fromStart;
+              var toStart = 1;
+              for (;toStart < to.length; ++toStart) {
+                if (to.charCodeAt(toStart) !== 47)
+                  break;
+              }
+              var toEnd = to.length;
+              var toLen = toEnd - toStart;
+              var length = fromLen < toLen ? fromLen : toLen;
+              var lastCommonSep = -1;
+              var i = 0;
+              for (;i <= length; ++i) {
+                if (i === length) {
+                  if (toLen > length) {
+                    if (to.charCodeAt(toStart + i) === 47) {
+                      return to.slice(toStart + i + 1);
+                    } else if (i === 0) {
+                      return to.slice(toStart + i);
+                    }
+                  } else if (fromLen > length) {
+                    if (from.charCodeAt(fromStart + i) === 47) {
+                      lastCommonSep = i;
+                    } else if (i === 0) {
+                      lastCommonSep = 0;
+                    }
+                  }
+                  break;
+                }
+                var fromCode = from.charCodeAt(fromStart + i);
+                var toCode = to.charCodeAt(toStart + i);
+                if (fromCode !== toCode)
+                  break;
+                else if (fromCode === 47)
+                  lastCommonSep = i;
+              }
+              var out = "";
+              for (i = fromStart + lastCommonSep + 1;i <= fromEnd; ++i) {
+                if (i === fromEnd || from.charCodeAt(i) === 47) {
+                  if (out.length === 0)
+                    out += "..";
+                  else
+                    out += "/..";
+                }
+              }
+              if (out.length > 0)
+                return out + to.slice(toStart + lastCommonSep);
+              else {
+                toStart += lastCommonSep;
+                if (to.charCodeAt(toStart) === 47)
+                  ++toStart;
+                return to.slice(toStart);
+              }
+            },
+            _makeLong: function _makeLong(path) {
+              return path;
+            },
+            dirname: function dirname(path) {
+              assertPath(path);
+              if (path.length === 0)
+                return ".";
+              var code = path.charCodeAt(0);
+              var hasRoot = code === 47;
+              var end = -1;
+              var matchedSlash = true;
+              for (var i = path.length - 1;i >= 1; --i) {
+                code = path.charCodeAt(i);
+                if (code === 47) {
+                  if (!matchedSlash) {
+                    end = i;
+                    break;
+                  }
+                } else {
+                  matchedSlash = false;
+                }
+              }
+              if (end === -1)
+                return hasRoot ? "/" : ".";
+              if (hasRoot && end === 1)
+                return "//";
+              return path.slice(0, end);
+            },
+            basename: function basename(path, ext) {
+              if (ext !== undefined && typeof ext !== "string")
+                throw new TypeError('"ext" argument must be a string');
+              assertPath(path);
+              var start = 0;
+              var end = -1;
+              var matchedSlash = true;
+              var i;
+              if (ext !== undefined && ext.length > 0 && ext.length <= path.length) {
+                if (ext.length === path.length && ext === path)
+                  return "";
+                var extIdx = ext.length - 1;
+                var firstNonSlashEnd = -1;
+                for (i = path.length - 1;i >= 0; --i) {
+                  var code = path.charCodeAt(i);
+                  if (code === 47) {
+                    if (!matchedSlash) {
+                      start = i + 1;
+                      break;
+                    }
+                  } else {
+                    if (firstNonSlashEnd === -1) {
+                      matchedSlash = false;
+                      firstNonSlashEnd = i + 1;
+                    }
+                    if (extIdx >= 0) {
+                      if (code === ext.charCodeAt(extIdx)) {
+                        if (--extIdx === -1) {
+                          end = i;
+                        }
+                      } else {
+                        extIdx = -1;
+                        end = firstNonSlashEnd;
+                      }
+                    }
+                  }
+                }
+                if (start === end)
+                  end = firstNonSlashEnd;
+                else if (end === -1)
+                  end = path.length;
+                return path.slice(start, end);
+              } else {
+                for (i = path.length - 1;i >= 0; --i) {
+                  if (path.charCodeAt(i) === 47) {
+                    if (!matchedSlash) {
+                      start = i + 1;
+                      break;
+                    }
+                  } else if (end === -1) {
+                    matchedSlash = false;
+                    end = i + 1;
+                  }
+                }
+                if (end === -1)
+                  return "";
+                return path.slice(start, end);
+              }
+            },
+            extname: function extname(path) {
+              assertPath(path);
+              var startDot = -1;
+              var startPart = 0;
+              var end = -1;
+              var matchedSlash = true;
+              var preDotState = 0;
+              for (var i = path.length - 1;i >= 0; --i) {
+                var code = path.charCodeAt(i);
+                if (code === 47) {
+                  if (!matchedSlash) {
+                    startPart = i + 1;
+                    break;
+                  }
+                  continue;
+                }
+                if (end === -1) {
+                  matchedSlash = false;
+                  end = i + 1;
+                }
+                if (code === 46) {
+                  if (startDot === -1)
+                    startDot = i;
+                  else if (preDotState !== 1)
+                    preDotState = 1;
+                } else if (startDot !== -1) {
+                  preDotState = -1;
+                }
+              }
+              if (startDot === -1 || end === -1 || preDotState === 0 || preDotState === 1 && startDot === end - 1 && startDot === startPart + 1) {
+                return "";
+              }
+              return path.slice(startDot, end);
+            },
+            format: function format(pathObject) {
+              if (pathObject === null || typeof pathObject !== "object") {
+                throw new TypeError('The "pathObject" argument must be of type Object. Received type ' + typeof pathObject);
+              }
+              return _format("/", pathObject);
+            },
+            parse: function parse(path) {
+              assertPath(path);
+              var ret = { root: "", dir: "", base: "", ext: "", name: "" };
+              if (path.length === 0)
+                return ret;
+              var code = path.charCodeAt(0);
+              var isAbsolute = code === 47;
+              var start;
+              if (isAbsolute) {
+                ret.root = "/";
+                start = 1;
+              } else {
+                start = 0;
+              }
+              var startDot = -1;
+              var startPart = 0;
+              var end = -1;
+              var matchedSlash = true;
+              var i = path.length - 1;
+              var preDotState = 0;
+              for (;i >= start; --i) {
+                code = path.charCodeAt(i);
+                if (code === 47) {
+                  if (!matchedSlash) {
+                    startPart = i + 1;
+                    break;
+                  }
+                  continue;
+                }
+                if (end === -1) {
+                  matchedSlash = false;
+                  end = i + 1;
+                }
+                if (code === 46) {
+                  if (startDot === -1)
+                    startDot = i;
+                  else if (preDotState !== 1)
+                    preDotState = 1;
+                } else if (startDot !== -1) {
+                  preDotState = -1;
+                }
+              }
+              if (startDot === -1 || end === -1 || preDotState === 0 || preDotState === 1 && startDot === end - 1 && startDot === startPart + 1) {
+                if (end !== -1) {
+                  if (startPart === 0 && isAbsolute)
+                    ret.base = ret.name = path.slice(1, end);
+                  else
+                    ret.base = ret.name = path.slice(startPart, end);
+                }
+              } else {
+                if (startPart === 0 && isAbsolute) {
+                  ret.name = path.slice(1, startDot);
+                  ret.base = path.slice(1, end);
+                } else {
+                  ret.name = path.slice(startPart, startDot);
+                  ret.base = path.slice(startPart, end);
+                }
+                ret.ext = path.slice(startDot, end);
+              }
+              if (startPart > 0)
+                ret.dir = path.slice(0, startPart - 1);
+              else if (isAbsolute)
+                ret.dir = "/";
+              return ret;
+            },
+            sep: "/",
+            delimiter: ":",
+            win32: null,
+            posix: null
+          };
+          posix.posix = posix;
+          module3.exports = posix;
+        }).call(this);
+      }).call(this, require2("_process"));
+    }, { _process: 5 }], 5: [function(require2, module3, exports3) {
+      var process2 = module3.exports = {};
+      var cachedSetTimeout;
+      var cachedClearTimeout;
+      function defaultSetTimout() {
+        throw new Error("setTimeout has not been defined");
+      }
+      function defaultClearTimeout() {
+        throw new Error("clearTimeout has not been defined");
+      }
+      (function() {
+        try {
+          if (typeof setTimeout === "function") {
+            cachedSetTimeout = setTimeout;
           } else {
-            this._addOutput(line);
+            cachedSetTimeout = defaultSetTimout;
+          }
+        } catch (e) {
+          cachedSetTimeout = defaultSetTimout;
+        }
+        try {
+          if (typeof clearTimeout === "function") {
+            cachedClearTimeout = clearTimeout;
+          } else {
+            cachedClearTimeout = defaultClearTimeout;
+          }
+        } catch (e) {
+          cachedClearTimeout = defaultClearTimeout;
+        }
+      })();
+      function runTimeout(fun) {
+        if (cachedSetTimeout === setTimeout) {
+          return setTimeout(fun, 0);
+        }
+        if ((cachedSetTimeout === defaultSetTimout || !cachedSetTimeout) && setTimeout) {
+          cachedSetTimeout = setTimeout;
+          return setTimeout(fun, 0);
+        }
+        try {
+          return cachedSetTimeout(fun, 0);
+        } catch (e) {
+          try {
+            return cachedSetTimeout.call(null, fun, 0);
+          } catch (e2) {
+            return cachedSetTimeout.call(this, fun, 0);
           }
+        }
       }
-      if (self.opts.compileDebug && newLineCount) {
-        this.currentLine += newLineCount;
-        this.source += "    ; __line = " + this.currentLine + `
-`;
+      function runClearTimeout(marker) {
+        if (cachedClearTimeout === clearTimeout) {
+          return clearTimeout(marker);
+        }
+        if ((cachedClearTimeout === defaultClearTimeout || !cachedClearTimeout) && clearTimeout) {
+          cachedClearTimeout = clearTimeout;
+          return clearTimeout(marker);
+        }
+        try {
+          return cachedClearTimeout(marker);
+        } catch (e) {
+          try {
+            return cachedClearTimeout.call(null, marker);
+          } catch (e2) {
+            return cachedClearTimeout.call(this, marker);
+          }
+        }
       }
-    }
-  };
-  exports.escapeXML = utils.escapeXML;
-  exports.__express = exports.renderFile;
-  exports.VERSION = _VERSION_STRING;
-  exports.name = _NAME;
-  if (typeof window != "undefined") {
-    window.ejs = exports;
-  }
+      var queue = [];
+      var draining = false;
+      var currentQueue;
+      var queueIndex = -1;
+      function cleanUpNextTick() {
+        if (!draining || !currentQueue) {
+          return;
+        }
+        draining = false;
+        if (currentQueue.length) {
+          queue = currentQueue.concat(queue);
+        } else {
+          queueIndex = -1;
+        }
+        if (queue.length) {
+          drainQueue();
+        }
+      }
+      function drainQueue() {
+        if (draining) {
+          return;
+        }
+        var timeout = runTimeout(cleanUpNextTick);
+        draining = true;
+        var len = queue.length;
+        while (len) {
+          currentQueue = queue;
+          queue = [];
+          while (++queueIndex < len) {
+            if (currentQueue) {
+              currentQueue[queueIndex].run();
+            }
+          }
+          queueIndex = -1;
+          len = queue.length;
+        }
+        currentQueue = null;
+        draining = false;
+        runClearTimeout(timeout);
+      }
+      process2.nextTick = function(fun) {
+        var args = new Array(arguments.length - 1);
+        if (arguments.length > 1) {
+          for (var i = 1;i < arguments.length; i++) {
+            args[i - 1] = arguments[i];
+          }
+        }
+        queue.push(new Item(fun, args));
+        if (queue.length === 1 && !draining) {
+          runTimeout(drainQueue);
+        }
+      };
+      function Item(fun, array) {
+        this.fun = fun;
+        this.array = array;
+      }
+      Item.prototype.run = function() {
+        this.fun.apply(null, this.array);
+      };
+      process2.title = "browser";
+      process2.browser = true;
+      process2.env = {};
+      process2.argv = [];
+      process2.version = "";
+      process2.versions = {};
+      function noop() {}
+      process2.on = noop;
+      process2.addListener = noop;
+      process2.once = noop;
+      process2.off = noop;
+      process2.removeListener = noop;
+      process2.removeAllListeners = noop;
+      process2.emit = noop;
+      process2.prependListener = noop;
+      process2.prependOnceListener = noop;
+      process2.listeners = function(name) {
+        return [];
+      };
+      process2.binding = function(name) {
+        throw new Error("process.binding is not supported");
+      };
+      process2.cwd = function() {
+        return "/";
+      };
+      process2.chdir = function(dir) {
+        throw new Error("process.chdir is not supported");
+      };
+      process2.umask = function() {
+        return 0;
+      };
+    }, {}] }, {}, [1])(1);
+  });
 });
 
 // node_modules/eventemitter3/index.js
 var require_eventemitter3 = __commonJS((exports, module) => {
   var has = Object.prototype.hasOwnProperty;
   var prefix = "~";
-  function Events() {
-  }
+  function Events() {}
   if (Object.create) {
     Events.prototype = Object.create(null);
     if (!new Events().__proto__)
@@ -1155,7 +1746,7 @@ async function handleDirectoryRequest(fsPath, requestPath, req, finalConfig) {
       };
     });
     const templatePath = requestPath === "/" ? "" : requestPath;
-    const rnd = import_ejs.render(finalConfig.serveOutputEjs, {
+    const rnd = import_ejs.default.render(finalConfig.serveOutputEjs, {
       dirs,
       files,
       requestPath: templatePath
@@ -1346,6 +1937,9 @@ class PQueue extends import__.default {
   #lastExecutionTime = 0;
   #intervalId;
   #timeoutId;
+  #strict;
+  #strictTicks = [];
+  #strictTicksStartIndex = 0;
   #queue;
   #queueClass;
   #pending = 0;
@@ -1363,6 +1957,7 @@ class PQueue extends import__.default {
       concurrency: Number.POSITIVE_INFINITY,
       autoStart: true,
       queueClass: PriorityQueue,
+      strict: false,
       ...options
     };
     if (!(typeof options.intervalCap === "number" && options.intervalCap >= 1)) {
@@ -1371,10 +1966,17 @@ class PQueue extends import__.default {
     if (options.interval === undefined || !(Number.isFinite(options.interval) && options.interval >= 0)) {
       throw new TypeError(`Expected \`interval\` to be a finite number >= 0, got \`${options.interval?.toString() ?? ""}\` (${typeof options.interval})`);
     }
+    if (options.strict && options.interval === 0) {
+      throw new TypeError("The `strict` option requires a non-zero `interval`");
+    }
+    if (options.strict && options.intervalCap === Number.POSITIVE_INFINITY) {
+      throw new TypeError("The `strict` option requires a finite `intervalCap`");
+    }
     this.#carryoverIntervalCount = options.carryoverIntervalCount ?? options.carryoverConcurrencyCount ?? false;
     this.#isIntervalIgnored = options.intervalCap === Number.POSITIVE_INFINITY || options.interval === 0;
     this.#intervalCap = options.intervalCap;
     this.#interval = options.interval;
+    this.#strict = options.strict;
     this.#queue = new options.queueClass;
     this.#queueClass = options.queueClass;
     this.concurrency = options.concurrency;
@@ -1385,8 +1987,48 @@ class PQueue extends import__.default {
     this.#isPaused = options.autoStart === false;
     this.#setupRateLimitTracking();
   }
+  #cleanupStrictTicks(now) {
+    while (this.#strictTicksStartIndex < this.#strictTicks.length) {
+      const oldestTick = this.#strictTicks[this.#strictTicksStartIndex];
+      if (oldestTick !== undefined && now - oldestTick >= this.#interval) {
+        this.#strictTicksStartIndex++;
+      } else {
+        break;
+      }
+    }
+    const shouldCompact = this.#strictTicksStartIndex > 100 && this.#strictTicksStartIndex > this.#strictTicks.length / 2 || this.#strictTicksStartIndex === this.#strictTicks.length;
+    if (shouldCompact) {
+      this.#strictTicks = this.#strictTicks.slice(this.#strictTicksStartIndex);
+      this.#strictTicksStartIndex = 0;
+    }
+  }
+  #consumeIntervalSlot(now) {
+    if (this.#strict) {
+      this.#strictTicks.push(now);
+    } else {
+      this.#intervalCount++;
+    }
+  }
+  #rollbackIntervalSlot() {
+    if (this.#strict) {
+      if (this.#strictTicks.length > this.#strictTicksStartIndex) {
+        this.#strictTicks.pop();
+      }
+    } else if (this.#intervalCount > 0) {
+      this.#intervalCount--;
+    }
+  }
+  #getActiveTicksCount() {
+    return this.#strictTicks.length - this.#strictTicksStartIndex;
+  }
   get #doesIntervalAllowAnother() {
-    return this.#isIntervalIgnored || this.#intervalCount < this.#intervalCap;
+    if (this.#isIntervalIgnored) {
+      return true;
+    }
+    if (this.#strict) {
+      return this.#getActiveTicksCount() < this.#intervalCap;
+    }
+    return this.#intervalCount < this.#intervalCap;
   }
   get #doesConcurrentAllowAnother() {
     return this.#pending < this.#concurrency;
@@ -1400,12 +2042,22 @@ class PQueue extends import__.default {
     this.emit("next");
   }
   #onResumeInterval() {
+    this.#timeoutId = undefined;
     this.#onInterval();
     this.#initializeIntervalIfNeeded();
-    this.#timeoutId = undefined;
   }
-  get #isIntervalPaused() {
-    const now = Date.now();
+  #isIntervalPausedAt(now) {
+    if (this.#strict) {
+      this.#cleanupStrictTicks(now);
+      const activeTicksCount = this.#getActiveTicksCount();
+      if (activeTicksCount >= this.#intervalCap) {
+        const oldestTick = this.#strictTicks[this.#strictTicksStartIndex];
+        const delay = this.#interval - (now - oldestTick);
+        this.#createIntervalTimeout(delay);
+        return true;
+      }
+      return false;
+    }
     if (this.#intervalId === undefined) {
       const delay = this.#intervalEnd - now;
       if (delay < 0) {
@@ -1450,21 +2102,25 @@ class PQueue extends import__.default {
       this.emit("empty");
       if (this.#pending === 0) {
         this.#clearTimeoutTimer();
+        if (this.#strict && this.#strictTicksStartIndex > 0) {
+          const now = Date.now();
+          this.#cleanupStrictTicks(now);
+        }
         this.emit("idle");
       }
       return false;
     }
     let taskStarted = false;
     if (!this.#isPaused) {
-      const canInitializeInterval = !this.#isIntervalPaused;
+      const now = Date.now();
+      const canInitializeInterval = !this.#isIntervalPausedAt(now);
       if (this.#doesIntervalAllowAnother && this.#doesConcurrentAllowAnother) {
         const job = this.#queue.dequeue();
         if (!this.#isIntervalIgnored) {
-          this.#intervalCount++;
+          this.#consumeIntervalSlot(now);
           this.#scheduleRateLimitUpdate();
         }
         this.emit("active");
-        this.#lastExecutionTime = Date.now();
         job();
         if (canInitializeInterval) {
           this.#initializeIntervalIfNeeded();
@@ -1478,22 +2134,26 @@ class PQueue extends import__.default {
     if (this.#isIntervalIgnored || this.#intervalId !== undefined) {
       return;
     }
+    if (this.#strict) {
+      return;
+    }
     this.#intervalId = setInterval(() => {
       this.#onInterval();
     }, this.#interval);
     this.#intervalEnd = Date.now() + this.#interval;
   }
   #onInterval() {
-    if (this.#intervalCount === 0 && this.#pending === 0 && this.#intervalId) {
-      this.#clearIntervalTimer();
+    if (!this.#strict) {
+      if (this.#intervalCount === 0 && this.#pending === 0 && this.#intervalId) {
+        this.#clearIntervalTimer();
+      }
+      this.#intervalCount = this.#carryoverIntervalCount ? this.#pending : 0;
     }
-    this.#intervalCount = this.#carryoverIntervalCount ? this.#pending : 0;
     this.#processQueue();
     this.#scheduleRateLimitUpdate();
   }
   #processQueue() {
-    while (this.#tryToStartAnother()) {
-    }
+    while (this.#tryToStartAnother()) {}
   }
   get concurrency() {
     return this.#concurrency;
@@ -1512,10 +2172,10 @@ class PQueue extends import__.default {
     this.#queue.setPriority(id, priority);
   }
   async add(function_, options = {}) {
-    options.id ??= (this.#idAssigner++).toString();
     options = {
       timeout: this.timeout,
-      ...options
+      ...options,
+      id: options.id ?? (this.#idAssigner++).toString()
     };
     return new Promise((resolve2, reject) => {
       const taskSymbol = Symbol(`task-${options.id}`);
@@ -1532,12 +2192,11 @@ class PQueue extends import__.default {
           try {
             options.signal?.throwIfAborted();
           } catch (error) {
-            if (!this.#isIntervalIgnored) {
-              this.#intervalCount--;
-            }
+            this.#rollbackIntervalConsumption();
             this.#runningTasks.delete(taskSymbol);
             throw error;
           }
+          this.#lastExecutionTime = Date.now();
           let operation = function_({ signal: options.signal });
           if (options.timeout) {
             operation = pTimeout(Promise.resolve(operation), {
@@ -1590,7 +2249,14 @@ class PQueue extends import__.default {
   }
   clear() {
     this.#queue = new this.#queueClass;
+    this.#clearIntervalTimer();
     this.#updateRateLimitState();
+    this.emit("empty");
+    if (this.#pending === 0) {
+      this.#clearTimeoutTimer();
+      this.emit("idle");
+    }
+    this.emit("next");
   }
   async onEmpty() {
     if (this.#queue.size === 0) {
@@ -1628,7 +2294,7 @@ class PQueue extends import__.default {
     }
     await this.#onEvent("rateLimitCleared");
   }
-  async onError() {
+  onError() {
     return new Promise((_resolve, reject) => {
       const handleError = (error) => {
         this.off("error", handleError);
@@ -1684,9 +2350,31 @@ class PQueue extends import__.default {
       this.#updateRateLimitState();
     });
   }
+  #rollbackIntervalConsumption() {
+    if (this.#isIntervalIgnored) {
+      return;
+    }
+    this.#rollbackIntervalSlot();
+    this.#scheduleRateLimitUpdate();
+  }
   #updateRateLimitState() {
     const previous = this.#rateLimitedInInterval;
-    const shouldBeRateLimited = !this.#isIntervalIgnored && this.#intervalCount >= this.#intervalCap && this.#queue.size > 0;
+    if (this.#isIntervalIgnored || this.#queue.size === 0) {
+      if (previous) {
+        this.#rateLimitedInInterval = false;
+        this.emit("rateLimitCleared");
+      }
+      return;
+    }
+    let count;
+    if (this.#strict) {
+      const now = Date.now();
+      this.#cleanupStrictTicks(now);
+      count = this.#getActiveTicksCount();
+    } else {
+      count = this.#intervalCount;
+    }
+    const shouldBeRateLimited = count >= this.#intervalCap;
     if (shouldBeRateLimited !== previous) {
       this.#rateLimitedInInterval = shouldBeRateLimited;
       this.emit(shouldBeRateLimited ? "rateLimit" : "rateLimitCleared");
@@ -1839,7 +2527,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.render(template, { hashedImports, cssFiles }));
+  Bun.write(paths.buildDestination + "/index.html", import_ejs2.default.render(template, { hashedImports, cssFiles }));
 }
 function printPrettyBuildOutput(outTable) {
   if (outTable.length === 0)
@@ -1920,8 +2608,7 @@ function hotReload() {
     let parsed = msg.data;
     try {
       parsed = JSON.parse(msg.data);
-    } catch (e) {
-    }
+    } catch (e) {}
     if (parsed?.type === "message") {
       console.log(devServer, parsed.message);
       return;
@@ -2146,8 +2833,7 @@ async function startBunDevServer(serverConfig, importMeta) {
         open(ws) {
           ws.subscribe("message");
         },
-        message(ws, message) {
-        },
+        message(ws, message) {},
         sendPings: true
       }
     });
@@ -2166,3 +2852,6 @@ export {
   getBunHMRFooter,
   bunHotReloadPlugin
 };
+
+//# debugId=CBC8475BE6C83F4364756E2164756E21
+//# sourceMappingURL=index.js.map