bunki 0.16.0 → 0.16.1

package/dist/index.js

@@ -15404,11 +15404,11 @@ var require_lib7 = __commonJS((exports, module) => {
   function lookupEscape(ch) {
     return escapeMap[ch];
   }
-  function _prettifyError(path4, withInternals, err) {
+  function _prettifyError(path5, withInternals, err) {
     if (!err.Update) {
       err = new _exports.TemplateError(err);
     }
-    err.Update(path4);
+    err.Update(path5);
     if (!withInternals) {
       var old = err;
       err = new Error(old.message);
@@ -15469,8 +15469,8 @@ var require_lib7 = __commonJS((exports, module) => {
     err.lineno = lineno;
     err.colno = colno;
     err.firstUpdate = true;
-    err.Update = function Update(path4) {
-      var msg = "(" + (path4 || "unknown path") + ")";
+    err.Update = function Update(path5) {
+      var msg = "(" + (path5 || "unknown path") + ")";
       if (this.firstUpdate) {
         if (this.lineno && this.colno) {
           msg += " [Line " + this.lineno + ", Column " + this.colno + "]";
@@ -19667,7 +19667,7 @@ var require_loader2 = __commonJS((exports, module) => {
     };
     return _setPrototypeOf(o, p);
   }
-  var path4 = __require("path");
+  var path5 = __require("path");
   var _require = require_object();
   var EmitterObj = _require.EmitterObj;
   module.exports = /* @__PURE__ */ function(_EmitterObj) {
@@ -19677,7 +19677,7 @@ var require_loader2 = __commonJS((exports, module) => {
     }
     var _proto = Loader.prototype;
     _proto.resolve = function resolve(from, to) {
-      return path4.resolve(path4.dirname(from), to);
+      return path5.resolve(path5.dirname(from), to);
     };
     _proto.isRelative = function isRelative(filename) {
       return filename.indexOf("./") === 0 || filename.indexOf("../") === 0;
@@ -19731,7 +19731,7 @@ var require_precompiled_loader = __commonJS((exports, module) => {
 
 // node_modules/picomatch/lib/constants.js
 var require_constants = __commonJS((exports, module) => {
-  var path4 = __require("path");
+  var path5 = __require("path");
   var WIN_SLASH = "\\\\/";
   var WIN_NO_SLASH = `[^${WIN_SLASH}]`;
   var DOT_LITERAL = "\\.";
@@ -19853,7 +19853,7 @@ var require_constants = __commonJS((exports, module) => {
     CHAR_UNDERSCORE: 95,
     CHAR_VERTICAL_LINE: 124,
     CHAR_ZERO_WIDTH_NOBREAK_SPACE: 65279,
-    SEP: path4.sep,
+    SEP: path5.sep,
     extglobChars(chars) {
       return {
         "!": { type: "negate", open: "(?:(?!(?:", close: `))${chars.STAR})` },
@@ -19871,7 +19871,7 @@ var require_constants = __commonJS((exports, module) => {
 
 // node_modules/picomatch/lib/utils.js
 var require_utils2 = __commonJS((exports) => {
-  var path4 = __require("path");
+  var path5 = __require("path");
   var win32 = process.platform === "win32";
   var {
     REGEX_BACKSLASH,
@@ -19900,7 +19900,7 @@ var require_utils2 = __commonJS((exports) => {
     if (options2 && typeof options2.windows === "boolean") {
       return options2.windows;
     }
-    return win32 === true || path4.sep === "\\";
+    return win32 === true || path5.sep === "\\";
   };
   exports.escapeLast = (input, char, lastIdx) => {
     const idx = input.lastIndexOf(char, lastIdx);
@@ -21024,7 +21024,7 @@ var require_parse3 = __commonJS((exports, module) => {
 
 // node_modules/picomatch/lib/picomatch.js
 var require_picomatch = __commonJS((exports, module) => {
-  var path4 = __require("path");
+  var path5 = __require("path");
   var scan = require_scan();
   var parse2 = require_parse3();
   var utils = require_utils2();
@@ -21110,7 +21110,7 @@ var require_picomatch = __commonJS((exports, module) => {
   };
   picomatch.matchBase = (input, glob, options2, posix = utils.isWindows(options2)) => {
     const regex = glob instanceof RegExp ? glob : picomatch.makeRe(glob, options2);
-    return regex.test(path4.basename(input));
+    return regex.test(path5.basename(input));
   };
   picomatch.isMatch = (str2, patterns, options2) => picomatch(patterns, options2)(str2);
   picomatch.parse = (pattern, options2) => {
@@ -21219,8 +21219,8 @@ var require_readdirp = __commonJS((exports, module) => {
     static get defaultOptions() {
       return {
         root: ".",
-        fileFilter: (path4) => true,
-        directoryFilter: (path4) => true,
+        fileFilter: (path5) => true,
+        directoryFilter: (path5) => true,
         type: FILE_TYPE,
         lstat: false,
         depth: 2147483648,
@@ -21239,7 +21239,7 @@ var require_readdirp = __commonJS((exports, module) => {
       this._directoryFilter = normalizeFilter(opts.directoryFilter);
       const statMethod = opts.lstat ? lstat : stat;
       if (wantBigintFsStats) {
-        this._stat = (path4) => statMethod(path4, { bigint: true });
+        this._stat = (path5) => statMethod(path5, { bigint: true });
       } else {
         this._stat = statMethod;
       }
@@ -21261,9 +21261,9 @@ var require_readdirp = __commonJS((exports, module) => {
       this.reading = true;
       try {
         while (!this.destroyed && batch > 0) {
-          const { path: path4, depth, files = [] } = this.parent || {};
+          const { path: path5, depth, files = [] } = this.parent || {};
           if (files.length > 0) {
-            const slice = files.splice(0, batch).map((dirent) => this._formatEntry(dirent, path4));
+            const slice = files.splice(0, batch).map((dirent) => this._formatEntry(dirent, path5));
             for (const entry of await Promise.all(slice)) {
               if (this.destroyed)
                 return;
@@ -21300,20 +21300,20 @@ var require_readdirp = __commonJS((exports, module) => {
         this.reading = false;
       }
     }
-    async _exploreDir(path4, depth) {
+    async _exploreDir(path5, depth) {
       let files;
       try {
-        files = await readdir(path4, this._rdOptions);
+        files = await readdir(path5, this._rdOptions);
       } catch (error) {
         this._onError(error);
       }
-      return { files, depth, path: path4 };
+      return { files, depth, path: path5 };
     }
-    async _formatEntry(dirent, path4) {
+    async _formatEntry(dirent, path5) {
       let entry;
       try {
         const basename = this._isDirent ? dirent.name : dirent;
-        const fullPath = sysPath.resolve(sysPath.join(path4, basename));
+        const fullPath = sysPath.resolve(sysPath.join(path5, basename));
         entry = { path: sysPath.relative(this._root, fullPath), fullPath, basename };
         entry[this._statsProp] = this._isDirent ? dirent : await this._stat(fullPath);
       } catch (err) {
@@ -21402,24 +21402,24 @@ var require_normalize_path = __commonJS((exports, module) => {
    * Copyright (c) 2014-2018, Jon Schlinkert.
    * Released under the MIT License.
    */
-  module.exports = function(path4, stripTrailing) {
-    if (typeof path4 !== "string") {
+  module.exports = function(path5, stripTrailing) {
+    if (typeof path5 !== "string") {
       throw new TypeError("expected path to be a string");
     }
-    if (path4 === "\\" || path4 === "/")
+    if (path5 === "\\" || path5 === "/")
       return "/";
-    var len = path4.length;
+    var len = path5.length;
     if (len <= 1)
-      return path4;
+      return path5;
     var prefix = "";
-    if (len > 4 && path4[3] === "\\") {
-      var ch = path4[2];
-      if ((ch === "?" || ch === ".") && path4.slice(0, 2) === "\\\\") {
-        path4 = path4.slice(2);
+    if (len > 4 && path5[3] === "\\") {
+      var ch = path5[2];
+      if ((ch === "?" || ch === ".") && path5.slice(0, 2) === "\\\\") {
+        path5 = path5.slice(2);
         prefix = "//";
       }
     }
-    var segs = path4.split(/[/\\]+/);
+    var segs = path5.split(/[/\\]+/);
     if (stripTrailing !== false && segs[segs.length - 1] === "") {
       segs.pop();
     }
@@ -21454,17 +21454,17 @@ var require_anymatch = __commonJS((exports, module) => {
     if (!isList && typeof _path !== "string") {
       throw new TypeError("anymatch: second argument must be a string: got " + Object.prototype.toString.call(_path));
     }
-    const path4 = normalizePath(_path, false);
+    const path5 = normalizePath(_path, false);
     for (let index = 0;index < negPatterns.length; index++) {
       const nglob = negPatterns[index];
-      if (nglob(path4)) {
+      if (nglob(path5)) {
         return returnIndex ? -1 : false;
       }
     }
-    const applied = isList && [path4].concat(args.slice(1));
+    const applied = isList && [path5].concat(args.slice(1));
     for (let index = 0;index < patterns.length; index++) {
       const pattern = patterns[index];
-      if (isList ? pattern(...applied) : pattern(path4)) {
+      if (isList ? pattern(...applied) : pattern(path5)) {
         return returnIndex ? index : true;
       }
     }
@@ -22983,10 +22983,10 @@ var require_binary_extensions = __commonJS((exports, module) => {
 
 // node_modules/is-binary-path/index.js
 var require_is_binary_path = __commonJS((exports, module) => {
-  var path4 = __require("path");
+  var path5 = __require("path");
   var binaryExtensions = require_binary_extensions();
   var extensions = new Set(binaryExtensions);
-  module.exports = (filePath) => extensions.has(path4.extname(filePath).slice(1).toLowerCase());
+  module.exports = (filePath) => extensions.has(path5.extname(filePath).slice(1).toLowerCase());
 });
 
 // node_modules/chokidar/lib/constants.js
@@ -23112,16 +23112,16 @@ var require_nodefs_handler = __commonJS((exports, module) => {
   };
   var isEmptySet = (val) => val instanceof Set ? val.size === 0 : !val;
   var FsWatchInstances = new Map;
-  function createFsWatchInstance(path4, options2, listener, errHandler, emitRaw) {
+  function createFsWatchInstance(path5, options2, listener, errHandler, emitRaw) {
     const handleEvent = (rawEvent, evPath) => {
-      listener(path4);
-      emitRaw(rawEvent, evPath, { watchedPath: path4 });
-      if (evPath && path4 !== evPath) {
-        fsWatchBroadcast(sysPath.resolve(path4, evPath), KEY_LISTENERS, sysPath.join(path4, evPath));
+      listener(path5);
+      emitRaw(rawEvent, evPath, { watchedPath: path5 });
+      if (evPath && path5 !== evPath) {
+        fsWatchBroadcast(sysPath.resolve(path5, evPath), KEY_LISTENERS, sysPath.join(path5, evPath));
       }
     };
     try {
-      return fs2.watch(path4, options2, handleEvent);
+      return fs2.watch(path5, options2, handleEvent);
     } catch (error) {
       errHandler(error);
     }
@@ -23134,12 +23134,12 @@ var require_nodefs_handler = __commonJS((exports, module) => {
       listener(val1, val2, val3);
     });
   };
-  var setFsWatchListener = (path4, fullPath, options2, handlers) => {
+  var setFsWatchListener = (path5, fullPath, options2, handlers) => {
     const { listener, errHandler, rawEmitter } = handlers;
     let cont = FsWatchInstances.get(fullPath);
     let watcher;
     if (!options2.persistent) {
-      watcher = createFsWatchInstance(path4, options2, listener, errHandler, rawEmitter);
+      watcher = createFsWatchInstance(path5, options2, listener, errHandler, rawEmitter);
       return watcher.close.bind(watcher);
     }
     if (cont) {
@@ -23147,7 +23147,7 @@ var require_nodefs_handler = __commonJS((exports, module) => {
       addAndConvert(cont, KEY_ERR, errHandler);
       addAndConvert(cont, KEY_RAW, rawEmitter);
     } else {
-      watcher = createFsWatchInstance(path4, options2, fsWatchBroadcast.bind(null, fullPath, KEY_LISTENERS), errHandler, fsWatchBroadcast.bind(null, fullPath, KEY_RAW));
+      watcher = createFsWatchInstance(path5, options2, fsWatchBroadcast.bind(null, fullPath, KEY_LISTENERS), errHandler, fsWatchBroadcast.bind(null, fullPath, KEY_RAW));
       if (!watcher)
         return;
       watcher.on(EV_ERROR, async (error) => {
@@ -23155,7 +23155,7 @@ var require_nodefs_handler = __commonJS((exports, module) => {
         cont.watcherUnusable = true;
         if (isWindows && error.code === "EPERM") {
           try {
-            const fd = await open(path4, "r");
+            const fd = await open(path5, "r");
             await close(fd);
             broadcastErr(error);
           } catch (err) {}
@@ -23185,7 +23185,7 @@ var require_nodefs_handler = __commonJS((exports, module) => {
     };
   };
   var FsWatchFileInstances = new Map;
-  var setFsWatchFileListener = (path4, fullPath, options2, handlers) => {
+  var setFsWatchFileListener = (path5, fullPath, options2, handlers) => {
     const { listener, rawEmitter } = handlers;
     let cont = FsWatchFileInstances.get(fullPath);
     let listeners = new Set;
@@ -23211,7 +23211,7 @@ var require_nodefs_handler = __commonJS((exports, module) => {
           });
           const currmtime = curr.mtimeMs;
           if (curr.size !== prev.size || currmtime > prev.mtimeMs || currmtime === 0) {
-            foreach(cont.listeners, (listener2) => listener2(path4, curr));
+            foreach(cont.listeners, (listener2) => listener2(path5, curr));
           }
         })
       };
@@ -23234,25 +23234,25 @@ var require_nodefs_handler = __commonJS((exports, module) => {
       this.fsw = fsW;
       this._boundHandleError = (error) => fsW._handleError(error);
     }
-    _watchWithNodeFs(path4, listener) {
+    _watchWithNodeFs(path5, listener) {
       const opts = this.fsw.options;
-      const directory = sysPath.dirname(path4);
-      const basename = sysPath.basename(path4);
+      const directory = sysPath.dirname(path5);
+      const basename = sysPath.basename(path5);
       const parent = this.fsw._getWatchedDir(directory);
       parent.add(basename);
-      const absolutePath = sysPath.resolve(path4);
+      const absolutePath = sysPath.resolve(path5);
       const options2 = { persistent: opts.persistent };
       if (!listener)
         listener = EMPTY_FN;
       let closer;
       if (opts.usePolling) {
         options2.interval = opts.enableBinaryInterval && isBinaryPath(basename) ? opts.binaryInterval : opts.interval;
-        closer = setFsWatchFileListener(path4, absolutePath, options2, {
+        closer = setFsWatchFileListener(path5, absolutePath, options2, {
           listener,
           rawEmitter: this.fsw._emitRaw
         });
       } else {
-        closer = setFsWatchListener(path4, absolutePath, options2, {
+        closer = setFsWatchListener(path5, absolutePath, options2, {
           listener,
           errHandler: this._boundHandleError,
           rawEmitter: this.fsw._emitRaw
@@ -23270,7 +23270,7 @@ var require_nodefs_handler = __commonJS((exports, module) => {
       let prevStats = stats;
       if (parent.has(basename))
         return;
-      const listener = async (path4, newStats) => {
+      const listener = async (path5, newStats) => {
         if (!this.fsw._throttle(THROTTLE_MODE_WATCH, file, 5))
           return;
         if (!newStats || newStats.mtimeMs === 0) {
@@ -23284,9 +23284,9 @@ var require_nodefs_handler = __commonJS((exports, module) => {
               this.fsw._emit(EV_CHANGE, file, newStats2);
             }
             if (isLinux && prevStats.ino !== newStats2.ino) {
-              this.fsw._closeFile(path4);
+              this.fsw._closeFile(path5);
               prevStats = newStats2;
-              this.fsw._addPathCloser(path4, this._watchWithNodeFs(file, listener));
+              this.fsw._addPathCloser(path5, this._watchWithNodeFs(file, listener));
             } else {
               prevStats = newStats2;
             }
@@ -23310,7 +23310,7 @@ var require_nodefs_handler = __commonJS((exports, module) => {
       }
       return closer;
     }
-    async _handleSymlink(entry, directory, path4, item) {
+    async _handleSymlink(entry, directory, path5, item) {
       if (this.fsw.closed) {
         return;
       }
@@ -23320,7 +23320,7 @@ var require_nodefs_handler = __commonJS((exports, module) => {
         this.fsw._incrReadyCount();
         let linkPath;
         try {
-          linkPath = await fsrealpath(path4);
+          linkPath = await fsrealpath(path5);
         } catch (e) {
           this.fsw._emitReady();
           return true;
@@ -23330,12 +23330,12 @@ var require_nodefs_handler = __commonJS((exports, module) => {
         if (dir.has(item)) {
           if (this.fsw._symlinkPaths.get(full) !== linkPath) {
             this.fsw._symlinkPaths.set(full, linkPath);
-            this.fsw._emit(EV_CHANGE, path4, entry.stats);
+            this.fsw._emit(EV_CHANGE, path5, entry.stats);
           }
         } else {
           dir.add(item);
           this.fsw._symlinkPaths.set(full, linkPath);
-          this.fsw._emit(EV_ADD, path4, entry.stats);
+          this.fsw._emit(EV_ADD, path5, entry.stats);
         }
         this.fsw._emitReady();
         return true;
@@ -23364,9 +23364,9 @@ var require_nodefs_handler = __commonJS((exports, module) => {
           return;
         }
         const item = entry.path;
-        let path4 = sysPath.join(directory, item);
+        let path5 = sysPath.join(directory, item);
         current.add(item);
-        if (entry.stats.isSymbolicLink() && await this._handleSymlink(entry, directory, path4, item)) {
+        if (entry.stats.isSymbolicLink() && await this._handleSymlink(entry, directory, path5, item)) {
           return;
         }
         if (this.fsw.closed) {
@@ -23375,8 +23375,8 @@ var require_nodefs_handler = __commonJS((exports, module) => {
         }
         if (item === target || !target && !previous.has(item)) {
           this.fsw._incrReadyCount();
-          path4 = sysPath.join(dir, sysPath.relative(dir, path4));
-          this._addToNodeFs(path4, initialAdd, wh, depth + 1);
+          path5 = sysPath.join(dir, sysPath.relative(dir, path5));
+          this._addToNodeFs(path5, initialAdd, wh, depth + 1);
         }
       }).on(EV_ERROR, this._boundHandleError);
       return new Promise((resolve) => stream.once(STR_END, () => {
@@ -23424,13 +23424,13 @@ var require_nodefs_handler = __commonJS((exports, module) => {
       }
       return closer;
     }
-    async _addToNodeFs(path4, initialAdd, priorWh, depth, target) {
+    async _addToNodeFs(path5, initialAdd, priorWh, depth, target) {
       const ready = this.fsw._emitReady;
-      if (this.fsw._isIgnored(path4) || this.fsw.closed) {
+      if (this.fsw._isIgnored(path5) || this.fsw.closed) {
         ready();
         return false;
       }
-      const wh = this.fsw._getWatchHelpers(path4, depth);
+      const wh = this.fsw._getWatchHelpers(path5, depth);
       if (!wh.hasGlob && priorWh) {
         wh.hasGlob = priorWh.hasGlob;
         wh.globFilter = priorWh.globFilter;
@@ -23445,11 +23445,11 @@ var require_nodefs_handler = __commonJS((exports, module) => {
           ready();
           return false;
         }
-        const follow = this.fsw.options.followSymlinks && !path4.includes(STAR) && !path4.includes(BRACE_START);
+        const follow = this.fsw.options.followSymlinks && !path5.includes(STAR) && !path5.includes(BRACE_START);
         let closer;
         if (stats.isDirectory()) {
-          const absPath = sysPath.resolve(path4);
-          const targetPath = follow ? await fsrealpath(path4) : path4;
+          const absPath = sysPath.resolve(path5);
+          const targetPath = follow ? await fsrealpath(path5) : path5;
           if (this.fsw.closed)
             return;
           closer = await this._handleDir(wh.watchPath, stats, initialAdd, depth, target, wh, targetPath);
@@ -23459,28 +23459,28 @@ var require_nodefs_handler = __commonJS((exports, module) => {
             this.fsw._symlinkPaths.set(absPath, targetPath);
           }
         } else if (stats.isSymbolicLink()) {
-          const targetPath = follow ? await fsrealpath(path4) : path4;
+          const targetPath = follow ? await fsrealpath(path5) : path5;
           if (this.fsw.closed)
             return;
           const parent = sysPath.dirname(wh.watchPath);
           this.fsw._getWatchedDir(parent).add(wh.watchPath);
           this.fsw._emit(EV_ADD, wh.watchPath, stats);
-          closer = await this._handleDir(parent, stats, initialAdd, depth, path4, wh, targetPath);
+          closer = await this._handleDir(parent, stats, initialAdd, depth, path5, wh, targetPath);
           if (this.fsw.closed)
             return;
           if (targetPath !== undefined) {
-            this.fsw._symlinkPaths.set(sysPath.resolve(path4), targetPath);
+            this.fsw._symlinkPaths.set(sysPath.resolve(path5), targetPath);
           }
         } else {
           closer = this._handleFile(wh.watchPath, stats, initialAdd);
         }
         ready();
-        this.fsw._addPathCloser(path4, closer);
+        this.fsw._addPathCloser(path5, closer);
         return false;
       } catch (error) {
         if (this.fsw._handleError(error)) {
           ready();
-          return path4;
+          return path5;
         }
       }
     }
@@ -23500,9 +23500,9 @@ var require_fsevents2 = __commonJS((exports) => {
   }
   var Native = require_fsevents();
   var events = Native.constants;
-  function watch(path4, since, handler) {
-    if (typeof path4 !== "string") {
-      throw new TypeError(`fsevents argument 1 must be a string and not a ${typeof path4}`);
+  function watch(path5, since, handler) {
+    if (typeof path5 !== "string") {
+      throw new TypeError(`fsevents argument 1 must be a string and not a ${typeof path5}`);
     }
     if (typeof since === "function" && typeof handler === "undefined") {
       handler = since;
@@ -23514,18 +23514,18 @@ var require_fsevents2 = __commonJS((exports) => {
     if (typeof handler !== "function") {
       throw new TypeError(`fsevents argument 3 must be a function and not a ${typeof handler}`);
     }
-    let instance = Native.start(Native.global, path4, since, handler);
+    let instance = Native.start(Native.global, path5, since, handler);
     if (!instance)
-      throw new Error(`could not watch: ${path4}`);
+      throw new Error(`could not watch: ${path5}`);
     return () => {
       const result = instance ? Promise.resolve(instance).then(Native.stop) : Promise.resolve(undefined);
       instance = undefined;
       return result;
     };
   }
-  function getInfo(path4, flags) {
+  function getInfo(path5, flags) {
     return {
-      path: path4,
+      path: path5,
       flags,
       event: getEventType(flags),
       type: getFileType(flags),
@@ -23642,18 +23642,18 @@ var require_fsevents_handler = __commonJS((exports, module) => {
     131840,
     262912
   ]);
-  var createFSEventsInstance = (path4, callback) => {
-    const stop = fsevents.watch(path4, callback);
+  var createFSEventsInstance = (path5, callback) => {
+    const stop = fsevents.watch(path5, callback);
     return { stop };
   };
-  function setFSEventsListener(path4, realPath, listener, rawEmitter) {
+  function setFSEventsListener(path5, realPath, listener, rawEmitter) {
     let watchPath = sysPath.extname(realPath) ? sysPath.dirname(realPath) : realPath;
     const parentPath = sysPath.dirname(watchPath);
     let cont = FSEventsWatchers.get(watchPath);
     if (couldConsolidate(parentPath)) {
       watchPath = parentPath;
     }
-    const resolvedPath = sysPath.resolve(path4);
+    const resolvedPath = sysPath.resolve(path5);
     const hasSymlink = resolvedPath !== realPath;
     const filteredListener = (fullPath, flags, info) => {
       if (hasSymlink)
@@ -23703,10 +23703,10 @@ var require_fsevents_handler = __commonJS((exports, module) => {
       }
     };
   }
-  var couldConsolidate = (path4) => {
+  var couldConsolidate = (path5) => {
     let count = 0;
     for (const watchPath of FSEventsWatchers.keys()) {
-      if (watchPath.indexOf(path4) === 0) {
+      if (watchPath.indexOf(path5) === 0) {
         count++;
         if (count >= consolidateThreshhold) {
           return true;
@@ -23716,9 +23716,9 @@ var require_fsevents_handler = __commonJS((exports, module) => {
     return false;
   };
   var canUse = () => fsevents && FSEventsWatchers.size < 128;
-  var calcDepth = (path4, root) => {
+  var calcDepth = (path5, root) => {
     let i = 0;
-    while (!path4.indexOf(root) && (path4 = sysPath.dirname(path4)) !== root)
+    while (!path5.indexOf(root) && (path5 = sysPath.dirname(path5)) !== root)
       i++;
     return i;
   };
@@ -23728,42 +23728,42 @@ var require_fsevents_handler = __commonJS((exports, module) => {
     constructor(fsw) {
       this.fsw = fsw;
     }
-    checkIgnored(path4, stats) {
+    checkIgnored(path5, stats) {
       const ipaths = this.fsw._ignoredPaths;
-      if (this.fsw._isIgnored(path4, stats)) {
-        ipaths.add(path4);
+      if (this.fsw._isIgnored(path5, stats)) {
+        ipaths.add(path5);
         if (stats && stats.isDirectory()) {
-          ipaths.add(path4 + ROOT_GLOBSTAR);
+          ipaths.add(path5 + ROOT_GLOBSTAR);
         }
         return true;
       }
-      ipaths.delete(path4);
-      ipaths.delete(path4 + ROOT_GLOBSTAR);
+      ipaths.delete(path5);
+      ipaths.delete(path5 + ROOT_GLOBSTAR);
     }
-    addOrChange(path4, fullPath, realPath, parent, watchedDir, item, info, opts) {
+    addOrChange(path5, fullPath, realPath, parent, watchedDir, item, info, opts) {
       const event = watchedDir.has(item) ? EV_CHANGE : EV_ADD;
-      this.handleEvent(event, path4, fullPath, realPath, parent, watchedDir, item, info, opts);
+      this.handleEvent(event, path5, fullPath, realPath, parent, watchedDir, item, info, opts);
     }
-    async checkExists(path4, fullPath, realPath, parent, watchedDir, item, info, opts) {
+    async checkExists(path5, fullPath, realPath, parent, watchedDir, item, info, opts) {
       try {
-        const stats = await stat(path4);
+        const stats = await stat(path5);
         if (this.fsw.closed)
           return;
         if (sameTypes(info, stats)) {
-          this.addOrChange(path4, fullPath, realPath, parent, watchedDir, item, info, opts);
+          this.addOrChange(path5, fullPath, realPath, parent, watchedDir, item, info, opts);
         } else {
-          this.handleEvent(EV_UNLINK, path4, fullPath, realPath, parent, watchedDir, item, info, opts);
+          this.handleEvent(EV_UNLINK, path5, fullPath, realPath, parent, watchedDir, item, info, opts);
         }
       } catch (error) {
         if (error.code === "EACCES") {
-          this.addOrChange(path4, fullPath, realPath, parent, watchedDir, item, info, opts);
+          this.addOrChange(path5, fullPath, realPath, parent, watchedDir, item, info, opts);
         } else {
-          this.handleEvent(EV_UNLINK, path4, fullPath, realPath, parent, watchedDir, item, info, opts);
+          this.handleEvent(EV_UNLINK, path5, fullPath, realPath, parent, watchedDir, item, info, opts);
         }
       }
     }
-    handleEvent(event, path4, fullPath, realPath, parent, watchedDir, item, info, opts) {
-      if (this.fsw.closed || this.checkIgnored(path4))
+    handleEvent(event, path5, fullPath, realPath, parent, watchedDir, item, info, opts) {
+      if (this.fsw.closed || this.checkIgnored(path5))
         return;
       if (event === EV_UNLINK) {
         const isDirectory2 = info.type === FSEVENT_TYPE_DIRECTORY;
@@ -23773,17 +23773,17 @@ var require_fsevents_handler = __commonJS((exports, module) => {
       } else {
         if (event === EV_ADD) {
           if (info.type === FSEVENT_TYPE_DIRECTORY)
-            this.fsw._getWatchedDir(path4);
+            this.fsw._getWatchedDir(path5);
           if (info.type === FSEVENT_TYPE_SYMLINK && opts.followSymlinks) {
             const curDepth = opts.depth === undefined ? undefined : calcDepth(fullPath, realPath) + 1;
-            return this._addToFsEvents(path4, false, true, curDepth);
+            return this._addToFsEvents(path5, false, true, curDepth);
           }
           this.fsw._getWatchedDir(parent).add(item);
         }
         const eventName = info.type === FSEVENT_TYPE_DIRECTORY ? event + DIR_SUFFIX : event;
-        this.fsw._emit(eventName, path4);
+        this.fsw._emit(eventName, path5);
         if (eventName === EV_ADD_DIR)
-          this._addToFsEvents(path4, false, true);
+          this._addToFsEvents(path5, false, true);
       }
     }
     _watchWithFsEvents(watchPath, realPath, transform, globFilter) {
@@ -23795,38 +23795,38 @@ var require_fsevents_handler = __commonJS((exports, module) => {
           return;
         if (opts.depth !== undefined && calcDepth(fullPath, realPath) > opts.depth)
           return;
-        const path4 = transform(sysPath.join(watchPath, sysPath.relative(watchPath, fullPath)));
-        if (globFilter && !globFilter(path4))
+        const path5 = transform(sysPath.join(watchPath, sysPath.relative(watchPath, fullPath)));
+        if (globFilter && !globFilter(path5))
           return;
-        const parent = sysPath.dirname(path4);
-        const item = sysPath.basename(path4);
-        const watchedDir = this.fsw._getWatchedDir(info.type === FSEVENT_TYPE_DIRECTORY ? path4 : parent);
+        const parent = sysPath.dirname(path5);
+        const item = sysPath.basename(path5);
+        const watchedDir = this.fsw._getWatchedDir(info.type === FSEVENT_TYPE_DIRECTORY ? path5 : parent);
         if (wrongEventFlags.has(flags) || info.event === FSEVENT_UNKNOWN) {
           if (typeof opts.ignored === FUNCTION_TYPE) {
             let stats;
             try {
-              stats = await stat(path4);
+              stats = await stat(path5);
             } catch (error) {}
             if (this.fsw.closed)
               return;
-            if (this.checkIgnored(path4, stats))
+            if (this.checkIgnored(path5, stats))
               return;
             if (sameTypes(info, stats)) {
-              this.addOrChange(path4, fullPath, realPath, parent, watchedDir, item, info, opts);
+              this.addOrChange(path5, fullPath, realPath, parent, watchedDir, item, info, opts);
             } else {
-              this.handleEvent(EV_UNLINK, path4, fullPath, realPath, parent, watchedDir, item, info, opts);
+              this.handleEvent(EV_UNLINK, path5, fullPath, realPath, parent, watchedDir, item, info, opts);
             }
           } else {
-            this.checkExists(path4, fullPath, realPath, parent, watchedDir, item, info, opts);
+            this.checkExists(path5, fullPath, realPath, parent, watchedDir, item, info, opts);
           }
         } else {
           switch (info.event) {
             case FSEVENT_CREATED:
             case FSEVENT_MODIFIED:
-              return this.addOrChange(path4, fullPath, realPath, parent, watchedDir, item, info, opts);
+              return this.addOrChange(path5, fullPath, realPath, parent, watchedDir, item, info, opts);
             case FSEVENT_DELETED:
             case FSEVENT_MOVED:
-              return this.checkExists(path4, fullPath, realPath, parent, watchedDir, item, info, opts);
+              return this.checkExists(path5, fullPath, realPath, parent, watchedDir, item, info, opts);
           }
         }
       };
@@ -23847,12 +23847,12 @@ var require_fsevents_handler = __commonJS((exports, module) => {
           return this.fsw._emitReady();
         }
         this.fsw._incrReadyCount();
-        this._addToFsEvents(linkTarget || linkPath, (path4) => {
+        this._addToFsEvents(linkTarget || linkPath, (path5) => {
           let aliasedPath = linkPath;
           if (linkTarget && linkTarget !== DOT_SLASH) {
-            aliasedPath = path4.replace(linkTarget, linkPath);
-          } else if (path4 !== DOT_SLASH) {
-            aliasedPath = sysPath.join(linkPath, path4);
+            aliasedPath = path5.replace(linkTarget, linkPath);
+          } else if (path5 !== DOT_SLASH) {
+            aliasedPath = sysPath.join(linkPath, path5);
           }
           return transform(aliasedPath);
         }, false, curDepth);
@@ -23876,19 +23876,19 @@ var require_fsevents_handler = __commonJS((exports, module) => {
         this.fsw._emit(isDir ? EV_ADD_DIR : EV_ADD, pp, stats);
       }
     }
-    initWatch(realPath, path4, wh, processPath) {
+    initWatch(realPath, path5, wh, processPath) {
       if (this.fsw.closed)
         return;
       const closer = this._watchWithFsEvents(wh.watchPath, sysPath.resolve(realPath || wh.watchPath), processPath, wh.globFilter);
-      this.fsw._addPathCloser(path4, closer);
+      this.fsw._addPathCloser(path5, closer);
     }
-    async _addToFsEvents(path4, transform, forceAdd, priorDepth) {
+    async _addToFsEvents(path5, transform, forceAdd, priorDepth) {
       if (this.fsw.closed) {
         return;
       }
       const opts = this.fsw.options;
       const processPath = typeof transform === FUNCTION_TYPE ? transform : IDENTITY_FN;
-      const wh = this.fsw._getWatchHelpers(path4);
+      const wh = this.fsw._getWatchHelpers(path5);
       try {
         const stats = await statMethods[wh.statMethod](wh.watchPath);
         if (this.fsw.closed)
@@ -23898,7 +23898,7 @@ var require_fsevents_handler = __commonJS((exports, module) => {
         }
         if (stats.isDirectory()) {
           if (!wh.globFilter)
-            this.emitAdd(processPath(path4), stats, processPath, opts, forceAdd);
+            this.emitAdd(processPath(path5), stats, processPath, opts, forceAdd);
           if (priorDepth && priorDepth > opts.depth)
             return;
           this.fsw._readdirp(wh.watchPath, {
@@ -23934,13 +23934,13 @@ var require_fsevents_handler = __commonJS((exports, module) => {
       }
       if (opts.persistent && forceAdd !== true) {
         if (typeof transform === FUNCTION_TYPE) {
-          this.initWatch(undefined, path4, wh, processPath);
+          this.initWatch(undefined, path5, wh, processPath);
         } else {
           let realPath;
           try {
             realPath = await realpath(wh.watchPath);
           } catch (e) {}
-          this.initWatch(realPath, path4, wh, processPath);
+          this.initWatch(realPath, path5, wh, processPath);
         }
       }
     }
@@ -24031,20 +24031,20 @@ var require_chokidar = __commonJS((exports) => {
     }
     return str2;
   };
-  var normalizePathToUnix = (path4) => toUnix(sysPath.normalize(toUnix(path4)));
-  var normalizeIgnored = (cwd = EMPTY_STR) => (path4) => {
-    if (typeof path4 !== STRING_TYPE)
-      return path4;
-    return normalizePathToUnix(sysPath.isAbsolute(path4) ? path4 : sysPath.join(cwd, path4));
+  var normalizePathToUnix = (path5) => toUnix(sysPath.normalize(toUnix(path5)));
+  var normalizeIgnored = (cwd = EMPTY_STR) => (path5) => {
+    if (typeof path5 !== STRING_TYPE)
+      return path5;
+    return normalizePathToUnix(sysPath.isAbsolute(path5) ? path5 : sysPath.join(cwd, path5));
   };
-  var getAbsolutePath = (path4, cwd) => {
-    if (sysPath.isAbsolute(path4)) {
-      return path4;
+  var getAbsolutePath = (path5, cwd) => {
+    if (sysPath.isAbsolute(path5)) {
+      return path5;
     }
-    if (path4.startsWith(BANG)) {
-      return BANG + sysPath.join(cwd, path4.slice(1));
+    if (path5.startsWith(BANG)) {
+      return BANG + sysPath.join(cwd, path5.slice(1));
     }
-    return sysPath.join(cwd, path4);
+    return sysPath.join(cwd, path5);
   };
   var undef = (opts, key) => opts[key] === undefined;
 
@@ -24101,17 +24101,17 @@ var require_chokidar = __commonJS((exports) => {
   var STAT_METHOD_L = "lstat";
 
   class WatchHelper {
-    constructor(path4, watchPath, follow, fsw) {
+    constructor(path5, watchPath, follow, fsw) {
       this.fsw = fsw;
-      this.path = path4 = path4.replace(REPLACER_RE, EMPTY_STR);
+      this.path = path5 = path5.replace(REPLACER_RE, EMPTY_STR);
       this.watchPath = watchPath;
       this.fullWatchPath = sysPath.resolve(watchPath);
-      this.hasGlob = watchPath !== path4;
-      if (path4 === EMPTY_STR)
+      this.hasGlob = watchPath !== path5;
+      if (path5 === EMPTY_STR)
         this.hasGlob = false;
       this.globSymlink = this.hasGlob && follow ? undefined : false;
-      this.globFilter = this.hasGlob ? anymatch(path4, undefined, ANYMATCH_OPTS) : false;
-      this.dirParts = this.getDirParts(path4);
+      this.globFilter = this.hasGlob ? anymatch(path5, undefined, ANYMATCH_OPTS) : false;
+      this.dirParts = this.getDirParts(path5);
       this.dirParts.forEach((parts) => {
         if (parts.length > 1)
           parts.pop();
@@ -24139,13 +24139,13 @@ var require_chokidar = __commonJS((exports) => {
       const matchesGlob = this.hasGlob && typeof this.globFilter === FUNCTION_TYPE ? this.globFilter(resolvedPath) : true;
       return matchesGlob && this.fsw._isntIgnored(resolvedPath, stats) && this.fsw._hasReadPermissions(stats);
     }
-    getDirParts(path4) {
+    getDirParts(path5) {
       if (!this.hasGlob)
         return [];
       const parts = [];
-      const expandedPath = path4.includes(BRACE_START) ? braces.expand(path4) : [path4];
-      expandedPath.forEach((path5) => {
-        parts.push(sysPath.relative(this.watchPath, path5).split(SLASH_OR_BACK_SLASH_RE));
+      const expandedPath = path5.includes(BRACE_START) ? braces.expand(path5) : [path5];
+      expandedPath.forEach((path6) => {
+        parts.push(sysPath.relative(this.watchPath, path6).split(SLASH_OR_BACK_SLASH_RE));
       });
       return parts;
     }
@@ -24261,21 +24261,21 @@ var require_chokidar = __commonJS((exports) => {
       this.closed = false;
       let paths = unifyPaths(paths_);
       if (cwd) {
-        paths = paths.map((path4) => {
-          const absPath = getAbsolutePath(path4, cwd);
-          if (disableGlobbing || !isGlob(path4)) {
+        paths = paths.map((path5) => {
+          const absPath = getAbsolutePath(path5, cwd);
+          if (disableGlobbing || !isGlob(path5)) {
             return absPath;
           }
           return normalizePath(absPath);
         });
       }
-      paths = paths.filter((path4) => {
-        if (path4.startsWith(BANG)) {
-          this._ignoredPaths.add(path4.slice(1));
+      paths = paths.filter((path5) => {
+        if (path5.startsWith(BANG)) {
+          this._ignoredPaths.add(path5.slice(1));
           return false;
         }
-        this._ignoredPaths.delete(path4);
-        this._ignoredPaths.delete(path4 + SLASH_GLOBSTAR);
+        this._ignoredPaths.delete(path5);
+        this._ignoredPaths.delete(path5 + SLASH_GLOBSTAR);
         this._userIgnored = undefined;
         return true;
       });
@@ -24284,13 +24284,13 @@ var require_chokidar = __commonJS((exports) => {
           this._readyCount = paths.length;
         if (this.options.persistent)
           this._readyCount += paths.length;
-        paths.forEach((path4) => this._fsEventsHandler._addToFsEvents(path4));
+        paths.forEach((path5) => this._fsEventsHandler._addToFsEvents(path5));
       } else {
         if (!this._readyCount)
           this._readyCount = 0;
         this._readyCount += paths.length;
-        Promise.all(paths.map(async (path4) => {
-          const res = await this._nodeFsHandler._addToNodeFs(path4, !_internal, 0, 0, _origAdd);
+        Promise.all(paths.map(async (path5) => {
+          const res = await this._nodeFsHandler._addToNodeFs(path5, !_internal, 0, 0, _origAdd);
           if (res)
             this._emitReady();
           return res;
@@ -24309,16 +24309,16 @@ var require_chokidar = __commonJS((exports) => {
         return this;
       const paths = unifyPaths(paths_);
       const { cwd } = this.options;
-      paths.forEach((path4) => {
-        if (!sysPath.isAbsolute(path4) && !this._closers.has(path4)) {
+      paths.forEach((path5) => {
+        if (!sysPath.isAbsolute(path5) && !this._closers.has(path5)) {
           if (cwd)
-            path4 = sysPath.join(cwd, path4);
-          path4 = sysPath.resolve(path4);
+            path5 = sysPath.join(cwd, path5);
+          path5 = sysPath.resolve(path5);
         }
-        this._closePath(path4);
-        this._ignoredPaths.add(path4);
-        if (this._watched.has(path4)) {
-          this._ignoredPaths.add(path4 + SLASH_GLOBSTAR);
+        this._closePath(path5);
+        this._ignoredPaths.add(path5);
+        if (this._watched.has(path5)) {
+          this._ignoredPaths.add(path5 + SLASH_GLOBSTAR);
         }
         this._userIgnored = undefined;
       });
@@ -24361,15 +24361,15 @@ var require_chokidar = __commonJS((exports) => {
       if (event !== EV_ERROR)
         this.emit(EV_ALL, ...args);
     }
-    async _emit(event, path4, val1, val2, val3) {
+    async _emit(event, path5, val1, val2, val3) {
       if (this.closed)
         return;
       const opts = this.options;
       if (isWindows)
-        path4 = sysPath.normalize(path4);
+        path5 = sysPath.normalize(path5);
       if (opts.cwd)
-        path4 = sysPath.relative(opts.cwd, path4);
-      const args = [event, path4];
+        path5 = sysPath.relative(opts.cwd, path5);
+      const args = [event, path5];
       if (val3 !== undefined)
         args.push(val1, val2, val3);
       else if (val2 !== undefined)
@@ -24378,25 +24378,25 @@ var require_chokidar = __commonJS((exports) => {
         args.push(val1);
       const awf = opts.awaitWriteFinish;
       let pw;
-      if (awf && (pw = this._pendingWrites.get(path4))) {
+      if (awf && (pw = this._pendingWrites.get(path5))) {
         pw.lastChange = new Date;
         return this;
       }
       if (opts.atomic) {
         if (event === EV_UNLINK) {
-          this._pendingUnlinks.set(path4, args);
+          this._pendingUnlinks.set(path5, args);
           setTimeout(() => {
-            this._pendingUnlinks.forEach((entry, path5) => {
+            this._pendingUnlinks.forEach((entry, path6) => {
               this.emit(...entry);
               this.emit(EV_ALL, ...entry);
-              this._pendingUnlinks.delete(path5);
+              this._pendingUnlinks.delete(path6);
             });
           }, typeof opts.atomic === "number" ? opts.atomic : 100);
           return this;
         }
-        if (event === EV_ADD && this._pendingUnlinks.has(path4)) {
+        if (event === EV_ADD && this._pendingUnlinks.has(path5)) {
           event = args[0] = EV_CHANGE;
-          this._pendingUnlinks.delete(path4);
+          this._pendingUnlinks.delete(path5);
         }
       }
       if (awf && (event === EV_ADD || event === EV_CHANGE) && this._readyEmitted) {
@@ -24414,16 +24414,16 @@ var require_chokidar = __commonJS((exports) => {
             this.emitWithAll(event, args);
           }
         };
-        this._awaitWriteFinish(path4, awf.stabilityThreshold, event, awfEmit);
+        this._awaitWriteFinish(path5, awf.stabilityThreshold, event, awfEmit);
         return this;
       }
       if (event === EV_CHANGE) {
-        const isThrottled = !this._throttle(EV_CHANGE, path4, 50);
+        const isThrottled = !this._throttle(EV_CHANGE, path5, 50);
         if (isThrottled)
           return this;
       }
       if (opts.alwaysStat && val1 === undefined && (event === EV_ADD || event === EV_ADD_DIR || event === EV_CHANGE)) {
-        const fullPath = opts.cwd ? sysPath.join(opts.cwd, path4) : path4;
+        const fullPath = opts.cwd ? sysPath.join(opts.cwd, path5) : path5;
         let stats;
         try {
           stats = await stat(fullPath);
@@ -24442,21 +24442,21 @@ var require_chokidar = __commonJS((exports) => {
       }
       return error || this.closed;
     }
-    _throttle(actionType, path4, timeout) {
+    _throttle(actionType, path5, timeout) {
       if (!this._throttled.has(actionType)) {
         this._throttled.set(actionType, new Map);
       }
       const action = this._throttled.get(actionType);
-      const actionPath = action.get(path4);
+      const actionPath = action.get(path5);
       if (actionPath) {
         actionPath.count++;
         return false;
       }
       let timeoutObject;
       const clear = () => {
-        const item = action.get(path4);
+        const item = action.get(path5);
         const count = item ? item.count : 0;
-        action.delete(path4);
+        action.delete(path5);
         clearTimeout(timeoutObject);
         if (item)
           clearTimeout(item.timeoutObject);
@@ -24464,45 +24464,45 @@ var require_chokidar = __commonJS((exports) => {
       };
       timeoutObject = setTimeout(clear, timeout);
       const thr = { timeoutObject, clear, count: 0 };
-      action.set(path4, thr);
+      action.set(path5, thr);
       return thr;
     }
     _incrReadyCount() {
       return this._readyCount++;
     }
-    _awaitWriteFinish(path4, threshold, event, awfEmit) {
+    _awaitWriteFinish(path5, threshold, event, awfEmit) {
       let timeoutHandler;
-      let fullPath = path4;
-      if (this.options.cwd && !sysPath.isAbsolute(path4)) {
-        fullPath = sysPath.join(this.options.cwd, path4);
+      let fullPath = path5;
+      if (this.options.cwd && !sysPath.isAbsolute(path5)) {
+        fullPath = sysPath.join(this.options.cwd, path5);
       }
       const now = new Date;
       const awaitWriteFinish = (prevStat) => {
         fs2.stat(fullPath, (err, curStat) => {
-          if (err || !this._pendingWrites.has(path4)) {
+          if (err || !this._pendingWrites.has(path5)) {
             if (err && err.code !== "ENOENT")
               awfEmit(err);
             return;
           }
           const now2 = Number(new Date);
           if (prevStat && curStat.size !== prevStat.size) {
-            this._pendingWrites.get(path4).lastChange = now2;
+            this._pendingWrites.get(path5).lastChange = now2;
           }
-          const pw = this._pendingWrites.get(path4);
+          const pw = this._pendingWrites.get(path5);
           const df = now2 - pw.lastChange;
           if (df >= threshold) {
-            this._pendingWrites.delete(path4);
+            this._pendingWrites.delete(path5);
             awfEmit(undefined, curStat);
           } else {
             timeoutHandler = setTimeout(awaitWriteFinish, this.options.awaitWriteFinish.pollInterval, curStat);
           }
         });
       };
-      if (!this._pendingWrites.has(path4)) {
-        this._pendingWrites.set(path4, {
+      if (!this._pendingWrites.has(path5)) {
+        this._pendingWrites.set(path5, {
           lastChange: now,
           cancelWait: () => {
-            this._pendingWrites.delete(path4);
+            this._pendingWrites.delete(path5);
             clearTimeout(timeoutHandler);
             return event;
           }
@@ -24513,26 +24513,26 @@ var require_chokidar = __commonJS((exports) => {
     _getGlobIgnored() {
       return [...this._ignoredPaths.values()];
     }
-    _isIgnored(path4, stats) {
-      if (this.options.atomic && DOT_RE.test(path4))
+    _isIgnored(path5, stats) {
+      if (this.options.atomic && DOT_RE.test(path5))
         return true;
       if (!this._userIgnored) {
         const { cwd } = this.options;
         const ign = this.options.ignored;
         const ignored = ign && ign.map(normalizeIgnored(cwd));
-        const paths = arrify(ignored).filter((path5) => typeof path5 === STRING_TYPE && !isGlob(path5)).map((path5) => path5 + SLASH_GLOBSTAR);
+        const paths = arrify(ignored).filter((path6) => typeof path6 === STRING_TYPE && !isGlob(path6)).map((path6) => path6 + SLASH_GLOBSTAR);
         const list = this._getGlobIgnored().map(normalizeIgnored(cwd)).concat(ignored, paths);
         this._userIgnored = anymatch(list, undefined, ANYMATCH_OPTS);
       }
-      return this._userIgnored([path4, stats]);
+      return this._userIgnored([path5, stats]);
     }
-    _isntIgnored(path4, stat2) {
-      return !this._isIgnored(path4, stat2);
+    _isntIgnored(path5, stat2) {
+      return !this._isIgnored(path5, stat2);
     }
-    _getWatchHelpers(path4, depth) {
-      const watchPath = depth || this.options.disableGlobbing || !isGlob(path4) ? path4 : globParent(path4);
+    _getWatchHelpers(path5, depth) {
+      const watchPath = depth || this.options.disableGlobbing || !isGlob(path5) ? path5 : globParent(path5);
       const follow = this.options.followSymlinks;
-      return new WatchHelper(path4, watchPath, follow, this);
+      return new WatchHelper(path5, watchPath, follow, this);
     }
     _getWatchedDir(directory) {
       if (!this._boundRemove)
@@ -24551,59 +24551,59 @@ var require_chokidar = __commonJS((exports) => {
       return Boolean(4 & it2);
     }
     _remove(directory, item, isDirectory2) {
-      const path4 = sysPath.join(directory, item);
-      const fullPath = sysPath.resolve(path4);
-      isDirectory2 = isDirectory2 != null ? isDirectory2 : this._watched.has(path4) || this._watched.has(fullPath);
-      if (!this._throttle("remove", path4, 100))
+      const path5 = sysPath.join(directory, item);
+      const fullPath = sysPath.resolve(path5);
+      isDirectory2 = isDirectory2 != null ? isDirectory2 : this._watched.has(path5) || this._watched.has(fullPath);
+      if (!this._throttle("remove", path5, 100))
         return;
       if (!isDirectory2 && !this.options.useFsEvents && this._watched.size === 1) {
         this.add(directory, item, true);
       }
-      const wp = this._getWatchedDir(path4);
+      const wp = this._getWatchedDir(path5);
       const nestedDirectoryChildren = wp.getChildren();
-      nestedDirectoryChildren.forEach((nested) => this._remove(path4, nested));
+      nestedDirectoryChildren.forEach((nested) => this._remove(path5, nested));
       const parent = this._getWatchedDir(directory);
       const wasTracked = parent.has(item);
       parent.remove(item);
       if (this._symlinkPaths.has(fullPath)) {
         this._symlinkPaths.delete(fullPath);
       }
-      let relPath = path4;
+      let relPath = path5;
       if (this.options.cwd)
-        relPath = sysPath.relative(this.options.cwd, path4);
+        relPath = sysPath.relative(this.options.cwd, path5);
       if (this.options.awaitWriteFinish && this._pendingWrites.has(relPath)) {
         const event = this._pendingWrites.get(relPath).cancelWait();
         if (event === EV_ADD)
           return;
       }
-      this._watched.delete(path4);
+      this._watched.delete(path5);
       this._watched.delete(fullPath);
       const eventName = isDirectory2 ? EV_UNLINK_DIR : EV_UNLINK;
-      if (wasTracked && !this._isIgnored(path4))
-        this._emit(eventName, path4);
+      if (wasTracked && !this._isIgnored(path5))
+        this._emit(eventName, path5);
       if (!this.options.useFsEvents) {
-        this._closePath(path4);
+        this._closePath(path5);
       }
     }
-    _closePath(path4) {
-      this._closeFile(path4);
-      const dir = sysPath.dirname(path4);
-      this._getWatchedDir(dir).remove(sysPath.basename(path4));
+    _closePath(path5) {
+      this._closeFile(path5);
+      const dir = sysPath.dirname(path5);
+      this._getWatchedDir(dir).remove(sysPath.basename(path5));
     }
-    _closeFile(path4) {
-      const closers = this._closers.get(path4);
+    _closeFile(path5) {
+      const closers = this._closers.get(path5);
       if (!closers)
         return;
       closers.forEach((closer) => closer());
-      this._closers.delete(path4);
+      this._closers.delete(path5);
     }
-    _addPathCloser(path4, closer) {
+    _addPathCloser(path5, closer) {
       if (!closer)
         return;
-      let list = this._closers.get(path4);
+      let list = this._closers.get(path5);
       if (!list) {
         list = [];
-        this._closers.set(path4, list);
+        this._closers.set(path5, list);
       }
       list.push(closer);
     }
@@ -24649,7 +24649,7 @@ var require_node_loaders = __commonJS((exports, module) => {
     return _setPrototypeOf(o, p);
   }
   var fs2 = __require("fs");
-  var path4 = __require("path");
+  var path5 = __require("path");
   var Loader = require_loader2();
   var _require = require_precompiled_loader();
   var PrecompiledLoader = _require.PrecompiledLoader;
@@ -24667,7 +24667,7 @@ var require_node_loaders = __commonJS((exports, module) => {
       _this.noCache = !!opts.noCache;
       if (searchPaths) {
         searchPaths = Array.isArray(searchPaths) ? searchPaths : [searchPaths];
-        _this.searchPaths = searchPaths.map(path4.normalize);
+        _this.searchPaths = searchPaths.map(path5.normalize);
       } else {
         _this.searchPaths = ["."];
       }
@@ -24680,7 +24680,7 @@ var require_node_loaders = __commonJS((exports, module) => {
         var paths = _this.searchPaths.filter(fs2.existsSync);
         var watcher = chokidar.watch(paths);
         watcher.on("all", function(event, fullname) {
-          fullname = path4.resolve(fullname);
+          fullname = path5.resolve(fullname);
           if (event === "change" && fullname in _this.pathsToNames) {
             _this.emit("update", _this.pathsToNames[fullname], fullname);
           }
@@ -24696,8 +24696,8 @@ var require_node_loaders = __commonJS((exports, module) => {
       var fullpath = null;
       var paths = this.searchPaths;
       for (var i = 0;i < paths.length; i++) {
-        var basePath = path4.resolve(paths[i]);
-        var p = path4.resolve(paths[i], name);
+        var basePath = path5.resolve(paths[i]);
+        var p = path5.resolve(paths[i], name);
         if (p.indexOf(basePath) === 0 && fs2.existsSync(p)) {
           fullpath = p;
           break;
@@ -24946,13 +24946,13 @@ var require_globals = __commonJS((exports, module) => {
 
 // node_modules/nunjucks/src/express-app.js
 var require_express_app = __commonJS((exports, module) => {
-  var path4 = __require("path");
+  var path5 = __require("path");
   module.exports = function express(env, app) {
     function NunjucksView(name, opts) {
       this.name = name;
       this.path = name;
       this.defaultEngine = opts.defaultEngine;
-      this.ext = path4.extname(name);
+      this.ext = path5.extname(name);
       if (!this.ext && !this.defaultEngine) {
         throw new Error("No default engine was specified and no extension was provided.");
       }
@@ -25329,7 +25329,7 @@ var require_environment = __commonJS((exports, module) => {
       return _Obj2.apply(this, arguments) || this;
     }
     var _proto3 = Template2.prototype;
-    _proto3.init = function init(src, env, path4, eagerCompile) {
+    _proto3.init = function init(src, env, path5, eagerCompile) {
       this.env = env || new Environment;
       if (lib.isObject(src)) {
         switch (src.type) {
@@ -25347,7 +25347,7 @@ var require_environment = __commonJS((exports, module) => {
       } else {
         throw new Error("src must be a string or an object describing the source");
       }
-      this.path = path4;
+      this.path = path5;
       if (eagerCompile) {
         try {
           this._compile();
@@ -25497,7 +25497,7 @@ var require_precompile_global = __commonJS((exports, module) => {
 // node_modules/nunjucks/src/precompile.js
 var require_precompile = __commonJS((exports, module) => {
   var fs2 = __require("fs");
-  var path4 = __require("path");
+  var path5 = __require("path");
   var _require = require_lib7();
   var _prettifyError = _require._prettifyError;
   var compiler = require_compiler();
@@ -25534,8 +25534,8 @@ var require_precompile = __commonJS((exports, module) => {
     var templates = [];
     function addTemplates(dir) {
       fs2.readdirSync(dir).forEach(function(file) {
-        var filepath = path4.join(dir, file);
-        var subpath = filepath.substr(path4.join(input, "/").length);
+        var filepath = path5.join(dir, file);
+        var subpath = filepath.substr(path5.join(input, "/").length);
         var stat = fs2.statSync(filepath);
         if (stat && stat.isDirectory()) {
           subpath += "/";
@@ -25552,7 +25552,7 @@ var require_precompile = __commonJS((exports, module) => {
     } else if (pathStats.isDirectory()) {
       addTemplates(input);
       for (var i = 0;i < templates.length; i++) {
-        var name = templates[i].replace(path4.join(input, "/"), "");
+        var name = templates[i].replace(path5.join(input, "/"), "");
         try {
           precompiled.push(_precompile(fs2.readFileSync(templates[i], "utf-8"), name, env));
         } catch (e) {
@@ -25924,11 +25924,11 @@ var require_nunjucks = __commonJS((exports, module) => {
     reset: function reset() {
       e = undefined;
     },
-    compile: function compile(src, env, path4, eagerCompile) {
+    compile: function compile(src, env, path5, eagerCompile) {
       if (!e) {
         configure();
       }
-      return new Template(src, env, path4, eagerCompile);
+      return new Template(src, env, path5, eagerCompile);
     },
     render: function render(name, ctx, cb) {
       if (!e) {
@@ -25997,6 +25997,9 @@ var require_slugify = __commonJS((exports, module) => {
     return replace;
   });
 });
+// src/parser.ts
+import path2 from "path";
+
 // src/utils/file-utils.ts
 var {Glob } = globalThis.Bun;
 import path from "path";
@@ -26041,7 +26044,12 @@ async function readFileAsText(filePath) {
   }
 }
 function getBaseFilename(filePath, extension = ".md") {
-  return path.basename(filePath, extension);
+  const basename = path.basename(filePath, extension);
+  if (basename.toLowerCase() === "readme") {
+    const dir = path.dirname(filePath);
+    return path.basename(dir);
+  }
+  return basename;
 }
 async function createDir(dirPath) {
   try {
@@ -30832,6 +30840,20 @@ async function parseMarkdownFile(filePath, cdnConfig) {
         };
       }
     }
+    if (data.tags && Array.isArray(data.tags)) {
+      const tagsWithSpaces = data.tags.filter((tag) => tag.includes(" "));
+      if (tagsWithSpaces.length > 0) {
+        return {
+          post: null,
+          error: {
+            file: filePath,
+            type: "validation",
+            message: `Tags must not contain spaces. Found: ${tagsWithSpaces.map((t) => `"${t}"`).join(", ")}`,
+            suggestion: `Use hyphens instead of spaces. Example: "new-york-city" instead of "new york city"`
+          }
+        };
+      }
+    }
     let slug = getBaseFilename(filePath);
     const sanitizedHtml = convertMarkdownToHtml(content, cdnConfig);
     const pacificDate = toPacificTime(data.date);
@@ -30895,14 +30917,55 @@ async function parseMarkdownFile(filePath, cdnConfig) {
 }
 
 // src/parser.ts
+function detectFileConflicts(files) {
+  const errors = [];
+  const slugMap = new Map;
+  for (const filePath of files) {
+    const slug = getBaseFilename(filePath);
+    const dir = path2.dirname(filePath);
+    const year = path2.basename(dir);
+    const key = `${year}/${slug}`;
+    if (!slugMap.has(key)) {
+      slugMap.set(key, []);
+    }
+    slugMap.get(key).push(filePath);
+  }
+  for (const [key, paths] of slugMap.entries()) {
+    if (paths.length > 1) {
+      errors.push({
+        file: paths[0],
+        type: "validation",
+        message: `Conflicting files for '${key}': ${paths.map((p) => path2.relative(process.cwd(), p)).join(" AND ")}`,
+        suggestion: `Remove one of the files. Keep either the .md file OR the /README.md file, not both.`
+      });
+    }
+  }
+  return errors;
+}
 async function parseMarkdownDirectory(contentDir, strictMode = false, cdnConfig) {
   try {
     const markdownFiles = await findFilesByPattern("**/*.md", contentDir, true);
     console.log(`Found ${markdownFiles.length} markdown files`);
+    const conflictErrors = detectFileConflicts(markdownFiles);
+    if (conflictErrors.length > 0) {
+      console.error(`
+\u26A0\uFE0F  Found ${conflictErrors.length} file conflict(s):
+`);
+      conflictErrors.forEach((e) => {
+        console.error(`    \u274C ${e.message}`);
+        if (e.suggestion) {
+          console.error(`       \uD83D\uDCA1 ${e.suggestion}`);
+        }
+      });
+      console.error("");
+      if (strictMode) {
+        throw new Error(`File conflicts detected. Fix conflicts before building.`);
+      }
+    }
     const resultsPromises = markdownFiles.map((filePath) => parseMarkdownFile(filePath, cdnConfig));
     const results = await Promise.all(resultsPromises);
     const posts = [];
-    const errors = [];
+    const errors = [...conflictErrors];
     for (const result of results) {
       if (result.post) {
         posts.push(result.post);
@@ -30986,16 +31049,16 @@ async function parseMarkdownDirectory(contentDir, strictMode = false, cdnConfig)
 }
 // src/server.ts
 import fs from "fs";
-import path3 from "path";
+import path4 from "path";
 
 // src/config.ts
-import path2 from "path";
+import path3 from "path";
 var PROJECT_ROOT = process.cwd();
 var ALLOWED_CONFIG_EXTS = [".ts", ".js", ".mjs", ".cjs", ".json"];
 function isSafeConfigPath(p) {
   try {
-    const normalized = path2.resolve(p);
-    if (!ALLOWED_CONFIG_EXTS.includes(path2.extname(normalized)))
+    const normalized = path3.resolve(p);
+    if (!ALLOWED_CONFIG_EXTS.includes(path3.extname(normalized)))
       return false;
     if (!normalized.startsWith(PROJECT_ROOT))
       return false;
@@ -31006,16 +31069,16 @@ function isSafeConfigPath(p) {
     return false;
   }
 }
-var DEFAULT_CONTENT_DIR = path2.join(process.cwd(), "content");
-var DEFAULT_OUTPUT_DIR = path2.join(process.cwd(), "dist");
-var DEFAULT_TEMPLATES_DIR = path2.join(process.cwd(), "templates");
-var DEFAULT_CONFIG_TS = path2.join(process.cwd(), "bunki.config.ts");
+var DEFAULT_CONTENT_DIR = path3.join(process.cwd(), "content");
+var DEFAULT_OUTPUT_DIR = path3.join(process.cwd(), "dist");
+var DEFAULT_TEMPLATES_DIR = path3.join(process.cwd(), "templates");
+var DEFAULT_CONFIG_TS = path3.join(process.cwd(), "bunki.config.ts");
 var DEFAULT_CONFIG_FILE = DEFAULT_CONFIG_TS;
 async function configExists(configPath = DEFAULT_CONFIG_FILE) {
   return await Bun.file(configPath).exists();
 }
 async function loadConfig(configPath = DEFAULT_CONFIG_FILE) {
-  const resolved = path2.isAbsolute(configPath) ? configPath : path2.join(PROJECT_ROOT, configPath);
+  const resolved = path3.isAbsolute(configPath) ? configPath : path3.join(PROJECT_ROOT, configPath);
   if (!isSafeConfigPath(resolved)) {
     throw new Error("Unsafe config path: must be within project directory");
   }
@@ -31150,18 +31213,18 @@ async function startServer(outputDir = DEFAULT_OUTPUT_DIR, port = 3000) {
         let filePath = "";
         if (homePaginationMatch) {
           const pageNumber = homePaginationMatch[1];
-          filePath = path3.join(outputDir, "page", pageNumber, "index.html");
+          filePath = path4.join(outputDir, "page", pageNumber, "index.html");
         } else if (tagPaginationMatch) {
           const tagSlug = tagPaginationMatch[1];
           const pageNumber = tagPaginationMatch[2];
-          filePath = path3.join(outputDir, "tags", tagSlug, "page", pageNumber, "index.html");
+          filePath = path4.join(outputDir, "tags", tagSlug, "page", pageNumber, "index.html");
         } else if (yearPaginationMatch) {
           const year = yearPaginationMatch[1];
           const pageNumber = yearPaginationMatch[2];
-          filePath = path3.join(outputDir, year, "page", pageNumber, "index.html");
+          filePath = path4.join(outputDir, year, "page", pageNumber, "index.html");
         } else {
-          const directPath = path3.join(outputDir, pathname);
-          const withoutSlash = path3.join(outputDir, pathname + ".html");
+          const directPath = path4.join(outputDir, pathname);
+          const withoutSlash = path4.join(outputDir, pathname + ".html");
           const withHtml = pathname.endsWith(".html") ? directPath : withoutSlash;
           const bunFileDirect = Bun.file(directPath);
           const bunFileHtml = Bun.file(withHtml);
@@ -31170,7 +31233,7 @@ async function startServer(outputDir = DEFAULT_OUTPUT_DIR, port = 3000) {
           } else if (await bunFileHtml.exists()) {
             filePath = withHtml;
           } else {
-            const indexPath = path3.join(outputDir, pathname, "index.html");
+            const indexPath = path4.join(outputDir, pathname, "index.html");
             const bunFileIndex = Bun.file(indexPath);
             if (await bunFileIndex.exists()) {
               filePath = indexPath;
@@ -31184,7 +31247,7 @@ async function startServer(outputDir = DEFAULT_OUTPUT_DIR, port = 3000) {
           }
         }
         console.log(`Serving file: ${filePath}`);
-        const extname = path3.extname(filePath);
+        const extname = path4.extname(filePath);
         let contentType = "text/html";
         switch (extname) {
           case ".js":
@@ -31239,12 +31302,12 @@ var import_nunjucks = __toESM(require_nunjucks(), 1);
 var import_slugify = __toESM(require_slugify(), 1);
 var {Glob: Glob2 } = globalThis.Bun;
 import fs3 from "fs";
-import path5 from "path";
+import path6 from "path";
 
 // src/utils/css-processor.ts
 import { spawn } from "child_process";
 import fs2 from "fs";
-import path4 from "path";
+import path5 from "path";
 async function processCSS(options2) {
   const { css, projectRoot, outputDir, verbose = false } = options2;
   if (!css.enabled) {
@@ -31253,15 +31316,15 @@ async function processCSS(options2) {
     }
     return;
   }
-  const inputPath = path4.resolve(projectRoot, css.input);
-  const outputPath = path4.resolve(outputDir, css.output);
-  const postcssConfigPath = css.postcssConfig ? path4.resolve(projectRoot, css.postcssConfig) : path4.resolve(projectRoot, "postcss.config.js");
+  const inputPath = path5.resolve(projectRoot, css.input);
+  const outputPath = path5.resolve(outputDir, css.output);
+  const postcssConfigPath = css.postcssConfig ? path5.resolve(projectRoot, css.postcssConfig) : path5.resolve(projectRoot, "postcss.config.js");
   try {
     await fs2.promises.access(inputPath);
   } catch (error) {
     throw new Error(`CSS input file not found: ${inputPath}`);
   }
-  const outputDirPath = path4.dirname(outputPath);
+  const outputDirPath = path5.dirname(outputPath);
   await fs2.promises.mkdir(outputDirPath, { recursive: true });
   if (verbose) {
     console.log("\uD83C\uDFA8 Building CSS with PostCSS...");
@@ -31565,7 +31628,7 @@ class SiteGenerator {
       setNoFollowExceptions(this.options.config.noFollowExceptions);
     }
     let tagDescriptions = {};
-    const tagsTomlPath = path5.join(process.cwd(), "src", "tags.toml");
+    const tagsTomlPath = path6.join(process.cwd(), "src", "tags.toml");
     const tagsTomlFile = Bun.file(tagsTomlPath);
     if (await tagsTomlFile.exists()) {
       try {
@@ -31633,7 +31696,7 @@ class SiteGenerator {
       const notFoundHtml = import_nunjucks.default.render("404.njk", {
         site: this.options.config
       });
-      await Bun.write(path5.join(this.options.outputDir, "404.html"), notFoundHtml);
+      await Bun.write(path6.join(this.options.outputDir, "404.html"), notFoundHtml);
       console.log("Generated 404.html");
     } catch (error) {
       if (error instanceof Error && error.message.includes("404.njk")) {
@@ -31645,7 +31708,7 @@ class SiteGenerator {
   }
   async generateYearArchives() {
     for (const [year, yearPosts] of Object.entries(this.site.postsByYear)) {
-      const yearDir = path5.join(this.options.outputDir, year);
+      const yearDir = path6.join(this.options.outputDir, year);
       await ensureDir(yearDir);
       const pageSize = 10;
       const totalPages = Math.ceil(yearPosts.length / pageSize);
@@ -31684,11 +31747,11 @@ class SiteGenerator {
           jsonLd
         });
         if (page === 1) {
-          await Bun.write(path5.join(yearDir, "index.html"), yearPageHtml);
+          await Bun.write(path6.join(yearDir, "index.html"), yearPageHtml);
         } else {
-          const pageDir = path5.join(yearDir, "page", page.toString());
+          const pageDir = path6.join(yearDir, "page", page.toString());
           await ensureDir(pageDir);
-          await Bun.write(path5.join(pageDir, "index.html"), yearPageHtml);
+          await Bun.write(path6.join(pageDir, "index.html"), yearPageHtml);
         }
       }
     }
@@ -31718,18 +31781,18 @@ class SiteGenerator {
         noindex: page > 2
       });
       if (page === 1) {
-        await Bun.write(path5.join(this.options.outputDir, "index.html"), pageHtml);
+        await Bun.write(path6.join(this.options.outputDir, "index.html"), pageHtml);
       } else {
-        const pageDir = path5.join(this.options.outputDir, "page", page.toString());
+        const pageDir = path6.join(this.options.outputDir, "page", page.toString());
         await ensureDir(pageDir);
-        await Bun.write(path5.join(pageDir, "index.html"), pageHtml);
+        await Bun.write(path6.join(pageDir, "index.html"), pageHtml);
       }
     }
   }
   async generatePostPages() {
     for (const post of this.site.posts) {
       const postPath = post.url.substring(1);
-      const postDir = path5.join(this.options.outputDir, postPath);
+      const postDir = path6.join(this.options.outputDir, postPath);
       await ensureDir(postDir);
       const imageUrl = extractFirstImageUrl(post.html, this.options.config.baseUrl);
       const schemas = generatePostPageSchemas({
@@ -31744,19 +31807,19 @@ class SiteGenerator {
         post,
         jsonLd
       });
-      await Bun.write(path5.join(postDir, "index.html"), postHtml);
+      await Bun.write(path6.join(postDir, "index.html"), postHtml);
     }
   }
   async generateTagPages() {
-    const tagsDir = path5.join(this.options.outputDir, "tags");
+    const tagsDir = path6.join(this.options.outputDir, "tags");
     await ensureDir(tagsDir);
     const tagIndexHtml = import_nunjucks.default.render("tags.njk", {
       site: this.options.config,
       tags: this.getSortedTags()
     });
-    await Bun.write(path5.join(tagsDir, "index.html"), tagIndexHtml);
+    await Bun.write(path6.join(tagsDir, "index.html"), tagIndexHtml);
     for (const [tagName, tagData] of Object.entries(this.site.tags)) {
-      const tagDir = path5.join(tagsDir, tagData.slug);
+      const tagDir = path6.join(tagsDir, tagData.slug);
       await ensureDir(tagDir);
       const pageSize = 10;
       const totalPages = Math.ceil(tagData.posts.length / pageSize);
@@ -31799,24 +31862,24 @@ class SiteGenerator {
           jsonLd
         });
         if (page === 1) {
-          await Bun.write(path5.join(tagDir, "index.html"), tagPageHtml);
+          await Bun.write(path6.join(tagDir, "index.html"), tagPageHtml);
         } else {
-          const pageDir = path5.join(tagDir, "page", page.toString());
+          const pageDir = path6.join(tagDir, "page", page.toString());
           await ensureDir(pageDir);
-          await Bun.write(path5.join(pageDir, "index.html"), tagPageHtml);
+          await Bun.write(path6.join(pageDir, "index.html"), tagPageHtml);
         }
       }
     }
   }
   async generateMapPage() {
     try {
-      const mapDir = path5.join(this.options.outputDir, "map");
+      const mapDir = path6.join(this.options.outputDir, "map");
       await ensureDir(mapDir);
       const mapHtml = import_nunjucks.default.render("map.njk", {
         site: this.options.config,
         posts: this.site.posts
       });
-      await Bun.write(path5.join(mapDir, "index.html"), mapHtml);
+      await Bun.write(path6.join(mapDir, "index.html"), mapHtml);
       console.log("Generated map page");
     } catch (error) {
       if (error instanceof Error && error.message.includes("map.njk")) {
@@ -31846,7 +31909,7 @@ class SiteGenerator {
     }
   }
   async fallbackCSSGeneration(cssConfig) {
-    const cssFilePath = path5.resolve(process.cwd(), cssConfig.input);
+    const cssFilePath = path6.resolve(process.cwd(), cssConfig.input);
     const cssFile = Bun.file(cssFilePath);
     if (!await cssFile.exists()) {
       console.warn(`CSS input file not found: ${cssFilePath}`);
@@ -31854,8 +31917,8 @@ class SiteGenerator {
     }
     try {
       const cssContent = await cssFile.text();
-      const outputPath = path5.resolve(this.options.outputDir, cssConfig.output);
-      const outputDir = path5.dirname(outputPath);
+      const outputPath = path6.resolve(this.options.outputDir, cssConfig.output);
+      const outputDir = path6.dirname(outputPath);
       await ensureDir(outputDir);
       await Bun.write(outputPath, cssContent);
       console.log("\u2705 CSS file copied successfully (fallback mode)");
@@ -31864,8 +31927,8 @@ class SiteGenerator {
     }
   }
   async copyStaticAssets() {
-    const assetsDir = path5.join(this.options.templatesDir, "assets");
-    const publicDir = path5.join(process.cwd(), "public");
+    const assetsDir = path6.join(this.options.templatesDir, "assets");
+    const publicDir = path6.join(process.cwd(), "public");
     async function dirExists(p) {
       try {
         const stat = await fs3.promises.stat(p);
@@ -31877,15 +31940,15 @@ class SiteGenerator {
     const assetsDirFile = Bun.file(assetsDir);
     if (await assetsDirFile.exists() && await dirExists(assetsDir)) {
       const assetGlob = new Glob2("**/*.*");
-      const assetsOutputDir = path5.join(this.options.outputDir, "assets");
+      const assetsOutputDir = path6.join(this.options.outputDir, "assets");
       await ensureDir(assetsOutputDir);
       for await (const file of assetGlob.scan({
         cwd: assetsDir,
         absolute: true
       })) {
-        const relativePath = path5.relative(assetsDir, file);
-        const targetPath = path5.join(assetsOutputDir, relativePath);
-        const targetDir = path5.dirname(targetPath);
+        const relativePath = path6.relative(assetsDir, file);
+        const targetPath = path6.join(assetsOutputDir, relativePath);
+        const targetDir = path6.dirname(targetPath);
         await ensureDir(targetDir);
         await copyFile(file, targetPath);
       }
@@ -31896,9 +31959,9 @@ class SiteGenerator {
           withFileTypes: true
         });
         for (const entry of entries) {
-          const srcPath = path5.join(srcDir, entry.name);
-          const relativePath = path5.relative(publicDir, srcPath);
-          const destPath = path5.join(this.options.outputDir, relativePath);
+          const srcPath = path6.join(srcDir, entry.name);
+          const relativePath = path6.relative(publicDir, srcPath);
+          const destPath = path6.join(this.options.outputDir, relativePath);
           if (!relativePath)
             continue;
           if (entry.isDirectory()) {
@@ -31907,7 +31970,7 @@ class SiteGenerator {
           } else if (entry.isFile()) {
             const targetFile = Bun.file(destPath);
             if (!await targetFile.exists()) {
-              const targetDir = path5.dirname(destPath);
+              const targetDir = path6.dirname(destPath);
               await ensureDir(targetDir);
               await copyFile(srcPath, destPath);
             }
@@ -32007,7 +32070,7 @@ ${channelXml}
 ${rssItems}
   </channel>
 </rss>`;
-    await Bun.write(path5.join(this.options.outputDir, "feed.xml"), rssContent);
+    await Bun.write(path6.join(this.options.outputDir, "feed.xml"), rssContent);
   }
   async generateSitemap() {
     const currentDate = toPacificTime(new Date).toISOString();
@@ -32126,7 +32189,7 @@ ${rssItems}
       }
     }
     sitemapContent += `</urlset>`;
-    await Bun.write(path5.join(this.options.outputDir, "sitemap.xml"), sitemapContent);
+    await Bun.write(path6.join(this.options.outputDir, "sitemap.xml"), sitemapContent);
     console.log("Generated sitemap.xml");
     const urlCount = this.site.posts.length + Object.keys(this.site.tags).length + 10;
     const sitemapSize = sitemapContent.length;
@@ -32146,7 +32209,7 @@ ${rssItems}
   </sitemap>
 `;
     sitemapIndexContent += `</sitemapindex>`;
-    await Bun.write(path5.join(this.options.outputDir, "sitemap_index.xml"), sitemapIndexContent);
+    await Bun.write(path6.join(this.options.outputDir, "sitemap_index.xml"), sitemapIndexContent);
     console.log("Generated sitemap_index.xml");
   }
   async generateRobotsTxt() {
@@ -32168,16 +32231,16 @@ Sitemap: ${config.baseUrl}/sitemap.xml
 # Disallow: /admin/
 # Disallow: /api/
 `;
-    await Bun.write(path5.join(this.options.outputDir, "robots.txt"), robotsTxtContent);
+    await Bun.write(path6.join(this.options.outputDir, "robots.txt"), robotsTxtContent);
     console.log("Generated robots.txt");
   }
 }
 // src/utils/image-uploader.ts
-import path7 from "path";
+import path8 from "path";
 
 // src/utils/s3-uploader.ts
 var {S3Client } = globalThis.Bun;
-import path6 from "path";
+import path7 from "path";
 
 class S3Uploader {
   s3Config;
@@ -32300,8 +32363,8 @@ class S3Uploader {
       let failedCount = 0;
       const uploadTasks = imageFiles.map((imageFile) => async () => {
         try {
-          const imagePath = path6.join(imagesDir, imageFile);
-          const filename = path6.basename(imagePath);
+          const imagePath = path7.join(imagesDir, imageFile);
+          const filename = path7.basename(imagePath);
           const file = Bun.file(imagePath);
           const contentType = file.type;
           if (process.env.BUNKI_DRY_RUN === "true") {} else {
@@ -32335,10 +32398,10 @@ function createUploader(config) {
 }
 
 // src/utils/image-uploader.ts
-var DEFAULT_IMAGES_DIR = path7.join(process.cwd(), "assets");
+var DEFAULT_IMAGES_DIR = path8.join(process.cwd(), "assets");
 async function uploadImages(options2 = {}) {
   try {
-    const imagesDir = path7.resolve(options2.images || DEFAULT_IMAGES_DIR);
+    const imagesDir = path8.resolve(options2.images || DEFAULT_IMAGES_DIR);
     if (!await fileExists(imagesDir)) {
       console.log(`Creating images directory at ${imagesDir}...`);
       await ensureDir(imagesDir);
@@ -32375,7 +32438,7 @@ async function uploadImages(options2 = {}) {
     const uploader = createUploader(s3Config);
     const imageUrlMap = await uploader.uploadImages(imagesDir, options2.minYear);
     if (options2.outputJson) {
-      const outputFile = path7.resolve(options2.outputJson);
+      const outputFile = path8.resolve(options2.outputJson);
       await Bun.write(outputFile, JSON.stringify(imageUrlMap, null, 2));
       console.log(`Image URL mapping saved to ${outputFile}`);
     }