@inertiajs/core 2.3.17 → 3.0.0-beta.2

package/dist/index.js

@@ -1,66 +1,8 @@
-"use strict";
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-// src/index.ts
-var index_exports = {};
-__export(index_exports, {
-  FormComponentResetSymbol: () => FormComponentResetSymbol,
-  UseFormUtils: () => UseFormUtils,
-  config: () => config,
-  createHeadManager: () => createHeadManager,
-  formDataToObject: () => formDataToObject,
-  getInitialPageFromDOM: () => getInitialPageFromDOM,
-  getScrollableParent: () => getScrollableParent,
-  hideProgress: () => hide2,
-  hrefToUrl: () => hrefToUrl,
-  isUrlMethodPair: () => isUrlMethodPair,
-  mergeDataIntoQueryString: () => mergeDataIntoQueryString,
-  objectToFormData: () => objectToFormData,
-  progress: () => progress,
-  resetFormFields: () => resetFormFields,
-  revealProgress: () => reveal,
-  router: () => router,
-  setupProgress: () => setupProgress,
-  shouldIntercept: () => shouldIntercept,
-  shouldNavigate: () => shouldNavigate,
-  urlHasProtocol: () => urlHasProtocol,
-  urlToString: () => urlToString,
-  urlWithoutHash: () => urlWithoutHash,
-  useInfiniteScroll: () => useInfiniteScroll
-});
-module.exports = __toCommonJS(index_exports);
-
 // src/router.ts
-var import_lodash_es5 = require("lodash-es");
+import { cloneDeep as cloneDeep3, get as get7, isEqual as isEqual3, set as set5 } from "lodash-es";
 
 // src/config.ts
