@absolutejs/absolute 0.15.0 → 0.15.2

package/dist/index.js

@@ -1,5 +1,21 @@
 // @bun
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
 var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __toESM = (mod, isNodeMode, target) => {
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  for (let key of __getOwnPropNames(mod))
+    if (!__hasOwnProp.call(to, key))
+      __defProp(to, key, {
+        get: () => mod[key],
+        enumerable: true
+      });
+  return to;
+};
+var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, {
@@ -42,6 +58,7 @@ __export(exports_compileVue, {
   compileVue: () => compileVue,
   clearVueHmrCaches: () => clearVueHmrCaches
 });
+import { existsSync as existsSync2 } from "fs";
 import { mkdir as mkdir2 } from "fs/promises";
 import { basename as basename2, dirname as dirname2, join as join2, relative as relative2, resolve as resolve2 } from "path";
 import {
@@ -51,7 +68,7 @@ import {
   compileStyle
 } from "@vue/compiler-sfc";
 var {file: file2, write: write2, Transpiler: Transpiler2 } = globalThis.Bun;
-var hmrClientPath2, transpiler2, scriptCache, scriptSetupCache, templateCache, styleCache, vueHmrMetadata, detectVueChangeType = (filePath, descriptor) => {
+var devClientDir2, hmrClientPath2, transpiler2, scriptCache, scriptSetupCache, templateCache, styleCache, vueHmrMetadata, detectVueChangeType = (filePath, descriptor) => {
   const prevScript = scriptCache.get(filePath);
   const prevScriptSetup = scriptSetupCache.get(filePath);
   const prevTemplate = templateCache.get(filePath);
@@ -347,7 +364,13 @@ if (typeof __VUE_HMR_RUNTIME__ !== 'undefined') {
   };
 };
 var init_compileVue = __esm(() => {
-  hmrClientPath2 = resolve2(import.meta.dir, "../dev/client/hmrClient.ts").replace(/\\/g, "/");
+  devClientDir2 = (() => {
+    const fromSource = resolve2(import.meta.dir, "../dev/client");
+    if (existsSync2(fromSource))
+      return fromSource;
+    return resolve2(import.meta.dir, "./dev/client");
+  })();
+  hmrClientPath2 = join2(devClientDir2, "hmrClient.ts").replace(/\\/g, "/");
   transpiler2 = new Transpiler2({ loader: "ts", target: "browser" });
   scriptCache = new Map;
   scriptSetupCache = new Map;
@@ -356,17 +379,264 @@ var init_compileVue = __esm(() => {
   vueHmrMetadata = new Map;
 });
 
+// node_modules/react-refresh/cjs/react-refresh-runtime.development.js
+var require_react_refresh_runtime_development = __commonJS((exports) => {
+  (function() {
+    function computeFullKey(signature) {
+      if (signature.fullKey !== null)
+        return signature.fullKey;
+      var fullKey = signature.ownKey;
+      try {
+        var hooks = signature.getCustomHooks();
+      } catch (err) {
+        return signature.forceReset = true, signature.fullKey = fullKey;
+      }
+      for (var i = 0;i < hooks.length; i++) {
+        var hook = hooks[i];
+        if (typeof hook !== "function")
+          return signature.forceReset = true, signature.fullKey = fullKey;
+        hook = allSignaturesByType.get(hook);
+        if (hook !== undefined) {
+          var nestedHookKey = computeFullKey(hook);
+          hook.forceReset && (signature.forceReset = true);
+          fullKey += `
+---
+` + nestedHookKey;
+        }
+      }
+      return signature.fullKey = fullKey;
+    }
+    function resolveFamily(type) {
+      return updatedFamiliesByType.get(type);
+    }
+    function cloneMap(map) {
+      var clone = new Map;
+      map.forEach(function(value, key) {
+        clone.set(key, value);
+      });
+      return clone;
+    }
+    function cloneSet(set) {
+      var clone = new Set;
+      set.forEach(function(value) {
+        clone.add(value);
+      });
+      return clone;
+    }
+    function getProperty(object, property) {
+      try {
+        return object[property];
+      } catch (err) {}
+    }
+    function register(type, id) {
+      if (!(type === null || typeof type !== "function" && typeof type !== "object" || allFamiliesByType.has(type))) {
+        var family = allFamiliesByID.get(id);
+        family === undefined ? (family = { current: type }, allFamiliesByID.set(id, family)) : pendingUpdates.push([family, type]);
+        allFamiliesByType.set(type, family);
+        if (typeof type === "object" && type !== null)
+          switch (getProperty(type, "$$typeof")) {
+            case REACT_FORWARD_REF_TYPE:
+              register(type.render, id + "$render");
+              break;
+            case REACT_MEMO_TYPE:
+              register(type.type, id + "$type");
+          }
+      }
+    }
+    function setSignature(type, key) {
+      var forceReset = 2 < arguments.length && arguments[2] !== undefined ? arguments[2] : false, getCustomHooks = 3 < arguments.length ? arguments[3] : undefined;
+      allSignaturesByType.has(type) || allSignaturesByType.set(type, {
+        forceReset,
+        ownKey: key,
+        fullKey: null,
+        getCustomHooks: getCustomHooks || function() {
+          return [];
+        }
+      });
+      if (typeof type === "object" && type !== null)
+        switch (getProperty(type, "$$typeof")) {
+          case REACT_FORWARD_REF_TYPE:
+            setSignature(type.render, key, forceReset, getCustomHooks);
+            break;
+          case REACT_MEMO_TYPE:
+            setSignature(type.type, key, forceReset, getCustomHooks);
+        }
+    }
+    function collectCustomHooksForSignature(type) {
+      type = allSignaturesByType.get(type);
+      type !== undefined && computeFullKey(type);
+    }
+    var REACT_FORWARD_REF_TYPE = Symbol.for("react.forward_ref"), REACT_MEMO_TYPE = Symbol.for("react.memo"), PossiblyWeakMap = typeof WeakMap === "function" ? WeakMap : Map, allFamiliesByID = new Map, allFamiliesByType = new PossiblyWeakMap, allSignaturesByType = new PossiblyWeakMap, updatedFamiliesByType = new PossiblyWeakMap, pendingUpdates = [], helpersByRendererID = new Map, helpersByRoot = new Map, mountedRoots = new Set, failedRoots = new Set, rootElements = typeof WeakMap === "function" ? new WeakMap : null, isPerformingRefresh = false;
+    exports._getMountedRootCount = function() {
+      return mountedRoots.size;
+    };
+    exports.collectCustomHooksForSignature = collectCustomHooksForSignature;
+    exports.createSignatureFunctionForTransform = function() {
+      var savedType, hasCustomHooks, didCollectHooks = false;
+      return function(type, key, forceReset, getCustomHooks) {
+        if (typeof key === "string")
+          return savedType || (savedType = type, hasCustomHooks = typeof getCustomHooks === "function"), type == null || typeof type !== "function" && typeof type !== "object" || setSignature(type, key, forceReset, getCustomHooks), type;
+        !didCollectHooks && hasCustomHooks && (didCollectHooks = true, collectCustomHooksForSignature(savedType));
+      };
+    };
+    exports.getFamilyByID = function(id) {
+      return allFamiliesByID.get(id);
+    };
+    exports.getFamilyByType = function(type) {
+      return allFamiliesByType.get(type);
+    };
+    exports.hasUnrecoverableErrors = function() {
+      return false;
+    };
+    exports.injectIntoGlobalHook = function(globalObject) {
+      var hook = globalObject.__REACT_DEVTOOLS_GLOBAL_HOOK__;
+      if (hook === undefined) {
+        var nextID = 0;
+        globalObject.__REACT_DEVTOOLS_GLOBAL_HOOK__ = hook = {
+          renderers: new Map,
+          supportsFiber: true,
+          inject: function() {
+            return nextID++;
+          },
+          onScheduleFiberRoot: function() {},
+          onCommitFiberRoot: function() {},
+          onCommitFiberUnmount: function() {}
+        };
+      }
+      if (hook.isDisabled)
+        console.warn("Something has shimmed the React DevTools global hook (__REACT_DEVTOOLS_GLOBAL_HOOK__). Fast Refresh is not compatible with this shim and will be disabled.");
+      else {
+        var oldInject = hook.inject;
+        hook.inject = function(injected) {
+          var id = oldInject.apply(this, arguments);
+          typeof injected.scheduleRefresh === "function" && typeof injected.setRefreshHandler === "function" && helpersByRendererID.set(id, injected);
+          return id;
+        };
+        hook.renderers.forEach(function(injected, id) {
+          typeof injected.scheduleRefresh === "function" && typeof injected.setRefreshHandler === "function" && helpersByRendererID.set(id, injected);
+        });
+        var oldOnCommitFiberRoot = hook.onCommitFiberRoot, oldOnScheduleFiberRoot = hook.onScheduleFiberRoot || function() {};
+        hook.onScheduleFiberRoot = function(id, root, children) {
+          isPerformingRefresh || (failedRoots.delete(root), rootElements !== null && rootElements.set(root, children));
+          return oldOnScheduleFiberRoot.apply(this, arguments);
+        };
+        hook.onCommitFiberRoot = function(id, root, maybePriorityLevel, didError) {
+          var helpers = helpersByRendererID.get(id);
+          if (helpers !== undefined) {
+            helpersByRoot.set(root, helpers);
+            helpers = root.current;
+            var alternate = helpers.alternate;
+            alternate !== null ? (alternate = alternate.memoizedState != null && alternate.memoizedState.element != null && mountedRoots.has(root), helpers = helpers.memoizedState != null && helpers.memoizedState.element != null, !alternate && helpers ? (mountedRoots.add(root), failedRoots.delete(root)) : alternate && helpers || (alternate && !helpers ? (mountedRoots.delete(root), didError ? failedRoots.add(root) : helpersByRoot.delete(root)) : alternate || helpers || didError && failedRoots.add(root))) : mountedRoots.add(root);
+          }
+          return oldOnCommitFiberRoot.apply(this, arguments);
+        };
+      }
+    };
+    exports.isLikelyComponentType = function(type) {
+      switch (typeof type) {
+        case "function":
+          if (type.prototype != null) {
+            if (type.prototype.isReactComponent)
+              return true;
+            var ownNames = Object.getOwnPropertyNames(type.prototype);
+            if (1 < ownNames.length || ownNames[0] !== "constructor" || type.prototype.__proto__ !== Object.prototype)
+              return false;
+          }
+          type = type.name || type.displayName;
+          return typeof type === "string" && /^[A-Z]/.test(type);
+        case "object":
+          if (type != null)
+            switch (getProperty(type, "$$typeof")) {
+              case REACT_FORWARD_REF_TYPE:
+              case REACT_MEMO_TYPE:
+                return true;
+            }
+          return false;
+        default:
+          return false;
+      }
+    };
+    exports.performReactRefresh = function() {
+      if (pendingUpdates.length === 0 || isPerformingRefresh)
+        return null;
+      isPerformingRefresh = true;
+      try {
+        var staleFamilies = new Set, updatedFamilies = new Set, updates = pendingUpdates;
+        pendingUpdates = [];
+        updates.forEach(function(_ref) {
+          var family = _ref[0];
+          _ref = _ref[1];
+          var prevType = family.current;
+          updatedFamiliesByType.set(prevType, family);
+          updatedFamiliesByType.set(_ref, family);
+          family.current = _ref;
+          prevType.prototype && prevType.prototype.isReactComponent || _ref.prototype && _ref.prototype.isReactComponent ? _ref = false : (prevType = allSignaturesByType.get(prevType), _ref = allSignaturesByType.get(_ref), _ref = prevType === undefined && _ref === undefined || prevType !== undefined && _ref !== undefined && computeFullKey(prevType) === computeFullKey(_ref) && !_ref.forceReset ? true : false);
+          _ref ? updatedFamilies.add(family) : staleFamilies.add(family);
+        });
+        var update = {
+          updatedFamilies,
+          staleFamilies
+        };
+        helpersByRendererID.forEach(function(helpers) {
+          helpers.setRefreshHandler(resolveFamily);
+        });
+        var didError = false, firstError = null, failedRootsSnapshot = cloneSet(failedRoots), mountedRootsSnapshot = cloneSet(mountedRoots), helpersByRootSnapshot = cloneMap(helpersByRoot);
+        failedRootsSnapshot.forEach(function(root) {
+          var helpers = helpersByRootSnapshot.get(root);
+          if (helpers === undefined)
+            throw Error("Could not find helpers for a root. This is a bug in React Refresh.");
+          failedRoots.has(root);
+          if (rootElements !== null && rootElements.has(root)) {
+            var element = rootElements.get(root);
+            try {
+              helpers.scheduleRoot(root, element);
+            } catch (err) {
+              didError || (didError = true, firstError = err);
+            }
+          }
+        });
+        mountedRootsSnapshot.forEach(function(root) {
+          var helpers = helpersByRootSnapshot.get(root);
+          if (helpers === undefined)
+            throw Error("Could not find helpers for a root. This is a bug in React Refresh.");
+          mountedRoots.has(root);
+          try {
+            helpers.scheduleRefresh(root, update);
+          } catch (err) {
+            didError || (didError = true, firstError = err);
+          }
+        });
+        if (didError)
+          throw firstError;
+        return update;
+      } finally {
+        isPerformingRefresh = false;
+      }
+    };
+    exports.register = register;
+    exports.setSignature = setSignature;
+  })();
+});
+
+// node_modules/react-refresh/runtime.js
+var require_runtime = __commonJS((exports, module) => {
+  var react_refresh_runtime_development = __toESM(require_react_refresh_runtime_development());
+  if (false) {} else {
+    module.exports = react_refresh_runtime_development;
+  }
+});
+
 // src/dev/simpleHTMLHMR.ts
 var exports_simpleHTMLHMR = {};
 __export(exports_simpleHTMLHMR, {
   handleHTMLUpdate: () => handleHTMLUpdate
 });
-import { readFileSync as readFileSync4, existsSync as existsSync3 } from "fs";
+import { readFileSync as readFileSync4, existsSync as existsSync6 } from "fs";
 import { resolve as resolve13 } from "path";
 var handleHTMLUpdate = async (htmlFilePath) => {
   try {
     const resolvedPath = resolve13(htmlFilePath);
-    if (!existsSync3(resolvedPath)) {
+    if (!existsSync6(resolvedPath)) {
       return null;
     }
     const htmlContent = readFileSync4(resolvedPath, "utf-8");
@@ -648,12 +918,12 @@ var exports_simpleHTMXHMR = {};
 __export(exports_simpleHTMXHMR, {
   handleHTMXUpdate: () => handleHTMXUpdate
 });
-import { readFileSync as readFileSync5, existsSync as existsSync4 } from "fs";
+import { readFileSync as readFileSync5, existsSync as existsSync7 } from "fs";
 import { resolve as resolve16 } from "path";
 var handleHTMXUpdate = async (htmxFilePath) => {
   try {
     const resolvedPath = resolve16(htmxFilePath);
-    if (!existsSync4(resolvedPath)) {
+    if (!existsSync7(resolvedPath)) {
       return null;
     }
     const htmlContent = readFileSync5(resolvedPath, "utf-8");
@@ -722,6 +992,7 @@ import { cwd, env as env2, exit } from "process";
 var {$, build: bunBuild2, Glob: Glob3 } = globalThis.Bun;
 
 // src/build/compileSvelte.ts
+import { existsSync } from "fs";
 import { mkdir, stat } from "fs/promises";
 import {
   dirname,
@@ -735,7 +1006,13 @@ import {
 import { env } from "process";
 var {write, file, Transpiler } = globalThis.Bun;
 import { compile, compileModule, preprocess } from "svelte/compiler";
-var hmrClientPath = resolve(import.meta.dir, "../dev/client/hmrClient.ts").replace(/\\/g, "/");
+var devClientDir = (() => {
+  const fromSource = resolve(import.meta.dir, "../dev/client");
+  if (existsSync(fromSource))
+    return fromSource;
+  return resolve(import.meta.dir, "./dev/client");
+})();
+var hmrClientPath = join(devClientDir, "hmrClient.ts").replace(/\\/g, "/");
 var transpiler = new Transpiler({ loader: "ts", target: "browser" });
 var exists = async (path) => {
   try {
@@ -935,12 +1212,19 @@ var generateManifest = (outputs, buildPath) => outputs.reduce((manifest, artifac
 }, {});
 
 // src/build/generateReactIndexes.ts
+import { existsSync as existsSync3 } from "fs";
 import { mkdir as mkdir3, rm, writeFile } from "fs/promises";
 import { basename as basename3, join as join3, resolve as resolve3 } from "path";
 var {Glob } = globalThis.Bun;
-var hmrClientPath3 = resolve3(import.meta.dir, "../dev/client/hmrClient.ts").replace(/\\/g, "/");
-var refreshSetupPath = resolve3(import.meta.dir, "../dev/client/reactRefreshSetup.ts").replace(/\\/g, "/");
-var generateReactIndexFiles = async (reactPagesDirectory, reactIndexesDirectory, isDev = false) => {
+var devClientDir3 = (() => {
+  const fromSource = resolve3(import.meta.dir, "../dev/client");
+  if (existsSync3(fromSource))
+    return fromSource;
+  return resolve3(import.meta.dir, "./dev/client");
+})();
+var hmrClientPath3 = join3(devClientDir3, "hmrClient.ts").replace(/\\/g, "/");
+var refreshSetupPath = join3(devClientDir3, "reactRefreshSetup.ts").replace(/\\/g, "/");
+var generateReactIndexFiles = async (reactPagesDirectory, reactIndexesDirectory, isDev = false, enableRefresh = false) => {
   await rm(reactIndexesDirectory, { force: true, recursive: true });
   await mkdir3(reactIndexesDirectory);
   const pagesGlob = new Glob("*.*");
@@ -954,7 +1238,7 @@ var generateReactIndexFiles = async (reactPagesDirectory, reactIndexesDirectory,
     const hmrPreamble = isDev ? [
       `window.__HMR_FRAMEWORK__ = "react";`,
       `window.__REACT_COMPONENT_KEY__ = "${componentName}Index";`,
-      `import '${refreshSetupPath}';`,
+      ...enableRefresh ? [`import '${refreshSetupPath}';`] : [],
       `import '${hmrClientPath3}';
 `
     ] : [];
@@ -1169,7 +1453,7 @@ var generateReactIndexFiles = async (reactPagesDirectory, reactIndexesDirectory,
     return writeFile(join3(reactIndexesDirectory, `${componentName}.tsx`), content);
   });
   await Promise.all(promises);
-  if (isDev) {
+  if (enableRefresh) {
     await writeFile(join3(reactIndexesDirectory, "_refresh.tsx"), `import 'react';
 import 'react-dom/client';
 `);
@@ -1450,6 +1734,14 @@ var validateSafePath = (targetPath, baseDirectory) => {
 
 // src/core/build.ts
 var isDev = env2.NODE_ENV !== "production";
+var hasReactRefresh = (() => {
+  try {
+    __require.resolve("/home/alexkahn/abs/absolutejs/node_modules/react-refresh/runtime.js");
+    return true;
+  } catch {
+    return false;
+  }
+})();
 var vueFeatureFlags = {
   __VUE_OPTIONS_API__: "true",
   __VUE_PROD_DEVTOOLS__: isDev ? "true" : "false",
@@ -1541,7 +1833,7 @@ var build2 = async ({
     return matchingEntries;
   };
   if (reactIndexesPath && reactPagesPath) {
-    await generateReactIndexFiles(reactPagesPath, reactIndexesPath, isDev);
+    await generateReactIndexFiles(reactPagesPath, reactIndexesPath, isDev, isDev && hasReactRefresh);
   }
   if (assetsPath && (!isIncremental || normalizedIncrementalFiles?.some((f) => f.includes("/assets/")))) {
     cpSync(assetsPath, join5(buildPath, "assets"), {
@@ -1635,7 +1927,7 @@ var build2 = async ({
   }
   let reactClientLogs = [];
   let reactClientOutputs = [];
-  if (isDev && reactIndexesPath && reactClientEntryPoints.length > 0) {
+  if (isDev && hasReactRefresh && reactIndexesPath && reactClientEntryPoints.length > 0) {
     const refreshEntry = join5(reactIndexesPath, "_refresh.tsx");
     if (!reactClientEntryPoints.includes(refreshEntry)) {
       reactClientEntryPoints.push(refreshEntry);
@@ -1653,7 +1945,7 @@ var build2 = async ({
       target: "browser",
       throw: false
     };
-    if (isDev) {
+    if (isDev && hasReactRefresh) {
       reactBuildConfig.reactFastRefresh = true;
     }
     const reactClientResult = await bunBuild2(reactBuildConfig);
@@ -1823,7 +2115,7 @@ import { statSync } from "fs";
 import { resolve as resolve18 } from "path";
 
 // src/dev/dependencyGraph.ts
-import { readFileSync as readFileSync2, readdirSync, existsSync } from "fs";
+import { readFileSync as readFileSync2, readdirSync, existsSync as existsSync4 } from "fs";
 import { resolve as resolve7 } from "path";
 var createDependencyGraph = () => ({
   dependencies: new Map,
@@ -1831,7 +2123,7 @@ var createDependencyGraph = () => ({
 });
 var extractDependencies = (filePath) => {
   try {
-    if (!existsSync(filePath)) {
+    if (!existsSync4(filePath)) {
       return [];
     }
     const content = readFileSync2(filePath, "utf-8");
@@ -1923,7 +2215,7 @@ var resolveImportPath = (importPath, fromFile) => {
 };
 var addFileToGraph = (graph, filePath) => {
   const normalizedPath = resolve7(filePath);
-  if (!existsSync(normalizedPath)) {
+  if (!existsSync4(normalizedPath)) {
     return;
   }
   const dependencies = extractDependencies(normalizedPath);
@@ -2023,7 +2315,7 @@ var buildInitialDependencyGraph = (graph, directories) => {
   };
   for (const dir of directories) {
     const resolvedDir = resolve7(dir);
-    if (existsSync(resolvedDir)) {
+    if (existsSync4(resolvedDir)) {
       scanDirectory(resolvedDir);
     }
   }
@@ -2105,7 +2397,7 @@ var incrementSourceFileVersions = (state, filePaths) => {
 
 // src/dev/fileWatcher.ts
 import { watch } from "fs";
-import { existsSync as existsSync2 } from "fs";
+import { existsSync as existsSync5 } from "fs";
 import { join as join6, resolve as resolve9 } from "path";
 
 // src/dev/pathUtils.ts
@@ -2222,7 +2514,7 @@ var startFileWatching = (state, config, onFileChange) => {
   const watchPaths = getWatchPaths(config, state.resolvedPaths);
   for (const path of watchPaths) {
     const absolutePath = resolve9(path).replace(/\\/g, "/");
-    if (!existsSync2(absolutePath)) {
+    if (!existsSync5(absolutePath)) {
       continue;
     }
     const watcher = watch(absolutePath, { recursive: true }, (event, filename) => {
@@ -2235,14 +2527,14 @@ var startFileWatching = (state, config, onFileChange) => {
       if (shouldIgnorePath(fullPath)) {
         return;
       }
-      if (event === "rename" && !existsSync2(fullPath)) {
+      if (event === "rename" && !existsSync5(fullPath)) {
         try {
           removeFileFromGraph(state.dependencyGraph, fullPath);
         } catch {}
         onFileChange(fullPath);
         return;
       }
-      if (existsSync2(fullPath)) {
+      if (existsSync5(fullPath)) {
         onFileChange(fullPath);
         try {
           addFileToGraph(state.dependencyGraph, fullPath);
@@ -2352,7 +2644,7 @@ var cleanStaleAssets = async (store, manifest, buildDir) => {
 var lookupAsset = (store, path) => store.get(path);
 
 // src/dev/rebuildTrigger.ts
-import { existsSync as existsSync5 } from "fs";
+import { existsSync as existsSync8 } from "fs";
 import { basename as basename8, resolve as resolve17 } from "path";
 
 // src/dev/fileHashTracker.ts
@@ -2663,13 +2955,13 @@ var queueFileChange = (state, filePath, config, onRebuildComplete) => {
       const validFiles = [];
       const processedFiles = new Set;
       for (const filePathInSet of filePathSet) {
-        if (!existsSync5(filePathInSet)) {
+        if (!existsSync8(filePathInSet)) {
           state.fileHashes.delete(filePathInSet);
           try {
             const affectedFiles = getAffectedFiles(state.dependencyGraph, filePathInSet);
             const deletedPathResolved = resolve17(filePathInSet);
             for (const affectedFile of affectedFiles) {
-              if (affectedFile !== deletedPathResolved && !processedFiles.has(affectedFile) && existsSync5(affectedFile)) {
+              if (affectedFile !== deletedPathResolved && !processedFiles.has(affectedFile) && existsSync8(affectedFile)) {
                 validFiles.push(affectedFile);
                 processedFiles.add(affectedFile);
               }
@@ -2690,7 +2982,7 @@ var queueFileChange = (state, filePath, config, onRebuildComplete) => {
           try {
             const dependents = state.dependencyGraph.dependents.get(normalizedFilePath);
             if (dependents && dependents.size > 0) {
-              const dependentFiles = Array.from(dependents).filter((f) => existsSync5(f));
+              const dependentFiles = Array.from(dependents).filter((f) => existsSync8(f));
               if (dependentFiles.length > 0) {
                 incrementSourceFileVersions(state, dependentFiles);
               }
@@ -2699,7 +2991,7 @@ var queueFileChange = (state, filePath, config, onRebuildComplete) => {
           try {
             const affectedFiles = getAffectedFiles(state.dependencyGraph, normalizedFilePath);
             for (const affectedFile of affectedFiles) {
-              if (!processedFiles.has(affectedFile) && affectedFile !== normalizedFilePath && existsSync5(affectedFile)) {
+              if (!processedFiles.has(affectedFile) && affectedFile !== normalizedFilePath && existsSync8(affectedFile)) {
                 validFiles.push(affectedFile);
                 processedFiles.add(affectedFile);
               }
@@ -3446,5 +3738,5 @@ export {
   BUN_BUILD_WARNING_SUPPRESSION
 };
 
-//# debugId=FE1A3F856A389BB564756E2164756E21
+//# debugId=0146B3AA5058A58F64756E2164756E21
 //# sourceMappingURL=index.js.map