-var import_lodash_es = require("lodash-es");
+import { get, has, set } from "lodash-es";
 var Config = class {
   constructor(defaults) {
     this.config = {};
@@ -76,14 +18,14 @@ var Config = class {
     this.config = newConfig;
   }
   get(key) {
-    return (0, import_lodash_es.has)(this.config, key) ? (0, import_lodash_es.get)(this.config, key) : (0, import_lodash_es.get)(this.defaults, key);
+    return has(this.config, key) ? get(this.config, key) : get(this.defaults, key);
   }
   set(keyOrValues, value) {
     if (typeof keyOrValues === "string") {
-      (0, import_lodash_es.set)(this.config, keyOrValues, value);
+      set(this.config, keyOrValues, value);
     } else {
       Object.entries(keyOrValues).forEach(([key, val]) => {
-        (0, import_lodash_es.set)(this.config, key, val);
+        set(this.config, key, val);
       });
     }
   }
@@ -94,18 +36,15 @@ var config = new Config({
     forceIndicesArrayFormatInFormData: true,
     withAllErrors: false
   },
-  future: {
-    preserveEqualProps: false,
-    useDataInertiaHeadAttribute: false,
-    useDialogForErrorModal: false,
-    useScriptElementForInitialPage: false
-  },
   prefetch: {
     cacheFor: 3e4,
     hoverDelay: 75
   }
 });
 
+// src/eventHandler.ts
+import { get as get4 } from "lodash-es";
+
 // src/debounce.ts
 function debounce(fn, delay) {
   let timeoutID;
@@ -125,14 +64,14 @@ var fireBeforeEvent = (visit) => {
 var fireErrorEvent = (errors) => {
   return fireEvent("error", { detail: { errors } });
 };
-var fireExceptionEvent = (exception) => {
-  return fireEvent("exception", { cancelable: true, detail: { exception } });
+var fireNetworkErrorEvent = (exception) => {
+  return fireEvent("networkError", { cancelable: true, detail: { exception } });
 };
 var fireFinishEvent = (visit) => {
   return fireEvent("finish", { detail: { visit } });
 };
-var fireInvalidEvent = (response) => {
-  return fireEvent("invalid", { cancelable: true, detail: { response } });
+var fireHttpExceptionEvent = (response) => {
+  return fireEvent("httpException", { cancelable: true, detail: { response } });
 };
 var fireBeforeUpdateEvent = (page2) => {
   return fireEvent("beforeUpdate", { detail: { page: page2 } });
@@ -150,7 +89,7 @@ var fireSuccessEvent = (page2) => {
   return fireEvent("success", { detail: { page: page2 } });
 };
 var firePrefetchedEvent = (response, visit) => {
-  return fireEvent("prefetched", { detail: { fetchedAt: Date.now(), response: response.data, visit } });
+  return fireEvent("prefetched", { detail: { fetchedAt: Date.now(), response, visit } });
 };
 var firePrefetchingEvent = (visit) => {
   return fireEvent("prefetching", { detail: { visit } });
@@ -160,7 +99,7 @@ var fireFlashEvent = (flash) => {
 };
 
 // src/history.ts
-var import_lodash_es3 = require("lodash-es");
+import { cloneDeep as cloneDeep2, isEqual } from "lodash-es";
 
 // src/sessionStorage.ts
 var SessionStorage = class {
@@ -331,8 +270,11 @@ var getKeyFromSessionStorage = async () => {
   return key;
 };
 
+// src/page.ts
+import { get as get3, set as set3 } from "lodash-es";
+
 // src/prefetched.ts
-var import_lodash_es2 = require("lodash-es");
+import { cloneDeep, get as get2 } from "lodash-es";
 
 // src/objectUtils.ts
 var objectsAreEqual = (obj1, obj2, excludeKeys) => {
@@ -564,7 +506,7 @@ var PrefetchedRequests = class {
     }) || null;
   }
   withoutPurposePrefetchHeader(params) {
-    const newParams = (0, import_lodash_es2.cloneDeep)(params);
+    const newParams = cloneDeep(params);
     if (newParams.headers["Purpose"] === "prefetch") {
       delete newParams.headers["Purpose"];
     }
@@ -593,7 +535,10 @@ var PrefetchedRequests = class {
         "onCancelToken",
         "onPrefetching",
         "async",
-        "viewTransition"
+        "viewTransition",
+        "optimistic",
+        "component",
+        "pageProps"
       ]
     );
   }
@@ -603,7 +548,7 @@ var PrefetchedRequests = class {
         const pageResponse = response.getPageResponse();
         page.mergeOncePropsIntoResponse(pageResponse, { force: true });
         for (const [group, deferredProps] of Object.entries(pageResponse.deferredProps ?? {})) {
-          const remaining = deferredProps.filter((prop) => pageResponse.props[prop] === void 0);
+          const remaining = deferredProps.filter((prop) => get2(pageResponse.props, prop) === void 0);
           if (remaining.length > 0) {
             pageResponse.deferredProps[group] = remaining;
           } else {
@@ -647,7 +592,7 @@ var elementInViewport = (el) => {
 var getScrollableParent = (element) => {
   const allowsVerticalScroll = (el) => {
     const computedStyle = window.getComputedStyle(el);
-    if (["scroll", "overlay"].includes(computedStyle.overflowY)) {
+    if (computedStyle.overflowY === "scroll") {
       return true;
     }
     if (computedStyle.overflowY !== "auto") {
@@ -660,7 +605,7 @@ var getScrollableParent = (element) => {
   };
   const allowsHorizontalScroll = (el) => {
     const computedStyle = window.getComputedStyle(el);
-    if (["scroll", "overlay"].includes(computedStyle.overflowX)) {
+    if (computedStyle.overflowX === "scroll") {
       return true;
     }
     if (computedStyle.overflowX !== "auto") {
@@ -736,16 +681,10 @@ var requestAnimationFrame = (cb, times = 1) => {
     }
   });
 };
-var getInitialPageFromDOM = (id, useScriptElement = false) => {
+var getInitialPageFromDOM = (id) => {
   if (typeof window === "undefined") {
     return null;
   }
-  if (!useScriptElement) {
-    const el = document.getElementById(id);
-    if (el?.dataset.page) {
-      return JSON.parse(el.dataset.page);
-    }
-  }
   const scriptEl = document.querySelector(`script[data-page="${id}"][type="application/json"]`);
   if (scriptEl?.textContent) {
     return JSON.parse(scriptEl.textContent);
@@ -844,9 +783,6 @@ var Scroll = class {
   }
 };
 
-// src/url.ts
-var qs = __toESM(require("qs"), 1);
-
 // src/files.ts
 var isFile = (value) => typeof File !== "undefined" && value instanceof File || value instanceof Blob || typeof FileList !== "undefined" && value instanceof FileList && value.length > 0;
 function hasFiles(data) {
@@ -893,6 +829,88 @@ function append(form, key, value, format) {
   objectToFormData(value, form, key, format);
 }
 
+// src/queryString.ts
+function hasIndices(url) {
+  return /\[\d+\]/.test(decodeURIComponent(url.search));
+}
+function parse(query) {
+  if (!query || query === "?") {
+    return {};
+  }
+  const result = {};
+  query.replace(/^\?/, "").split("&").filter(Boolean).forEach((segment) => {
+    const [rawKey, rawValue] = splitPair(segment);
+    set2(result, decode(rawKey), decode(rawValue));
+  });
+  return result;
+}
+function stringify(data, arrayFormat) {
+  const pairs = [];
+  build(data, "", pairs, arrayFormat);
+  return pairs.length ? "?" + pairs.join("&") : "";
+}
+function splitPair(pair) {
+  const index = pair.indexOf("=");
+  return index === -1 ? [pair, ""] : [pair.substring(0, index), pair.substring(index + 1)];
+}
+function decode(value) {
+  return decodeURIComponent(value.replace(/\+/g, " "));
+}
+function set2(target, key, value) {
+  const keys = parseKey(key);
+  let current = target;
+  while (keys.length > 1) {
+    const segment = keys.shift();
+    const nextIsArrayPush = keys[0] === "";
+    if (typeof current[segment] !== "object" || current[segment] === null) {
+      current[segment] = nextIsArrayPush ? [] : {};
+    }
+    current = current[segment];
+  }
+  const final = keys.shift();
+  if (final === "" && Array.isArray(current)) {
+    current.push(value);
+  } else {
+    current[final] = value;
+  }
+}
+function parseKey(key) {
+  const segments = [];
+  const base = key.split("[")[0];
+  if (base) {
+    segments.push(base);
+  }
+  let match;
+  const pattern = /\[([^\]]*)\]/g;
+  while ((match = pattern.exec(key)) !== null) {
+    segments.push(match[1]);
+  }
+  return segments;
+}
+function build(value, prefix, pairs, arrayFormat) {
+  if (value === void 0) {
+    return;
+  }
+  if (value === null) {
+    pairs.push(`${prefix}=`);
+    return;
+  }
+  if (Array.isArray(value)) {
+    value.forEach((item, index) => {
+      const key = arrayFormat === "indices" ? `${prefix}[${index}]` : `${prefix}[]`;
+      build(item, key, pairs, arrayFormat);
+    });
+    return;
+  }
+  if (typeof value === "object") {
+    Object.keys(value).forEach((key) => {
+      build(value[key], prefix ? `${prefix}[${key}]` : key, pairs, arrayFormat);
+    });
+    return;
+  }
+  pairs.push(`${prefix}=${encodeURIComponent(String(value))}`);
+}
+
 // src/url.ts
 function hrefToUrl(href) {
   return new URL(href.toString(), typeof window === "undefined" ? void 0 : window.location.toString());
@@ -921,15 +939,8 @@ function mergeDataIntoQueryString(method, href, data, qsArrayFormat = "brackets"
   const hasHash = href.toString().includes("#");
   const url = new URL(href.toString(), typeof window === "undefined" ? "http://localhost" : window.location.toString());
   if (hasDataForQueryString) {
-    const hasIndices = /\[\d+\]/.test(decodeURIComponent(url.search));
-    const parseOptions = { ignoreQueryPrefix: true, allowSparse: true };
-    url.search = qs.stringify(
-      { ...qs.parse(url.search, parseOptions), ...data },
-      {
-        encodeValuesOnly: true,
-        arrayFormat: hasIndices ? "indices" : qsArrayFormat
-      }
-    );
+    const arrayFormat = hasIndices(url) ? "indices" : qsArrayFormat;
+    url.search = stringify({ ...parse(url.search), ...data }, arrayFormat);
   }
   return [
     [
@@ -961,6 +972,18 @@ var isSameUrlWithoutQueryOrHash = (url1, url2) => {
 function isUrlMethodPair(href) {
   return href !== null && typeof href === "object" && href !== void 0 && "url" in href && "method" in href;
 }
+function resolveUrlMethodPairComponent(pair) {
+  if (!pair.component) {
+    return null;
+  }
+  if (Array.isArray(pair.component)) {
+    console.error(
+      `The "component" property on the URL method pair received an array of components (${pair.component.join(", ")}), but only a single component string is supported for instant visits. Pass an explicit component name instead.`
+    );
+    return null;
+  }
+  return pair.component;
+}
 function urlHasProtocol(url) {
   return /^([a-z][a-z0-9+.-]*:)?\/\/[^/]/i.test(url);
 }
@@ -1015,7 +1038,7 @@ var CurrentPage = class {
     if (page2.clearHistory) {
       history.clear();
     }
-    return this.resolve(page2.component).then((component) => {
+    return this.resolve(page2.component, page2).then((component) => {
       if (componentId !== this.componentId) {
         return;
       }
@@ -1025,6 +1048,7 @@ var CurrentPage = class {
       const scrollRegions = !isServer3 && preserveScroll ? Scroll.getScrollRegions() : [];
       replace = replace || isSameUrlWithoutHash(hrefToUrl(page2.url), location);
       const pageForHistory = { ...page2, flash: {} };
+      delete pageForHistory.optimisticUpdatedAt;
       return new Promise(
         (resolve) => replace ? history.replaceState(pageForHistory, resolve) : history.pushState(pageForHistory, resolve)
       ).then(() => {
@@ -1073,7 +1097,7 @@ var CurrentPage = class {
   setQuietly(page2, {
     preserveState = false
   } = {}) {
-    return this.resolve(page2.component).then((component) => {
+    return this.resolve(page2.component, page2).then((component) => {
       this.page = page2;
       this.cleared = false;
       history.setCurrent(page2);
@@ -1098,6 +1122,12 @@ var CurrentPage = class {
   merge(data) {
     this.page = { ...this.page, ...data };
   }
+  setPropsQuietly(props) {
+    this.page = { ...this.page, props };
+    return this.resolve(this.page.component, this.page).then((component) => {
+      return this.swap({ component, page: this.page, preserveState: true, viewTransition: false });
+    });
+  }
   setFlash(flash) {
     this.page = { ...this.page, flash };
     this.onFlashCallback?.(flash);
@@ -1126,8 +1156,22 @@ var CurrentPage = class {
       viewTransitionCallback(transitionResult);
     });
   }
-  resolve(component) {
-    return Promise.resolve(this.resolveComponent(component));
+  resolve(component, page2) {
+    return Promise.resolve(this.resolveComponent(component, page2));
+  }
+  recordOptimisticUpdate(keys, updatedAt) {
+    if (!this.page.optimisticUpdatedAt) {
+      this.page.optimisticUpdatedAt = {};
+    }
+    for (const key of keys) {
+      if (updatedAt > (this.page.optimisticUpdatedAt[key] || 0)) {
+        this.page.optimisticUpdatedAt[key] = updatedAt;
+      }
+    }
+  }
+  shouldPreserveOptimistic(key, updatedAt) {
+    const lastUpdatedAt = this.page.optimisticUpdatedAt?.[key];
+    return lastUpdatedAt !== void 0 && updatedAt < lastUpdatedAt;
   }
   isTheSame(page2) {
     return this.page.component === page2.component;
@@ -1147,8 +1191,8 @@ var CurrentPage = class {
       if (existingOnceProp === void 0) {
         return;
       }
-      if (force || response.props[onceProp.prop] === void 0) {
-        response.props[onceProp.prop] = this.page.props[existingOnceProp.prop];
+      if (force || get3(response.props, onceProp.prop) === void 0) {
+        set3(response.props, onceProp.prop, get3(this.page.props, existingOnceProp.prop));
         response.onceProps[key].expiresAt = existingOnceProp.expiresAt;
       }
     });
@@ -1236,7 +1280,7 @@ var History = class {
     } catch {
       return {
         ...page2,
-        props: (0, import_lodash_es3.cloneDeep)(page2.props)
+        props: cloneDeep2(page2.props)
       };
     }
   }
@@ -1275,7 +1319,7 @@ var History = class {
         if (!window.history.state?.page) {
           return;
         }
-        if ((0, import_lodash_es3.isEqual)(this.getScrollRegions(), scrollRegions)) {
+        if (isEqual(this.getScrollRegions(), scrollRegions)) {
           return;
         }
         return this.doReplaceState({
@@ -1291,7 +1335,7 @@ var History = class {
         if (!window.history.state?.page) {
           return;
         }
-        if ((0, import_lodash_es3.isEqual)(this.getDocumentScrollPosition(), scrollRegion)) {
+        if (isEqual(this.getDocumentScrollPosition(), scrollRegion)) {
           return;
         }
         return this.doReplaceState({
@@ -1308,7 +1352,7 @@ var History = class {
     return window.history.state?.documentScrollPosition || { top: 0, left: 0 };
   }
   replaceState(page2, cb = null) {
-    if ((0, import_lodash_es3.isEqual)(this.current, page2)) {
+    if (isEqual(this.current, page2)) {
       cb && cb();
       return;
     }
@@ -1486,7 +1530,7 @@ var EventHandler = class {
         const pendingDeferred = {};
         const pageProps = page.get().props;
         for (const [group, props] of Object.entries(data.initialDeferredProps ?? data.deferredProps ?? {})) {
-          const missing = props.filter((prop) => pageProps[prop] === void 0);
+          const missing = props.filter((prop) => get4(pageProps, prop) === void 0);
           if (missing.length > 0) {
             pendingDeferred[group] = missing;
           }
@@ -1511,10 +1555,8 @@ var NavigationType = class {
     if (typeof window === "undefined") {
       return "navigate";
     }
-    if (window.performance && window.performance.getEntriesByType && window.performance.getEntriesByType("navigation").length > 0) {
-      return window.performance.getEntriesByType("navigation")[0].type;
-    }
-    return "navigate";
+    const entry = window.performance?.getEntriesByType("navigation")[0];
+    return entry?.type ?? "navigate";
   }
   get() {
     return this.type;
@@ -1639,8 +1681,8 @@ var Poll = class {
       }
     }, this.interval);
   }
-  isInBackground(hidden) {
-    this.throttle = this.keepAlive ? false : hidden;
+  isInBackground(hidden2) {
+    this.throttle = this.keepAlive ? false : hidden2;
     if (this.throttle) {
       this.cbCount = 0;
     }
@@ -1681,7 +1723,245 @@ var Polls = class {
 var polls = new Polls();
 
 // src/request.ts
-var import_axios = __toESM(require("axios"), 1);
+import { get as get6 } from "lodash-es";
+
+// src/http.ts
+import { client as precognitionClient } from "laravel-precognition";
+
+// src/httpHandlers.ts
+var HttpHandlers = class {
+  constructor() {
+    this.requestHandlers = [];
+    this.responseHandlers = [];
+    this.errorHandlers = [];
+  }
+  onRequest(handler) {
+    this.requestHandlers.push(handler);
+    return () => {
+      this.requestHandlers = this.requestHandlers.filter((h) => h !== handler);
+    };
+  }
+  onResponse(handler) {
+    this.responseHandlers.push(handler);
+    return () => {
+      this.responseHandlers = this.responseHandlers.filter((h) => h !== handler);
+    };
+  }
+  onError(handler) {
+    this.errorHandlers.push(handler);
+    return () => {
+      this.errorHandlers = this.errorHandlers.filter((h) => h !== handler);
+    };
+  }
+  async processRequest(config2) {
+    let result = config2;
+    for (const handler of this.requestHandlers) {
+      result = await handler(result);
+    }
+    return result;
+  }
+  async processResponse(response) {
+    let result = response;
+    for (const handler of this.responseHandlers) {
+      result = await handler(result);
+    }
+    return result;
+  }
+  async processError(error) {
+    for (const handler of this.errorHandlers) {
+      await handler(error);
+    }
+  }
+};
+var httpHandlers = new HttpHandlers();
+
+// src/httpErrors.ts
+var HttpResponseError = class extends Error {
+  constructor(message, response, url) {
+    super(url ? `${message} (${url})` : message);
+    this.name = "HttpResponseError";
+    this.response = response;
+    this.url = url;
+  }
+};
+var HttpCancelledError = class extends Error {
+  constructor(message = "Request was cancelled", url) {
+    super(url ? `${message} (${url})` : message);
+    this.name = "HttpCancelledError";
+    this.url = url;
+  }
+};
+var HttpNetworkError = class extends Error {
+  constructor(message, url, cause) {
+    super(url ? `${message} (${url})` : message);
+    this.code = "ERR_NETWORK";
+    this.name = "HttpNetworkError";
+    this.url = url;
+    this.cause = cause;
+  }
+};
+
+// src/xhrHttpClient.ts
+function getCookie(name) {
+  const match = document.cookie.match(new RegExp("(^|;\\s*)(" + name + ")=([^;]*)"));
+  return match ? decodeURIComponent(match[3]) : null;
+}
+function parseHeaders(xhr) {
+  const headers = {};
+  xhr.getAllResponseHeaders().split("\r\n").forEach((line) => {
+    const index = line.indexOf(":");
+    if (index > 0) {
+      headers[line.slice(0, index).toLowerCase().trim()] = line.slice(index + 1).trim();
+    }
+  });
+  return headers;
+}
+function setHeaders(xhr, config2) {
+  if (!config2.headers) {
+    return;
+  }
+  const isFormData2 = config2.data instanceof FormData;
+  Object.entries(config2.headers).forEach(([key, value]) => {
+    if (key.toLowerCase() !== "content-type" || !isFormData2) {
+      xhr.setRequestHeader(key, String(value));
+    }
+  });
+}
+function buildUrlWithParams(url, params) {
+  if (!params || Object.keys(params).length === 0) {
+    return url;
+  }
+  const [urlWithParams] = mergeDataIntoQueryString("get", url, params);
+  return urlWithParams;
+}
+var XhrHttpClient = class {
+  constructor(options = {}) {
+    this.xsrfCookieName = options.xsrfCookieName ?? "XSRF-TOKEN";
+    this.xsrfHeaderName = options.xsrfHeaderName ?? "X-XSRF-TOKEN";
+  }
+  async request(config2) {
+    const processedConfig = await httpHandlers.processRequest(config2);
+    try {
+      const response = await this.doRequest(processedConfig);
+      return await httpHandlers.processResponse(response);
+    } catch (error) {
+      if (error instanceof HttpResponseError || error instanceof HttpNetworkError || error instanceof HttpCancelledError) {
+        await httpHandlers.processError(error);
+      }
+      throw error;
+    }
+  }
+  doRequest(config2) {
+    return new Promise((resolve, reject) => {
+      const xhr = new XMLHttpRequest();
+      const url = buildUrlWithParams(config2.url, config2.params);
+      xhr.open(config2.method.toUpperCase(), url, true);
+      const xsrfToken = getCookie(this.xsrfCookieName);
+      if (xsrfToken) {
+        xhr.setRequestHeader(this.xsrfHeaderName, xsrfToken);
+      }
+      let body = null;
+      if (config2.data !== null && config2.data !== void 0) {
+        if (config2.data instanceof FormData) {
+          body = config2.data;
+        } else if (typeof config2.data === "object") {
+          body = JSON.stringify(config2.data);
+          if (!config2.headers?.["Content-Type"] && !config2.headers?.["content-type"]) {
+            xhr.setRequestHeader("Content-Type", "application/json");
+          }
+        } else {
+          body = String(config2.data);
+        }
+      }
+      setHeaders(xhr, config2);
+      if (config2.onUploadProgress) {
+        xhr.upload.onprogress = (event) => {
+          config2.onUploadProgress({
+            progress: event.lengthComputable ? event.loaded / event.total : void 0,
+            loaded: event.loaded,
+            total: event.lengthComputable ? event.total : void 0
+          });
+        };
+      }
+      if (config2.signal) {
+        config2.signal.addEventListener("abort", () => xhr.abort());
+      }
+      xhr.onabort = () => reject(new HttpCancelledError("Request was cancelled", config2.url));
+      xhr.onerror = () => reject(new HttpNetworkError("Network error", config2.url));
+      xhr.onload = () => {
+        const response = {
+          status: xhr.status,
+          data: xhr.responseText,
+          headers: parseHeaders(xhr)
+        };
+        if (xhr.status >= 400) {
+          reject(new HttpResponseError(`Request failed with status ${xhr.status}`, response, config2.url));
+        } else {
+          resolve(response);
+        }
+      };
+      xhr.send(body);
+    });
+  }
+};
+var xhrHttpClient = new XhrHttpClient();
+
+// src/http.ts
+var httpClient = xhrHttpClient;
+function isHttpClientOptions(client) {
+  return !("request" in client);
+}
+var http = {
+  /**
+   * Get the current HTTP client
+   */
+  getClient() {
+    return httpClient;
+  },
+  /**
+   * Set the HTTP client to use for all Inertia requests
+   */
+  setClient(clientOrOptions) {
+    if (!isHttpClientOptions(clientOrOptions)) {
+      httpClient = clientOrOptions;
+      return;
+    }
+    httpClient = new XhrHttpClient(clientOrOptions);
+    if (clientOrOptions.xsrfCookieName) {
+      precognitionClient.withXsrfCookieName(clientOrOptions.xsrfCookieName);
+    }
+    if (clientOrOptions.xsrfHeaderName) {
+      precognitionClient.withXsrfHeaderName(clientOrOptions.xsrfHeaderName);
+    }
+  },
+  /**
+   * Register a request handler that runs before each request
+   */
+  onRequest: httpHandlers.onRequest.bind(httpHandlers),
+  /**
+   * Register a response handler that runs after each successful response
+   */
+  onResponse: httpHandlers.onResponse.bind(httpHandlers),
+  /**
+   * Register an error handler that runs when a request fails
+   */
+  onError: httpHandlers.onError.bind(httpHandlers),
+  /**
+   * Process a request config through all registered request handlers.
+   * For use by custom HttpClient implementations.
+   */
+  processRequest: httpHandlers.processRequest.bind(httpHandlers),
+  /**
+   * Process a response through all registered response handlers.
+   * For use by custom HttpClient implementations.
+   */
+  processResponse: httpHandlers.processResponse.bind(httpHandlers),
+  /**
+   * Process an error through all registered error handlers.
+   * For use by custom HttpClient implementations.
+   */
+  processError: httpHandlers.processError.bind(httpHandlers)
+};
 
 // src/requestParams.ts
 var RequestParams = class _RequestParams {
@@ -1699,6 +1979,8 @@ var RequestParams = class _RequestParams {
         onCancel: this.wrapCallback(params, "onCancel"),
         onSuccess: this.wrapCallback(params, "onSuccess"),
         onError: this.wrapCallback(params, "onError"),
+        onHttpException: this.wrapCallback(params, "onHttpException"),
+        onNetworkError: this.wrapCallback(params, "onNetworkError"),
         onFlash: this.wrapCallback(params, "onFlash"),
         onCancelToken: this.wrapCallback(params, "onCancelToken"),
         onPrefetched: this.wrapCallback(params, "onPrefetched"),
@@ -1831,12 +2113,10 @@ var RequestParams = class _RequestParams {
 };
 
 // src/response.ts
-var import_lodash_es4 = require("lodash-es");
+import { get as get5, isEqual as isEqual2, set as set4 } from "lodash-es";
 
-// src/modal.ts
-var modal_default = {
-  modal: null,
-  listener: null,
+// src/dialog.ts
+var dialog_default = {
   createIframeAndPage(html) {
     if (typeof html === "object") {
       html = `All Inertia requests must receive a valid Inertia response, however a plain JSON response was received.<hr>${JSON.stringify(
@@ -1855,44 +2135,6 @@ var modal_default = {
   },
   show(html) {
     const { iframe, page: page2 } = this.createIframeAndPage(html);
-    this.modal = document.createElement("div");
-    this.modal.style.position = "fixed";
-    this.modal.style.width = "100vw";
-    this.modal.style.height = "100vh";
-    this.modal.style.padding = "50px";
-    this.modal.style.boxSizing = "border-box";
-    this.modal.style.backgroundColor = "rgba(0, 0, 0, .6)";
-    this.modal.style.zIndex = 2e5;
-    this.modal.addEventListener("click", () => this.hide());
-    this.modal.appendChild(iframe);
-    document.body.prepend(this.modal);
-    document.body.style.overflow = "hidden";
-    if (!iframe.contentWindow) {
-      throw new Error("iframe not yet ready.");
-    }
-    iframe.contentWindow.document.open();
-    iframe.contentWindow.document.write(page2.outerHTML);
-    iframe.contentWindow.document.close();
-    this.listener = this.hideOnEscape.bind(this);
-    document.addEventListener("keydown", this.listener);
-  },
-  hide() {
-    this.modal.outerHTML = "";
-    this.modal = null;
-    document.body.style.overflow = "visible";
-    document.removeEventListener("keydown", this.listener);
-  },
-  hideOnEscape(event) {
-    if (event.keyCode === 27) {
-      this.hide();
-    }
-  }
-};
-
-// src/dialog.ts
-var dialog_default = {
-  show(html) {
-    const { iframe, page: page2 } = modal_default.createIframeAndPage(html);
     iframe.style.boxSizing = "border-box";
     iframe.style.display = "block";
     const dialog = document.createElement("dialog");
@@ -1946,10 +2188,14 @@ var Response = class _Response {
     this.response = response;
     this.originatingPage = originatingPage;
     this.wasPrefetched = false;
+    this.processed = false;
   }
   static create(params, response, originatingPage) {
     return new _Response(params, response, originatingPage);
   }
+  isProcessed() {
+    return this.processed;
+  }
   async handlePrefetch() {
     if (isSameUrlWithoutHash(this.requestParams.all().url, window.location)) {
       this.handle();
@@ -1967,9 +2213,22 @@ var Response = class _Response {
       return Promise.resolve();
     }
     this.requestParams.runCallbacks();
+    this.processed = true;
     if (!this.isInertiaResponse()) {
       return this.handleNonInertiaResponse();
     }
+    if (this.isHttpException()) {
+      const response = {
+        ...this.response,
+        data: this.getDataFromResponse(this.response.data)
+      };
+      if (this.requestParams.all().onHttpException(response) === false) {
+        return;
+      }
+      if (!fireHttpExceptionEvent(response)) {
+        return;
+      }
+    }
     await history.processQueue();
     history.preserveUrl = this.requestParams.all().preserveUrl;
     const previousFlash = page.get().flash;
@@ -1985,7 +2244,7 @@ var Response = class _Response {
       router.flush(page.get().url);
     }
     const { flash } = page.get();
-    if (Object.keys(flash).length > 0 && (!this.requestParams.isPartial() || !(0, import_lodash_es4.isEqual)(flash, previousFlash))) {
+    if (Object.keys(flash).length > 0 && (!this.requestParams.isPartial() || !isEqual2(flash, previousFlash))) {
       fireFlashEvent(flash);
       this.requestParams.all().onFlash(flash);
     }
@@ -2004,6 +2263,14 @@ var Response = class _Response {
     return this.response.data = data;
   }
   async handleNonInertiaResponse() {
+    if (this.isInertiaRedirect()) {
+      router.visit(this.getHeader("x-inertia-redirect"), {
+        ...this.requestParams.all(),
+        method: "get",
+        data: {}
+      });
+      return;
+    }
     if (this.isLocationVisit()) {
       const locationUrl = hrefToUrl(this.getHeader("x-inertia-location"));
       setHashIfSameUrl(this.requestParams.all().url, locationUrl);
@@ -2013,13 +2280,19 @@ var Response = class _Response {
       ...this.response,
       data: this.getDataFromResponse(this.response.data)
     };
-    if (fireInvalidEvent(response)) {
-      return config.get("future.useDialogForErrorModal") ? dialog_default.show(response.data) : modal_default.show(response.data);
+    if (this.requestParams.all().onHttpException(response) === false) {
+      return;
+    }
+    if (fireHttpExceptionEvent(response)) {
+      return dialog_default.show(response.data);
     }
   }
   isInertiaResponse() {
     return this.hasHeader("x-inertia");
   }
+  isHttpException() {
+    return this.response.status >= 400;
+  }
   hasStatus(status2) {
     return this.response.status === status2;
   }
@@ -2029,6 +2302,9 @@ var Response = class _Response {
   hasHeader(header) {
     return this.getHeader(header) !== void 0;
   }
+  isInertiaRedirect() {
+    return this.hasStatus(409) && this.hasHeader("x-inertia-redirect");
+  }
   isLocationVisit() {
     return this.hasStatus(409) && this.hasHeader("x-inertia-location");
   }
@@ -2059,6 +2335,7 @@ var Response = class _Response {
     }
     this.mergeProps(pageResponse);
     page.mergeOncePropsIntoResponse(pageResponse);
+    this.preserveOptimisticProps(pageResponse);
     this.preserveEqualProps(pageResponse);
     await this.setRememberedState(pageResponse);
     this.requestParams.setPreserveOptions(pageResponse);
@@ -2098,16 +2375,32 @@ var Response = class _Response {
   }
   pageUrl(pageResponse) {
     const responseUrl = hrefToUrl(pageResponse.url);
-    setHashIfSameUrl(this.requestParams.all().url, responseUrl);
+    if (pageResponse.preserveFragment) {
+      responseUrl.hash = this.requestParams.all().url.hash;
+    } else {
+      setHashIfSameUrl(this.requestParams.all().url, responseUrl);
+    }
     return responseUrl.pathname + responseUrl.search + responseUrl.hash;
   }
+  preserveOptimisticProps(pageResponse) {
+    const optimisticUpdatedAt = page.get().optimisticUpdatedAt;
+    if (!optimisticUpdatedAt || !router.hasPendingOptimistic()) {
+      return;
+    }
+    for (const key of Object.keys(pageResponse.props)) {
+      if (key in optimisticUpdatedAt) {
+        pageResponse.props[key] = page.get().props[key];
+      }
+    }
+    pageResponse.optimisticUpdatedAt = { ...optimisticUpdatedAt };
+  }
   preserveEqualProps(pageResponse) {
-    if (pageResponse.component !== page.get().component || config.get("future.preserveEqualProps") !== true) {
+    if (pageResponse.component !== page.get().component) {
       return;
     }
     const currentPageProps = page.get().props;
     Object.entries(pageResponse.props).forEach(([key, value]) => {
-      if ((0, import_lodash_es4.isEqual)(value, currentPageProps[key])) {
+      if (isEqual2(value, currentPageProps[key])) {
         pageResponse.props[key] = currentPageProps[key];
       }
     });
@@ -2121,8 +2414,8 @@ var Response = class _Response {
     const propsToDeepMerge = pageResponse.deepMergeProps || [];
     const matchPropsOn = pageResponse.matchPropsOn || [];
     const mergeProp = (prop, shouldAppend) => {
-      const currentProp = (0, import_lodash_es4.get)(page.get().props, prop);
-      const incomingProp = (0, import_lodash_es4.get)(pageResponse.props, prop);
+      const currentProp = get5(page.get().props, prop);
+      const incomingProp = get5(pageResponse.props, prop);
       if (Array.isArray(incomingProp)) {
         const newArray = this.mergeOrMatchItems(
           currentProp || [],
@@ -2131,20 +2424,20 @@ var Response = class _Response {
           matchPropsOn,
           shouldAppend
         );
-        (0, import_lodash_es4.set)(pageResponse.props, prop, newArray);
+        set4(pageResponse.props, prop, newArray);
       } else if (typeof incomingProp === "object" && incomingProp !== null) {
         const newObject = {
           ...currentProp || {},
           ...incomingProp
         };
-        (0, import_lodash_es4.set)(pageResponse.props, prop, newObject);
+        set4(pageResponse.props, prop, newObject);
       }
     };
     propsToAppend.forEach((prop) => mergeProp(prop, true));
     propsToPrepend.forEach((prop) => mergeProp(prop, false));
     propsToDeepMerge.forEach((prop) => {
-      const currentProp = page.get().props[prop];
-      const incomingProp = pageResponse.props[prop];
+      const currentProp = get5(page.get().props, prop);
+      const incomingProp = get5(pageResponse.props, prop);
       const deepMerge = (target, source, matchProp) => {
         if (Array.isArray(source)) {
           return this.mergeOrMatchItems(target, source, matchProp, matchPropsOn);
@@ -2160,15 +2453,21 @@ var Response = class _Response {
         }
         return source;
       };
-      pageResponse.props[prop] = deepMerge(currentProp, incomingProp, prop);
+      set4(pageResponse.props, prop, deepMerge(currentProp, incomingProp, prop));
     });
-    pageResponse.props = { ...page.get().props, ...pageResponse.props };
-    if (this.requestParams.isDeferredPropsRequest()) {
-      const currentErrors = page.get().props.errors;
-      if (currentErrors && Object.keys(currentErrors).length > 0) {
-        pageResponse.props.errors = currentErrors;
+    const nestedTopKeys = new Set(
+      [...this.requestParams.all().only, ...this.requestParams.all().except].filter((prop) => prop.includes(".")).map((prop) => prop.split(".")[0])
+    );
+    for (const key of nestedTopKeys) {
+      const currentValue = page.get().props[key];
+      if (this.isObject(currentValue) && this.isObject(pageResponse.props[key])) {
+        pageResponse.props[key] = this.deepMergeObjects(currentValue, pageResponse.props[key]);
       }
     }
+    pageResponse.props = { ...page.get().props, ...pageResponse.props };
+    if (this.shouldPreserveErrors(pageResponse)) {
+      pageResponse.props.errors = page.get().props.errors;
+    }
     if (page.get().scrollProps) {
       pageResponse.scrollProps = {
         ...page.get().scrollProps || {},
@@ -2190,6 +2489,42 @@ var Response = class _Response {
       pageResponse.initialDeferredProps = currentOriginalDeferred;
     }
   }
+  /**
+   * By default, the Laravel adapter shares validation errors via Inertia::always(),
+   * so responses always include errors, even when empty. Components like
+   * InfiniteScroll and WhenVisible, as well as loading deferred props,
+   * perform async requests that should practically never reset errors.
+   */
+  shouldPreserveErrors(pageResponse) {
+    if (!this.requestParams.all().preserveErrors) {
+      return false;
+    }
+    const currentErrors = page.get().props.errors;
+    if (!currentErrors || Object.keys(currentErrors).length === 0) {
+      return false;
+    }
+    const responseErrors = pageResponse.props.errors;
+    if (responseErrors && Object.keys(responseErrors).length > 0) {
+      return false;
+    }
+    return true;
+  }
+  isObject(item) {
+    return item && typeof item === "object" && !Array.isArray(item);
+  }
+  deepMergeObjects(target, source) {
+    const result = { ...target };
+    for (const key of Object.keys(source)) {
+      const targetValue = target[key];
+      const sourceValue = source[key];
+      if (this.isObject(targetValue) && this.isObject(sourceValue)) {
+        result[key] = this.deepMergeObjects(targetValue, sourceValue);
+      } else {
+        result[key] = sourceValue;
+      }
+    }
+    return result;
+  }
   mergeOrMatchItems(existingItems, newItems, matchProp, matchPropsOn, shouldAppend = true) {
     const items = Array.isArray(existingItems) ? existingItems : [];
     const matchingKey = matchPropsOn.find((key) => {
@@ -2253,18 +2588,25 @@ var Response = class _Response {
 
 // src/request.ts
 var Request = class _Request {
-  constructor(params, page2) {
+  constructor(params, page2, { optimistic = false } = {}) {
     this.page = page2;
     this.requestHasFinished = false;
     this.requestParams = RequestParams.create(params);
     this.cancelToken = new AbortController();
+    this.optimistic = optimistic;
   }
-  static create(params, page2) {
-    return new _Request(params, page2);
+  static create(params, page2, options) {
+    return new _Request(params, page2, options);
   }
   isPrefetch() {
     return this.requestParams.isPrefetch();
   }
+  isOptimistic() {
+    return this.optimistic;
+  }
+  isPendingOptimistic() {
+    return this.isOptimistic() && (!this.response || !this.response.isProcessed());
+  }
   async send() {
     this.requestParams.onCancelToken(() => this.cancel({ cancelled: true }));
     fireStartEvent(this.requestParams.all());
@@ -2274,31 +2616,30 @@ var Request = class _Request {
       firePrefetchingEvent(this.requestParams.all());
     }
     const originallyPrefetch = this.requestParams.all().prefetch;
-    return (0, import_axios.default)({
+    return http.getClient().request({
       method: this.requestParams.all().method,
       url: urlWithoutHash(this.requestParams.all().url).href,
       data: this.requestParams.data(),
-      params: this.requestParams.queryParams(),
       signal: this.cancelToken.signal,
       headers: this.getHeaders(),
-      onUploadProgress: this.onProgress.bind(this),
-      // Why text? This allows us to delay JSON.parse until we're ready to use the response,
-      // helps with performance particularly on large responses + history encryption
-      responseType: "text"
+      onUploadProgress: this.onProgress.bind(this)
     }).then((response) => {
       this.response = Response.create(this.requestParams, response, this.page);
       return this.response.handle();
     }).catch((error) => {
-      if (error?.response) {
+      if (error instanceof HttpResponseError) {
         this.response = Response.create(this.requestParams, error.response, this.page);
         return this.response.handle();
       }
       return Promise.reject(error);
     }).catch((error) => {
-      if (import_axios.default.isCancel(error)) {
+      if (error instanceof HttpCancelledError) {
+        return;
+      }
+      if (this.requestParams.all().onNetworkError(error) === false) {
         return;
       }
-      if (fireExceptionEvent(error)) {
+      if (fireNetworkErrorEvent(error)) {
         if (originallyPrefetch) {
           this.requestParams.onPrefetchError(error);
         }
@@ -2353,7 +2694,7 @@ var Request = class _Request {
       headers["X-Inertia-Version"] = page2.version;
     }
     const onceProps = Object.entries(page2.onceProps || {}).filter(([, onceProp]) => {
-      if (page2.props[onceProp.prop] === void 0) {
+      if (get6(page2.props, onceProp.prop) === void 0) {
         return false;
       }
       return !onceProp.expiresAt || onceProp.expiresAt > Date.now();
@@ -2381,8 +2722,8 @@ var RequestStream = class {
   interruptInFlight() {
     this.cancel({ interrupted: true }, false);
   }
-  cancelInFlight({ prefetch = true } = {}) {
-    this.requests.filter((request) => prefetch || !request.isPrefetch()).forEach((request) => request.cancel({ cancelled: true }));
+  cancelInFlight({ prefetch = true, optimistic = true } = {}) {
+    this.requests.filter((request) => prefetch || !request.isPrefetch()).filter((request) => optimistic || !request.isOptimistic()).forEach((request) => request.cancel({ cancelled: true }));
   }
   cancel({ cancelled = false, interrupted = false } = {}, force = false) {
     if (!force && !this.shouldCancel()) {
@@ -2394,9 +2735,14 @@ var RequestStream = class {
   shouldCancel() {
     return this.interruptible && this.requests.length >= this.maxConcurrent;
   }
+  hasPendingOptimistic() {
+    return this.requests.some((request) => request.isPendingOptimistic());
+  }
 };
 
 // src/router.ts
+var noop = () => {
+};
 var Router = class {
   constructor() {
     this.syncRequestStream = new RequestStream({
@@ -2408,6 +2754,7 @@ var Router = class {
       interruptible: false
     });
     this.clientVisitQueue = new Queue();
+    this.pendingOptimisticCallback = void 0;
   }
   init({
     initialPage,
@@ -2435,6 +2782,10 @@ var Router = class {
       window.location.href = url;
     });
   }
+  optimistic(callback) {
+    this.pendingOptimisticCallback = callback;
+    return this;
+  }
   get(url, data = {}, options = {}) {
     return this.visit(url, { ...options, method: "get", data });
   }
@@ -2487,6 +2838,9 @@ var Router = class {
   cancel() {
     this.syncRequestStream.cancelInFlight();
   }
+  hasPendingOptimistic() {
+    return this.asyncRequestStream.hasPendingOptimistic();
+  }
   cancelAll({ async = true, prefetch = true, sync = true } = {}) {
     if (async) {
       this.asyncRequestStream.cancelInFlight({ prefetch });
@@ -2496,15 +2850,20 @@ var Router = class {
     }
   }
   poll(interval, requestOptions = {}, options = {}) {
-    return polls.add(interval, () => this.reload(requestOptions), {
+    return polls.add(interval, () => this.reload({ preserveErrors: true, ...requestOptions }), {
       autoStart: options.autoStart ?? true,
       keepAlive: options.keepAlive ?? false
     });
   }
   visit(href, options = {}) {
+    options.optimistic = options.optimistic ?? this.pendingOptimisticCallback;
+    this.pendingOptimisticCallback = void 0;
+    if (options.optimistic) {
+      options.async = options.async ?? true;
+    }
     const visit = this.getPendingVisit(href, {
       ...options,
-      showProgress: options.showProgress ?? !options.async
+      showProgress: options.showProgress ?? (!options.async || !!options.optimistic)
     });
     const events = this.getVisitEvents(options);
     if (events.onBefore(visit) === false || !fireBeforeEvent(visit)) {
@@ -2514,11 +2873,14 @@ var Router = class {
     const isPartialReload = visit.only.length > 0 || visit.except.length > 0 || visit.reset.length > 0;
     const isSamePage = isPartialReload ? isSameUrlWithoutQueryOrHash(visit.url, currentPageUrl) : isSameUrlWithoutHash(visit.url, currentPageUrl);
     if (!isSamePage) {
-      this.asyncRequestStream.cancelInFlight({ prefetch: false });
+      this.asyncRequestStream.cancelInFlight({ prefetch: false, optimistic: false });
     }
     if (!visit.async) {
       this.syncRequestStream.interruptInFlight();
     }
+    if (options.optimistic) {
+      this.applyOptimisticUpdate(options.optimistic, events);
+    }
     if (!page.isCleared() && !visit.preserveUrl) {
       Scroll.save();
     }
@@ -2526,14 +2888,34 @@ var Router = class {
       ...visit,
       ...events
     };
-    const prefetched = prefetchedRequests.get(requestParams);
-    if (prefetched) {
-      progress.reveal(prefetched.inFlight);
-      prefetchedRequests.use(prefetched, requestParams);
+    const sendRequest = () => {
+      const prefetched = prefetchedRequests.get(requestParams);
+      if (prefetched) {
+        progress.reveal(prefetched.inFlight);
+        prefetchedRequests.use(prefetched, requestParams);
+      } else {
+        progress.reveal(true);
+        const requestStream = visit.async ? this.asyncRequestStream : this.syncRequestStream;
+        requestStream.send(Request.create(requestParams, page.get(), { optimistic: !!options.optimistic }));
+      }
+    };
+    if (Array.isArray(visit.component)) {
+      console.error(
+        `The "component" prop received an array of components (${visit.component.join(", ")}), but only a single component string is supported for instant visits. Pass an explicit component name instead.`
+      );
+      visit.component = null;
+    }
+    if (visit.component) {
+      history.processQueue().then(() => {
+        this.performInstantSwap(visit).then(() => {
+          requestParams.preserveState = true;
+          requestParams.replace = true;
+          requestParams.viewTransition = false;
+          sendRequest();
+        });
+      });
     } else {
-      progress.reveal(true);
-      const requestStream = visit.async ? this.asyncRequestStream : this.syncRequestStream;
-      requestStream.send(Request.create(requestParams, page.get()));
+      sendRequest();
     }
   }
   getCached(href, options = {}) {
@@ -2610,8 +2992,8 @@ var Router = class {
   decryptHistory() {
     return history.decrypt();
   }
-  resolveComponent(component) {
-    return page.resolve(component);
+  resolveComponent(component, page2) {
+    return page.resolve(component, page2);
   }
   replace(params) {
     this.clientVisit(params, { replace: true });
@@ -2621,8 +3003,8 @@ var Router = class {
       preserveScroll: true,
       preserveState: true,
       props(currentProps) {
-        const newValue = typeof value === "function" ? value((0, import_lodash_es5.get)(currentProps, name), currentProps) : value;
-        return (0, import_lodash_es5.set)((0, import_lodash_es5.cloneDeep)(currentProps), name, newValue);
+        const newValue = typeof value === "function" ? value(get7(currentProps, name), currentProps) : value;
+        return set5(cloneDeep3(currentProps), name, newValue);
       },
       ...options || {}
     });
@@ -2679,7 +3061,10 @@ var Router = class {
   performClientVisit(params, { replace = false } = {}) {
     const current = page.get();
     const onceProps = typeof params.props === "function" ? Object.fromEntries(
-      Object.values(current.onceProps ?? {}).map((onceProp) => [onceProp.prop, current.props[onceProp.prop]])
+      Object.values(current.onceProps ?? {}).map((onceProp) => [
+        onceProp.prop,
+        get7(current.props, onceProp.prop)
+      ])
     ) : {};
     const props = typeof params.props === "function" ? params.props(current.props, onceProps) : params.props ?? current.props;
     const flash = typeof params.flash === "function" ? params.flash(current.flash) : params.flash;
@@ -2712,6 +3097,34 @@ var Router = class {
       onError?.(scopedErrors);
     }).finally(() => onFinish?.(params));
   }
+  performInstantSwap(visit) {
+    const current = page.get();
+    const sharedProps = Object.fromEntries(
+      (current.sharedProps ?? []).filter((key) => key in current.props).map((key) => [key, current.props[key]])
+    );
+    const resolvedPageProps = typeof visit.pageProps === "function" ? visit.pageProps(cloneDeep3(current.props), cloneDeep3(sharedProps)) : visit.pageProps;
+    const intermediateProps = resolvedPageProps !== null ? { ...resolvedPageProps } : { ...sharedProps };
+    const intermediatePage = {
+      component: visit.component,
+      url: visit.url.pathname + visit.url.search + visit.url.hash,
+      version: current.version,
+      props: {
+        ...intermediateProps,
+        errors: {}
+      },
+      flash: {},
+      clearHistory: false,
+      encryptHistory: current.encryptHistory,
+      sharedProps: current.sharedProps,
+      rememberedState: {}
+    };
+    return page.set(intermediatePage, {
+      replace: visit.replace,
+      preserveScroll: RequestParams.resolvePreserveOption(visit.preserveScroll, intermediatePage),
+      preserveState: false,
+      viewTransition: visit.viewTransition
+    });
+  }
   getPrefetchParams(href, options) {
     return {
       ...this.getPendingVisit(href, {
@@ -2724,14 +3137,14 @@ var Router = class {
       ...this.getVisitEvents(options)
     };
   }
-  getPendingVisit(href, options, pendingVisitOptions = {}) {
+  getPendingVisit(href, options) {
     if (isUrlMethodPair(href)) {
       const urlMethodPair = href;
       href = urlMethodPair.url;
       options.method = options.method ?? urlMethodPair.method;
     }
     const defaultVisitOptionsCallback = config.get("visitOptions");
-    const configuredOptions = defaultVisitOptionsCallback ? defaultVisitOptionsCallback(href.toString(), (0, import_lodash_es5.cloneDeep)(options)) || {} : {};
+    const configuredOptions = defaultVisitOptionsCallback ? defaultVisitOptionsCallback(href.toString(), cloneDeep3(options)) || {} : {};
     const mergedOptions = {
       method: "get",
       data: {},
@@ -2749,9 +3162,12 @@ var Router = class {
       fresh: false,
       reset: [],
       preserveUrl: false,
+      preserveErrors: false,
       prefetch: false,
       invalidateCacheTags: [],
       viewTransition: false,
+      component: null,
+      pageProps: null,
       ...options,
       ...configuredOptions
     };
@@ -2767,7 +3183,6 @@ var Router = class {
       completed: false,
       interrupted: false,
       ...mergedOptions,
-      ...pendingVisitOptions,
       url,
       data: _data
     };
@@ -2778,36 +3193,66 @@ var Router = class {
   }
   getVisitEvents(options) {
     return {
-      onCancelToken: options.onCancelToken || (() => {
-      }),
-      onBefore: options.onBefore || (() => {
-      }),
-      onBeforeUpdate: options.onBeforeUpdate || (() => {
-      }),
-      onStart: options.onStart || (() => {
-      }),
-      onProgress: options.onProgress || (() => {
-      }),
-      onFinish: options.onFinish || (() => {
-      }),
-      onCancel: options.onCancel || (() => {
-      }),
-      onSuccess: options.onSuccess || (() => {
-      }),
-      onError: options.onError || (() => {
-      }),
-      onFlash: options.onFlash || (() => {
-      }),
-      onPrefetched: options.onPrefetched || (() => {
-      }),
-      onPrefetching: options.onPrefetching || (() => {
-      })
+      onCancelToken: options.onCancelToken || noop,
+      onBefore: options.onBefore || noop,
+      onBeforeUpdate: options.onBeforeUpdate || noop,
+      onStart: options.onStart || noop,
+      onProgress: options.onProgress || noop,
+      onFinish: options.onFinish || noop,
+      onCancel: options.onCancel || noop,
+      onSuccess: options.onSuccess || noop,
+      onError: options.onError || noop,
+      onHttpException: options.onHttpException || noop,
+      onNetworkError: options.onNetworkError || noop,
+      onFlash: options.onFlash || noop,
+      onPrefetched: options.onPrefetched || noop,
+      onPrefetching: options.onPrefetching || noop
+    };
+  }
+  applyOptimisticUpdate(optimistic, events) {
+    const currentProps = page.get().props;
+    const optimisticProps = optimistic(cloneDeep3(currentProps));
+    if (!optimisticProps) {
+      return;
+    }
+    const propsSnapshot = {};
+    for (const key of Object.keys(optimisticProps)) {
+      if (!isEqual3(currentProps[key], optimisticProps[key])) {
+        propsSnapshot[key] = cloneDeep3(currentProps[key]);
+      }
+    }
+    if (Object.keys(propsSnapshot).length === 0) {
+      return;
+    }
+    const updatedAt = Date.now();
+    page.recordOptimisticUpdate(Object.keys(propsSnapshot), updatedAt);
+    page.setPropsQuietly({ ...currentProps, ...optimisticProps });
+    let shouldRestore = true;
+    const originalOnSuccess = events.onSuccess;
+    events.onSuccess = (page2) => {
+      shouldRestore = false;
+      return originalOnSuccess(page2);
+    };
+    const originalOnFinish = events.onFinish;
+    events.onFinish = (visit) => {
+      if (shouldRestore) {
+        const propsToRestore = {};
+        for (const [key, value] of Object.entries(propsSnapshot)) {
+          if (!page.shouldPreserveOptimistic(key, updatedAt)) {
+            propsToRestore[key] = value;
+          }
+        }
+        if (Object.keys(propsToRestore).length > 0) {
+          page.setPropsQuietly({ ...page.get().props, ...propsToRestore });
+        }
+      }
+      return originalOnFinish(visit);
     };
   }
   loadDeferredProps(deferred) {
     if (deferred) {
-      Object.entries(deferred).forEach(([_, group]) => {
-        this.doReload({ only: group, deferredProps: true });
+      Object.values(deferred).forEach((props) => {
+        this.doReload({ only: props, deferredProps: true, preserveErrors: true });
       });
     }
   }
@@ -2923,8 +3368,108 @@ var UseFormUtils = class {
   }
 };
 
+// src/axiosHttpClient.ts
+function normalizeHeaders(headers) {
+  if (!headers || typeof headers !== "object") {
+    return {};
+  }
+  const normalized = {};
+  const entries = typeof headers.entries === "function" ? Array.from(headers.entries()) : Object.entries(headers);
+  for (const [key, value] of entries) {
+    if (typeof value === "string") {
+      normalized[key.toLowerCase()] = value;
+    } else if (Array.isArray(value)) {
+      normalized[key.toLowerCase()] = value.join(", ");
+    }
+  }
+  return normalized;
+}
+function toHttpProgressEvent(axiosEvent) {
+  return {
+    progress: axiosEvent.progress,
+    loaded: axiosEvent.loaded,
+    total: axiosEvent.total
+  };
+}
+var axiosModulePromise;
+function loadAxiosModule() {
+  if (!axiosModulePromise) {
+    axiosModulePromise = import("axios").catch((error) => {
+      axiosModulePromise = void 0;
+      throw error;
+    });
+  }
+  return axiosModulePromise;
+}
+var AxiosHttpClient = class {
+  constructor(instance) {
+    this.axiosInstance = instance ? Promise.resolve(instance) : loadAxiosModule().then((module) => module.default);
+  }
+  async getAxios() {
+    return this.axiosInstance;
+  }
+  async request(config2) {
+    const processedConfig = await httpHandlers.processRequest(config2);
+    try {
+      const response = await this.doRequest(processedConfig);
+      return await httpHandlers.processResponse(response);
+    } catch (error) {
+      if (error instanceof HttpResponseError || error instanceof HttpNetworkError || error instanceof HttpCancelledError) {
+        await httpHandlers.processError(error);
+      }
+      throw error;
+    }
+  }
+  async doRequest(config2) {
+    const axios = await this.getAxios();
+    try {
+      const response = await axios({
+        method: config2.method,
+        url: config2.url,
+        data: config2.data,
+        params: config2.params,
+        headers: config2.headers,
+        signal: config2.signal,
+        responseType: "text",
+        onUploadProgress: config2.onUploadProgress ? (event) => config2.onUploadProgress(toHttpProgressEvent(event)) : void 0
+      });
+      return {
+        status: response.status,
+        data: response.data,
+        headers: normalizeHeaders(response.headers)
+      };
+    } catch (error) {
+      const axiosModule = await loadAxiosModule();
+      if (axiosModule.default.isCancel(error)) {
+        throw new HttpCancelledError("Request was cancelled", config2.url);
+      }
+      if (error && typeof error === "object" && "response" in error) {
+        const axiosError = error;
+        const httpResponse = {
+          status: axiosError.response.status,
+          data: axiosError.response.data,
+          headers: normalizeHeaders(axiosError.response.headers)
+        };
+        throw new HttpResponseError(
+          `Request failed with status ${axiosError.response.status}`,
+          httpResponse,
+          config2.url
+        );
+      }
+      throw new HttpNetworkError(
+        error instanceof Error ? error.message : "Network error",
+        config2.url,
+        error instanceof Error ? error : void 0
+      );
+    }
+  }
+};
+function axiosAdapter(instance) {
+  return new AxiosHttpClient(instance);
+}
+
 // src/formObject.ts
-var import_lodash_es6 = require("lodash-es");
+import { get as get8, set as set6 } from "lodash-es";
 function undotKey(key) {
   if (!key.includes(".")) {
     return key;
@@ -2937,7 +3482,7 @@ function undotKey(key) {
   };
   return key.replace(/\\\./g, "__ESCAPED_DOT__").split(/(\[[^\]]*\])/).filter(Boolean).map(transformSegment).join("").replace(/__ESCAPED_DOT__/g, ".");
 }
-function parseKey(key) {
+function parseKey2(key) {
   const path = [];
   const pattern = /([^\[\]]+)|\[(\d*)\]/g;
   let match;
@@ -2991,17 +3536,17 @@ function formDataToObject(source) {
     if (value instanceof File && value.size === 0 && value.name === "") {
       continue;
     }
-    const path = parseKey(undotKey(key));
+    const path = parseKey2(undotKey(key));
     if (path[path.length - 1] === "") {
       const arrayPath = path.slice(0, -1);
-      const existing = (0, import_lodash_es6.get)(form, arrayPath);
+      const existing = get8(form, arrayPath);
       if (Array.isArray(existing)) {
         existing.push(value);
       } else if (existing && typeof existing === "object" && !isFile(existing)) {
         const numericKeys = Object.keys(existing).filter((k) => /^\d+$/.test(k)).map(Number).sort((a, b) => a - b);
-        (0, import_lodash_es6.set)(form, arrayPath, numericKeys.length > 0 ? [...numericKeys.map((k) => existing[k]), value] : [value]);
+        set6(form, arrayPath, numericKeys.length > 0 ? [...numericKeys.map((k) => existing[k]), value] : [value]);
       } else {
-        (0, import_lodash_es6.set)(form, arrayPath, [value]);
+        set6(form, arrayPath, [value]);
       }
       continue;
     }
@@ -3012,9 +3557,6 @@ function formDataToObject(source) {
 
 // src/head.ts
 var Renderer = {
-  preferredAttribute() {
-    return config.get("future.useDataInertiaHeadAttribute") ? "data-inertia" : "inertia";
-  },
   buildDOMElement(tag) {
     const template = document.createElement("template");
     template.innerHTML = tag;
@@ -3030,13 +3572,12 @@ var Renderer = {
     return script;
   },
   isInertiaManagedElement(element) {
-    return element.nodeType === Node.ELEMENT_NODE && element.getAttribute(this.preferredAttribute()) !== null;
+    return element.nodeType === Node.ELEMENT_NODE && element.getAttribute("data-inertia") !== null;
   },
   findMatchingElementIndex(element, elements) {
-    const attribute = this.preferredAttribute();
-    const key = element.getAttribute(attribute);
+    const key = element.getAttribute("data-inertia");
     if (key !== null) {
-      return elements.findIndex((element2) => element2.getAttribute(attribute) === key);
+      return elements.findIndex((element2) => element2.getAttribute("data-inertia") === key);
     }
     return -1;
   },
@@ -3048,12 +3589,12 @@ var Renderer = {
     targetElements.forEach((targetElement) => {
       const index = this.findMatchingElementIndex(targetElement, sourceElements);
       if (index === -1) {
-        targetElement?.parentNode?.removeChild(targetElement);
+        targetElement.remove();
         return;
       }
       const sourceElement = sourceElements.splice(index, 1)[0];
       if (sourceElement && !targetElement.isEqualNode(sourceElement)) {
-        targetElement?.parentNode?.replaceChild(sourceElement, targetElement);
+        targetElement.replaceWith(sourceElement);
       }
     });
     sourceElements.forEach((element) => document.head.appendChild(element));
@@ -3087,9 +3628,8 @@ function createHeadManager(isServer3, titleCallback, onUpdate) {
   }
   function collect() {
     const title = titleCallback("");
-    const attribute = Renderer.preferredAttribute();
     const defaults = {
-      ...title ? { title: `<title ${attribute}="">${title}</title>` } : {}
+      ...title ? { title: `<title data-inertia="">${title}</title>` } : {}
     };
     const elements = Object.values(states).reduce((carry, elements2) => carry.concat(elements2), []).reduce((carry, element) => {
       if (element.indexOf("<") === -1) {
@@ -3100,7 +3640,7 @@ function createHeadManager(isServer3, titleCallback, onUpdate) {
         carry.title = title2 ? `${title2[1]}${titleCallback(title2[2])}${title2[3]}` : element;
         return carry;
       }
-      const match = element.match(attribute === "inertia" ? / inertia="[^"]+"/ : / data-inertia="[^"]+"/);
+      const match = element.match(/ data-inertia="[^"]+"/);
       if (match) {
         carry[match[0]] = element;
       } else {
@@ -3119,7 +3659,6 @@ function createHeadManager(isServer3, titleCallback, onUpdate) {
     createProvider: function() {
       const id = connect();
       return {
-        preferredAttribute: Renderer.preferredAttribute,
         reconnect: () => reconnect(id),
         update: (elements) => update(id, elements),
         disconnect: () => disconnect(id)
@@ -3204,9 +3743,10 @@ var useInfiniteScrollData = (options) => {
     }
     state.loading = true;
     router.reload({
+      preserveErrors: true,
       ...reloadOptions,
-      data: { [getPageName()]: page2 },
-      only: [options.getPropName()],
+      data: { ...reloadOptions.data || {}, [getPageName()]: page2 },
+      only: [...reloadOptions.only || [], options.getPropName()],
       preserveUrl: true,
       // we handle URL updates manually via useInfiniteScrollQueryString()
       headers: {
@@ -3607,6 +4147,7 @@ function useInfiniteScroll(options) {
   };
   const originalFetchNext = dataManager.fetchNext;
   dataManager.fetchNext = (reloadOptions = {}) => {
+    reloadOptions = { ...options.getReloadOptions?.(), ...reloadOptions };
     if (options.inReverseMode()) {
       reloadOptions = addScrollPreservationCallbacks(reloadOptions);
     }
@@ -3614,6 +4155,7 @@ function useInfiniteScroll(options) {
   };
   const originalFetchPrevious = dataManager.fetchPrevious;
   dataManager.fetchPrevious = (reloadOptions = {}) => {
+    reloadOptions = { ...options.getReloadOptions?.(), ...reloadOptions };
     if (!options.inReverseMode()) {
       reloadOptions = addScrollPreservationCallbacks(reloadOptions);
     }
@@ -3632,6 +4174,121 @@ function useInfiniteScroll(options) {
   };
 }
 
+// src/layout.ts
+import { isEqual as isEqual4 } from "lodash-es";
+function createLayoutPropsStore() {
+  let shared = {};
+  let named = {};
+  let snapshot = { shared, named };
+  const listeners = /* @__PURE__ */ new Set();
+  let pendingNotify = false;
+  const updateSnapshot = () => {
+    snapshot = { shared, named };
+  };
+  const notify = () => {
+    if (pendingNotify) {
+      return;
+    }
+    pendingNotify = true;
+    queueMicrotask(() => {
+      pendingNotify = false;
+      listeners.forEach((fn) => fn());
+    });
+  };
+  return {
+    set(props) {
+      const merged = { ...shared, ...props };
+      if (isEqual4(shared, merged)) {
+        return;
+      }
+      shared = merged;
+      updateSnapshot();
+      notify();
+    },
+    setFor(name, props) {
+      const current = named[name] || {};
+      const merged = { ...current, ...props };
+      if (isEqual4(current, merged)) {
+        return;
+      }
+      named = { ...named, [name]: merged };
+      updateSnapshot();
+      notify();
+    },
+    reset() {
+      shared = {};
+      named = {};
+      updateSnapshot();
+      notify();
+    },
+    subscribe(callback) {
+      listeners.add(callback);
+      return () => listeners.delete(callback);
+    },
+    get: () => snapshot
+  };
+}
+function mergeLayoutProps(defaults, staticProps, dynamicProps) {
+  const result = { ...defaults };
+  for (const key of Object.keys(defaults)) {
+    if (key in staticProps && staticProps[key] !== void 0) {
+      result[key] = staticProps[key];
+    }
+    if (key in dynamicProps && dynamicProps[key] !== void 0) {
+      result[key] = dynamicProps[key];
+    }
+  }
+  return result;
+}
+function isPlainObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function hasComponentKey(value) {
+  return isPlainObject(value) && "component" in value;
+}
+function isNamedLayouts(value, isComponent) {
+  if (!isPlainObject(value) || isComponent(value) || "component" in value) {
+    return false;
+  }
+  return Object.values(value).some((v) => isComponent(v) || Array.isArray(v) && isComponent(v[0]));
+}
+function isTuple(value, isComponent) {
+  return Array.isArray(value) && value.length === 2 && isComponent(value[0]) && isPlainObject(value[1]) && !isComponent(value[1]);
+}
+function extract(item, isComponent) {
+  if (Array.isArray(item) && isComponent(item[0])) {
+    return { component: item[0], props: item[1] ?? {} };
+  }
+  if (hasComponentKey(item) && isComponent(item.component)) {
+    return { component: item.component, props: item.props ?? {} };
+  }
+  if (isComponent(item)) {
+    return { component: item, props: {} };
+  }
+  throw new Error(`Invalid layout definition: received ${typeof item}`);
+}
+function normalizeLayouts(layout, isComponent, isRenderFunction) {
+  if (!layout || isRenderFunction && isRenderFunction(layout)) {
+    return [];
+  }
+  if (isNamedLayouts(layout, isComponent)) {
+    return Object.entries(layout).map(([name, value]) => ({ ...extract(value, isComponent), name }));
+  }
+  if (isTuple(layout, isComponent)) {
+    return [{ component: layout[0], props: layout[1] ?? {} }];
+  }
+  if (Array.isArray(layout)) {
+    return layout.map((item) => extract(item, isComponent));
+  }
+  if (hasComponentKey(layout) && isComponent(layout.component)) {
+    return [{ component: layout.component, props: layout.props ?? {} }];
+  }
+  if (isComponent(layout)) {
+    return [{ component: layout, props: {} }];
+  }
+  return [];
+}
+
 // src/navigationEvents.ts
 function isContentEditableOrPrevented(event) {
   return event.target instanceof HTMLElement && event.target.isContentEditable || event.defaultPrevented;
@@ -3647,11 +4304,11 @@ function shouldNavigate(event) {
 
 // src/progress-component.ts
 var baseComponentSelector = "nprogress";
+var usePopover;
 var progress2;
 var settings = {
   minimum: 0.08,
   easing: "linear",
-  positionUsing: "translate3d",
   speed: 200,
   trickle: true,
   trickleSpeed: 200,
@@ -3661,6 +4318,7 @@ var settings = {
   parent: "body",
   color: "#29d",
   includeCSS: true,
+  popover: null,
   template: [
     '<div class="bar" role="bar">',
     '<div class="peg"></div>',
@@ -3671,16 +4329,21 @@ var settings = {
   ].join("")
 };
 var status = null;
+var hidden = false;
 var configure = (options) => {
   Object.assign(settings, options);
+  usePopover = settings.popover ?? "popover" in HTMLElement.prototype;
   if (settings.includeCSS) {
     injectCSS(settings.color);
   }
   progress2 = document.createElement("div");
   progress2.id = baseComponentSelector;
   progress2.innerHTML = settings.template;
+  if (usePopover) {
+    progress2.popover = "manual";
+  }
 };
-var set5 = (n) => {
+var set7 = (n) => {
   const started = isStarted();
   n = clamp(n, settings.minimum, 1);
   status = n === 1 ? null : n;
@@ -3690,21 +4353,10 @@ var set5 = (n) => {
   const ease = settings.easing;
   progress3.offsetWidth;
   queue4((next) => {
-    const barStyles = (() => {
-      if (settings.positionUsing === "translate3d") {
-        return {
-          transition: `all ${speed}ms ${ease}`,
-          transform: `translate3d(${toBarPercentage(n)}%,0,0)`
-        };
-      }
-      if (settings.positionUsing === "translate") {
-        return {
-          transition: `all ${speed}ms ${ease}`,
-          transform: `translate(${toBarPercentage(n)}%,0)`
-        };
-      }
-      return { marginLeft: `${toBarPercentage(n)}%` };
-    })();
+    const barStyles = {
+      transition: `all ${speed}ms ${ease}`,
+      transform: `translate3d(${toBarPercentage(n)}%,0,0)`
+    };
     for (const key in barStyles) {
       bar.style[key] = barStyles[key];
     }
@@ -3729,7 +4381,7 @@ var set5 = (n) => {
 var isStarted = () => typeof status === "number";
 var start = () => {
   if (!status) {
-    set5(0);
+    set7(0);
   }
   const work = function() {
     setTimeout(function() {
@@ -3749,7 +4401,7 @@ var done = (force) => {
     return;
   }
   increaseByRandom(0.3 + 0.5 * Math.random());
-  set5(1);
+  set7(1);
 };
 var increaseByRandom = (amount) => {
   const n = status;
@@ -3773,7 +4425,7 @@ var increaseByRandom = (amount) => {
     }
     return 0;
   })();
-  return set5(clamp(n + amount, 0, 0.994));
+  return set7(clamp(n + amount, 0, 0.994));
 };
 var render = (fromStart) => {
   if (isRendered()) {
@@ -3782,35 +4434,47 @@ var render = (fromStart) => {
   document.documentElement.classList.add(`${baseComponentSelector}-busy`);
   const bar = progress2.querySelector(settings.barSelector);
   const perc = fromStart ? "-100" : toBarPercentage(status || 0);
-  const parent = getParent();
   bar.style.transition = "all 0 linear";
   bar.style.transform = `translate3d(${perc}%,0,0)`;
   if (!settings.showSpinner) {
     progress2.querySelector(settings.spinnerSelector)?.remove();
   }
-  if (parent !== document.body) {
-    parent.classList.add(`${baseComponentSelector}-custom-parent`);
+  if (usePopover) {
+    document.body.appendChild(progress2);
+    if (!hidden) {
+      progress2.showPopover();
+    }
+  } else {
+    const parent = getParent();
+    if (parent !== document.body) {
+      parent.classList.add(`${baseComponentSelector}-custom-parent`);
+    }
+    parent.appendChild(progress2);
+    if (hidden) {
+      progress2.style.display = "none";
+    }
   }
-  parent.appendChild(progress2);
   return progress2;
 };
 var getParent = () => {
-  return isDOM(settings.parent) ? settings.parent : document.querySelector(settings.parent);
+  return document.querySelector(settings.parent);
 };
 var remove = () => {
   document.documentElement.classList.remove(`${baseComponentSelector}-busy`);
-  getParent().classList.remove(`${baseComponentSelector}-custom-parent`);
+  if (usePopover && progress2?.isConnected) {
+    try {
+      progress2.hidePopover();
+    } catch {
+    }
+  }
+  if (!usePopover) {
+    getParent().classList.remove(`${baseComponentSelector}-custom-parent`);
+  }
   progress2?.remove();
 };
 var isRendered = () => {
   return document.getElementById(baseComponentSelector) !== null;
 };
-var isDOM = (obj) => {
-  if (typeof HTMLElement === "object") {
-    return obj instanceof HTMLElement;
-  }
-  return obj && typeof obj === "object" && obj.nodeType === 1 && typeof obj.nodeName === "string";
-};
 function clamp(n, min, max) {
   if (n < min) {
     return min;
@@ -3841,6 +4505,21 @@ var injectCSS = (color) => {
   element.textContent = `
     #${baseComponentSelector} {
       pointer-events: none;
+      background: none;
+      border: none;
+      margin: 0;
+      padding: 0;
+      overflow: visible;
+      inset: unset;
+      width: 100%;
+      height: 0;
+      position: fixed;
+      top: 0;
+      left: 0;
+    }
+
+    #${baseComponentSelector}::backdrop {
+      display: none;
     }
 
     #${baseComponentSelector} .bar {
@@ -3906,12 +4585,30 @@ var injectCSS = (color) => {
   document.head.appendChild(element);
 };
 var show = () => {
-  if (progress2) {
+  hidden = false;
+  if (!progress2?.isConnected) {
+    return;
+  }
+  if (usePopover) {
+    try {
+      progress2.showPopover();
+    } catch {
+    }
+  } else {
     progress2.style.display = "";
   }
 };
 var hide = () => {
-  if (progress2) {
+  hidden = true;
+  if (!progress2?.isConnected) {
+    return;
+  }
+  if (usePopover) {
+    try {
+      progress2.hidePopover();
+    } catch {
+    }
+  } else {
     progress2.style.display = "none";
   }
 };
@@ -3919,7 +4616,7 @@ var progress_component_default = {
   configure,
   isStarted,
   done,
-  set: set5,
+  set: set7,
   remove,
   start,
   status,
@@ -3966,8 +4663,6 @@ var Progress = class {
   }
 };
 var progress = new Progress();
-var reveal = progress.reveal;
-var hide2 = progress.hide;
 function addEventListeners(delay) {
   document.addEventListener("inertia:start", (e) => handleStartEvent(e, delay));
   document.addEventListener("inertia:progress", handleProgressEvent);
@@ -4001,10 +4696,11 @@ function setupProgress({
   delay = 250,
   color = "#29d",
   includeCSS = true,
-  showSpinner = false
+  showSpinner = false,
+  popover = null
 } = {}) {
   addEventListeners(delay);
-  progress_component_default.configure({ showSpinner, includeCSS, color });
+  progress_component_default.configure({ showSpinner, includeCSS, color, popover });
 }
 
 // src/resetFormFields.ts
@@ -4145,8 +4841,51 @@ function resetFormFields(formElement, defaults, fieldNames) {
   }
 }
 
+// src/ssrUtils.ts
+function buildSSRBody(id, page2, html) {
+  const json = JSON.stringify(page2).replace(/\//g, "\\/");
+  return `<script data-page="${id}" type="application/json">${json}<\/script><div data-server-rendered="true" id="${id}">${html}</div>`;
+}
+
 // src/index.ts
 var router = new Router();
+export {
+  FormComponentResetSymbol,
+  HttpCancelledError,
+  HttpNetworkError,
+  HttpResponseError,
+  UseFormUtils,
+  XhrHttpClient,
+  axiosAdapter,
+  buildSSRBody,
+  config,
+  createHeadManager,
+  createLayoutPropsStore,
+  formDataToObject,
+  getInitialPageFromDOM,
+  getScrollableParent,
+  hasFiles,
+  hrefToUrl,
+  http,
+  isSameUrlWithoutQueryOrHash,
+  isUrlMethodPair,
+  mergeDataIntoQueryString,
+  mergeLayoutProps,
+  normalizeLayouts,
+  objectToFormData,
+  progress,
+  resetFormFields,
+  resolveUrlMethodPairComponent,
+  router,
+  setupProgress,
+  shouldIntercept,
+  shouldNavigate,
+  urlHasProtocol,
+  urlToString,
+  urlWithoutHash,
+  useInfiniteScroll,
+  xhrHttpClient
+};
 /* NProgress, (c) 2013, 2014 Rico Sta. Cruz - http://ricostacruz.com/nprogress
  * @license MIT */
 //# sourceMappingURL=index.js.map